optirs-learned 0.3.1

// Advanced Coordinator for Advanced AI Optimization
//
// This module implements the Advanced mode coordinator that orchestrates
// multiple advanced AI optimization techniques including learned optimizers,
// neural architecture search, few-shot learning, and adaptive strategies.

pub mod config;
pub mod ensemble;
pub mod orchestrator;
pub mod performance_prediction;
pub mod resource_management;
pub mod adaptation;
pub mod knowledge_base;
pub mod state;
pub mod analytics;
pub mod integration;

// Re-export main types for backward compatibility
pub use config::*;
pub use ensemble::*;
pub use orchestrator::*;
pub use performance_prediction::*;
pub use resource_management::*;
pub use adaptation::*;
pub use knowledge_base::*;
pub use state::{OptimizationContext, OptimizationState, ProblemCharacteristics, ResourceConstraints, TimeConstraints, OptimizationPhase, LandscapeFeatures, ComputationalBudget, ConvergenceCriteria};
pub use analytics::{PerformanceAnalyzer, PerformanceSnapshot, PerformanceMetrics, PerformanceContext};
pub use analytics::performance::ResourceUsage;
pub use integration::*;

use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::numeric::Float;
use std::collections::{HashMap, VecDeque};
use std::fmt::Debug;
use std::time::{Duration, Instant, SystemTime};

use super::{
    adaptive_transformer_enhancement::{AdaptiveConfig, AdaptiveTransformerEnhancement},
    few_shot_learning_enhancement::{DistributionModel, FewShotConfig, FewShotLearningEnhancement},
    neural_architecture_search::{ArchitectureSearchSpace, NASConfig, NeuralArchitectureSearch},
    LSTMOptimizer, LearnedOptimizerConfig,
};

use crate::error::{OptimError, Result};

/// Coordinator state for tracking optimization progress
#[derive(Debug, Clone)]
pub struct CoordinatorState<T: Float + Debug + Send + Sync + 'static> {
    /// Current metrics
    pub current_metrics: CoordinatorMetrics<T>,
    /// Resource utilization
    pub resource_utilization: ResourceUtilization<T>,
    /// Total optimization steps
    pub total_steps: usize,
    /// Last update time
    pub last_update: SystemTime,
}

/// Coordinator performance metrics
#[derive(Debug, Clone)]
pub struct CoordinatorMetrics<T: Float + Debug + Send + Sync + 'static> {
    /// Overall performance score
    pub overall_performance: T,
    /// Convergence rate
    pub convergence_rate: T,
    /// Resource efficiency
    pub resource_efficiency: T,
    /// Adaptation success rate
    pub adaptation_success_rate: T,
    /// Ensemble diversity
    pub ensemble_diversity: T,
}

/// Resource utilization tracking
#[derive(Debug, Clone)]
pub struct ResourceUtilization<T: Float + Debug + Send + Sync + 'static> {
    /// CPU utilization
    pub cpu_utilization: T,
    /// Memory utilization
    pub memory_utilization: T,
    /// GPU utilization
    pub gpu_utilization: T,
    /// Network utilization
    pub network_utilization: T,
}

/// Optimization landscape analyzer
pub struct OptimizationAnalyzer<T: Float + Debug + Send + Sync + 'static> {
    _phantom: std::marker::PhantomData<T>,
}

/// Advanced optimizer trait
pub trait AdvancedOptimizer<T: Float + Debug + Send + Sync + 'static>: Send + Sync + std::fmt::Debug {
    /// Optimize step with context
    fn optimize_step_with_context(
        &mut self,
        parameters: &Array1<T>,
        gradients: &Array1<T>,
        context: &OptimizationContext<T>,
    ) -> Result<Array1<T>>;

    /// Adapt to landscape
    fn adapt_to_landscape(&mut self, landscape_features: &LandscapeFeatures<T>) -> Result<()>;

    /// Get capabilities
    fn get_capabilities(&self) -> OptimizerCapabilities;

    /// Get performance score
    fn get_performance_score(&self) -> T;

    /// Clone optimizer
    fn clone_optimizer(&self) -> Box<dyn AdvancedOptimizer<T>>;
}

/// Computational complexity information
#[derive(Debug, Clone)]
pub struct ComputationalComplexity {
    pub time_complexity: String,
    pub space_complexity: String,
    pub parallelism_factor: f64,
}

/// Convergence guarantees
#[derive(Debug, Clone)]
pub struct ConvergenceGuarantees {
    pub guarantees_convergence: bool,
    pub convergence_rate: Option<f64>,
    pub conditions: Vec<String>,
}

/// Optimizer capabilities
#[derive(Debug, Clone)]
pub struct OptimizerCapabilities {
    /// Supported problem types
    pub supported_problems: Vec<ProblemType>,
    /// Scalability information
    pub scalability: ScalabilityInfo,
    /// Memory requirements
    pub memory_requirements: ResourceRequirements,
    /// Computational complexity
    pub computational_complexity: ComputationalComplexity,
    /// Convergence guarantees
    pub convergence_guarantees: ConvergenceGuarantees,
}

/// Ensemble strategy types
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EnsembleStrategy {
    /// Weighted voting based on performance
    WeightedVoting,
    /// Stacking with meta-learner
    Stacking,
    /// Boosting approach
    Boosting,
    /// Bagging approach
    Bagging,
    /// Dynamic selection
    DynamicSelection,
    /// Mixture of experts
    MixtureOfExperts,
}

/// Optimizer selection algorithm
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OptimizerSelectionAlgorithm {
    /// Multi-armed bandit approach
    MultiArmedBandit,
    /// Upper confidence bound
    UpperConfidenceBound,
    /// Thompson sampling
    ThompsonSampling,
    /// Epsilon-greedy
    EpsilonGreedy,
    /// Portfolio approach
    Portfolio,
    /// Contextual bandits
    ContextualBandits,
}

/// Advanced Coordinator - Advanced AI optimization orchestrator
pub struct AdvancedCoordinator<T: Float + Debug + Send + Sync + std::fmt::Debug> {
    /// Ensemble of learned optimizers
    optimizer_ensemble: OptimizerEnsemble<T>,

    /// Neural architecture search engine
    nas_engine: Option<NeuralArchitectureSearch<T>>,

    /// Adaptive transformer enhancement
    transformer_enhancement: Option<AdaptiveTransformerEnhancement<T>>,

    /// Few-shot learning system
    few_shot_system: Option<FewShotLearningEnhancement<T>>,

    /// Meta-learning orchestrator
    meta_learning_orchestrator: MetaLearningOrchestrator<T>,

    /// Performance predictor
    performance_predictor: PerformancePredictor<T>,

    /// Resource manager
    resource_manager: ResourceManager<T>,

    /// Adaptation controller
    adaptation_controller: AdaptationController<T>,

    /// Knowledge base
    knowledge_base: OptimizationKnowledgeBase<T>,

    /// Advanced configuration
    config: AdvancedConfig<T>,

    /// Coordinator state
    state: CoordinatorState<T>,

    /// Performance history
    performance_history: VecDeque<PerformanceSnapshot<T>>,
}

impl<
        T: Float
            + 'static
            + std::iter::Sum
            + for<'a> std::iter::Sum<&'a T>
            + Send
            + Sync
            + Default
            + scirs2_core::ndarray::ScalarOperand
            + std::fmt::Debug,
    > AdvancedCoordinator<T>
{
    /// Create new Advanced coordinator
    pub fn new(config: AdvancedConfig<T>) -> Result<Self> {
        let mut coordinator = Self {
            optimizer_ensemble: OptimizerEnsemble::new()?,
            nas_engine: if config.enable_nas {
                Some(NeuralArchitectureSearch::new(
                    NASConfig::default(),
                )?)
            } else {
                None
            },
            transformer_enhancement: if config.enable_transformer_enhancement {
                Some(AdaptiveTransformerEnhancement::new(
                    AdaptiveConfig::default(),
                )?)
            } else {
                None
            },
            few_shot_system: if config.enable_few_shot_learning {
                Some(FewShotLearningEnhancement::new(FewShotConfig::default())?)
            } else {
                None
            },
            meta_learning_orchestrator: MetaLearningOrchestrator::new()?,
            performance_predictor: PerformancePredictor::new()?,
            resource_manager: ResourceManager::new()?,
            adaptation_controller: AdaptationController::new(config.adaptation_config.clone()),
            knowledge_base: OptimizationKnowledgeBase::new()?,
            state: CoordinatorState::new(),
            performance_history: VecDeque::new(),
            config,
        };

        // Initialize the coordinator
        coordinator.initialize()?;

        Ok(coordinator)
    }

    /// Main optimization orchestration method
    pub fn optimize_advanced(
        &mut self,
        parameters: &Array1<T>,
        gradients: &Array1<T>,
        context: OptimizationContext<T>,
    ) -> Result<Array1<T>> {
        let start_time = Instant::now();

        // Phase 1: Context Analysis and Landscape Assessment
        let landscape_features = self.analyze_optimization_landscape(parameters, gradients, &context)?;

        // Phase 2: Optimizer Selection and Resource Allocation
        let selected_optimizers = self.select_optimal_optimizers(&landscape_features, &context)?;
        let resource_allocation = self.resource_manager.allocate_resources(&selected_optimizers, &context)?;

        // Phase 3: Performance Prediction and Strategy Planning
        let performance_predictions = self.performance_predictor.predict_performance(
            &selected_optimizers,
            &landscape_features,
            &context,
        )?;

        // Phase 4: Meta-Learning Orchestration
        let meta_learning_guidance = self.meta_learning_orchestrator.orchestrate_meta_learning(
            &selected_optimizers,
            &landscape_features,
            &performance_predictions,
        )?;

        // Phase 5: Parallel Optimization Execution
        let optimization_results = self.execute_parallel_optimization(
            parameters,
            gradients,
            &selected_optimizers,
            &resource_allocation,
            &meta_learning_guidance,
            &context,
        )?;

        // Phase 6: Result Ensemble and Integration
        let ensembled_result = self.optimizer_ensemble.ensemble_results(
            &optimization_results,
            &performance_predictions,
            &context,
        )?;

        // Phase 7: Adaptation and Learning
        self.perform_adaptation_and_learning(
            &ensembled_result,
            &optimization_results,
            &landscape_features,
            &context,
            start_time.elapsed(),
        )?;

        // Phase 8: Knowledge Base Update
        let experience = crate::learned_optimizers::optimization_coordinator::knowledge_base::OptimizationExperience {
            optimizer_name: "ensemble".to_string(),
            problem_characteristics: parameters.clone(),
            performance: if !ensembled_result.is_empty() { ensembled_result[0] } else { T::zero() },
            settings: std::collections::HashMap::new(),
        };
        self.knowledge_base.update_with_optimization_experience(&experience)?;

        // Phase 9: State and Performance Tracking
        self.update_coordinator_state(&ensembled_result, &optimization_results, start_time.elapsed())?;

        Ok(ensembled_result)
    }

    /// Initialize the Advanced coordinator
    fn initialize(&mut self) -> Result<()> {
        // Register default optimizers
        self.register_default_optimizers()?;

        // Initialize meta-learning strategies
        self.initialize_meta_learning()?;

        // Setup adaptation triggers
        self.setup_adaptation_triggers()?;

        // Initialize knowledge base
        self.knowledge_base.initialize()?;

        Ok(())
    }

    /// Register default optimizers in the ensemble
    fn register_default_optimizers(&mut self) -> Result<()> {
        // This would register various learned optimizers
        // Implementation details would be in the ensemble module
        self.optimizer_ensemble.register_default_optimizers()
    }

    /// Initialize meta-learning strategies
    fn initialize_meta_learning(&mut self) -> Result<()> {
        self.meta_learning_orchestrator.initialize_strategies()
    }

    /// Setup adaptation triggers
    fn setup_adaptation_triggers(&mut self) -> Result<()> {
        self.adaptation_controller.setup_default_triggers()
    }

    /// Analyze optimization landscape
    fn analyze_optimization_landscape(
        &mut self,
        parameters: &Array1<T>,
        gradients: &Array1<T>,
        context: &OptimizationContext<T>,
    ) -> Result<LandscapeFeatures<T>> {
        // Delegate to analytics module
        let analyzer = OptimizationAnalyzer::new()?;
        analyzer.analyze_landscape(parameters, gradients, context)
    }

    /// Select optimal optimizers for current context
    fn select_optimal_optimizers(
        &mut self,
        landscape_features: &LandscapeFeatures<T>,
        context: &OptimizationContext<T>,
    ) -> Result<Vec<String>> {
        self.optimizer_ensemble.select_optimizers(landscape_features, context)
    }

    /// Execute parallel optimization with multiple optimizers
    fn execute_parallel_optimization(
        &mut self,
        parameters: &Array1<T>,
        gradients: &Array1<T>,
        selected_optimizers: &[String],
        resource_allocation: &ResourceAllocation<T>,
        meta_learning_guidance: &MetaLearningGuidance<T>,
        context: &OptimizationContext<T>,
    ) -> Result<HashMap<String, Array1<T>>> {
        self.optimizer_ensemble.execute_parallel_optimization(
            parameters,
            gradients,
            selected_optimizers,
            resource_allocation,
            meta_learning_guidance,
            context,
        )
    }

    /// Perform adaptation and learning
    fn perform_adaptation_and_learning(
        &mut self,
        result: &Array1<T>,
        optimization_results: &HashMap<String, Array1<T>>,
        landscape_features: &LandscapeFeatures<T>,
        context: &OptimizationContext<T>,
        elapsed_time: Duration,
    ) -> Result<()> {
        // Trigger adaptation based on results
        if let Some(_adaptation_event) = self.adaptation_controller.trigger_adaptation(context)? {
            // Handle adaptation event if needed
        }

        // Update performance predictions
        self.performance_predictor.update_with_results(
            optimization_results,
            landscape_features,
            context,
        )?;

        Ok(())
    }

    /// Update coordinator state
    fn update_coordinator_state(
        &mut self,
        result: &Array1<T>,
        optimization_results: &HashMap<String, Array1<T>>,
        elapsed_time: Duration,
    ) -> Result<()> {
        // Create performance snapshot
        let snapshot = PerformanceSnapshot {
            timestamp: SystemTime::now(),
            step: 0, // Default
            loss: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()), // Default
            accuracy: Some(scirs2_core::numeric::NumCast::from(0.9).unwrap_or_else(|| T::zero())), // Default
            training_time: elapsed_time,
            memory_usage: 1024, // Default 1MB
            gpu_utilization: Some(0.0), // Default no GPU
            learning_rate: scirs2_core::numeric::NumCast::from(0.001).unwrap_or_else(|| T::zero()), // Default
            gradient_norm: Some(scirs2_core::numeric::NumCast::from(1.0).unwrap_or_else(|| T::zero())), // Default
            metrics: PerformanceMetrics {
                loss: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
                val_loss: Some(scirs2_core::numeric::NumCast::from(0.12).unwrap_or_else(|| T::zero())),
                accuracy: Some(scirs2_core::numeric::NumCast::from(0.9).unwrap_or_else(|| T::zero())),
                val_accuracy: Some(scirs2_core::numeric::NumCast::from(0.88).unwrap_or_else(|| T::zero())),
                learning_rate: scirs2_core::numeric::NumCast::from(0.001).unwrap_or_else(|| T::zero()),
                gradient_norm: Some(scirs2_core::numeric::NumCast::from(1.0).unwrap_or_else(|| T::zero())),
                parameter_norm: Some(scirs2_core::numeric::NumCast::from(5.0).unwrap_or_else(|| T::zero())),
                throughput: Some(scirs2_core::numeric::NumCast::from(1.0).unwrap_or_else(|| T::zero())),
                convergence_rate: Some(scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero())),
                custom_metrics: HashMap::new(),
            },
            resource_usage: ResourceUsage {
                cpu_usage: 50.0, // Default 50% CPU usage
                memory_usage: 1024 * 1024 * 1024, // Default 1GB in bytes
                gpu_memory_usage: Some(512 * 1024 * 1024), // Default 512MB GPU memory
                gpu_utilization: Some(0.0), // Default no GPU utilization
                disk_io_rate: Some(scirs2_core::numeric::NumCast::from(10.0).unwrap_or_else(|| T::zero())), // Default 10 MB/s
                network_io_rate: Some(T::zero()), // Default no network I/O
                power_consumption: Some(50.0), // Default 50W
            },
            context: PerformanceContext {
                model_architecture: "Unknown".to_string(),
                dataset_info: format!("Dimension: {}", result.len()),
                batch_size: 32, // Default
                optimizer_type: "Adaptive".to_string(),
                training_regime: "Standard".to_string(),
                hardware_config: "Unknown".to_string(),
                environment: std::collections::HashMap::new(),
                hyperparameters: {
                    let mut params = std::collections::HashMap::new();
                    params.insert("dimensionality".to_string(), scirs2_core::numeric::NumCast::from(result.len()).unwrap_or_else(|| T::zero()));
                    params
                },
            },
        };

        // Update performance history
        self.performance_history.push_back(snapshot);
        if self.performance_history.len() > 1000 {
            self.performance_history.pop_front();
        }

        // Update coordinator state
        self.state.update_with_optimization_step(result, optimization_results, elapsed_time)?;

        Ok(())
    }

    /// Calculate overall performance score
    fn calculate_overall_score(&self, result: &Array1<T>) -> Result<T> {
        // Simple norm-based score for now
        let norm = result.iter().map(|&x| x * x).fold(T::zero(), |acc, x| acc + x).sqrt();
        Ok(T::one() / (T::one() + norm))
    }

    /// Calculate individual optimizer scores
    fn calculate_optimizer_scores(&self, results: &HashMap<String, Array1<T>>) -> Result<HashMap<String, T>> {
        let mut scores = HashMap::new();
        for (optimizer_id, result) in results {
            let norm = result.iter().map(|&x| x * x).fold(T::zero(), |acc, x| acc + x).sqrt();
            let score = T::one() / (T::one() + norm);
            scores.insert(optimizer_id.clone(), score);
        }
        Ok(scores)
    }

    /// Calculate convergence rate
    fn calculate_convergence_rate(&self) -> Result<T> {
        if self.performance_history.len() < 2 {
            return Ok(T::zero());
        }

        let recent_scores: Vec<_> = self.performance_history
            .iter()
            .rev()
            .take(10)
            .map(|snapshot| snapshot.overall_score)
            .collect();

        if recent_scores.len() < 2 {
            return Ok(T::zero());
        }

        let initial_score = recent_scores.last().expect("unwrap failed");
        let final_score = recent_scores.first().expect("unwrap failed");

        if *initial_score > T::zero() {
            Ok((*final_score - *initial_score) / *initial_score)
        } else {
            Ok(T::zero())
        }
    }

    /// Get current performance metrics
    pub fn get_performance_metrics(&self) -> CoordinatorMetrics<T> {
        self.state.current_metrics.clone()
    }

    /// Get optimization knowledge base
    pub fn get_knowledge_base(&self) -> &OptimizationKnowledgeBase<T> {
        &self.knowledge_base
    }

    /// Get resource utilization
    pub fn get_resource_utilization(&self) -> ResourceUtilization<T> {
        self.state.resource_utilization.clone()
    }

    /// Reset coordinator state
    pub fn reset(&mut self) -> Result<()> {
        self.optimizer_ensemble.reset()?;
        self.meta_learning_orchestrator.reset()?;
        self.performance_predictor.reset()?;
        self.resource_manager.reset()?;
        self.adaptation_controller.reset()?;
        self.knowledge_base.reset()?;
        self.state = CoordinatorState::new();
        self.performance_history.clear();
        Ok(())
    }
}

// Default implementations for supporting types
impl<T: Float + Debug + Send + Sync + 'static> Default for CoordinatorMetrics<T> {
    fn default() -> Self {
        Self {
            overall_performance: T::zero(),
            convergence_rate: T::zero(),
            resource_efficiency: T::zero(),
            adaptation_success_rate: T::zero(),
            ensemble_diversity: T::zero(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> Default for ResourceUtilization<T> {
    fn default() -> Self {
        Self {
            cpu_utilization: T::zero(),
            memory_utilization: T::zero(),
            gpu_utilization: T::zero(),
            network_utilization: T::zero(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> CoordinatorState<T> {
    pub fn new() -> Self {
        Self {
            current_metrics: CoordinatorMetrics::default(),
            resource_utilization: ResourceUtilization::default(),
            total_steps: 0,
            last_update: SystemTime::now(),
        }
    }

    pub fn update_with_optimization_step(
        &mut self,
        _result: &Array1<T>,
        _optimization_results: &HashMap<String, Array1<T>>,
        _elapsed_time: Duration,
    ) -> Result<()> {
        self.total_steps += 1;
        self.last_update = SystemTime::now();
        Ok(())
    }
}

impl<T: Float + Debug + Send + Sync + 'static> OptimizationAnalyzer<T> {
    pub fn new() -> Result<Self> {
        Ok(Self {
            _phantom: std::marker::PhantomData,
        })
    }

    pub fn analyze_landscape(
        &self,
        _parameters: &Array1<T>,
        _gradients: &Array1<T>,
        _context: &OptimizationContext<T>,
    ) -> Result<LandscapeFeatures<T>> {
        // Placeholder implementation - create a basic landscape features instance
        use crate::learned_optimizers::optimization_coordinator::state::*;
        use std::time::{SystemTime, Duration};

        Ok(LandscapeFeatures {
            curvature_info: CurvatureInfo {
                mean_curvature: T::zero(),
                max_curvature: T::zero(),
                condition_number: T::one(),
                spectral_gap: T::zero(),
                eigenvalue_distribution: EigenvalueDistribution {
                    largest_eigenvalue: T::one(),
                    smallest_eigenvalue: T::zero(),
                    mean_eigenvalue: scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()),
                    eigenvalue_variance: T::zero(),
                    negative_eigenvalues: 0,
                    spectral_density: Vec::new(),
                },
                hessian_quality: T::one(),
            },
            gradient_characteristics: GradientCharacteristics {
                gradient_norm: T::zero(),
                gradient_variance: T::zero(),
                gradient_correlation: T::zero(),
                directional_derivative: T::zero(),
                gradient_predictability: T::zero(),
                gradient_consistency: T::one(),
                signal_to_noise_ratio: T::one(),
            },
            local_geometry: LocalGeometry {
                local_minima_density: T::zero(),
                saddle_point_density: T::zero(),
                basin_width: T::one(),
                escape_difficulty: scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()),
                local_convexity: T::zero(),
                local_smoothness: T::one(),
                barrier_height: T::zero(),
            },
            global_structure: GlobalStructure {
                connectivity: T::one(),
                symmetry: T::one(),
                hierarchical_structure: T::zero(),
                fractal_dimension: scirs2_core::numeric::NumCast::from(2.0).unwrap_or_else(|| T::zero()),
                global_convexity: scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()),
                scale_separation: T::one(),
                modularity: scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()),
            },
            noise_characteristics: NoiseCharacteristics {
                noise_level: T::zero(),
                noise_type: NoiseType::Gaussian,
                signal_to_noise_ratio: scirs2_core::numeric::NumCast::from(100.0).unwrap_or_else(|| T::zero()),
                noise_correlation: T::zero(),
                noise_stationarity: T::one(),
                noise_predictability: scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()),
                frequency_spectrum: Vec::new(),
            },
            trajectory_features: TrajectoryFeatures {
                path_length: T::one(),
                path_efficiency: T::one(),
                oscillation: T::zero(),
                convergence_rate: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
                step_consistency: T::one(),
                direction_consistency: T::one(),
                progress_rate: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
            },
            extraction_time: SystemTime::now(),
            validity_duration: Duration::from_secs(3600),
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_advanced_coordinator_creation() {
        let config = AdvancedConfig::<f32>::default();
        let coordinator = AdvancedCoordinator::new(config);
        assert!(coordinator.is_ok());
    }

    #[test]
    fn test_coordinator_reset() {
        let config = AdvancedConfig::<f32>::default();
        let mut coordinator = AdvancedCoordinator::new(config).expect("unwrap failed");
        assert!(coordinator.reset().is_ok());
    }
}