use crate::error::{Result, SimulatorError};
use crate::statevector::StateVectorSimulator;
use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::Complex64;
use std::collections::HashMap;
use super::types::{
AlgorithmResourceStats, EnhancedPhaseEstimation, OptimizationLevel, OptimizedGroverAlgorithm,
OptimizedShorAlgorithm, QuantumAlgorithmConfig,
};
pub fn benchmark_quantum_algorithms() -> Result<HashMap<String, f64>> {
let mut results = HashMap::new();
let shor_start = std::time::Instant::now();
let config = QuantumAlgorithmConfig::default();
let mut shor = OptimizedShorAlgorithm::new(config)?;
let _shor_result = shor.factor(15)?;
results.insert(
"shor_15".to_string(),
shor_start.elapsed().as_secs_f64() * 1000.0,
);
let grover_start = std::time::Instant::now();
let config = QuantumAlgorithmConfig::default();
let mut grover = OptimizedGroverAlgorithm::new(config)?;
let oracle = |x: usize| x == 5 || x == 10;
let _grover_result = grover.search(4, oracle, 2)?;
results.insert(
"grover_4qubits".to_string(),
grover_start.elapsed().as_secs_f64() * 1000.0,
);
let qpe_start = std::time::Instant::now();
let config = QuantumAlgorithmConfig::default();
let mut qpe = EnhancedPhaseEstimation::new(config)?;
let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0), Complex64::new(0.0, 0.0)]);
let unitary = |sim: &mut StateVectorSimulator, target_qubit: usize| -> Result<()> {
sim.apply_z_public(target_qubit)?;
Ok(())
};
let _qpe_result = qpe.estimate_eigenvalues(unitary, &eigenstate, 1e-3)?;
results.insert(
"phase_estimation".to_string(),
qpe_start.elapsed().as_secs_f64() * 1000.0,
);
Ok(results)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_shor_algorithm_creation() {
let config = QuantumAlgorithmConfig::default();
let shor = OptimizedShorAlgorithm::new(config);
assert!(shor.is_ok());
}
#[test]
fn test_shor_trivial_cases() {
let config = QuantumAlgorithmConfig::default();
let mut shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let result = shor.factor(14).expect("Factoring 14 should succeed");
assert!(result.factors.contains(&2));
assert!(result.factors.contains(&7));
}
#[test]
fn test_grover_algorithm_creation() {
let config = QuantumAlgorithmConfig::default();
let grover = OptimizedGroverAlgorithm::new(config);
assert!(grover.is_ok());
}
#[test]
fn test_grover_optimal_iterations() {
let config = QuantumAlgorithmConfig::default();
let grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let num_items = 16;
let num_targets = 1;
let iterations = grover.calculate_optimal_iterations(num_items, num_targets);
assert!((3..=4).contains(&iterations));
}
#[test]
fn test_phase_estimation_creation() {
let config = QuantumAlgorithmConfig::default();
let qpe = EnhancedPhaseEstimation::new(config);
assert!(qpe.is_ok());
}
#[test]
fn test_continued_fractions() {
let config = QuantumAlgorithmConfig::default();
let _shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let convergents = OptimizedShorAlgorithm::continued_fractions(0.375, 100);
assert!(!convergents.is_empty());
assert!(convergents.iter().any(|&(num, den)| num == 3 && den == 8));
}
#[test]
fn test_modular_exponentiation() {
let config = QuantumAlgorithmConfig::default();
let _shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
assert_eq!(OptimizedShorAlgorithm::mod_exp(2, 3, 5), 3);
assert_eq!(OptimizedShorAlgorithm::mod_exp(3, 4, 7), 4);
}
#[test]
fn test_phase_estimation_simple() {
let config = QuantumAlgorithmConfig::default();
let mut qpe =
EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0), Complex64::new(0.0, 0.0)]);
let z_unitary =
|sim: &mut StateVectorSimulator, _target_qubit: usize| -> Result<()> { Ok(()) };
let result = qpe.estimate_eigenvalues(z_unitary, &eigenstate, 1e-2);
assert!(result.is_ok());
let qpe_result = result.expect("Phase estimation should succeed");
assert!(!qpe_result.eigenvalues.is_empty());
assert_eq!(qpe_result.eigenvalues.len(), qpe_result.precisions.len());
}
#[test]
fn test_grover_search_functionality() {
let config = QuantumAlgorithmConfig::default();
let mut grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let oracle = |x: usize| x == 3;
let result = grover.search(3, oracle, 1);
if let Err(e) = &result {
eprintln!("Grover search failed: {e:?}");
}
assert!(result.is_ok());
let grover_result = result.expect("Grover search should succeed");
assert_eq!(grover_result.iterations, grover_result.optimal_iterations);
assert!(grover_result.success_probability >= 0.0);
assert!(grover_result.success_probability <= 1.0);
}
#[test]
fn test_shor_algorithm_classical_cases() {
let config = QuantumAlgorithmConfig::default();
let mut shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let result = shor.factor(10).expect("Factoring 10 should succeed");
assert!(!result.factors.is_empty());
assert!(result.factors.contains(&2) || result.factors.contains(&5));
let result = shor.factor(7).expect("Factoring 7 should succeed");
if !result.factors.is_empty() {
let product: u64 = result.factors.iter().product();
assert_eq!(product, 7);
}
}
#[test]
fn test_quantum_algorithm_benchmarks() {
let benchmarks = benchmark_quantum_algorithms();
assert!(benchmarks.is_ok());
let results = benchmarks.expect("Benchmarks should succeed");
assert!(results.contains_key("shor_15"));
assert!(results.contains_key("grover_4qubits"));
assert!(results.contains_key("phase_estimation"));
for (algorithm, time) in results {
assert!(
time >= 0.0,
"Algorithm {algorithm} had negative execution time"
);
}
}
#[test]
fn test_grover_optimal_iterations_calculation() {
let config = QuantumAlgorithmConfig::default();
let grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
assert_eq!(grover.calculate_optimal_iterations(4, 1), 1);
assert_eq!(grover.calculate_optimal_iterations(16, 1), 3);
let iterations_64_1 = grover.calculate_optimal_iterations(64, 1);
assert!((6..=8).contains(&iterations_64_1));
}
#[test]
fn test_phase_estimation_precision_control() {
let config = QuantumAlgorithmConfig {
precision_tolerance: 1e-3,
..Default::default()
};
let mut qpe =
EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0)]);
let identity_op =
|_sim: &mut StateVectorSimulator, _target: usize| -> Result<()> { Ok(()) };
let result = qpe.estimate_eigenvalues(identity_op, &eigenstate, 1e-3);
assert!(result.is_ok());
let qpe_result = result.expect("Phase estimation should succeed");
assert!(qpe_result.precisions[0] <= 1e-3);
assert!(qpe_result.phase_qubits >= 3);
}
#[test]
fn test_grover_multiple_targets() {
let config = QuantumAlgorithmConfig::default();
let mut grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let oracle = |x: usize| x == 2 || x == 5;
let result = grover.search(3, oracle, 2);
assert!(result.is_ok());
let grover_result = result.expect("Grover search should succeed");
assert!(grover_result.success_probability >= 0.0);
assert!(grover_result.success_probability <= 1.0);
assert!(grover_result.iterations > 0);
}
#[test]
fn test_grover_four_qubits() {
let config = QuantumAlgorithmConfig::default();
let mut grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let oracle = |x: usize| x == 7;
let result = grover.search(4, oracle, 1);
assert!(result.is_ok());
let grover_result = result.expect("Grover search should succeed");
assert!(grover_result.resource_stats.qubits_used >= 4);
assert!(grover_result.iterations >= 2 && grover_result.iterations <= 5);
}
#[test]
fn test_shor_perfect_square() {
let config = QuantumAlgorithmConfig::default();
let mut shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let result = shor.factor(16).expect("Factoring 16 should succeed");
assert!(result.factors.contains(&4) || result.factors.contains(&2));
}
#[test]
fn test_shor_semiprime() {
let config = QuantumAlgorithmConfig::default();
let mut shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let result = shor.factor(15).expect("Factoring 15 should succeed");
assert!(result.execution_time_ms >= 0.0);
if !result.factors.is_empty() {
for &factor in &result.factors {
assert!(15 % factor == 0 || factor == 15);
}
}
}
#[test]
fn test_optimization_levels() {
let levels = vec![
OptimizationLevel::Basic,
OptimizationLevel::Memory,
OptimizationLevel::Speed,
OptimizationLevel::Hardware,
OptimizationLevel::Maximum,
];
for level in levels {
let config = QuantumAlgorithmConfig {
optimization_level: level,
..Default::default()
};
let grover = OptimizedGroverAlgorithm::new(config.clone());
assert!(grover.is_ok());
let shor = OptimizedShorAlgorithm::new(config.clone());
assert!(shor.is_ok());
let qpe = EnhancedPhaseEstimation::new(config);
assert!(qpe.is_ok());
}
}
#[test]
fn test_resource_stats() {
let config = QuantumAlgorithmConfig::default();
let mut shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let result = shor.factor(6).expect("Factoring 6 should succeed");
let stats = &result.resource_stats;
assert!(!result.factors.is_empty() || stats.qubits_used == 0);
}
#[test]
fn test_grover_resource_stats() {
let config = QuantumAlgorithmConfig::default();
let mut grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let oracle = |x: usize| x == 1;
let result = grover
.search(2, oracle, 1)
.expect("Grover search should succeed");
assert!(result.resource_stats.qubits_used > 0);
assert!(result.resource_stats.gate_count > 0);
}
#[test]
fn test_phase_estimation_resource_stats() {
let config = QuantumAlgorithmConfig::default();
let mut qpe =
EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0)]);
let identity_op =
|_sim: &mut StateVectorSimulator, _target: usize| -> Result<()> { Ok(()) };
let result = qpe
.estimate_eigenvalues(identity_op, &eigenstate, 1e-2)
.expect("Phase estimation should succeed");
assert!(result.resource_stats.qubits_used > 0);
}
#[test]
fn test_config_defaults() {
let config = QuantumAlgorithmConfig::default();
assert_eq!(config.optimization_level, OptimizationLevel::Maximum);
assert!(config.use_classical_preprocessing);
assert!(config.enable_error_mitigation);
assert_eq!(config.max_circuit_depth, 1000);
assert!((config.precision_tolerance - 1e-10).abs() < 1e-15);
assert!(config.enable_parallel);
}
#[test]
fn test_shor_result_structure() {
let config = QuantumAlgorithmConfig::default();
let mut shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let result = shor.factor(6).expect("Factoring 6 should succeed");
assert_eq!(result.n, 6);
assert!(result.execution_time_ms >= 0.0);
assert!(result.classical_preprocessing_ms >= 0.0);
assert!(result.quantum_computation_ms >= 0.0);
assert!(result.success_probability >= 0.0);
assert!(result.success_probability <= 1.0);
}
#[test]
fn test_grover_result_structure() {
let config = QuantumAlgorithmConfig::default();
let mut grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let oracle = |x: usize| x == 0;
let result = grover
.search(2, oracle, 1)
.expect("Grover search should succeed");
assert!(result.resource_stats.qubits_used > 0);
assert!(result.success_probability >= 0.0);
assert!(result.success_probability <= 1.0);
assert!(result.execution_time_ms >= 0.0);
}
#[test]
fn test_modular_exponentiation_edge_cases() {
let config = QuantumAlgorithmConfig::default();
let _shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
assert_eq!(OptimizedShorAlgorithm::mod_exp(1, 100, 7), 1);
assert_eq!(OptimizedShorAlgorithm::mod_exp(5, 0, 7), 1);
assert_eq!(OptimizedShorAlgorithm::mod_exp(2, 10, 1024), 0);
}
#[test]
fn test_continued_fractions_edge_cases() {
let config = QuantumAlgorithmConfig::default();
let _shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let convergents = OptimizedShorAlgorithm::continued_fractions(0.5, 10);
assert!(convergents.iter().any(|&(num, den)| num == 1 && den == 2));
let convergents = OptimizedShorAlgorithm::continued_fractions(1.0 / 3.0, 20);
assert!(convergents.iter().any(|&(num, den)| num == 1 && den == 3));
}
#[test]
fn test_grover_iterations_scaling() {
let config = QuantumAlgorithmConfig::default();
let grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let iter_8 = grover.calculate_optimal_iterations(8, 1);
let iter_32 = grover.calculate_optimal_iterations(32, 1);
let ratio = iter_32 as f64 / iter_8 as f64;
assert!((1.5..=2.5).contains(&ratio));
}
#[test]
fn test_error_mitigation_disabled() {
let config = QuantumAlgorithmConfig {
enable_error_mitigation: false,
..Default::default()
};
let mut grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let oracle = |x: usize| x == 1;
let result = grover.search(2, oracle, 1);
assert!(result.is_ok());
}
#[test]
fn test_parallel_disabled() {
let config = QuantumAlgorithmConfig {
enable_parallel: false,
..Default::default()
};
let mut shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
let result = shor.factor(6);
assert!(result.is_ok());
}
#[test]
fn test_algorithm_resource_stats_default() {
let stats = AlgorithmResourceStats::default();
assert_eq!(stats.qubits_used, 0);
assert_eq!(stats.gate_count, 0);
assert_eq!(stats.circuit_depth, 0);
assert_eq!(stats.cnot_count, 0);
assert_eq!(stats.t_gate_count, 0);
assert_eq!(stats.memory_usage_bytes, 0);
assert_eq!(stats.measurement_count, 0);
}
#[test]
fn test_shor_small_numbers() {
let config = QuantumAlgorithmConfig::default();
let mut shor =
OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
for n in [4, 6, 8, 9, 10, 12] {
let result = shor.factor(n);
assert!(result.is_ok(), "Failed to factor {n}");
}
}
#[test]
fn test_grover_single_qubit() {
let config = QuantumAlgorithmConfig::default();
let mut grover = OptimizedGroverAlgorithm::new(config)
.expect("Grover algorithm creation should succeed");
let oracle = |x: usize| x == 1;
let result = grover.search(1, oracle, 1);
assert!(result.is_ok());
}
}