scirs2-fft 0.4.2

//! Performance optimization engine for FFT operations

use super::types::*;
use crate::error::FFTResult;
use scirs2_core::numeric::Float;
use std::collections::{HashMap, VecDeque};
use std::fmt::Debug;
use std::time::Instant;

/// Performance optimization engine
#[derive(Debug)]
#[allow(dead_code)]
pub struct PerformanceOptimizationEngine<F: Float + Debug> {
    /// Current optimization strategy
    pub(crate) strategy: OptimizationStrategy,
    /// Performance targets
    pub(crate) targets: PerformanceTargets,
    /// Adaptive parameters
    pub adaptive_params: AdaptiveParameters<F>,
    /// Optimization history
    pub(crate) optimization_history: VecDeque<OptimizationResult>,
}

/// Performance targets
#[derive(Debug, Clone, Default)]
pub struct PerformanceTargets {
    /// Maximum acceptable execution time (microseconds)
    pub max_execution_time: Option<f64>,
    /// Maximum memory usage (bytes)
    pub max_memory_usage: Option<usize>,
    /// Minimum accuracy requirement
    pub min_accuracy: Option<f64>,
    /// Maximum energy consumption
    pub max_energy: Option<f64>,
}

/// Adaptive parameters for optimization
#[derive(Debug, Clone)]
pub struct AdaptiveParameters<F: Float> {
    /// Learning rate for parameter updates
    pub learning_rate: F,
    /// Momentum for parameter updates
    pub momentum: F,
    /// Decay rate for historical data
    pub decay_rate: F,
    /// Exploration rate for new algorithms
    pub exploration_rate: F,
}

impl<F: Float> Default for AdaptiveParameters<F> {
    fn default() -> Self {
        Self {
            learning_rate: F::from(0.01).expect("Failed to convert constant to float"),
            momentum: F::from(0.9).expect("Failed to convert constant to float"),
            decay_rate: F::from(0.99).expect("Failed to convert constant to float"),
            exploration_rate: F::from(0.1).expect("Failed to convert constant to float"),
        }
    }
}

/// Result of optimization attempt
#[derive(Debug, Clone)]
pub struct OptimizationResult {
    /// Algorithm that was optimized
    pub algorithm: FftAlgorithmType,
    /// Parameters that were adjusted
    pub adjusted_parameters: HashMap<String, f64>,
    /// Performance improvement achieved
    pub improvement: f64,
    /// Success/failure status
    pub success: bool,
    /// Timestamp
    pub timestamp: Instant,
}

impl<F: Float + Debug> PerformanceOptimizationEngine<F> {
    pub fn new() -> FFTResult<Self> {
        Ok(Self {
            strategy: OptimizationStrategy::Balanced,
            targets: PerformanceTargets::default(),
            adaptive_params: AdaptiveParameters::default(),
            optimization_history: VecDeque::new(),
        })
    }
}