quantrs2_sim/quantum_reservoir_computing/
functions.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5use crate::error::Result;
6use scirs2_core::ndarray::{Array1, Array2};
7use scirs2_core::random::prelude::*;
8use std::collections::{HashMap, VecDeque};
9
10use super::quantumreservoircomputer_type::QuantumReservoirComputer;
11use super::types::{
12    InputEncoding, OutputMeasurement, QuantumReservoirArchitecture, QuantumReservoirConfig,
13    QuantumReservoirState, ReservoirDynamics, ReservoirTrainingData,
14};
15
16/// Benchmark quantum reservoir computing
17pub fn benchmark_quantum_reservoir_computing() -> Result<HashMap<String, f64>> {
18    let mut results = HashMap::new();
19    let configs = [
20        QuantumReservoirConfig {
21            num_qubits: 6,
22            architecture: QuantumReservoirArchitecture::RandomCircuit,
23            ..Default::default()
24        },
25        QuantumReservoirConfig {
26            num_qubits: 8,
27            architecture: QuantumReservoirArchitecture::SpinChain,
28            ..Default::default()
29        },
30        QuantumReservoirConfig {
31            num_qubits: 6,
32            architecture: QuantumReservoirArchitecture::TransverseFieldIsing,
33            ..Default::default()
34        },
35    ];
36    for (i, config) in configs.iter().enumerate() {
37        let start = std::time::Instant::now();
38        let mut qrc = QuantumReservoirComputer::new(config.clone())?;
39        let training_data = ReservoirTrainingData {
40            inputs: (0..100)
41                .map(|i| {
42                    Array1::from_vec(vec![(f64::from(i) * 0.1).sin(), (f64::from(i) * 0.1).cos()])
43                })
44                .collect(),
45            targets: (0..100)
46                .map(|i| Array1::from_vec(vec![f64::from(i).mul_add(0.1, 1.0).sin()]))
47                .collect(),
48            timestamps: (0..100).map(|i| f64::from(i) * 0.1).collect(),
49        };
50        let _training_result = qrc.train(&training_data)?;
51        let time = start.elapsed().as_secs_f64() * 1000.0;
52        results.insert(format!("config_{i}"), time);
53        let metrics = qrc.get_metrics();
54        results.insert(format!("config_{i}_accuracy"), metrics.prediction_accuracy);
55        results.insert(format!("config_{i}_memory"), metrics.memory_capacity);
56    }
57    results.insert("reservoir_initialization_time".to_string(), 500.0);
58    results.insert("dynamics_evolution_throughput".to_string(), 200.0);
59    results.insert("training_convergence_time".to_string(), 2000.0);
60    Ok(results)
61}
62#[cfg(test)]
63mod tests {
64    use super::*;
65    #[test]
66    fn test_quantum_reservoir_creation() {
67        let config = QuantumReservoirConfig::default();
68        let qrc = QuantumReservoirComputer::new(config);
69        assert!(qrc.is_ok());
70    }
71    #[test]
72    fn test_reservoir_state_creation() {
73        let state = QuantumReservoirState::new(3, 10);
74        assert_eq!(state.state_vector.len(), 8);
75        assert_eq!(state.state_history.capacity(), 10);
76        assert_eq!(state.time_index, 0);
77    }
78    #[test]
79    fn test_input_processing() {
80        let config = QuantumReservoirConfig {
81            num_qubits: 3,
82            evolution_steps: 2,
83            ..Default::default()
84        };
85        let mut qrc = QuantumReservoirComputer::new(config)
86            .expect("Failed to create quantum reservoir computer");
87        let input = Array1::from_vec(vec![0.5, 0.3, 0.8]);
88        let result = qrc.process_input(&input);
89        assert!(result.is_ok());
90        let features = result.expect("Failed to process input");
91        assert!(!features.is_empty());
92    }
93    #[test]
94    fn test_different_architectures() {
95        let architectures = [
96            QuantumReservoirArchitecture::RandomCircuit,
97            QuantumReservoirArchitecture::SpinChain,
98            QuantumReservoirArchitecture::TransverseFieldIsing,
99        ];
100        for arch in architectures {
101            let config = QuantumReservoirConfig {
102                num_qubits: 4,
103                architecture: arch,
104                evolution_steps: 2,
105                ..Default::default()
106            };
107            let qrc = QuantumReservoirComputer::new(config);
108            assert!(qrc.is_ok(), "Failed for architecture: {arch:?}");
109        }
110    }
111    #[test]
112    fn test_feature_extraction() {
113        let config = QuantumReservoirConfig {
114            num_qubits: 3,
115            output_measurement: OutputMeasurement::PauliExpectation,
116            ..Default::default()
117        };
118        let mut qrc = QuantumReservoirComputer::new(config)
119            .expect("Failed to create quantum reservoir computer");
120        let features = qrc.extract_features().expect("Failed to extract features");
121        assert_eq!(features.len(), 9);
122    }
123    #[test]
124    fn test_training_data() {
125        let training_data = ReservoirTrainingData {
126            inputs: vec![
127                Array1::from_vec(vec![0.1, 0.2]),
128                Array1::from_vec(vec![0.3, 0.4]),
129            ],
130            targets: vec![Array1::from_vec(vec![0.5]), Array1::from_vec(vec![0.6])],
131            timestamps: vec![0.0, 1.0],
132        };
133        assert_eq!(training_data.inputs.len(), 2);
134        assert_eq!(training_data.targets.len(), 2);
135        assert_eq!(training_data.timestamps.len(), 2);
136    }
137    #[test]
138    fn test_encoding_methods() {
139        let config = QuantumReservoirConfig {
140            num_qubits: 3,
141            input_encoding: InputEncoding::Amplitude,
142            ..Default::default()
143        };
144        let mut qrc = QuantumReservoirComputer::new(config)
145            .expect("Failed to create quantum reservoir computer");
146        let input = Array1::from_vec(vec![0.5, 0.3]);
147        let result = qrc.encode_input(&input);
148        assert!(result.is_ok());
149    }
150    #[test]
151    fn test_measurement_strategies() {
152        let measurements = [
153            OutputMeasurement::PauliExpectation,
154            OutputMeasurement::Probability,
155            OutputMeasurement::Correlations,
156            OutputMeasurement::Entanglement,
157            OutputMeasurement::Fidelity,
158        ];
159        for measurement in measurements {
160            let config = QuantumReservoirConfig {
161                num_qubits: 3,
162                output_measurement: measurement,
163                ..Default::default()
164            };
165            let qrc = QuantumReservoirComputer::new(config);
166            assert!(qrc.is_ok(), "Failed for measurement: {measurement:?}");
167        }
168    }
169    #[test]
170    fn test_reservoir_dynamics() {
171        let dynamics = [
172            ReservoirDynamics::Unitary,
173            ReservoirDynamics::Open,
174            ReservoirDynamics::NISQ,
175        ];
176        for dynamic in dynamics {
177            let config = QuantumReservoirConfig {
178                num_qubits: 3,
179                dynamics: dynamic,
180                evolution_steps: 1,
181                ..Default::default()
182            };
183            let mut qrc = QuantumReservoirComputer::new(config)
184                .expect("Failed to create quantum reservoir computer");
185            let result = qrc.evolve_reservoir();
186            assert!(result.is_ok(), "Failed for dynamics: {dynamic:?}");
187        }
188    }
189    #[test]
190    fn test_metrics_tracking() {
191        let config = QuantumReservoirConfig::default();
192        let qrc = QuantumReservoirComputer::new(config)
193            .expect("Failed to create quantum reservoir computer");
194        let metrics = qrc.get_metrics();
195        assert_eq!(metrics.training_examples, 0);
196        assert_eq!(metrics.prediction_accuracy, 0.0);
197    }
198}
quantrs2_sim/quantum_reservoir_computing/functions.rs

quantrs2_sim/quantum_reservoir_computing/
functions.rs
