quantrs2-device 0.1.3

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

use crate::{
    backend_traits::{query_backend_capabilities, BackendCapabilities},
    calibration::{CalibrationManager, DeviceCalibration},
    hardware_parallelization::{HardwareParallelizationEngine, ParallelizationConfig},
    integrated_device_manager::{DeviceInfo, IntegratedQuantumDeviceManager},
    job_scheduling::{JobPriority, QuantumJobScheduler, SchedulingStrategy},
    translation::HardwareBackend,
    vqa_support::{ObjectiveFunction, VQAConfig, VQAExecutor},
    CircuitResult, DeviceError, DeviceResult,
};
use quantrs2_circuit::prelude::Circuit;
use quantrs2_core::{
    error::{QuantRS2Error, QuantRS2Result},
    gate::GateOp,
    qubit::QubitId,
};
use scirs2_core::ndarray::{Array1, Array2, ArrayView1, ArrayView2};
#[cfg(feature = "scirs2")]
use scirs2_graph::{dijkstra_path, minimum_spanning_tree, Graph};
#[cfg(feature = "scirs2")]
use scirs2_optimize::{differential_evolution, minimize, OptimizeResult};
#[cfg(feature = "scirs2")]
use scirs2_stats::{corrcoef, mean, pearsonr, spearmanr, std};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap, VecDeque};
use std::sync::{Arc, Mutex, RwLock};
use std::time::{Duration, Instant, SystemTime};
use tokio::sync::{Mutex as AsyncMutex, RwLock as AsyncRwLock, Semaphore};

use super::types::*;
// Explicitly use our local HybridOptimizer to avoid ambiguity with quantrs2_circuit
use super::types::HybridOptimizer as LocalHybridOptimizer;
// Re-export for tests with explicit name
use LocalHybridOptimizer as HybridOptimizer;
/// Recovery strategy trait
pub trait RecoveryStrategy {
    fn can_handle(&self, error: &DeviceError) -> bool;
    fn recover(
        &self,
        error: &DeviceError,
        context: &HashMap<String, String>,
    ) -> DeviceResult<RecoveryAction>;
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_hybrid_loop_config_default() {
        let config = HybridLoopConfig::default();
        assert_eq!(config.strategy, HybridLoopStrategy::VariationalOptimization);
        assert_eq!(config.optimization_config.optimizer, HybridOptimizer::Adam);
        assert!(config.optimization_config.enable_scirs2_optimization);
    }
    #[test]
    fn test_convergence_criteria() {
        let criteria = vec![
            ConvergenceCriterion::ValueTolerance(1e-6),
            ConvergenceCriterion::MaxIterations(1000),
        ];
        for criterion in criteria {
            match criterion {
                ConvergenceCriterion::ValueTolerance(tol) => assert!(tol > 0.0),
                ConvergenceCriterion::MaxIterations(max_iter) => assert!(max_iter > 0),
                _ => {}
            }
        }
    }
    #[test]
    fn test_hybrid_optimizer_types() {
        let optimizers = [
            HybridOptimizer::Adam,
            HybridOptimizer::GradientDescent,
            HybridOptimizer::SPSA,
            HybridOptimizer::SciRS2Optimized,
        ];
        assert_eq!(optimizers.len(), 4);
        assert!(optimizers.contains(&HybridOptimizer::Adam));
        assert!(optimizers.contains(&HybridOptimizer::GradientDescent));
        assert!(optimizers.contains(&HybridOptimizer::SPSA));
        assert!(optimizers.contains(&HybridOptimizer::SciRS2Optimized));
    }
    #[test]
    fn test_hybrid_executor_creation() {
        let config = HybridLoopConfig::default();
        let devices = HashMap::new();
        let cal_mgr = crate::calibration::CalibrationManager::new();
        let device_manager = Arc::new(RwLock::new(
            crate::integrated_device_manager::IntegratedQuantumDeviceManager::new(
                Default::default(),
                devices,
                cal_mgr.clone(),
            )
            .expect("Failed to create IntegratedQuantumDeviceManager in test"),
        ));
        let calibration_manager = Arc::new(RwLock::new(cal_mgr));
        let parallelization_engine = Arc::new(
            crate::hardware_parallelization::HardwareParallelizationEngine::new(
                Default::default(),
                device_manager.clone(),
                calibration_manager.clone(),
                Arc::new(RwLock::new(
                    crate::routing_advanced::AdvancedQubitRouter::new(
                        Default::default(),
                        crate::routing_advanced::AdvancedRoutingStrategy::Hybrid,
                        42,
                    ),
                )),
            ),
        );
        let scheduler = Arc::new(crate::job_scheduling::QuantumJobScheduler::new(
            Default::default(),
        ));
        {
            let _executor = HybridQuantumClassicalExecutor::new(
                config,
                device_manager,
                calibration_manager,
                parallelization_engine,
                scheduler,
            );
        }
    }
}