'
+
+ def generate_performance_charts(self, df: pd.DataFrame) -> Dict[str, str]:
+ """Generate comprehensive performance visualization charts"""
+ charts = {}
+
+ if df.empty:
+ return charts
+
+ # 1. Executive Summary Chart - Key Metrics Overview
+ fig, axes = plt.subplots(2, 2, figsize=(12, 8))
+ fig.suptitle('Performance Overview', fontsize=16, fontweight='bold')
+
+ # Execution time distribution
+ df['execution_time_ms'].hist(bins=30, ax=axes[0,0], alpha=0.7, color='skyblue')
+ axes[0,0].set_title('Execution Time Distribution')
+ axes[0,0].set_xlabel('Time (ms)')
+ axes[0,0].set_ylabel('Frequency')
+
+ # Memory usage scatter
+ if 'object_count' in df.columns:
+ axes[0,1].scatter(df['object_count'], df['memory_delta_mb'], alpha=0.6, color='lightcoral')
+ axes[0,1].set_title('Memory Usage vs Object Count')
+ axes[0,1].set_xlabel('Object Count')
+ axes[0,1].set_ylabel('Memory Delta (MB)')
+
+ # Performance by operation type
+ if 'operation_name' in df.columns and df['operation_name'].nunique() > 1:
+ operation_means = df.groupby('operation_name')['execution_time_ms'].mean().sort_values()
+ operation_means.plot(kind='barh', ax=axes[1,0], color='lightgreen')
+ axes[1,0].set_title('Average Performance by Operation')
+ axes[1,0].set_xlabel('Average Time (ms)')
+
+ # Scalability preview
+ if 'grid_size' in df.columns:
+ size_means = df.groupby('grid_size')['execution_time_ms'].mean()
+ size_means.plot(kind='line', ax=axes[1,1], marker='o', color='orange')
+ axes[1,1].set_title('Performance Scaling by Grid Size')
+ axes[1,1].set_xlabel('Grid Size')
+ axes[1,1].set_ylabel('Average Time (ms)')
+
+ plt.tight_layout()
+ charts['performance_overview'] = self.create_embedded_chart(fig, 'performance_overview')
+ plt.close(fig)
+
+ # 2. Detailed Scalability Analysis
+ if 'object_count' in df.columns and 'grid_size' in df.columns:
+ fig, axes = plt.subplots(2, 2, figsize=(14, 10))
+ fig.suptitle('Scalability Analysis', fontsize=16, fontweight='bold')
+
+ # Object count scaling
+ sns.regplot(data=df, x='object_count', y='execution_time_ms',
+ ax=axes[0,0], scatter_kws={'alpha': 0.5})
+ axes[0,0].set_title('Performance vs Object Count')
+ axes[0,0].set_xlabel('Object Count')
+ axes[0,0].set_ylabel('Execution Time (ms)')
+
+ # Grid size scaling
+ sns.boxplot(data=df, x='grid_size', y='execution_time_ms', ax=axes[0,1])
+ axes[0,1].set_title('Performance Distribution by Grid Size')
+ axes[0,1].set_xlabel('Grid Size')
+ axes[0,1].set_ylabel('Execution Time (ms)')
+
+ # Object density impact
+ if 'object_density' in df.columns:
+ sns.scatterplot(data=df, x='object_density', y='execution_time_ms',
+ hue='grid_size', ax=axes[1,0])
+ axes[1,0].set_title('Performance vs Object Density')
+ axes[1,0].set_xlabel('Objects per Cell')
+ axes[1,0].set_ylabel('Execution Time (ms)')
+
+ # Time per object efficiency
+ if 'time_per_object' in df.columns:
+ sns.lineplot(data=df, x='object_count', y='time_per_object',
+ hue='grid_size', ax=axes[1,1])
+ axes[1,1].set_title('Efficiency: Time per Object')
+ axes[1,1].set_xlabel('Object Count')
+ axes[1,1].set_ylabel('Time per Object (ms)')
+
+ plt.tight_layout()
+ charts['scalability_analysis'] = self.create_embedded_chart(fig, 'scalability_analysis')
+ plt.close(fig)
+
+ # 3. Spillage Impact Analysis
+ if 'use_spillage' in df.columns:
+ fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+ fig.suptitle('Spillage Mode Impact Analysis', fontsize=16, fontweight='bold')
+
+ # Performance comparison
+ sns.boxplot(data=df, x='use_spillage', y='execution_time_ms', ax=axes[0])
+ axes[0].set_title('Execution Time by Spillage Mode')
+ axes[0].set_xlabel('Spillage Enabled')
+ axes[0].set_ylabel('Execution Time (ms)')
+
+ # Memory impact
+ sns.boxplot(data=df, x='use_spillage', y='memory_delta_mb', ax=axes[1])
+ axes[1].set_title('Memory Usage by Spillage Mode')
+ axes[1].set_xlabel('Spillage Enabled')
+ axes[1].set_ylabel('Memory Delta (MB)')
+
+ # Distribution comparison
+ spillage_true = df[df['use_spillage'] == True]['execution_time_ms']
+ spillage_false = df[df['use_spillage'] == False]['execution_time_ms']
+
+ axes[2].hist([spillage_false, spillage_true], bins=20, alpha=0.7,
+ label=['Without Spillage', 'With Spillage'], color=['lightblue', 'lightcoral'])
+ axes[2].set_title('Performance Distribution Comparison')
+ axes[2].set_xlabel('Execution Time (ms)')
+ axes[2].set_ylabel('Frequency')
+ axes[2].legend()
+
+ plt.tight_layout()
+ charts['spillage_impact'] = self.create_embedded_chart(fig, 'spillage_impact')
+ plt.close(fig)
+
+ # Generate optimization comparison charts
+ optimization_charts = self.generate_optimization_charts(df)
+ charts.update(optimization_charts)
+
+ return charts
+
+ def generate_optimization_charts(self, df: pd.DataFrame) -> Dict[str, str]:
+ """Generate charts specifically for optimization comparisons"""
+ charts = {}
+
+ if df.empty:
+ return charts
+
+ # A* Suffix Stitching Comparison
+ if 'use_suffix_stitching' in df.columns:
+ fig, axes = plt.subplots(2, 2, figsize=(14, 10))
+ fig.suptitle('A* Suffix Stitching Optimization Analysis', fontsize=16, fontweight='bold')
+
+ # Performance comparison
+ sns.boxplot(data=df, x='use_suffix_stitching', y='execution_time_ms', ax=axes[0,0])
+ axes[0,0].set_title('Execution Time: Suffix Stitching Impact')
+ axes[0,0].set_xlabel('Suffix Stitching Enabled')
+ axes[0,0].set_ylabel('Execution Time (ms)')
+ axes[0,0].set_xticklabels(['Disabled', 'Enabled'])
+
+ # Memory impact
+ sns.boxplot(data=df, x='use_suffix_stitching', y='memory_delta_mb', ax=axes[0,1])
+ axes[0,1].set_title('Memory Usage: Suffix Stitching Impact')
+ axes[0,1].set_xlabel('Suffix Stitching Enabled')
+ axes[0,1].set_ylabel('Memory Delta (MB)')
+ axes[0,1].set_xticklabels(['Disabled', 'Enabled'])
+
+ # Path quality metrics (if available)
+ if 'avg_path_length' in df.columns:
+ sns.boxplot(data=df, x='use_suffix_stitching', y='avg_path_length', ax=axes[1,0])
+ axes[1,0].set_title('Path Quality: Average Path Length')
+ axes[1,0].set_xlabel('Suffix Stitching Enabled')
+ axes[1,0].set_ylabel('Average Path Length')
+ axes[1,0].set_xticklabels(['Disabled', 'Enabled'])
+
+ # Performance improvement visualization
+ if len(df[df['use_suffix_stitching'] == True]) > 0 and len(df[df['use_suffix_stitching'] == False]) > 0:
+ enabled_times = df[df['use_suffix_stitching'] == True]['execution_time_ms']
+ disabled_times = df[df['use_suffix_stitching'] == False]['execution_time_ms']
+
+ improvement_pct = ((disabled_times.mean() - enabled_times.mean()) / disabled_times.mean()) * 100
+
+ categories = ['Disabled', 'Enabled']
+ times = [disabled_times.mean(), enabled_times.mean()]
+ colors = ['lightcoral', 'lightgreen']
+
+ bars = axes[1,1].bar(categories, times, color=colors, alpha=0.7)
+ axes[1,1].set_title(f'Performance Improvement: {improvement_pct:.1f}%')
+ axes[1,1].set_ylabel('Average Execution Time (ms)')
+
+ # Add value labels on bars
+ for bar, time in zip(bars, times):
+ axes[1,1].text(bar.get_x() + bar.get_width()/2., bar.get_height(),
+ f'{time:.1f}ms', ha='center', va='bottom')
+
+ plt.tight_layout()
+ charts['suffix_stitching_optimization'] = self.create_embedded_chart(fig, 'suffix_stitching_optimization', 'A* Suffix Stitching Optimization')
+ plt.close(fig)
+
+ # Optimization Matrix Heatmap
+ if all(col in df.columns for col in ['use_suffix_stitching', 'use_spillage']):
+ fig, axes = plt.subplots(1, 2, figsize=(16, 6))
+ fig.suptitle('Optimization Matrix Analysis', fontsize=16, fontweight='bold')
+
+ # Create optimization combinations
+ df['optimization_combo'] = df.apply(lambda row:
+ f"Suffix: {'On' if row.get('use_suffix_stitching', True) else 'Off'}\n"
+ f"Spillage: {'On' if row.get('use_spillage', False) else 'Off'}", axis=1)
+
+ # Performance heatmap
+ pivot_perf = df.pivot_table(values='execution_time_ms',
+ index='use_spillage',
+ columns='use_suffix_stitching',
+ aggfunc='mean')
+
+ sns.heatmap(pivot_perf, annot=True, fmt='.1f', cmap='RdYlGn_r', ax=axes[0])
+ axes[0].set_title('Execution Time (ms) by Optimization Combination')
+ axes[0].set_xlabel('Suffix Stitching')
+ axes[0].set_ylabel('Spillage Model')
+ axes[0].set_xticklabels(['Disabled', 'Enabled'])
+ axes[0].set_yticklabels(['Disabled', 'Enabled'])
+
+ # Memory heatmap
+ pivot_mem = df.pivot_table(values='memory_delta_mb',
+ index='use_spillage',
+ columns='use_suffix_stitching',
+ aggfunc='mean')
+
+ sns.heatmap(pivot_mem, annot=True, fmt='.2f', cmap='RdYlBu_r', ax=axes[1])
+ axes[1].set_title('Memory Usage (MB) by Optimization Combination')
+ axes[1].set_xlabel('Suffix Stitching')
+ axes[1].set_ylabel('Spillage Model')
+ axes[1].set_xticklabels(['Disabled', 'Enabled'])
+ axes[1].set_yticklabels(['Disabled', 'Enabled'])
+
+ plt.tight_layout()
+ charts['optimization_matrix_heatmap'] = self.create_embedded_chart(fig, 'optimization_matrix_heatmap', 'Optimization Matrix Heatmap')
+ plt.close(fig)
+
+ # Performance Improvement Summary Chart
+ if 'use_suffix_stitching' in df.columns:
+ fig, ax = plt.subplots(1, 1, figsize=(12, 8))
+
+ # Calculate improvement percentages for different metrics
+ improvements = {}
+
+ if len(df[df['use_suffix_stitching'] == True]) > 0 and len(df[df['use_suffix_stitching'] == False]) > 0:
+ enabled_df = df[df['use_suffix_stitching'] == True]
+ disabled_df = df[df['use_suffix_stitching'] == False]
+
+ # Execution time improvement
+ time_improvement = ((disabled_df['execution_time_ms'].mean() -
+ enabled_df['execution_time_ms'].mean()) /
+ disabled_df['execution_time_ms'].mean()) * 100
+ improvements['Execution Time'] = time_improvement
+
+ # Memory improvement
+ if 'memory_delta_mb' in df.columns:
+ mem_improvement = ((disabled_df['memory_delta_mb'].mean() -
+ enabled_df['memory_delta_mb'].mean()) /
+ abs(disabled_df['memory_delta_mb'].mean())) * 100
+ improvements['Memory Efficiency'] = mem_improvement
+
+ # Path quality improvement (if available)
+ if 'path_efficiency' in df.columns:
+ path_improvement = ((enabled_df['path_efficiency'].mean() -
+ disabled_df['path_efficiency'].mean()) /
+ disabled_df['path_efficiency'].mean()) * 100
+ improvements['Path Efficiency'] = path_improvement
+
+ # Create bar chart
+ metrics = list(improvements.keys())
+ values = list(improvements.values())
+ colors = ['green' if v > 0 else 'red' for v in values]
+
+ bars = ax.barh(metrics, values, color=colors, alpha=0.7)
+ ax.set_title('Optimization Performance Improvements (%)', fontsize=14, fontweight='bold')
+ ax.set_xlabel('Improvement Percentage (%)')
+ ax.axvline(x=0, color='black', linestyle='-', linewidth=0.5)
+
+ # Add value labels
+ for bar, value in zip(bars, values):
+ ax.text(value + (1 if value > 0 else -1), bar.get_y() + bar.get_height()/2,
+ f'{value:+.1f}%', ha='left' if value > 0 else 'right', va='center')
+
+ # Add grid
+ ax.grid(axis='x', alpha=0.3)
+
+ plt.tight_layout()
+ charts['performance_improvements'] = self.create_embedded_chart(fig, 'performance_improvements', 'Performance Improvements Summary')
+ plt.close(fig)
+
+ return charts
+
+ def create_plot_index_file(self, results_key: str):
+ """Create an index file listing all saved plots for thesis reference"""
+ if not self.save_individual_plots:
+ return
+
+ # Get all plot files
+ plot_files = {
+ 'png': list(self.plots_dir.glob("*.png")),
+ 'svg': list(self.plots_dir.glob("*.svg")),
+ 'pdf': list(self.plots_dir.glob("*.pdf"))
+ }
+
+ # Create index content
+ index_content = f"""# Plot Files Index - {results_key}
+Generated on: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+
+This directory contains individual plot files saved from the benchmark report,
+formatted for thesis use with high resolution (300 DPI) and clean styling.
+
+## Available Formats:
+- **PNG**: High-resolution raster images (300 DPI) - good for most thesis applications
+- **SVG**: Vector graphics - scalable without quality loss, ideal for academic publications
+- **PDF**: Vector format - publication-ready, perfect for LaTeX documents
+
+## Plot Categories:
+
+### Performance Overview Plots:
+- `performance_overview.*` - Overall performance metrics distribution
+- `execution_time_distribution.*` - Timing analysis across scenarios
+- `memory_usage_analysis.*` - Memory consumption patterns
+
+### Optimization Analysis Plots:
+- `suffix_stitching_optimization.*` - A* suffix stitching performance comparison
+- `optimization_matrix_heatmap.*` - Complete optimization combinations analysis
+- `performance_improvements.*` - Summary of all optimization benefits
+
+### Spillage Model Analysis:
+- `spillage_impact.*` - Performance impact of spillage model enabled/disabled
+
+### Scalability Analysis:
+- `scalability_analysis.*` - Performance scaling with problem size
+- `grid_size_performance.*` - Performance vs. grid size relationship
+
+## Usage in Thesis:
+
+### LaTeX Example:
+```latex
+\\begin{{figure}}[htbp]
+ \\centering
+ \\includegraphics[width=0.8\\textwidth]{{plots/suffix_stitching_optimization.pdf}}
+ \\caption{{A* Suffix Stitching Optimization Performance Analysis}}
+ \\label{{fig:suffix_stitching_opt}}
+\\end{{figure}}
+```
+
+### Word/LibreOffice:
+Use the PNG files (300 DPI) for high-quality images that maintain clarity when scaled.
+
+## File Summary:
+"""
+
+ # Add file listings
+ for format_type, files in plot_files.items():
+ if files:
+ index_content += f"\n### {format_type.upper()} Files ({len(files)} files):\n"
+ for file in sorted(files):
+ file_size = file.stat().st_size
+ size_str = f"{file_size / 1024:.1f} KB" if file_size < 1024*1024 else f"{file_size / (1024*1024):.1f} MB"
+ index_content += f"- `{file.name}` ({size_str})\n"
+
+ # Add optimization-specific descriptions
+ index_content += """
+## Plot Descriptions for Thesis Context:
+
+### Suffix Stitching Optimization Analysis
+Shows the performance improvement achieved by the A* suffix stitching optimization.
+Key metrics: execution time reduction, memory efficiency, path quality maintenance.
+
+### Optimization Matrix Heatmap
+Demonstrates how different optimization combinations affect performance.
+Useful for showing incremental benefits of each optimization technique.
+
+### Performance Improvements Summary
+Bar chart showing percentage improvements across different metrics.
+Perfect for highlighting the quantitative benefits of your algorithmic contributions.
+
+### Spillage Model Impact Analysis
+Compares performance with and without the spillage physics simulation.
+Shows the computational cost of adding realistic spillage behavior.
+
+## Thesis Integration Tips:
+
+1. **Figure Captions**: Include quantitative results (e.g., "X% improvement in execution time")
+2. **References**: Cite the specific benchmark configuration and test parameters
+3. **Consistency**: Use the same format (PNG/SVG/PDF) throughout your thesis
+4. **Resolution**: All images are saved at 300 DPI for print-quality output
+5. **Color Scheme**: Plots use a consistent, professional color scheme suitable for academic publication
+
+## Technical Details:
+- Font sizes optimized for thesis readability (12pt base, 14pt labels, 16pt titles)
+- High contrast colors for both color and grayscale printing
+- Clean, minimal styling following academic publication standards
+- Tight bounding boxes for efficient space usage in documents
+"""
+
+ # Save index file
+ index_file = self.plots_dir / "PLOT_INDEX.md"
+ with open(index_file, 'w', encoding='utf-8') as f:
+ f.write(index_content)
+
+ # Also create a simple text version
+ simple_index = f"Plot files generated for {results_key}:\n\n"
+ for format_type, files in plot_files.items():
+ if files:
+ simple_index += f"{format_type.upper()} files:\n"
+ for file in sorted(files):
+ simple_index += f" - {file.name}\n"
+ simple_index += "\n"
+
+ simple_index_file = self.plots_dir / "plot_list.txt"
+ with open(simple_index_file, 'w', encoding='utf-8') as f:
+ f.write(simple_index)
+
+ print(f"\n📊 Individual plots saved to: {self.plots_dir}")
+ print(f"📋 Plot index created: {index_file}")
+ print(f"📝 Simple list created: {simple_index_file}")
+
+ def generate_executive_summary(self, analysis: Dict[str, Any], df: pd.DataFrame) -> str:
+ """Generate executive summary section"""
+ metadata = analysis.get('metadata', {})
+ overall_perf = analysis.get('overall_performance', {})
+ scalability = analysis.get('scalability_analysis', {})
+ spillage = analysis.get('spillage_analysis', {})
+
+ # Key statistics
+ exec_stats = overall_perf.get('execution_time', {})
+ avg_time = exec_stats.get('mean', 0)
+ time_std = exec_stats.get('std', 0)
+
+ # Performance rating
+ if avg_time < 100:
+ performance_rating = "Excellent"
+ rating_color = "green"
+ elif avg_time < 500:
+ performance_rating = "Good"
+ rating_color = "orange"
+ else:
+ performance_rating = "Needs Optimization"
+ rating_color = "red"
+
+ summary = f"""
+ Earth Moving Algorithm Performance Analysis
+
+ Generated: 2025-09-12 07:23:07
+ Results File: benchmark_detailed_comprehensive_20250912_054514.json
+
+
+
+
+
+ Executive Summary
+ +
+
+
+
+
+
+ Overall Performance
+Needs Optimization
+
+ Average: 1007.9ms ± 1529.6ms
+
+
+
+
+ Test Coverage
+16,470 samples
+
+ 2161 scenarios tested
+
+
+
+ Scalability
+
+
+ Variable
+
+
+ Complex/Decreasing - Unusual behavior
+
+
+
+ Key Findings
+-
+
- Spillage mode adds -63.4% performance overhead
- Algorithm exhibits complex/decreasing - unusual behavior scaling behavior
- Performance optimization recommended for large scenarios +
+
+
+
+ Performance Visualizations
+ +
+ 
+
+
+ Performance Overview
+
+
+ 
+
+
+ Scalability Analysis
+
+
+ 
+
+ Spillage Impact Analysis
+
+
+
+
+ Detailed Performance Analysis
+ +
+
+ Scalability Analysis
+
+
+
+
+
+ Grid Size
+Complexity: O(n²) - Quadratic with linear component
+Linear Fit R²: 0.702
+Predictability: Moderate
+
+
+
+ Object Count
+Complexity: Complex/Decreasing - Unusual behavior
+Linear Fit R²: 0.528
+Predictability: Low
+
+
+ Total Cells
+Complexity: O(n²) - Quadratic with linear component
+Linear Fit R²: 0.931
+Predictability: High
+
+
+
+ Spillage Mode Impact
+
+
+ Performance Overhead: -63.4%
+Recommendation: Low overhead - spillage recommended for better accuracy
+Statistical Significance: No
+
+
+
+
+
+ Operation Performance Comparison
+| Operation | +Average Time (ms) | +Std Dev (ms) | +Min (ms) | +Max (ms) | +Samples | +
|---|---|---|---|---|---|
| Full Calculation 15X15 20Obj | +85.38 | +208.67 | +16.01 | +1150.15 | +200 | +
| Full Calculation 15X15 35Obj | +119.76 | +305.24 | +21.19 | +1770.62 | +200 | +
| Full Calculation 15X15 55Obj | +226.31 | +656.24 | +26.87 | +3966.15 | +200 | +
| Full Calculation 15X15 75Obj | +211.52 | +650.30 | +28.89 | +4231.97 | +200 | +
| Full Calculation 15X15 100Obj | +264.53 | +805.47 | +34.19 | +4059.01 | +200 | +
| Full Calculation 20X20 20Obj | +110.22 | +189.98 | +42.41 | +1004.86 | +200 | +
| Full Calculation 20X20 35Obj | +147.31 | +308.26 | +47.35 | +1572.62 | +200 | +
| Full Calculation 20X20 55Obj | +214.03 | +508.06 | +52.23 | +2859.60 | +200 | +
| Full Calculation 20X20 75Obj | +281.75 | +760.41 | +57.61 | +4094.47 | +200 | +
| Full Calculation 20X20 100Obj | +405.46 | +1134.41 | +61.78 | +6092.68 | +200 | +
| Full Calculation 25X25 20Obj | +183.12 | +277.54 | +75.17 | +1627.64 | +200 | +
| Full Calculation 25X25 35Obj | +254.61 | +472.54 | +79.72 | +2412.19 | +200 | +
| Full Calculation 25X25 55Obj | +322.29 | +716.25 | +87.06 | +3697.44 | +200 | +
| Full Calculation 25X25 75Obj | +347.85 | +856.16 | +87.91 | +4193.01 | +200 | +
| Full Calculation 25X25 100Obj | +511.32 | +1439.70 | +93.09 | +9316.44 | +200 | +
| Full Calculation 30X30 20Obj | +224.06 | +314.01 | +106.05 | +1572.37 | +200 | +
| Full Calculation 30X30 35Obj | +283.57 | +469.08 | +111.69 | +2259.64 | +200 | +
| Full Calculation 30X30 55Obj | +350.01 | +711.56 | +116.37 | +3675.11 | +200 | +
| Full Calculation 30X30 75Obj | +474.14 | +1074.89 | +122.33 | +5312.36 | +200 | +
| Full Calculation 30X30 100Obj | +607.02 | +1605.32 | +126.48 | +8782.09 | +200 | +
| Full Calculation 35X35 20Obj | +282.52 | +384.67 | +135.65 | +1733.55 | +200 | +
| Full Calculation 35X35 35Obj | +328.74 | +509.52 | +142.43 | +2752.51 | +200 | +
| Full Calculation 35X35 55Obj | +409.00 | +765.68 | +153.97 | +3555.95 | +200 | +
| Full Calculation 35X35 75Obj | +514.17 | +1046.05 | +159.07 | +5659.81 | +200 | +
| Full Calculation 35X35 100Obj | +658.10 | +1596.46 | +167.89 | +9224.96 | +200 | +
| Pure Env Update 25X25 | +150.79 | +14.94 | +131.68 | +256.02 | +240 | +
| Pure Env Update 30X30 | +193.49 | +46.22 | +158.71 | +616.26 | +240 | +
| Pure Env Update 35X35 | +201.53 | +34.68 | +179.52 | +535.22 | +240 | +
| Spillage Enabled 15X15 | +584.28 | +980.13 | +133.04 | +5083.50 | +750 | +
| Spillage Disabled 15X15 | +281.50 | +249.49 | +133.37 | +1665.42 | +750 | +
| Spillage Enabled 20X20 | +786.20 | +1381.55 | +181.87 | +8005.24 | +750 | +
| Spillage Disabled 20X20 | +401.22 | +421.03 | +180.95 | +5317.75 | +750 | +
| Spillage Enabled 25X25 | +917.48 | +1577.22 | +228.99 | +9388.64 | +750 | +
| Spillage Disabled 25X25 | +486.63 | +454.01 | +228.88 | +2463.73 | +750 | +
| Spillage Enabled 30X30 | +1038.06 | +1718.83 | +273.44 | +9686.65 | +750 | +
| Spillage Disabled 30X30 | +622.01 | +663.03 | +274.80 | +4595.60 | +750 | +
| Spillage Enabled 35X35 | +1323.36 | +2331.93 | +331.36 | +15914.41 | +750 | +
| Spillage Disabled 35X35 | +831.49 | +983.27 | +332.51 | +7242.86 | +750 | +
| Strategic Analysis 15X15 | +1097.09 | +186.82 | +949.22 | +2831.39 | +450 | +
| Strategic Analysis 20X20 | +1701.09 | +277.49 | +1469.19 | +3701.32 | +450 | +
| Strategic Analysis 25X25 | +2469.16 | +369.81 | +2127.37 | +4433.12 | +450 | +
| Strategic Analysis 30X30 | +3364.01 | +514.72 | +2957.82 | +7406.55 | +450 | +
| Strategic Analysis 35X35 | +4353.08 | +506.22 | +3884.51 | +7293.78 | +450 | +
| Save Load 15X15 | +1529.02 | +489.95 | +1197.25 | +5517.52 | +200 | +
| Save Load 20X20 | +2269.52 | +440.92 | +1850.13 | +3901.13 | +200 | +
| Save Load 25X25 | +3389.83 | +681.29 | +2747.53 | +8553.41 | +200 | +
| Save Load 30X30 | +4507.59 | +586.75 | +3844.61 | +7300.85 | +200 | +
| Save Load 35X35 | +6350.15 | +1162.09 | +4984.78 | +13154.19 | +200 | +
+
+
+
+ Recommendations
+- Consider performance optimization for scenarios exceeding 1 second execution time
- Spillage Mode: Low overhead - spillage recommended for better accuracy
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+