quantrs2-device 0.1.3

Quantum device connectors for the QuantRS2 framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Auto-generated module
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use crate::{
    backend_traits::{query_backend_capabilities, BackendCapabilities},
    benchmarking::{BenchmarkConfig, DeviceExecutor, HardwareBenchmarkSuite},
    calibration::{CalibrationManager, DeviceCalibration},
    characterization::{AdvancedNoiseCharacterizer, NoiseCharacterizationConfig},
    ml_optimization::{train_test_split, IsolationForest, KMeans, KMeansResult, DBSCAN},
    qec::{QECConfig, QuantumErrorCorrector},
    CircuitResult, DeviceError, DeviceResult,
};
use quantrs2_circuit::prelude::*;
use scirs2_core::ndarray::{s, Array1, Array2};
use scirs2_core::random::prelude::*;
use std::collections::{BTreeMap, HashMap, VecDeque};
use std::time::{Duration, Instant, SystemTime};

use super::types::{AdvancedBenchmarkConfig, AdvancedHardwareBenchmarkSuite};

#[cfg(test)]
mod tests {
    use super::*;
    use crate::calibration::create_ideal_calibration;
    #[test]
    fn test_advanced_benchmark_config_default() {
        let config = AdvancedBenchmarkConfig::default();
        assert!(config.ml_config.enable_adaptive_selection);
        assert!(config.realtime_config.enable_realtime);
        assert!(config.prediction_config.enable_prediction);
    }
    #[tokio::test]
    async fn test_feature_extraction() {
        let config = AdvancedBenchmarkConfig::default();
        let calibration_manager = CalibrationManager::new();
        let topology = crate::topology::HardwareTopology::linear_topology(4);
        let suite = AdvancedHardwareBenchmarkSuite::new(config, calibration_manager, topology)
            .await
            .expect("AdvancedHardwareBenchmarkSuite creation should succeed");
        let base_results = crate::benchmarking::BenchmarkSuite {
            device_id: "test".to_string(),
            backend_capabilities: crate::backend_traits::BackendCapabilities::default(),
            config: BenchmarkConfig::default(),
            benchmark_results: vec![],
            statistical_analysis: crate::benchmarking::StatisticalAnalysis {
                execution_time_stats: crate::benchmarking::DescriptiveStats {
                    mean: 1.0,
                    median: 1.0,
                    std_dev: 0.1,
                    variance: 0.01,
                    min: 0.8,
                    max: 1.2,
                    q25: 0.9,
                    q75: 1.1,
                    confidence_interval: (0.9, 1.1),
                },
                fidelity_stats: crate::benchmarking::DescriptiveStats {
                    mean: 0.95,
                    median: 0.95,
                    std_dev: 0.02,
                    variance: 0.0004,
                    min: 0.90,
                    max: 0.99,
                    q25: 0.93,
                    q75: 0.97,
                    confidence_interval: (0.93, 0.97),
                },
                error_rate_stats: crate::benchmarking::DescriptiveStats {
                    mean: 0.05,
                    median: 0.05,
                    std_dev: 0.01,
                    variance: 0.0001,
                    min: 0.01,
                    max: 0.10,
                    q25: 0.04,
                    q75: 0.06,
                    confidence_interval: (0.04, 0.06),
                },
                correlationmatrix: Array2::eye(3),
                statistical_tests: HashMap::new(),
                distribution_fits: HashMap::new(),
            },
            graph_analysis: None,
            noise_analysis: None,
            performance_metrics: crate::benchmarking::PerformanceMetrics {
                overall_score: 85.0,
                reliability_score: 90.0,
                speed_score: 80.0,
                accuracy_score: 85.0,
                efficiency_score: 85.0,
                scalability_metrics: crate::benchmarking::ScalabilityMetrics {
                    depth_scaling_coefficient: 1.2,
                    width_scaling_coefficient: 1.5,
                    resource_efficiency: 0.8,
                    parallelization_factor: 0.7,
                },
            },
            execution_time: Duration::from_secs(60),
        };
        let features = AdvancedHardwareBenchmarkSuite::extract_features(&base_results)
            .expect("Feature extraction should succeed");
        assert_eq!(features.nrows(), 0);
    }
}