quantrs2-device 0.1.3

//! Performance analysis and validation for VQA
//!
//! This module provides comprehensive analysis tools for validating
//! and benchmarking variational quantum algorithms.

use super::{executor::VQAResult, objectives::ObjectiveResult};
use crate::DeviceResult;
use std::collections::HashMap;
use std::time::Duration;

/// Performance analysis configuration
#[derive(Debug, Clone)]
pub struct AnalysisConfig {
    /// Benchmark against classical methods
    pub benchmark_classical: bool,
    /// Analyze parameter landscapes
    pub landscape_analysis: bool,
    /// Statistical significance tests
    pub statistical_tests: bool,
}

impl Default for AnalysisConfig {
    fn default() -> Self {
        Self {
            benchmark_classical: true,
            landscape_analysis: false,
            statistical_tests: true,
        }
    }
}

/// Comprehensive analysis results
#[derive(Debug, Clone)]
pub struct AnalysisResult {
    /// Performance metrics
    pub performance: PerformanceMetrics,
    /// Convergence analysis
    pub convergence: ConvergenceAnalysis,
    /// Parameter landscape analysis
    pub landscape: Option<LandscapeAnalysis>,
    /// Classical benchmark comparison
    pub classical_comparison: Option<ClassicalComparison>,
}

/// Performance metrics
#[derive(Debug, Clone)]
pub struct PerformanceMetrics {
    /// Convergence rate
    pub convergence_rate: f64,
    /// Time to convergence
    pub time_to_convergence: Option<Duration>,
    /// Final accuracy
    pub final_accuracy: f64,
    /// Resource efficiency
    pub resource_efficiency: f64,
}

/// Convergence analysis
#[derive(Debug, Clone)]
pub struct ConvergenceAnalysis {
    /// Convergence achieved
    pub converged: bool,
    /// Convergence pattern
    pub pattern: ConvergencePattern,
    /// Stability metrics
    pub stability: f64,
}

/// Convergence patterns
#[derive(Debug, Clone)]
pub enum ConvergencePattern {
    /// Monotonic decrease
    Monotonic,
    /// Oscillatory but converging
    Oscillatory,
    /// Plateau reached
    Plateau,
    /// Divergent
    Divergent,
}

/// Parameter landscape analysis
#[derive(Debug, Clone)]
pub struct LandscapeAnalysis {
    /// Local minima detected
    pub local_minima: Vec<Vec<f64>>,
    /// Landscape roughness
    pub roughness: f64,
    /// Barrier heights
    pub barriers: Vec<f64>,
}

/// Classical benchmark comparison
#[derive(Debug, Clone)]
pub struct ClassicalComparison {
    /// Classical best result
    pub classical_best: f64,
    /// Quantum advantage factor
    pub quantum_advantage: f64,
    /// Resource comparison
    pub resource_ratio: f64,
}

/// Performance analyzer
#[derive(Debug)]
pub struct PerformanceAnalyzer {
    /// Configuration
    pub config: AnalysisConfig,
}

impl PerformanceAnalyzer {
    /// Create new performance analyzer
    pub const fn new(config: AnalysisConfig) -> Self {
        Self { config }
    }

    /// Analyze VQA performance
    pub fn analyze(&self, result: &VQAResult) -> DeviceResult<AnalysisResult> {
        let performance = self.analyze_performance(result)?;
        let convergence = self.analyze_convergence(result)?;

        let landscape = if self.config.landscape_analysis {
            Some(self.analyze_landscape(result)?)
        } else {
            None
        };

        let classical_comparison = if self.config.benchmark_classical {
            Some(self.benchmark_classical(result)?)
        } else {
            None
        };

        Ok(AnalysisResult {
            performance,
            convergence,
            landscape,
            classical_comparison,
        })
    }

    /// Analyze performance metrics
    fn analyze_performance(&self, result: &VQAResult) -> DeviceResult<PerformanceMetrics> {
        let convergence_rate = if result.history.len() > 1 {
            let initial = result.history[0];
            let final_val = result.history[result.history.len() - 1];
            (initial - final_val) / result.history.len() as f64
        } else {
            0.0
        };

        let time_to_convergence = if result.converged {
            Some(result.execution_time)
        } else {
            None
        };

        Ok(PerformanceMetrics {
            convergence_rate,
            time_to_convergence,
            final_accuracy: 1.0 - result.best_value.abs(),
            resource_efficiency: 1.0 / result.iterations as f64,
        })
    }

    /// Analyze convergence behavior
    fn analyze_convergence(&self, result: &VQAResult) -> DeviceResult<ConvergenceAnalysis> {
        let pattern = if result.history.len() < 2 {
            ConvergencePattern::Plateau
        } else {
            // Simple pattern detection
            let is_decreasing = result.history.windows(2).all(|w| w[1] <= w[0]);

            if is_decreasing {
                ConvergencePattern::Monotonic
            } else {
                ConvergencePattern::Oscillatory
            }
        };

        let stability = if result.history.len() > 10 {
            let last_10: Vec<f64> = result.history.iter().rev().take(10).copied().collect();
            let mean = last_10.iter().sum::<f64>() / last_10.len() as f64;
            let variance =
                last_10.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / last_10.len() as f64;
            1.0 / (1.0 + variance.sqrt())
        } else {
            0.5
        };

        Ok(ConvergenceAnalysis {
            converged: result.converged,
            pattern,
            stability,
        })
    }

    /// Analyze parameter landscape
    const fn analyze_landscape(&self, _result: &VQAResult) -> DeviceResult<LandscapeAnalysis> {
        // Simplified landscape analysis
        Ok(LandscapeAnalysis {
            local_minima: vec![],
            roughness: 0.5,
            barriers: vec![],
        })
    }

    /// Benchmark against classical methods
    fn benchmark_classical(&self, result: &VQAResult) -> DeviceResult<ClassicalComparison> {
        // Simple classical benchmark
        let classical_best = result.best_value * 1.1; // Assume classical is 10% worse
        let quantum_advantage = classical_best / result.best_value;

        Ok(ClassicalComparison {
            classical_best,
            quantum_advantage,
            resource_ratio: 1.0,
        })
    }
}