quantrs2_device/hybrid_quantum_classical/
functions.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5use crate::{
6    backend_traits::{query_backend_capabilities, BackendCapabilities},
7    calibration::{CalibrationManager, DeviceCalibration},
8    hardware_parallelization::{HardwareParallelizationEngine, ParallelizationConfig},
9    integrated_device_manager::{DeviceInfo, IntegratedQuantumDeviceManager},
10    job_scheduling::{JobPriority, QuantumJobScheduler, SchedulingStrategy},
11    translation::HardwareBackend,
12    vqa_support::{ObjectiveFunction, VQAConfig, VQAExecutor},
13    CircuitResult, DeviceError, DeviceResult,
14};
15use quantrs2_circuit::prelude::Circuit;
16use quantrs2_core::{
17    error::{QuantRS2Error, QuantRS2Result},
18    gate::GateOp,
19    qubit::QubitId,
20};
21use scirs2_core::ndarray::{Array1, Array2, ArrayView1, ArrayView2};
22#[cfg(feature = "scirs2")]
23use scirs2_graph::{dijkstra_path, minimum_spanning_tree, Graph};
24#[cfg(feature = "scirs2")]
25use scirs2_optimize::{differential_evolution, minimize, OptimizeResult};
26#[cfg(feature = "scirs2")]
27use scirs2_stats::{corrcoef, mean, pearsonr, spearmanr, std};
28use serde::{Deserialize, Serialize};
29use std::collections::{BTreeMap, HashMap, VecDeque};
30use std::sync::{Arc, Mutex, RwLock};
31use std::time::{Duration, Instant, SystemTime};
32use tokio::sync::{Mutex as AsyncMutex, RwLock as AsyncRwLock, Semaphore};
33
34use super::types::*;
35// Explicitly use our local HybridOptimizer to avoid ambiguity with quantrs2_circuit
36use super::types::HybridOptimizer as LocalHybridOptimizer;
37// Re-export for tests with explicit name
38use LocalHybridOptimizer as HybridOptimizer;
39/// Recovery strategy trait
40pub trait RecoveryStrategy {
41    fn can_handle(&self, error: &DeviceError) -> bool;
42    fn recover(
43        &self,
44        error: &DeviceError,
45        context: &HashMap<String, String>,
46    ) -> DeviceResult<RecoveryAction>;
47}
48#[cfg(test)]
49mod tests {
50    use super::*;
51    #[test]
52    fn test_hybrid_loop_config_default() {
53        let config = HybridLoopConfig::default();
54        assert_eq!(config.strategy, HybridLoopStrategy::VariationalOptimization);
55        assert_eq!(config.optimization_config.optimizer, HybridOptimizer::Adam);
56        assert!(config.optimization_config.enable_scirs2_optimization);
57    }
58    #[test]
59    fn test_convergence_criteria() {
60        let criteria = vec![
61            ConvergenceCriterion::ValueTolerance(1e-6),
62            ConvergenceCriterion::MaxIterations(1000),
63        ];
64        for criterion in criteria {
65            match criterion {
66                ConvergenceCriterion::ValueTolerance(tol) => assert!(tol > 0.0),
67                ConvergenceCriterion::MaxIterations(max_iter) => assert!(max_iter > 0),
68                _ => {}
69            }
70        }
71    }
72    #[test]
73    fn test_hybrid_optimizer_types() {
74        let optimizers = [
75            HybridOptimizer::Adam,
76            HybridOptimizer::GradientDescent,
77            HybridOptimizer::SPSA,
78            HybridOptimizer::SciRS2Optimized,
79        ];
80        assert_eq!(optimizers.len(), 4);
81        assert!(optimizers.contains(&HybridOptimizer::Adam));
82        assert!(optimizers.contains(&HybridOptimizer::GradientDescent));
83        assert!(optimizers.contains(&HybridOptimizer::SPSA));
84        assert!(optimizers.contains(&HybridOptimizer::SciRS2Optimized));
85    }
86    #[test]
87    fn test_hybrid_executor_creation() {
88        let config = HybridLoopConfig::default();
89        let devices = HashMap::new();
90        let cal_mgr = crate::calibration::CalibrationManager::new();
91        let device_manager = Arc::new(RwLock::new(
92            crate::integrated_device_manager::IntegratedQuantumDeviceManager::new(
93                Default::default(),
94                devices,
95                cal_mgr.clone(),
96            )
97            .expect("Failed to create IntegratedQuantumDeviceManager in test"),
98        ));
99        let calibration_manager = Arc::new(RwLock::new(cal_mgr));
100        let parallelization_engine = Arc::new(
101            crate::hardware_parallelization::HardwareParallelizationEngine::new(
102                Default::default(),
103                device_manager.clone(),
104                calibration_manager.clone(),
105                Arc::new(RwLock::new(
106                    crate::routing_advanced::AdvancedQubitRouter::new(
107                        Default::default(),
108                        crate::routing_advanced::AdvancedRoutingStrategy::Hybrid,
109                        42,
110                    ),
111                )),
112            ),
113        );
114        let scheduler = Arc::new(crate::job_scheduling::QuantumJobScheduler::new(
115            Default::default(),
116        ));
117        {
118            let _executor = HybridQuantumClassicalExecutor::new(
119                config,
120                device_manager,
121                calibration_manager,
122                parallelization_engine,
123                scheduler,
124            );
125        }
126    }
127}
quantrs2_device/hybrid_quantum_classical/functions.rs

quantrs2_device/hybrid_quantum_classical/
functions.rs
