quantrs2-anneal 0.1.3

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

use crate::applications::{ApplicationError, ApplicationResult};
use crate::ising::{IsingModel, QuboModel};
use std::collections::{BTreeMap, HashMap, VecDeque};
use std::time::{Duration, Instant, SystemTime};

use super::types::{
    AdaptiveQecConfig, CorrectionMetadata, DetectionAction, DetectionConfig, DetectionMethod,
    ErrorCorrectionStrategy, HierarchyConfig, MLNoiseConfig, NeuralArchitecture, NoiseAssessment,
    NoiseCharacteristics, NoisePrediction, NoiseSeverity, NoiseTrends, NoiseType,
    PerformanceAnalyzer, RealTimeAdaptiveQec, TrendDirection,
};

/// Create example real-time adaptive QEC system
pub fn create_example_adaptive_qec() -> ApplicationResult<RealTimeAdaptiveQec> {
    let config = AdaptiveQecConfig::default();
    let system = RealTimeAdaptiveQec::new(config);
    system.start()?;
    Ok(system)
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_adaptive_qec_creation() {
        let config = AdaptiveQecConfig::default();
        let system = RealTimeAdaptiveQec::new(config);
        assert_eq!(
            system.config.monitoring_interval,
            Duration::from_millis(100)
        );
    }
    #[test]
    fn test_noise_assessment() {
        let system = create_example_adaptive_qec().expect("Failed to create adaptive QEC system");
        let assessment = system
            .assess_noise_conditions()
            .expect("Failed to assess noise conditions");
        assert!(assessment.confidence > 0.0);
        assert!(assessment.confidence <= 1.0);
    }
    #[test]
    fn test_strategy_selection() {
        let system = create_example_adaptive_qec().expect("Failed to create adaptive QEC system");
        let problem = IsingModel::new(100);
        let noise_assessment = NoiseAssessment {
            current_noise: NoiseCharacteristics {
                timestamp: Instant::now(),
                noise_level: 0.005,
                noise_type: NoiseType::White,
                temporal_correlation: 0.1,
                spatial_correlation: 0.1,
                noise_spectrum: vec![0.005; 10],
                per_qubit_error_rates: vec![0.0005; 100],
                coherence_times: vec![50.0; 100],
                gate_fidelities: HashMap::new(),
            },
            severity: NoiseSeverity::Low,
            trends: NoiseTrends {
                direction: TrendDirection::Stable,
                rate: 0.001,
                confidence: 0.8,
            },
            confidence: 0.9,
            timestamp: Instant::now(),
        };
        let noise_prediction = NoisePrediction {
            predicted_noise: noise_assessment.current_noise.clone(),
            confidence: 0.85,
            horizon: Duration::from_secs(10),
            uncertainty_bounds: (0.003, 0.007),
        };
        let strategy = system
            .select_correction_strategy(&problem, &noise_assessment, &noise_prediction)
            .expect("Failed to select correction strategy");
        match &strategy {
            ErrorCorrectionStrategy::Detection(_) => assert!(true),
            ErrorCorrectionStrategy::Hybrid(_) => {
                assert!(false, "Got hybrid strategy instead of detection")
            }
            ErrorCorrectionStrategy::Correction(_) => {
                assert!(false, "Got correction strategy instead of detection")
            }
            _ => {
                assert!(
                    false,
                    "Expected detection strategy for low noise, got: {:?}",
                    strategy
                )
            }
        }
    }
    #[test]
    fn test_ml_config() {
        let ml_config = MLNoiseConfig::default();
        assert_eq!(ml_config.network_architecture, NeuralArchitecture::LSTM);
        assert_eq!(ml_config.training_window, 1000);
        assert!(ml_config.enable_neural_prediction);
    }
    #[test]
    fn test_hierarchy_config() {
        let hierarchy_config = HierarchyConfig::default();
        assert_eq!(hierarchy_config.num_levels, 3);
        assert_eq!(hierarchy_config.level_thresholds.len(), 3);
        assert!(hierarchy_config.enable_hierarchy);
    }
    #[test]
    fn test_performance_metrics_update() {
        let mut analyzer = PerformanceAnalyzer::new();
        let metadata = CorrectionMetadata {
            strategy_used: ErrorCorrectionStrategy::Detection(DetectionConfig {
                threshold: 0.01,
                method: DetectionMethod::Parity,
                action: DetectionAction::Flag,
            }),
            execution_time: Duration::from_millis(10),
            correction_overhead: 0.1,
            errors_detected: 5,
            errors_corrected: 4,
            confidence: 0.9,
        };
        let initial_efficiency = analyzer.metrics.correction_efficiency;
        analyzer.update_performance(&metadata);
        assert!(analyzer.metrics.correction_efficiency >= 0.0);
        assert!(analyzer.metrics.correction_efficiency <= 1.0);
    }
}