quantrs2_device/unified_benchmarking/
results.rs

1//! Result types for the unified benchmarking system
2
3use scirs2_core::ndarray::Array2;
4use serde::{Deserialize, Serialize};
5use std::collections::HashMap;
6use std::time::{Duration, SystemTime};
7
8use super::config::{
9    CircuitType, MultiQubitGate, SingleQubitGate, TwoQubitGate, UnifiedBenchmarkConfig,
10};
11use super::types::QuantumPlatform;
12
13/// Main unified benchmarking result structure
14#[derive(Debug, Clone, Serialize, Deserialize)]
15pub struct UnifiedBenchmarkResult {
16    /// Unique benchmark execution ID
17    pub execution_id: String,
18    /// Execution timestamp
19    pub timestamp: SystemTime,
20    /// Configuration used
21    pub config: UnifiedBenchmarkConfig,
22    /// Platform-specific results
23    pub platform_results: HashMap<QuantumPlatform, PlatformBenchmarkResult>,
24    /// Cross-platform analysis
25    pub cross_platform_analysis: CrossPlatformAnalysis,
26    /// SciRS2 analysis results
27    pub scirs2_analysis: SciRS2AnalysisResult,
28    /// Resource utilization analysis
29    pub resource_analysis: ResourceAnalysisResult,
30    /// Cost analysis
31    pub cost_analysis: CostAnalysisResult,
32    /// Performance optimization recommendations
33    pub optimization_recommendations: Vec<OptimizationRecommendation>,
34    /// Historical comparison
35    pub historical_comparison: Option<HistoricalComparisonResult>,
36    /// Execution metadata
37    pub execution_metadata: ExecutionMetadata,
38}
39
40/// Platform-specific benchmark results
41#[derive(Debug, Clone, Serialize, Deserialize)]
42pub struct PlatformBenchmarkResult {
43    pub platform: QuantumPlatform,
44    pub device_info: DeviceInfo,
45    pub gate_level_results: GateLevelResults,
46    pub circuit_level_results: CircuitLevelResults,
47    pub algorithm_level_results: AlgorithmLevelResults,
48    pub system_level_results: SystemLevelResults,
49    pub performance_metrics: PlatformPerformanceMetrics,
50    pub reliability_metrics: ReliabilityMetrics,
51    pub cost_metrics: CostMetrics,
52}
53
54/// Device information
55#[derive(Debug, Clone, Serialize, Deserialize)]
56pub struct DeviceInfo {
57    pub device_id: String,
58    pub provider: String,
59    pub technology: QuantumTechnology,
60    pub specifications: DeviceSpecifications,
61    pub current_status: DeviceStatus,
62    pub calibration_date: Option<SystemTime>,
63}
64
65#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
66pub enum QuantumTechnology {
67    Superconducting,
68    TrappedIon,
69    Photonic,
70    NeutralAtom,
71    Topological,
72    SpinQubit,
73    Other(String),
74}
75
76#[derive(Debug, Clone, Serialize, Deserialize)]
77pub struct DeviceSpecifications {
78    pub num_qubits: usize,
79    pub connectivity: ConnectivityInfo,
80    pub gate_set: Vec<String>,
81    pub coherence_times: CoherenceTimes,
82    pub gate_times: HashMap<String, Duration>,
83    pub error_rates: HashMap<String, f64>,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize)]
87pub struct ConnectivityInfo {
88    pub topology_type: TopologyType,
89    pub coupling_map: Vec<(usize, usize)>,
90    pub connectivity_matrix: Array2<f64>,
91}
92
93#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
94pub enum TopologyType {
95    Linear,
96    Ring,
97    Grid,
98    Heavy,
99    AllToAll,
100    Custom,
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize)]
104pub struct CoherenceTimes {
105    pub t1: HashMap<usize, Duration>,
106    pub t2: HashMap<usize, Duration>,
107    pub t2_echo: HashMap<usize, Duration>,
108}
109
110#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
111pub enum DeviceStatus {
112    Online,
113    Offline,
114    Maintenance,
115    Degraded,
116    Calibrating,
117    Unknown,
118}
119
120/// Gate-level benchmark results
121#[derive(Debug, Clone, Serialize, Deserialize)]
122pub struct GateLevelResults {
123    pub single_qubit_results: HashMap<SingleQubitGate, GatePerformanceResult>,
124    pub two_qubit_results: HashMap<TwoQubitGate, GatePerformanceResult>,
125    pub multi_qubit_results: HashMap<MultiQubitGate, GatePerformanceResult>,
126    pub randomized_benchmarking: RandomizedBenchmarkingResult,
127    pub process_tomography: Option<ProcessTomographyResult>,
128}
129
130#[derive(Debug, Clone, Serialize, Deserialize)]
131pub struct GatePerformanceResult {
132    pub gate_type: String,
133    pub fidelity: StatisticalSummary,
134    pub execution_time: StatisticalSummary,
135    pub error_rate: StatisticalSummary,
136    pub success_rate: f64,
137    pub measurements: Vec<GateMeasurement>,
138}
139
140#[derive(Debug, Clone, Serialize, Deserialize)]
141pub struct StatisticalSummary {
142    pub mean: f64,
143    pub std_dev: f64,
144    pub median: f64,
145    pub min: f64,
146    pub max: f64,
147    pub percentiles: HashMap<u8, f64>,
148    pub confidence_interval: (f64, f64),
149}
150
151#[derive(Debug, Clone, Serialize, Deserialize)]
152pub struct GateMeasurement {
153    pub timestamp: SystemTime,
154    pub fidelity: f64,
155    pub execution_time: Duration,
156    pub error_type: Option<String>,
157    pub additional_data: HashMap<String, f64>,
158}
159
160#[derive(Debug, Clone, Serialize, Deserialize)]
161pub struct RandomizedBenchmarkingResult {
162    pub clifford_fidelity: f64,
163    pub decay_parameter: f64,
164    pub confidence_interval: (f64, f64),
165    pub sequence_lengths: Vec<usize>,
166    pub survival_probabilities: Vec<f64>,
167}
168
169#[derive(Debug, Clone, Serialize, Deserialize)]
170pub struct ProcessTomographyResult {
171    pub process_matrix: Array2<f64>,
172    pub process_fidelity: f64,
173    pub diamond_distance: f64,
174    pub reconstruction_error: f64,
175}
176
177/// Circuit-level benchmark results
178#[derive(Debug, Clone, Serialize, Deserialize)]
179pub struct CircuitLevelResults {
180    pub depth_scaling: DepthScalingResult,
181    pub width_scaling: WidthScalingResult,
182    pub circuit_type_results: HashMap<CircuitType, CircuitTypeResult>,
183    pub parametric_results: HashMap<String, ParametricResult>,
184    pub volume_benchmarks: VolumeBenchmarkResult,
185}
186
187#[derive(Debug, Clone, Serialize, Deserialize)]
188pub struct DepthScalingResult {
189    pub depth_vs_fidelity: Vec<(usize, f64)>,
190    pub depth_vs_execution_time: Vec<(usize, Duration)>,
191    pub scaling_exponent: f64,
192    pub coherence_limited_depth: usize,
193}
194
195#[derive(Debug, Clone, Serialize, Deserialize)]
196pub struct WidthScalingResult {
197    pub width_vs_fidelity: Vec<(usize, f64)>,
198    pub width_vs_execution_time: Vec<(usize, Duration)>,
199    pub scaling_exponent: f64,
200    pub connectivity_limited_width: usize,
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize)]
204pub struct CircuitTypeResult {
205    pub circuit_type: CircuitType,
206    pub performance_metrics: CircuitPerformanceMetrics,
207    pub optimization_effectiveness: f64,
208    pub resource_utilization: CircuitResourceUtilization,
209}
210
211#[derive(Debug, Clone, Serialize, Deserialize)]
212pub struct CircuitPerformanceMetrics {
213    pub fidelity: StatisticalSummary,
214    pub execution_time: StatisticalSummary,
215    pub success_probability: f64,
216    pub depth_overhead: f64,
217    pub gate_overhead: f64,
218}
219
220#[derive(Debug, Clone, Serialize, Deserialize)]
221pub struct CircuitResourceUtilization {
222    pub cpu_time: Duration,
223    pub memory_usage: f64,
224    pub shots_used: usize,
225    pub queue_time: Duration,
226}
227
228#[derive(Debug, Clone, Serialize, Deserialize)]
229pub struct ParametricResult {
230    pub parameter_name: String,
231    pub parameter_values: Vec<f64>,
232    pub performance_data: Vec<CircuitPerformanceMetrics>,
233    pub optimal_parameters: HashMap<String, f64>,
234}
235
236#[derive(Debug, Clone, Serialize, Deserialize)]
237pub struct VolumeBenchmarkResult {
238    pub heavy_output: HeavyOutputResult,
239    pub cross_entropy: CrossEntropyResult,
240    pub quantum_volume: usize,
241}
242
243#[derive(Debug, Clone, Serialize, Deserialize)]
244pub struct HeavyOutputResult {
245    pub heavy_output_probability: f64,
246    pub theoretical_threshold: f64,
247    pub statistical_significance: f64,
248}
249
250#[derive(Debug, Clone, Serialize, Deserialize)]
251pub struct CrossEntropyResult {
252    pub cross_entropy_benchmarking_fidelity: f64,
253    pub linear_xeb_fidelity: f64,
254    pub log_xeb_fidelity: f64,
255}
256
257/// Algorithm-level benchmark results
258#[derive(Debug, Clone, Serialize, Deserialize)]
259pub struct AlgorithmLevelResults {
260    pub algorithm_results: HashMap<String, AlgorithmResult>,
261    pub nisq_performance: NISQPerformanceResult,
262    pub quantum_advantage: QuantumAdvantageResult,
263    pub classical_comparison: ClassicalComparisonResult,
264    pub variational_algorithm_performance: VariationalAlgorithmResult,
265}
266
267#[derive(Debug, Clone, Serialize, Deserialize)]
268pub struct AlgorithmResult {
269    pub algorithm_name: String,
270    pub problem_sizes: Vec<usize>,
271    pub success_rates: Vec<f64>,
272    pub execution_times: Vec<Duration>,
273    pub fidelities: Vec<f64>,
274    pub resource_requirements: Vec<ResourceRequirement>,
275    pub scalability_analysis: ScalabilityAnalysis,
276}
277
278#[derive(Debug, Clone, Serialize, Deserialize)]
279pub struct ResourceRequirement {
280    pub problem_size: usize,
281    pub qubits_required: usize,
282    pub circuit_depth: usize,
283    pub gate_count: HashMap<String, usize>,
284    pub shots_needed: usize,
285}
286
287#[derive(Debug, Clone, Serialize, Deserialize)]
288pub struct ScalabilityAnalysis {
289    pub polynomial_fit: PolynomialFit,
290    pub exponential_fit: ExponentialFit,
291    pub complexity_class: ComplexityClass,
292    pub quantum_advantage_threshold: Option<usize>,
293}
294
295#[derive(Debug, Clone, Serialize, Deserialize)]
296pub struct PolynomialFit {
297    pub coefficients: Vec<f64>,
298    pub r_squared: f64,
299    pub predicted_scaling: f64,
300}
301
302#[derive(Debug, Clone, Serialize, Deserialize)]
303pub struct ExponentialFit {
304    pub base: f64,
305    pub exponent: f64,
306    pub r_squared: f64,
307    pub predicted_scaling: f64,
308}
309
310#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
311pub enum ComplexityClass {
312    Constant,
313    Logarithmic,
314    Linear,
315    Quadratic,
316    Polynomial(u32),
317    Exponential,
318    Unknown,
319}
320
321#[derive(Debug, Clone, Serialize, Deserialize)]
322pub struct NISQPerformanceResult {
323    pub noise_resilience: f64,
324    pub error_mitigation_effectiveness: f64,
325    pub depth_limited_performance: HashMap<usize, f64>,
326    pub variational_optimization_convergence: ConvergenceAnalysis,
327}
328
329#[derive(Debug, Clone, Serialize, Deserialize)]
330pub struct QuantumAdvantageResult {
331    pub advantage_demonstrated: bool,
332    pub speedup_factor: Option<f64>,
333    pub confidence_level: f64,
334    pub problem_instances_tested: usize,
335}
336
337#[derive(Debug, Clone, Serialize, Deserialize)]
338pub struct ClassicalComparisonResult {
339    pub classical_runtime: Duration,
340    pub quantum_runtime: Duration,
341    pub speedup_ratio: f64,
342    pub accuracy_comparison: AccuracyComparison,
343}
344
345#[derive(Debug, Clone, Serialize, Deserialize)]
346pub struct AccuracyComparison {
347    pub classical_accuracy: f64,
348    pub quantum_accuracy: f64,
349    pub relative_error: f64,
350}
351
352#[derive(Debug, Clone, Serialize, Deserialize)]
353pub struct VariationalAlgorithmResult {
354    pub optimization_landscapes: HashMap<String, OptimizationLandscape>,
355    pub convergence_analysis: ConvergenceAnalysis,
356    pub parameter_sensitivity: ParameterSensitivityAnalysis,
357    pub barren_plateau_analysis: BarrenPlateauAnalysis,
358}
359
360#[derive(Debug, Clone, Serialize, Deserialize)]
361pub struct OptimizationLandscape {
362    pub parameter_space: Array2<f64>,
363    pub cost_surface: Array2<f64>,
364    pub local_minima: Vec<(Vec<f64>, f64)>,
365    pub global_minimum: (Vec<f64>, f64),
366}
367
368#[derive(Debug, Clone, Serialize, Deserialize)]
369pub struct ConvergenceAnalysis {
370    pub convergence_achieved: bool,
371    pub iterations_to_convergence: Option<usize>,
372    pub final_cost: f64,
373    pub cost_history: Vec<f64>,
374    pub gradient_norms: Vec<f64>,
375}
376
377#[derive(Debug, Clone, Serialize, Deserialize)]
378pub struct ParameterSensitivityAnalysis {
379    pub sensitivity_matrix: Array2<f64>,
380    pub most_sensitive_parameters: Vec<usize>,
381    pub robustness_score: f64,
382}
383
384#[derive(Debug, Clone, Serialize, Deserialize)]
385pub struct BarrenPlateauAnalysis {
386    pub plateau_detected: bool,
387    pub gradient_variance: f64,
388    pub effective_dimension: f64,
389    pub mitigation_strategies: Vec<String>,
390}
391
392/// System-level benchmark results
393#[derive(Debug, Clone, Serialize, Deserialize)]
394pub struct SystemLevelResults {
395    pub cross_platform_comparison: CrossPlatformComparison,
396    pub resource_utilization: SystemResourceUtilization,
397    pub reliability_analysis: SystemReliabilityAnalysis,
398    pub scalability_analysis: SystemScalabilityAnalysis,
399    pub cost_efficiency: SystemCostEfficiency,
400}
401
402#[derive(Debug, Clone, Serialize, Deserialize)]
403pub struct CrossPlatformComparison {
404    pub platform_rankings: Vec<PlatformRanking>,
405    pub relative_performance: HashMap<String, f64>,
406    pub statistical_significance: HashMap<String, f64>,
407}
408
409#[derive(Debug, Clone, Serialize, Deserialize)]
410pub struct PlatformRanking {
411    pub platform: QuantumPlatform,
412    pub overall_score: f64,
413    pub category_scores: HashMap<String, f64>,
414    pub rank: usize,
415}
416
417#[derive(Debug, Clone, Serialize, Deserialize)]
418pub struct SystemResourceUtilization {
419    pub average_queue_time: Duration,
420    pub throughput: f64,
421    pub utilization_rate: f64,
422    pub peak_usage_times: Vec<SystemTime>,
423}
424
425#[derive(Debug, Clone, Serialize, Deserialize)]
426pub struct SystemReliabilityAnalysis {
427    pub uptime: f64,
428    pub error_frequency: f64,
429    pub recovery_time: Duration,
430    pub failure_patterns: Vec<FailurePattern>,
431}
432
433#[derive(Debug, Clone, Serialize, Deserialize)]
434pub struct FailurePattern {
435    pub failure_type: String,
436    pub frequency: f64,
437    pub typical_duration: Duration,
438    pub impact_severity: f64,
439}
440
441#[derive(Debug, Clone, Serialize, Deserialize)]
442pub struct SystemScalabilityAnalysis {
443    pub max_supported_qubits: usize,
444    pub max_circuit_depth: usize,
445    pub performance_scaling: HashMap<String, ScalingMetric>,
446}
447
448#[derive(Debug, Clone, Serialize, Deserialize)]
449pub struct ScalingMetric {
450    pub metric_name: String,
451    pub scaling_function: String,
452    pub coefficients: Vec<f64>,
453    pub r_squared: f64,
454}
455
456#[derive(Debug, Clone, Serialize, Deserialize)]
457pub struct SystemCostEfficiency {
458    pub cost_per_shot: f64,
459    pub cost_per_gate: f64,
460    pub cost_efficiency_score: f64,
461    pub roi_analysis: ROIAnalysis,
462}
463
464#[derive(Debug, Clone, Serialize, Deserialize)]
465pub struct ROIAnalysis {
466    pub investment_cost: f64,
467    pub operational_cost: f64,
468    pub performance_benefit: f64,
469    pub roi_ratio: f64,
470}
471
472/// Performance metrics
473#[derive(Debug, Clone, Serialize, Deserialize)]
474pub struct PlatformPerformanceMetrics {
475    pub overall_fidelity: f64,
476    pub average_execution_time: Duration,
477    pub throughput: f64,
478    pub error_rate: f64,
479    pub availability: f64,
480}
481
482#[derive(Debug, Clone, Serialize, Deserialize)]
483pub struct ReliabilityMetrics {
484    pub uptime: f64,
485    pub mtbf: Duration, // Mean Time Between Failures
486    pub mttr: Duration, // Mean Time To Recovery
487    pub availability: f64,
488}
489
490#[derive(Debug, Clone, Serialize, Deserialize)]
491pub struct CostMetrics {
492    pub total_cost: f64,
493    pub cost_per_shot: f64,
494    pub cost_per_hour: f64,
495    pub cost_breakdown: HashMap<String, f64>,
496}
497
498/// Analysis results
499#[derive(Debug, Clone, Serialize, Deserialize)]
500pub struct CrossPlatformAnalysis {
501    pub platform_comparison: HashMap<String, f64>,
502    pub best_platform_per_metric: HashMap<String, QuantumPlatform>,
503    pub statistical_significance_tests: HashMap<String, f64>,
504}
505
506#[derive(Debug, Clone, Serialize, Deserialize)]
507pub struct SciRS2AnalysisResult {
508    pub statistical_analysis: StatisticalAnalysisResult,
509    pub ml_analysis: MLAnalysisResult,
510    pub optimization_analysis: OptimizationAnalysisResult,
511    pub graph_analysis: GraphAnalysisResult,
512}
513
514#[derive(Debug, Clone, Serialize, Deserialize)]
515pub struct StatisticalAnalysisResult {
516    pub hypothesis_tests: Vec<HypothesisTestResult>,
517    pub correlation_analysis: CorrelationAnalysisResult,
518    pub regression_analysis: RegressionAnalysisResult,
519    pub time_series_analysis: TimeSeriesAnalysisResult,
520}
521
522#[derive(Debug, Clone, Serialize, Deserialize)]
523pub struct HypothesisTestResult {
524    pub test_name: String,
525    pub p_value: f64,
526    pub statistic: f64,
527    pub critical_value: f64,
528    pub significant: bool,
529    pub effect_size: f64,
530}
531
532#[derive(Debug, Clone, Serialize, Deserialize)]
533pub struct CorrelationAnalysisResult {
534    pub correlationmatrix: Array2<f64>,
535    pub significant_correlations: Vec<CorrelationPair>,
536    pub partial_correlations: Array2<f64>,
537}
538
539#[derive(Debug, Clone, Serialize, Deserialize)]
540pub struct CorrelationPair {
541    pub variable1: String,
542    pub variable2: String,
543    pub correlation: f64,
544    pub p_value: f64,
545}
546
547#[derive(Debug, Clone, Serialize, Deserialize)]
548pub struct RegressionAnalysisResult {
549    pub linear_regression: LinearRegressionResult,
550    pub nonlinear_regression: NonlinearRegressionResult,
551    pub model_comparison: ModelComparisonResult,
552}
553
554#[derive(Debug, Clone, Serialize, Deserialize)]
555pub struct LinearRegressionResult {
556    pub coefficients: Vec<f64>,
557    pub r_squared: f64,
558    pub adjusted_r_squared: f64,
559    pub p_values: Vec<f64>,
560    pub residuals: Vec<f64>,
561}
562
563#[derive(Debug, Clone, Serialize, Deserialize)]
564pub struct NonlinearRegressionResult {
565    pub model_type: String,
566    pub parameters: Vec<f64>,
567    pub r_squared: f64,
568    pub mse: f64,
569    pub convergence_achieved: bool,
570}
571
572#[derive(Debug, Clone, Serialize, Deserialize)]
573pub struct ModelComparisonResult {
574    pub aic_scores: HashMap<String, f64>,
575    pub bic_scores: HashMap<String, f64>,
576    pub cross_validation_scores: HashMap<String, f64>,
577    pub best_model: String,
578}
579
580#[derive(Debug, Clone, Serialize, Deserialize)]
581pub struct TimeSeriesAnalysisResult {
582    pub trend_analysis: TrendAnalysisResult,
583    pub seasonality_analysis: SeasonalityAnalysisResult,
584    pub stationarity_tests: StationarityTestResults,
585    pub forecasting: ForecastingResults,
586}
587
588#[derive(Debug, Clone, Serialize, Deserialize)]
589pub struct TrendAnalysisResult {
590    pub trend_detected: bool,
591    pub trend_direction: String,
592    pub trend_strength: f64,
593    pub trend_coefficients: Vec<f64>,
594    pub change_points: Vec<usize>,
595}
596
597#[derive(Debug, Clone, Serialize, Deserialize)]
598pub struct SeasonalityAnalysisResult {
599    pub seasonal_components: Vec<f64>,
600    pub seasonal_period: usize,
601    pub seasonal_strength: f64,
602}
603
604#[derive(Debug, Clone, Serialize, Deserialize)]
605pub struct StationarityTestResults {
606    pub adf_test: HypothesisTestResult,
607    pub kpss_test: HypothesisTestResult,
608    pub is_stationary: bool,
609}
610
611#[derive(Debug, Clone, Serialize, Deserialize)]
612pub struct ForecastingResults {
613    pub forecasts: Vec<f64>,
614    pub confidence_intervals: Vec<(f64, f64)>,
615    pub forecast_horizon: usize,
616    pub model_performance: HashMap<String, f64>,
617}
618
619#[derive(Debug, Clone, Serialize, Deserialize)]
620pub struct MLAnalysisResult {
621    pub clustering_results: ClusteringResults,
622    pub classification_results: ClassificationResults,
623    pub regression_results: MLRegressionResults,
624    pub anomaly_detection: AnomalyDetectionResults,
625}
626
627#[derive(Debug, Clone, Serialize, Deserialize)]
628pub struct ClusteringResults {
629    pub cluster_assignments: Vec<usize>,
630    pub cluster_centers: Array2<f64>,
631    pub silhouette_score: f64,
632    pub inertia: f64,
633    pub optimal_clusters: usize,
634}
635
636#[derive(Debug, Clone, Serialize, Deserialize)]
637pub struct ClassificationResults {
638    pub model_accuracy: f64,
639    pub precision: Vec<f64>,
640    pub recall: Vec<f64>,
641    pub f1_score: Vec<f64>,
642    pub confusion_matrix: Array2<f64>,
643    pub feature_importance: Vec<f64>,
644}
645
646#[derive(Debug, Clone, Serialize, Deserialize)]
647pub struct MLRegressionResults {
648    pub models: Vec<MLModelResult>,
649    pub ensemble_result: EnsembleResult,
650    pub cross_validation: CrossValidationResult,
651}
652
653#[derive(Debug, Clone, Serialize, Deserialize)]
654pub struct MLModelResult {
655    pub model_type: String,
656    pub mse: f64,
657    pub mae: f64,
658    pub r_squared: f64,
659    pub predictions: Vec<f64>,
660}
661
662#[derive(Debug, Clone, Serialize, Deserialize)]
663pub struct EnsembleResult {
664    pub ensemble_mse: f64,
665    pub ensemble_mae: f64,
666    pub ensemble_r_squared: f64,
667    pub model_weights: Vec<f64>,
668}
669
670#[derive(Debug, Clone, Serialize, Deserialize)]
671pub struct CrossValidationResult {
672    pub cv_scores: Vec<f64>,
673    pub mean_cv_score: f64,
674    pub std_cv_score: f64,
675}
676
677#[derive(Debug, Clone, Serialize, Deserialize)]
678pub struct AnomalyDetectionResults {
679    pub anomaly_scores: Vec<f64>,
680    pub anomaly_labels: Vec<bool>,
681    pub anomaly_count: usize,
682    pub feature_importance: FeatureImportanceResults,
683}
684
685#[derive(Debug, Clone, Serialize, Deserialize)]
686pub struct FeatureImportanceResults {
687    pub importance_scores: Vec<f64>,
688    pub feature_names: Vec<String>,
689    pub ranked_features: Vec<(String, f64)>,
690}
691
692#[derive(Debug, Clone, Serialize, Deserialize)]
693pub struct OptimizationAnalysisResult {
694    pub optimization_results: Vec<OptimizationResult>,
695    pub pareto_analysis: ParetoAnalysisResult,
696    pub sensitivity_analysis: SensitivityAnalysisResult,
697    pub robustness_analysis: RobustnessAnalysisResult,
698}
699
700#[derive(Debug, Clone, Serialize, Deserialize)]
701pub struct OptimizationResult {
702    pub objective_function: String,
703    pub optimal_solution: Vec<f64>,
704    pub optimal_value: f64,
705    pub convergence_history: Vec<f64>,
706    pub optimization_time: Duration,
707}
708
709#[derive(Debug, Clone, Serialize, Deserialize)]
710pub struct ParetoAnalysisResult {
711    pub pareto_front: Vec<Vec<f64>>,
712    pub pareto_solutions: Vec<Vec<f64>>,
713    pub hypervolume: f64,
714    pub spread_metric: f64,
715}
716
717#[derive(Debug, Clone, Serialize, Deserialize)]
718pub struct SensitivityAnalysisResult {
719    pub sensitivity_indices: Vec<f64>,
720    pub total_sensitivity_indices: Vec<f64>,
721    pub interaction_effects: Array2<f64>,
722}
723
724#[derive(Debug, Clone, Serialize, Deserialize)]
725pub struct RobustnessAnalysisResult {
726    pub robustness_score: f64,
727    pub stability_analysis: StabilityAnalysis,
728    pub uncertainty_propagation: UncertaintyPropagation,
729}
730
731#[derive(Debug, Clone, Serialize, Deserialize)]
732pub struct StabilityAnalysis {
733    pub stability_score: f64,
734    pub perturbation_analysis: Vec<PerturbationResult>,
735}
736
737#[derive(Debug, Clone, Serialize, Deserialize)]
738pub struct PerturbationResult {
739    pub perturbation_magnitude: f64,
740    pub output_change: f64,
741    pub stability_metric: f64,
742}
743
744#[derive(Debug, Clone, Serialize, Deserialize)]
745pub struct UncertaintyPropagation {
746    pub input_uncertainties: Vec<f64>,
747    pub output_uncertainty: f64,
748    pub uncertainty_contributions: Vec<f64>,
749}
750
751#[derive(Debug, Clone, Serialize, Deserialize)]
752pub struct GraphAnalysisResult {
753    pub connectivity_analysis: ConnectivityAnalysisResult,
754    pub centrality_analysis: CentralityAnalysisResult,
755    pub community_detection: CommunityDetectionResult,
756    pub topology_optimization: TopologyOptimizationResult,
757}
758
759#[derive(Debug, Clone, Serialize, Deserialize)]
760pub struct ConnectivityAnalysisResult {
761    pub connectivity_matrix: Array2<f64>,
762    pub path_lengths: Array2<f64>,
763    pub clustering_coefficient: f64,
764    pub graph_density: f64,
765}
766
767#[derive(Debug, Clone, Serialize, Deserialize)]
768pub struct CentralityAnalysisResult {
769    pub betweenness_centrality: Vec<f64>,
770    pub closeness_centrality: Vec<f64>,
771    pub eigenvector_centrality: Vec<f64>,
772    pub pagerank: Vec<f64>,
773}
774
775#[derive(Debug, Clone, Serialize, Deserialize)]
776pub struct CommunityDetectionResult {
777    pub community_assignments: Vec<usize>,
778    pub modularity: f64,
779    pub num_communities: usize,
780    pub community_sizes: Vec<usize>,
781}
782
783#[derive(Debug, Clone, Serialize, Deserialize)]
784pub struct TopologyOptimizationResult {
785    pub optimal_topology: Array2<f64>,
786    pub optimization_objective: f64,
787    pub improvement_factor: f64,
788}
789
790#[derive(Debug, Clone, Serialize, Deserialize)]
791pub struct ResourceAnalysisResult {
792    pub cpu_utilization: ResourceUtilizationMetrics,
793    pub memory_utilization: ResourceUtilizationMetrics,
794    pub network_utilization: ResourceUtilizationMetrics,
795    pub storage_utilization: ResourceUtilizationMetrics,
796    pub capacity_planning: CapacityPlanningResult,
797}
798
799#[derive(Debug, Clone, Serialize, Deserialize)]
800pub struct ResourceUtilizationMetrics {
801    pub average_utilization: f64,
802    pub peak_utilization: f64,
803    pub utilization_distribution: Vec<f64>,
804    pub efficiency_score: f64,
805}
806
807#[derive(Debug, Clone, Serialize, Deserialize)]
808pub struct CapacityPlanningResult {
809    pub current_capacity: f64,
810    pub projected_demand: Vec<f64>,
811    pub capacity_recommendations: Vec<CapacityRecommendation>,
812    pub scaling_timeline: Vec<(SystemTime, f64)>,
813}
814
815#[derive(Debug, Clone, Serialize, Deserialize)]
816pub struct CapacityRecommendation {
817    pub resource_type: String,
818    pub recommended_capacity: f64,
819    pub timeline: Duration,
820    pub cost_estimate: f64,
821}
822
823#[derive(Debug, Clone, Serialize, Deserialize)]
824pub struct CostAnalysisResult {
825    pub total_cost: f64,
826    pub cost_breakdown: HashMap<String, f64>,
827    pub cost_per_metric: HashMap<String, f64>,
828    pub cost_optimization: CostOptimizationAnalysisResult,
829    pub roi_analysis: ROIAnalysisResult,
830}
831
832#[derive(Debug, Clone, Serialize, Deserialize)]
833pub struct CostOptimizationAnalysisResult {
834    pub potential_savings: f64,
835    pub optimization_strategies: Vec<CostOptimizationStrategy>,
836    pub implementation_roadmap: Vec<OptimizationStep>,
837}
838
839#[derive(Debug, Clone, Serialize, Deserialize)]
840pub struct CostOptimizationStrategy {
841    pub strategy_name: String,
842    pub potential_savings: f64,
843    pub implementation_cost: f64,
844    pub payback_period: Duration,
845}
846
847#[derive(Debug, Clone, Serialize, Deserialize)]
848pub struct OptimizationStep {
849    pub step_description: String,
850    pub timeline: Duration,
851    pub cost: f64,
852    pub expected_savings: f64,
853}
854
855#[derive(Debug, Clone, Serialize, Deserialize)]
856pub struct ROIAnalysisResult {
857    pub roi_percentage: f64,
858    pub payback_period: Duration,
859    pub net_present_value: f64,
860    pub break_even_analysis: BreakEvenAnalysis,
861}
862
863#[derive(Debug, Clone, Serialize, Deserialize)]
864pub struct BreakEvenAnalysis {
865    pub break_even_point: Duration,
866    pub break_even_volume: f64,
867    pub sensitivity_analysis: Vec<SensitivityFactor>,
868}
869
870#[derive(Debug, Clone, Serialize, Deserialize)]
871pub struct SensitivityFactor {
872    pub factor_name: String,
873    pub impact_on_breakeven: f64,
874    pub uncertainty_range: (f64, f64),
875}
876
877#[derive(Debug, Clone, Serialize, Deserialize)]
878pub struct OptimizationRecommendation {
879    pub recommendation_type: String,
880    pub description: String,
881    pub expected_improvement: f64,
882    pub implementation_effort: String,
883    pub priority: u8,
884}
885
886#[derive(Debug, Clone, Serialize, Deserialize)]
887pub struct HistoricalComparisonResult {
888    pub baseline_comparison: Vec<MetricComparison>,
889    pub trend_analysis: HashMap<String, TrendAnalysisResult>,
890    pub performance_evolution: Vec<PerformanceSnapshot>,
891}
892
893#[derive(Debug, Clone, Serialize, Deserialize)]
894pub struct MetricComparison {
895    pub metric_name: String,
896    pub current_value: f64,
897    pub baseline_value: f64,
898    pub percentage_change: f64,
899    pub statistical_significance: f64,
900}
901
902#[derive(Debug, Clone, Serialize, Deserialize)]
903pub struct PerformanceSnapshot {
904    pub timestamp: SystemTime,
905    pub metrics: HashMap<String, f64>,
906    pub configuration: String,
907}
908
909#[derive(Debug, Clone, Serialize, Deserialize)]
910pub struct ExecutionMetadata {
911    pub execution_start_time: SystemTime,
912    pub execution_end_time: SystemTime,
913    pub total_duration: Duration,
914    pub platforms_tested: Vec<QuantumPlatform>,
915    pub benchmarks_executed: usize,
916    pub system_info: SystemInfo,
917}
918
919#[derive(Debug, Clone, Serialize, Deserialize)]
920pub struct SystemInfo {
921    pub hostname: String,
922    pub operating_system: String,
923    pub cpu_info: String,
924    pub memory_total: u64,
925    pub disk_space: u64,
926    pub network_info: String,
927}
quantrs2_device/unified_benchmarking/results.rs

quantrs2_device/unified_benchmarking/
results.rs
