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

//! Analytics engine and analysis components

pub mod anomaly;
pub mod causal;
pub mod correlation;
pub mod distribution;
pub mod statistical;
pub mod time_series;

use super::config::AdvancedAnalyticsConfig;
use super::results::*;
use crate::DeviceResult;

/// Advanced analytics engine for mid-circuit measurements
pub struct AdvancedAnalyticsEngine {
    config: AdvancedAnalyticsConfig,
    statistical_analyzer: statistical::StatisticalAnalyzer,
    correlation_analyzer: correlation::CorrelationAnalyzer,
    time_series_analyzer: Option<time_series::TimeSeriesAnalyzer>,
    anomaly_detector: Option<anomaly::AnomalyDetector>,
    distribution_analyzer: distribution::DistributionAnalyzer,
    causal_analyzer: Option<causal::CausalAnalyzer>,
}

impl AdvancedAnalyticsEngine {
    /// Create new analytics engine
    pub fn new(config: &AdvancedAnalyticsConfig) -> Self {
        Self {
            config: config.clone(),
            statistical_analyzer: statistical::StatisticalAnalyzer::new(),
            correlation_analyzer: correlation::CorrelationAnalyzer::new(),
            time_series_analyzer: if config.enable_time_series {
                Some(time_series::TimeSeriesAnalyzer::new())
            } else {
                None
            },
            anomaly_detector: if config.enable_anomaly_detection {
                Some(anomaly::AnomalyDetector::new())
            } else {
                None
            },
            distribution_analyzer: distribution::DistributionAnalyzer::new(),
            causal_analyzer: if config.enable_causal_inference {
                Some(causal::CausalAnalyzer::new())
            } else {
                None
            },
        }
    }

    /// Perform comprehensive analytics
    pub async fn analyze(
        &self,
        measurement_history: &[MeasurementEvent],
        execution_stats: &ExecutionStats,
    ) -> DeviceResult<AdvancedAnalyticsResults> {
        // Extract measurement data for analysis
        let latencies: Vec<f64> = measurement_history.iter().map(|e| e.latency).collect();
        let confidences: Vec<f64> = measurement_history.iter().map(|e| e.confidence).collect();
        let timestamps: Vec<f64> = measurement_history.iter().map(|e| e.timestamp).collect();

        // Statistical analysis
        let statistical_analysis = self
            .statistical_analyzer
            .analyze(&latencies, &confidences)?;

        // Correlation analysis
        let correlation_analysis =
            self.correlation_analyzer
                .analyze(&latencies, &confidences, &timestamps)?;

        // Time series analysis (if enabled)
        let time_series_analysis = if let Some(ref analyzer) = self.time_series_analyzer {
            Some(analyzer.analyze(&latencies, &timestamps)?)
        } else {
            None
        };

        // Anomaly detection (if enabled)
        let anomaly_detection = if let Some(ref detector) = self.anomaly_detector {
            Some(detector.detect(&latencies, &confidences)?)
        } else {
            None
        };

        // Distribution analysis
        let distribution_analysis = self.distribution_analyzer.analyze(&latencies)?;

        // Causal analysis (if enabled)
        let causal_analysis = if let Some(ref analyzer) = self.causal_analyzer {
            Some(analyzer.analyze(&latencies, &confidences, &timestamps)?)
        } else {
            None
        };

        Ok(AdvancedAnalyticsResults {
            statistical_analysis,
            correlation_analysis,
            time_series_analysis,
            anomaly_detection,
            distribution_analysis,
            causal_analysis,
        })
    }
}