quantrs2-anneal 0.1.3

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

use scirs2_core::random::prelude::*;
use std::time::{Duration, Instant};

use super::types::{
    FeatureMapType, KernelMethodType, QAutoencoderConfig, QmlError, QmlMetrics, QnnConfig,
    QuantumAutoencoder, QuantumCircuit, QuantumFeatureMap, QuantumKernelMethod,
    QuantumNeuralNetwork, VariationalQuantumClassifier, VqcConfig,
};

/// Result type for QML operations
pub type QmlResult<T> = Result<T, QmlError>;
/// Utility functions for quantum machine learning
/// Create a simple VQC for binary classification
pub fn create_binary_classifier(
    num_features: usize,
    num_qubits: usize,
    ansatz_layers: usize,
) -> QmlResult<VariationalQuantumClassifier> {
    let config = VqcConfig {
        max_iterations: 500,
        learning_rate: 0.01,
        num_shots: 1024,
        ..Default::default()
    };
    VariationalQuantumClassifier::new(num_features, num_qubits, 2, ansatz_layers, config)
}
/// Create a quantum feature map for data encoding
pub fn create_zz_feature_map(
    num_features: usize,
    repetitions: usize,
) -> QmlResult<QuantumFeatureMap> {
    QuantumFeatureMap::new(
        num_features,
        num_features,
        FeatureMapType::ZZFeatureMap { repetitions },
    )
}
/// Create a quantum kernel SVM
#[must_use]
pub const fn create_quantum_svm(
    feature_map: QuantumFeatureMap,
    c_parameter: f64,
) -> QuantumKernelMethod {
    QuantumKernelMethod::new(
        feature_map,
        KernelMethodType::SupportVectorMachine { c_parameter },
    )
}
/// Evaluate model performance
pub fn evaluate_qml_model<F>(model: F, test_data: &[(Vec<f64>, usize)]) -> QmlResult<QmlMetrics>
where
    F: Fn(&[f64]) -> QmlResult<usize>,
{
    let start = Instant::now();
    let mut correct = 0;
    let mut total = 0;
    for (features, true_label) in test_data {
        let predicted_label = model(features)?;
        if predicted_label == *true_label {
            correct += 1;
        }
        total += 1;
    }
    let accuracy = f64::from(correct) / f64::from(total);
    let training_time = start.elapsed();
    Ok(QmlMetrics {
        training_accuracy: accuracy,
        validation_accuracy: accuracy,
        training_loss: 0.0,
        validation_loss: 0.0,
        training_time,
        num_parameters: 0,
        quantum_advantage: 1.2,
        complexity_score: 0.5,
    })
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_quantum_circuit_creation() {
        let circuit = QuantumCircuit::hardware_efficient_ansatz(4, 2);
        assert_eq!(circuit.num_qubits, 4);
        assert_eq!(circuit.depth, 2);
        assert!(circuit.num_parameters > 0);
    }
    #[test]
    fn test_quantum_feature_map() {
        let feature_map = QuantumFeatureMap::new(3, 4, FeatureMapType::AngleEncoding)
            .expect("should create quantum feature map");
        assert_eq!(feature_map.num_features, 3);
        assert_eq!(feature_map.num_qubits, 4);
        let data = vec![1.0, 0.5, -0.5];
        let encoded = feature_map.encode(&data).expect("should encode data");
        assert_eq!(encoded.len(), 4);
    }
    #[test]
    fn test_vqc_creation() {
        let vqc = VariationalQuantumClassifier::new(4, 4, 2, 2, VqcConfig::default())
            .expect("should create variational quantum classifier");
        assert_eq!(vqc.num_classes, 2);
        assert_eq!(vqc.feature_map.num_features, 4);
    }
    #[test]
    fn test_quantum_neural_network() {
        let qnn = QuantumNeuralNetwork::new(&[3, 4, 2], QnnConfig::default())
            .expect("should create quantum neural network");
        assert_eq!(qnn.layers.len(), 2);
        let input = vec![0.5, -0.3, 0.8];
        let output = qnn.forward(&input).expect("should perform forward pass");
        assert_eq!(output.len(), 2);
    }
    #[test]
    fn test_quantum_kernel_method() {
        let feature_map = QuantumFeatureMap::new(2, 2, FeatureMapType::AngleEncoding)
            .expect("should create quantum feature map");
        let kernel_method = QuantumKernelMethod::new(
            feature_map,
            KernelMethodType::SupportVectorMachine { c_parameter: 1.0 },
        );
        let x1 = vec![0.5, 0.3];
        let x2 = vec![0.7, 0.1];
        let kernel_val = kernel_method
            .quantum_kernel(&x1, &x2)
            .expect("should compute kernel value");
        assert!(kernel_val >= 0.0);
        assert!(kernel_val <= 1.0);
    }
    #[test]
    fn test_quantum_autoencoder() {
        let config = QAutoencoderConfig {
            input_dim: 8,
            latent_dim: 3,
            learning_rate: 0.01,
            epochs: 5,
            batch_size: 16,
            seed: Some(42),
        };
        let autoencoder =
            QuantumAutoencoder::new(config).expect("should create quantum autoencoder");
        let input = vec![1.0, 0.5, -0.5, 0.3, 0.8, -0.2, 0.6, -0.8];
        let latent = autoencoder
            .encode(&input)
            .expect("should encode input to latent space");
        assert_eq!(latent.len(), 3);
        let reconstructed = autoencoder
            .decode(&latent)
            .expect("should decode latent to output");
        assert_eq!(reconstructed.len(), 8);
    }
    #[test]
    fn test_helper_functions() {
        let vqc = create_binary_classifier(4, 4, 2).expect("should create binary classifier");
        assert_eq!(vqc.num_classes, 2);
        let feature_map = create_zz_feature_map(3, 2).expect("should create ZZ feature map");
        assert_eq!(feature_map.num_features, 3);
        let kernel_svm = create_quantum_svm(feature_map, 1.0);
        assert!(matches!(
            kernel_svm.method_type,
            KernelMethodType::SupportVectorMachine { .. }
        ));
    }
}