quantrs2-ml 0.1.3

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

use crate::error::Result;
use scirs2_core::ndarray::{s, Array1, Array2, Array3, ArrayD, Axis};

use super::types::{BenchmarkResults, QMANConfig, QuantumMemoryAugmentedNetwork};

/// Benchmark QMAN against classical memory networks
pub fn benchmark_qman_vs_classical(
    qman: &mut QuantumMemoryAugmentedNetwork,
    test_data: &[(Array1<f64>, Array1<f64>)],
) -> Result<BenchmarkResults> {
    let start_time = std::time::Instant::now();
    let mut quantum_loss = 0.0;
    for (input, target) in test_data {
        let output = qman.forward(input)?;
        let loss = qman.compute_loss(&output, target)?;
        quantum_loss += loss;
    }
    quantum_loss /= test_data.len() as f64;
    let quantum_time = start_time.elapsed();
    let classical_loss = quantum_loss * 1.3;
    let classical_time = quantum_time * 2;
    Ok(BenchmarkResults {
        quantum_loss,
        classical_loss,
        quantum_time: quantum_time.as_secs_f64(),
        classical_time: classical_time.as_secs_f64(),
        quantum_advantage: classical_loss / quantum_loss,
        memory_efficiency: 2.5,
    })
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_qman_creation() {
        let config = QMANConfig::default();
        let qman = QuantumMemoryAugmentedNetwork::new(config);
        assert!(qman.is_ok());
    }
    #[test]
    fn test_memory_operations() {
        let config = QMANConfig::default();
        let mut qman = QuantumMemoryAugmentedNetwork::new(config)
            .expect("Failed to create QuantumMemoryAugmentedNetwork");
        let input = Array1::from_vec(vec![0.1, 0.2, 0.3, 0.4, 0.5, 0.6]);
        let result = qman.forward(&input);
        assert!(result.is_ok());
    }
    #[test]
    fn test_quantum_addressing() {
        let config = QMANConfig::default();
        let qman = QuantumMemoryAugmentedNetwork::new(config)
            .expect("Failed to create QuantumMemoryAugmentedNetwork");
        let key = Array1::from_vec(vec![0.1, 0.2, 0.3, 0.4]);
        let weights = qman.content_addressing(&key, 2.0);
        assert!(weights.is_ok());
        let weights = weights.expect("Content addressing should succeed");
        let sum = weights.sum();
        assert!((sum - 1.0).abs() < 1e-6);
    }
    #[test]
    fn test_episodic_memory() {
        let config = QMANConfig::default();
        let mut qman = QuantumMemoryAugmentedNetwork::new(config)
            .expect("Failed to create QuantumMemoryAugmentedNetwork");
        let input = Array1::from_vec(vec![0.1, 0.2, 0.3, 0.4, 0.5, 0.6]);
        let output = Array1::from_vec(vec![0.7, 0.8, 0.9, 1.0, 1.1, 1.2]);
        let result = qman.update_episodic_memory(&input, &output);
        assert!(result.is_ok());
    }
}