optirs-learned 0.3.1

// Few-Shot Learning Enhancement for Learned Optimizers
//
// This module provides advanced few-shot learning capabilities for learned optimizers,
// enabling rapid adaptation to new optimization tasks with minimal data.

#[allow(dead_code)]

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

#[allow(unused_imports)]
use crate::error::Result;

/// Few-Shot Learning Enhancement System for Learned Optimizers
pub struct FewShotLearningEnhancement<T: Float + Debug + Send + Sync + 'static> {
    /// Support set manager
    support_set_manager: SupportSetManager<T>,

    /// Few-shot meta-learner
    meta_learner: FewShotMetaLearner<T>,

    /// Prototype network
    prototype_network: PrototypeNetwork<T>,

    /// Similarity matcher
    similarity_matcher: SimilarityMatcher<T>,

    /// Task distribution analyzer
    task_analyzer: TaskDistributionAnalyzer<T>,

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

    /// Few-shot configuration
    config: FewShotConfig<T>,

    /// Performance tracker
    performance_tracker: FewShotPerformanceTracker<T>,
}

/// Configuration for few-shot learning
#[derive(Debug, Clone)]
pub struct FewShotConfig<T: Float + Debug + Send + Sync + 'static> {
    /// Number of support examples per class
    pub support_size: usize,

    /// Number of query examples per class
    pub query_size: usize,

    /// Number of ways (classes) in few-shot tasks
    pub n_way: usize,

    /// Number of shots (examples per class)
    pub n_shot: usize,

    /// Meta-learning rate for few-shot adaptation
    pub meta_learning_rate: T,

    /// Inner loop learning rate
    pub inner_learning_rate: T,

    /// Number of inner loop steps
    pub inner_steps: usize,

    /// Use second-order gradients
    pub second_order: bool,

    /// Temperature for similarity computation
    pub temperature: T,

    /// Prototype update method
    pub prototype_update_method: PrototypeUpdateMethod,

    /// Distance metric for similarity
    pub distance_metric: DistanceMetric,

    /// Enable episodic training
    pub episodic_training: bool,

    /// Enable curriculum learning
    pub curriculum_learning: bool,

    /// Enable data augmentation
    pub data_augmentation: bool,

    /// Augmentation strategies
    pub augmentation_strategies: Vec<AugmentationStrategy>,

    /// Enable meta-regularization
    pub meta_regularization: bool,

    /// Regularization strength
    pub regularization_strength: T,

    /// Enable task-specific adaptation
    pub task_specific_adaptation: bool,

    /// Adaptation memory size
    pub adaptation_memory_size: usize,
}

/// Support set manager for few-shot learning
#[derive(Debug)]
pub struct SupportSetManager<T: Float + Debug + Send + Sync + 'static> {
    /// Current support sets
    support_sets: HashMap<String, SupportSet<T>>,

    /// Support set statistics
    statistics: SupportSetStatistics<T>,

    /// Selection strategy
    selection_strategy: SupportSetSelectionStrategy,

    /// Quality assessor
    quality_assessor: SupportSetQualityAssessor<T>,

    /// Cache for processed support sets
    processed_cache: HashMap<String, ProcessedSupportSet<T>>,
}

/// Support set representation
#[derive(Debug, Clone)]
pub struct SupportSet<T: Float + Debug + Send + Sync + 'static> {
    /// Examples in the support set
    pub examples: Vec<Example<T>>,

    /// Labels for each example
    pub labels: Vec<usize>,

    /// Task metadata
    pub task_metadata: TaskMetadata,

    /// Set quality metrics
    pub quality_metrics: SupportSetQuality<T>,

    /// Creation timestamp
    pub timestamp: Instant,
}

/// Individual example in support set
#[derive(Debug, Clone)]
pub struct Example<T: Float + Debug + Send + Sync + 'static> {
    /// Feature vector
    pub features: Array1<T>,

    /// Context features (if any)
    pub context: Option<Array1<T>>,

    /// Example weight
    pub weight: T,

    /// Difficulty score
    pub difficulty: Option<T>,

    /// Augmentation applied
    pub augmented: bool,
}

/// Task metadata for support sets
#[derive(Debug, Clone)]
pub struct TaskMetadata {
    /// Task identifier
    pub _taskid: String,

    /// Task type
    pub task_type: FewShotTaskType,

    /// Domain information
    pub domain: String,

    /// Complexity score
    pub complexity: f64,

    /// Task creation time
    pub creation_time: Instant,
}

/// Few-shot task types
#[derive(Debug, Clone, Copy)]
pub enum FewShotTaskType {
    /// Classification task
    Classification,

    /// Regression task
    Regression,

    /// Sequence learning
    SequenceLearning,

    /// Reinforcement learning
    ReinforcementLearning,

    /// Optimization task
    Optimization,

    /// Custom task type
    Custom,
}

/// Support set quality metrics
#[derive(Debug, Clone)]
pub struct SupportSetQuality<T: Float + Debug + Send + Sync + 'static> {
    /// Diversity score
    pub diversity: T,

    /// Representativeness score
    pub representativeness: T,

    /// Difficulty balance
    pub difficulty_balance: T,

    /// Coverage score
    pub coverage: T,

    /// Overall quality
    pub overall_quality: T,
}

/// Few-shot meta-learner
#[derive(Debug)]
pub struct FewShotMetaLearner<T: Float + Debug + Send + Sync + 'static> {
    /// Meta-network parameters
    meta_parameters: MetaParameters<T>,

    /// Episode memory
    episode_memory: EpisodeMemory<T>,

    /// Learning algorithm
    learning_algorithm: FewShotLearningAlgorithm,

    /// Gradient computer
    gradient_computer: MetaGradientComputer<T>,

    /// Adaptation engine
    adaptation_engine: FastAdaptationEngine<T>,
}

/// Prototype network for few-shot learning
#[derive(Debug)]
pub struct PrototypeNetwork<T: Float + Debug + Send + Sync + 'static> {
    /// Prototype embeddings
    pub prototypes: Array2<T>,

    /// Prototype weights
    pub prototype_weights: Array1<T>,

    /// Update rule
    pub update_rule: PrototypeUpdateRule<T>,

    /// Distance computer
    pub distance_computer: DistanceComputer<T>,

    /// Prototype history
    pub prototype_history: VecDeque<Array2<T>>,
}

/// Similarity matcher for task matching
#[derive(Debug)]
pub struct SimilarityMatcher<T: Float + Debug + Send + Sync + 'static> {
    /// Similarity computer
    similarity_computer: SimilarityComputer<T>,

    /// Task embeddings
    task_embeddings: HashMap<String, Array1<T>>,

    /// Similarity cache
    similarity_cache: SimilarityCache<T>,

    /// Matching threshold
    matching_threshold: T,

    /// Similarity metrics
    similarity_metrics: Vec<SimilarityMetric>,
}

/// Task distribution analyzer
#[derive(Debug)]
pub struct TaskDistributionAnalyzer<T: Float + Debug + Send + Sync + 'static> {
    /// Task distribution estimator
    distribution_estimator: TaskDistributionEstimator<T>,

    /// Novelty detector
    novelty_detector: TaskNoveltyDetector<T>,

    /// Difficulty estimator
    difficulty_estimator: TaskDifficultyEstimator<T>,

    /// Distribution history
    distribution_history: VecDeque<TaskDistribution<T>>,
}

/// Adaptation controller for few-shot learning
#[derive(Debug)]
pub struct AdaptationController<T: Float + Debug + Send + Sync + 'static> {
    /// Adaptation strategy
    strategy: AdaptationStrategy<T>,

    /// Adaptation rate controller
    rate_controller: AdaptationRateController<T>,

    /// Stopping criterion
    stopping_criterion: StoppingCriterion<T>,

    /// Adaptation memory
    adaptation_memory: AdaptationMemory<T>,

    /// Performance monitor
    performance_monitor: AdaptationPerformanceMonitor<T>,
}

/// Few-shot performance tracker
#[derive(Debug)]
pub struct FewShotPerformanceTracker<T: Float + Debug + Send + Sync + 'static> {
    /// Episode performance history
    episode_performance: VecDeque<EpisodePerformance<T>>,

    /// Task-specific performance
    task_performance: HashMap<String, TaskPerformance<T>>,

    /// Overall metrics
    overall_metrics: FewShotMetrics<T>,

    /// Performance trends
    performance_trends: PerformanceTrends<T>,
}

/// Methods for updating prototypes
#[derive(Debug, Clone, Copy)]
pub enum PrototypeUpdateMethod {
    /// Simple averaging
    SimpleAverage,

    /// Exponential moving average
    ExponentialMovingAverage,

    /// Attention-weighted update
    AttentionWeighted,

    /// Gradient-based update
    GradientBased,

    /// Learned update rule
    Learned,
}

/// Distance metrics for prototype matching
#[derive(Debug, Clone, Copy)]
pub enum DistanceMetric {
    /// Euclidean distance
    Euclidean,

    /// Cosine distance
    Cosine,

    /// Mahalanobis distance
    Mahalanobis,

    /// Learned metric
    Learned,

    /// Chi-squared distance
    ChiSquared,
}

/// Support set selection strategies
#[derive(Debug, Clone, Copy)]
pub enum SupportSetSelectionStrategy {
    /// Random selection
    Random,

    /// Diverse selection
    Diverse,

    /// Representative selection
    Representative,

    /// Hard examples
    HardExamples,

    /// Balanced selection
    Balanced,

    /// Curriculum-based
    Curriculum,
}

/// Data augmentation strategies
#[derive(Debug, Clone, Copy)]
pub enum AugmentationStrategy {
    /// Noise injection
    NoiseInjection,

    /// Feature perturbation
    FeaturePerturbation,

    /// Mixup augmentation
    Mixup,

    /// Manifold mixup
    ManifoldMixup,

    /// Learned augmentation
    LearnedAugmentation,
}

/// Few-shot learning algorithms
#[derive(Debug, Clone, Copy)]
pub enum FewShotLearningAlgorithm {
    /// Model-Agnostic Meta-Learning (MAML)
    MAML,

    /// Prototypical Networks
    Prototypical,

    /// Relation Networks
    Relation,

    /// Matching Networks
    Matching,

    /// Meta-SGD
    MetaSGD,

    /// Reptile
    Reptile,

    /// FOMAML (First-Order MAML)
    FOMAML,
}

/// Similarity metrics
#[derive(Debug, Clone, Copy)]
pub enum SimilarityMetric {
    /// Cosine similarity
    Cosine,

    /// Pearson correlation
    Pearson,

    /// Mutual information
    MutualInformation,

    /// Earth mover's distance
    EarthMover,

    /// KL divergence
    KLDivergence,
}

/// Meta-parameters for few-shot learning
#[derive(Debug, Clone)]
pub struct MetaParameters<T: Float + Debug + Send + Sync + 'static> {
    /// Initial parameters
    pub initial_params: HashMap<String, Array1<T>>,

    /// Meta-learned initialization
    pub meta_init: HashMap<String, Array1<T>>,

    /// Learning rate parameters
    pub lr_params: HashMap<String, T>,

    /// Adaptation parameters
    pub adaptation_params: HashMap<String, Array1<T>>,
}

/// Episode memory for meta-learning
#[derive(Debug)]
pub struct EpisodeMemory<T: Float + Debug + Send + Sync + 'static> {
    /// Recent episodes
    episodes: VecDeque<Episode<T>>,

    /// Episode features
    episode_features: HashMap<String, Array1<T>>,

    /// Memory capacity
    capacity: usize,

    /// Retrieval mechanism
    retrieval_mechanism: MemoryRetrievalMechanism,
}

/// Individual episode
#[derive(Debug, Clone)]
pub struct Episode<T: Float + Debug + Send + Sync + 'static> {
    /// Episode identifier
    pub id: String,

    /// Support set
    pub supportset: SupportSet<T>,

    /// Query set
    pub query_set: Vec<Example<T>>,

    /// Episode performance
    pub performance: EpisodePerformance<T>,

    /// Adaptation trajectory
    pub adaptation_trajectory: Vec<AdaptationStep<T>>,
}

/// Episode performance metrics
#[derive(Debug, Clone)]
pub struct EpisodePerformance<T: Float + Debug + Send + Sync + 'static> {
    /// Initial performance
    pub initial_performance: T,

    /// Final performance
    pub final_performance: T,

    /// Adaptation speed
    pub adaptation_speed: T,

    /// Convergence quality
    pub convergence_quality: T,

    /// Generalization gap
    pub generalization_gap: T,
}

/// Adaptation step in trajectory
#[derive(Debug, Clone)]
pub struct AdaptationStep<T: Float + Debug + Send + Sync + 'static> {
    /// Step number
    pub step: usize,

    /// Parameters at this step
    pub parameters: HashMap<String, Array1<T>>,

    /// Performance at this step
    pub performance: T,

    /// Gradient norm
    pub gradient_norm: T,

    /// Learning rate used
    pub learning_rate: T,
}

/// Meta-gradient computer
#[derive(Debug)]
pub struct MetaGradientComputer<T: Float + Debug + Send + Sync + 'static> {
    /// Gradient computation method
    computation_method: GradientComputationMethod,

    /// Second-order gradient support
    second_order_support: bool,

    /// Gradient cache
    gradient_cache: HashMap<String, Array1<T>>,

    /// Computational graph
    computational_graph: ComputationalGraph<T>,
}

/// Fast adaptation engine
#[derive(Debug)]
pub struct FastAdaptationEngine<T: Float + Debug + Send + Sync + 'static> {
    /// Adaptation algorithm
    algorithm: FastAdaptationAlgorithm,

    /// Optimization trajectory
    optimization_trajectory: Vec<OptimizationState<T>>,

    /// Convergence detector
    convergence_detector: ConvergenceDetector<T>,

    /// Early stopping mechanism
    early_stopping: EarlyStoppingMechanism<T>,
}

/// Prototype update rule
#[derive(Debug)]
pub struct PrototypeUpdateRule<T: Float + Debug + Send + Sync + 'static> {
    /// Update method
    method: PrototypeUpdateMethod,

    /// Update parameters
    parameters: HashMap<String, T>,

    /// Update history
    update_history: VecDeque<PrototypeUpdate<T>>,
}

/// Distance computer for prototypes
#[derive(Debug)]
pub struct DistanceComputer<T: Float + Debug + Send + Sync + 'static> {
    /// Distance metric
    metric: DistanceMetric,

    /// Metric parameters
    parameters: HashMap<String, T>,

    /// Distance cache
    distance_cache: HashMap<String, T>,

    /// Normalization method
    normalization: DistanceNormalization,
}

/// Similarity computer
#[derive(Debug)]
pub struct SimilarityComputer<T: Float + Debug + Send + Sync + 'static> {
    /// Similarity metrics
    metrics: Vec<SimilarityMetric>,

    /// Metric weights
    metric_weights: Array1<T>,

    /// Similarity cache
    cache: HashMap<String, T>,

    /// Computation parameters
    parameters: SimilarityParameters<T>,
}

/// Similarity cache
#[derive(Debug)]
pub struct SimilarityCache<T: Float + Debug + Send + Sync + 'static> {
    /// Cached similarities
    cache: HashMap<(String, String), T>,

    /// Cache hit rate
    hit_rate: f64,

    /// Cache capacity
    capacity: usize,

    /// Eviction policy
    eviction_policy: CacheEvictionPolicy,
}

/// Task distribution estimator
#[derive(Debug)]
pub struct TaskDistributionEstimator<T: Float + Debug + Send + Sync + 'static> {
    /// Distribution model
    distribution_model: DistributionModel<T>,

    /// Parameter estimates
    parameter_estimates: HashMap<String, T>,

    /// Estimation confidence
    confidence: T,

    /// Sample history
    sample_history: VecDeque<TaskSample<T>>,
}

/// Task novelty detector
#[derive(Debug)]
pub struct TaskNoveltyDetector<T: Float + Debug + Send + Sync + 'static> {
    /// Novelty threshold
    novelty_threshold: T,

    /// Reference distribution
    reference_distribution: TaskDistribution<T>,

    /// Novelty history
    novelty_history: VecDeque<NoveltyScore<T>>,

    /// Detection algorithm
    detection_algorithm: NoveltyDetectionAlgorithm,
}

/// Task difficulty estimator
#[derive(Debug)]
pub struct TaskDifficultyEstimator<T: Float + Debug + Send + Sync + 'static> {
    /// Difficulty model
    difficulty_model: DifficultyModel<T>,

    /// Feature extractor
    feature_extractor: DifficultyFeatureExtractor<T>,

    /// Difficulty cache
    difficulty_cache: HashMap<String, T>,

    /// Estimation history
    estimation_history: VecDeque<DifficultyEstimate<T>>,
}

/// Task distribution
#[derive(Debug, Clone)]
pub struct TaskDistribution<T: Float + Debug + Send + Sync + 'static> {
    /// Distribution parameters
    pub parameters: HashMap<String, T>,

    /// Distribution type
    pub distribution_type: DistributionType,

    /// Confidence bounds
    pub confidence_bounds: (T, T),

    /// Sample size
    pub sample_size: usize,
}

/// Additional supporting structures
#[derive(Debug, Clone)]
pub struct SupportSetStatistics<T: Float + Debug + Send + Sync + 'static> {
    /// Total support sets
    pub total_sets: usize,

    /// Average quality
    pub average_quality: T,

    /// Quality variance
    pub quality_variance: T,

    /// Size distribution
    pub size_distribution: Vec<usize>,
}

#[derive(Debug)]
pub struct SupportSetQualityAssessor<T: Float + Debug + Send + Sync + 'static> {
    /// Quality metrics
    metrics: Vec<QualityMetric>,

    /// Assessment method
    method: QualityAssessmentMethod,

    /// Quality thresholds
    thresholds: HashMap<String, T>,
}

#[derive(Debug)]
pub struct ProcessedSupportSet<T: Float + Debug + Send + Sync + 'static> {
    /// Processed features
    features: Array2<T>,

    /// Feature statistics
    statistics: FeatureStatistics<T>,

    /// Processing timestamp
    timestamp: Instant,

    /// Processing metadata
    metadata: ProcessingMetadata,
}

// Enums and additional types
#[derive(Debug, Clone, Copy)]
pub enum QualityMetric {
    Diversity,
    Representativeness,
    Balance,
    Coverage,
    Difficulty,
}

#[derive(Debug, Clone, Copy)]
pub enum QualityAssessmentMethod {
    Statistical,
    ModelBased,
    Ensemble,
    Learned,
}

#[derive(Debug, Clone)]
pub struct FeatureStatistics<T: Float + Debug + Send + Sync + 'static> {
    pub mean: Array1<T>,
    pub variance: Array1<T>,
    pub skewness: Array1<T>,
    pub kurtosis: Array1<T>,
}

#[derive(Debug, Clone)]
pub struct ProcessingMetadata {
    pub processing_time: u64,
    pub method_used: String,
    pub quality_score: f64,
}

#[derive(Debug, Clone, Copy)]
pub enum GradientComputationMethod {
    Automatic,
    Numerical,
    Analytical,
    Hybrid,
}

#[derive(Debug)]
pub struct ComputationalGraph<T: Float + Debug + Send + Sync + 'static> {
    /// Graph nodes
    nodes: Vec<GraphNode<T>>,

    /// Graph edges
    edges: Vec<GraphEdge>,

    /// Execution order
    execution_order: Vec<usize>,
}

#[derive(Debug, Clone)]
pub struct GraphNode<T: Float + Debug + Send + Sync + 'static> {
    /// Node ID
    id: usize,

    /// Operation type
    operation: OperationType,

    /// Node value
    value: Option<Array1<T>>,

    /// Gradient
    gradient: Option<Array1<T>>,
}

#[derive(Debug, Clone)]
pub struct GraphEdge {
    /// Source node
    source: usize,

    /// Target node
    target: usize,

    /// Edge weight
    weight: f64,
}

#[derive(Debug, Clone, Copy)]
pub enum OperationType {
    Linear,
    Nonlinear,
    Activation,
    Loss,
    Regularization,
}

#[derive(Debug, Clone, Copy)]
pub enum FastAdaptationAlgorithm {
    GradientDescent,
    Adam,
    RMSprop,
    Momentum,
    AdaGrad,
}

#[derive(Debug, Clone)]
pub struct OptimizationState<T: Float + Debug + Send + Sync + 'static> {
    /// Current parameters
    parameters: HashMap<String, Array1<T>>,

    /// Current performance
    performance: T,

    /// Optimization step
    step: usize,

    /// Convergence measure
    convergence_measure: T,
}

#[derive(Debug)]
pub struct ConvergenceDetector<T: Float + Debug + Send + Sync + 'static> {
    /// Convergence criteria
    criteria: Vec<ConvergenceCriterion<T>>,

    /// Detection threshold
    threshold: T,

    /// History window
    history_window: usize,

    /// Detection history
    detection_history: VecDeque<bool>,
}

#[derive(Debug)]
pub struct EarlyStoppingMechanism<T: Float + Debug + Send + Sync + 'static> {
    /// Patience parameter
    patience: usize,

    /// Best performance seen
    best_performance: T,

    /// Steps since improvement
    steps_since_improvement: usize,

    /// Stopping criterion
    stopping_criterion: StoppingCriterion<T>,
}

#[derive(Debug, Clone)]
pub struct PrototypeUpdate<T: Float + Debug + Send + Sync + 'static> {
    /// Update timestamp
    timestamp: Instant,

    /// Old prototypes
    old_prototypes: Array2<T>,

    /// New prototypes
    new_prototypes: Array2<T>,

    /// Update magnitude
    update_magnitude: T,
}

#[derive(Debug, Clone, Copy)]
pub enum DistanceNormalization {
    None,
    L1,
    L2,
    MinMax,
    ZScore,
}

#[derive(Debug, Clone)]
pub struct SimilarityParameters<T: Float + Debug + Send + Sync + 'static> {
    /// Temperature parameter
    temperature: T,

    /// Scaling factors
    scaling_factors: Array1<T>,

    /// Bias terms
    bias_terms: Array1<T>,
}

#[derive(Debug, Clone, Copy)]
pub enum CacheEvictionPolicy {
    LRU,
    LFU,
    Random,
    FIFO,
}

#[derive(Debug, Clone, Copy)]
pub enum DistributionModel<T> {
    Gaussian(T, T),
    Uniform(T, T),
    Beta(T, T),
    Gamma(T, T),
    Mixture,
}

#[derive(Debug, Clone)]
pub struct TaskSample<T: Float + Debug + Send + Sync + 'static> {
    /// Sample features
    features: Array1<T>,

    /// Sample label
    label: Option<usize>,

    /// Sample weight
    weight: T,

    /// Sample timestamp
    timestamp: Instant,
}

#[derive(Debug, Clone)]
pub struct NoveltyScore<T: Float + Debug + Send + Sync + 'static> {
    /// Novelty value
    score: T,

    /// Confidence
    confidence: T,

    /// Detection timestamp
    timestamp: Instant,

    /// Task identifier
    _taskid: String,
}

#[derive(Debug, Clone, Copy)]
pub enum NoveltyDetectionAlgorithm {
    OneClassSVM,
    IsolationForest,
    LocalOutlierFactor,
    EllipticEnvelope,
}

#[derive(Debug)]
pub struct DifficultyModel<T: Float + Debug + Send + Sync + 'static> {
    /// Model parameters
    parameters: HashMap<String, T>,

    /// Model type
    model_type: DifficultyModelType,

    /// Training history
    training_history: Vec<DifficultyTrainingExample<T>>,
}

#[derive(Debug)]
pub struct DifficultyFeatureExtractor<T: Float + Debug + Send + Sync + 'static> {
    /// Feature dimensions
    feature_dims: usize,

    /// Extraction method
    method: FeatureExtractionMethod,

    /// Feature cache
    cache: HashMap<String, Array1<T>>,
}

#[derive(Debug, Clone)]
pub struct DifficultyEstimate<T: Float + Debug + Send + Sync + 'static> {
    /// Estimated difficulty
    difficulty: T,

    /// Confidence interval
    confidence_interval: (T, T),

    /// Estimation method
    method: DifficultyEstimationMethod,

    /// Task features
    task_features: Array1<T>,
}

#[derive(Debug, Clone, Copy)]
pub enum DistributionType {
    Gaussian,
    Uniform,
    Beta,
    Gamma,
    Exponential,
    Mixture,
}

#[derive(Debug, Clone, Copy)]
pub enum DifficultyModelType {
    Linear,
    NonLinear,
    TreeBased,
    NeuralNetwork,
    Ensemble,
}

#[derive(Debug, Clone)]
pub struct DifficultyTrainingExample<T: Float + Debug + Send + Sync + 'static> {
    /// Example features
    features: Array1<T>,

    /// True difficulty
    true_difficulty: T,

    /// Prediction
    predicted_difficulty: Option<T>,

    /// Example weight
    weight: T,
}

#[derive(Debug, Clone, Copy)]
pub enum FeatureExtractionMethod {
    Statistical,
    Spectral,
    Topological,
    Learned,
    Hybrid,
}

#[derive(Debug, Clone, Copy)]
pub enum DifficultyEstimationMethod {
    Regression,
    Classification,
    Ranking,
    Clustering,
}

#[derive(Debug, Clone)]
pub struct ConvergenceCriterion<T: Float + Debug + Send + Sync + 'static> {
    /// Criterion type
    criterion_type: ConvergenceCriterionType,

    /// Threshold value
    threshold: T,

    /// Window size
    _windowsize: usize,

    /// Criterion weight
    weight: T,
}

#[derive(Debug, Clone, Copy)]
pub enum ConvergenceCriterionType {
    GradientNorm,
    ParameterChange,
    LossChange,
    PerformanceStability,
}

#[derive(Debug, Clone)]
pub struct StoppingCriterion<T: Float + Debug + Send + Sync + 'static> {
    /// Maximum iterations
    max_iterations: usize,

    /// Performance threshold
    performance_threshold: T,

    /// Improvement threshold
    improvement_threshold: T,

    /// Time budget
    time_budget: Option<std::time::Duration>,
}

#[derive(Debug, Clone, Copy)]
pub enum MemoryRetrievalMechanism {
    MostRecent,
    MostSimilar,
    Random,
    Diverse,
    Performance,
}

// Additional structures for adaptation
#[derive(Debug)]
pub struct AdaptationStrategy<T: Float + Debug + Send + Sync + 'static> {
    /// Strategy type
    _strategytype: AdaptationStrategyType,

    /// Strategy parameters
    parameters: HashMap<String, T>,

    /// Strategy history
    history: VecDeque<AdaptationResult<T>>,
}

#[derive(Debug)]
pub struct AdaptationRateController<T: Float + Debug + Send + Sync + 'static> {
    /// Base learning rate
    _baserate: T,

    /// Current learning rate
    current_rate: T,

    /// Rate schedule
    schedule: LearningRateSchedule,

    /// Adaptive control
    adaptive_control: bool,
}

#[derive(Debug)]
pub struct AdaptationMemory<T: Float + Debug + Send + Sync + 'static> {
    /// Memory entries
    entries: VecDeque<AdaptationMemoryEntry<T>>,

    /// Memory capacity
    capacity: usize,

    /// Access patterns
    access_patterns: HashMap<String, usize>,
}

#[derive(Debug)]
pub struct AdaptationPerformanceMonitor<T: Float + Debug + Send + Sync + 'static> {
    /// Performance history
    performance_history: VecDeque<T>,

    /// Monitoring window
    _windowsize: usize,

    /// Performance trends
    trends: PerformanceTrends<T>,

    /// Alert thresholds
    alert_thresholds: HashMap<String, T>,
}

#[derive(Debug)]
pub struct TaskPerformance<T: Float + Debug + Send + Sync + 'static> {
    /// Task identifier
    _taskid: String,

    /// Performance metrics
    metrics: HashMap<String, T>,

    /// Performance history
    history: VecDeque<T>,

    /// Adaptation statistics
    adaptation_stats: AdaptationStatistics<T>,
}

#[derive(Debug)]
pub struct FewShotMetrics<T: Float + Debug + Send + Sync + 'static> {
    /// Average performance across tasks
    avg_performance: T,

    /// Performance variance
    performance_variance: T,

    /// Adaptation speed
    avg_adaptation_speed: T,

    /// Success rate
    success_rate: T,

    /// Generalization score
    generalization_score: T,
}

#[derive(Debug)]
pub struct PerformanceTrends<T: Float + Debug + Send + Sync + 'static> {
    /// Trend direction
    trend_direction: TrendDirection,

    /// Trend strength
    trend_strength: T,

    /// Volatility measure
    volatility: T,

    /// Trend confidence
    confidence: T,
}

#[derive(Debug, Clone, Copy)]
pub enum AdaptationStrategyType {
    Conservative,
    Aggressive,
    Balanced,
    Learned,
    Adaptive,
}

#[derive(Debug, Clone)]
pub struct AdaptationResult<T: Float + Debug + Send + Sync + 'static> {
    /// Adaptation success
    success: bool,

    /// Performance improvement
    improvement: T,

    /// Adaptation time
    adaptation_time: std::time::Duration,

    /// Final performance
    final_performance: T,
}

#[derive(Debug, Clone, Copy)]
pub enum LearningRateSchedule {
    Constant,
    Exponential,
    Linear,
    Cosine,
    Adaptive,
}

#[derive(Debug, Clone)]
pub struct AdaptationMemoryEntry<T: Float + Debug + Send + Sync + 'static> {
    /// Entry ID
    id: String,

    /// Task context
    task_context: Array1<T>,

    /// Adaptation parameters
    adaptation_params: HashMap<String, T>,

    /// Performance achieved
    performance: T,

    /// Entry timestamp
    timestamp: Instant,
}

#[derive(Debug)]
pub struct AdaptationStatistics<T: Float + Debug + Send + Sync + 'static> {
    /// Average adaptation time
    avg_adaptation_time: std::time::Duration,

    /// Adaptation success rate
    success_rate: T,

    /// Average improvement
    avg_improvement: T,

    /// Adaptation variance
    adaptation_variance: T,
}

#[derive(Debug, Clone, Copy)]
pub enum TrendDirection {
    Improving,
    Declining,
    Stable,
    Volatile,
}

impl<T: Float + Debug + Send + Sync + 'static> Default for FewShotConfig<T> {
    fn default() -> Self {
        Self {
            support_size: 5,
            query_size: 15,
            n_way: 5,
            n_shot: 1,
            meta_learning_rate: scirs2_core::numeric::NumCast::from(0.001).unwrap_or_else(|| T::zero()),
            inner_learning_rate: scirs2_core::numeric::NumCast::from(0.01).unwrap_or_else(|| T::zero()),
            inner_steps: 5,
            second_order: false,
            temperature: scirs2_core::numeric::NumCast::from(1.0).unwrap_or_else(|| T::zero()),
            prototype_update_method: PrototypeUpdateMethod::ExponentialMovingAverage,
            distance_metric: DistanceMetric::Euclidean,
            episodic_training: true,
            curriculum_learning: false,
            data_augmentation: true,
            augmentation_strategies: vec![
                AugmentationStrategy::NoiseInjection,
                AugmentationStrategy::FeaturePerturbation,
            ],
            meta_regularization: true,
            regularization_strength: scirs2_core::numeric::NumCast::from(0.01).unwrap_or_else(|| T::zero()),
            task_specific_adaptation: true,
            adaptation_memory_size: 1000,
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static + std::iter::Sum + for<'a> std::iter::Sum<&'a T>>
    FewShotLearningEnhancement<T>
{
    /// Create new few-shot learning enhancement
    pub fn new(config: FewShotConfig<T>) -> Result<Self> {
        Ok(Self {
            support_set_manager: SupportSetManager::new(&config)?,
            meta_learner: FewShotMetaLearner::new(&config)?,
            prototype_network: PrototypeNetwork::new(&config)?,
            similarity_matcher: SimilarityMatcher::new(&config)?,
            task_analyzer: TaskDistributionAnalyzer::new(&config)?,
            adaptation_controller: AdaptationController::new(&config)?,
            performance_tracker: FewShotPerformanceTracker::new(&config)?,
            config,
        })
    }

    /// Perform few-shot adaptation to new task
    pub fn adapt_to_task(
        &mut self,
        supportset: SupportSet<T>,
        _taskid: String,
    ) -> Result<AdaptationResult<T>> {
        let start_time = Instant::now();

        // Analyze task distribution
        let _task_analysis = self.task_analyzer.analyze_task(&supportset)?;

        // Find similar tasks
        let similar_tasks = self
            .similarity_matcher
            .find_similar_tasks(&_taskid, &supportset)?;

        // Initialize adaptation from similar tasks
        let initial_params = self.initialize_from_similar_tasks(&similar_tasks)?;

        // Perform rapid adaptation
        let adaptation_result =
            self.adaptation_controller
                .adapt(&supportset, initial_params, &self.config)?;

        // Update performance tracking
        self.performance_tracker.record_adaptation(
            &_taskid,
            &adaptation_result,
            start_time.elapsed(),
        )?;

        // Update support _set manager
        self.support_set_manager
            .add_support_set(_taskid.clone(), supportset)?;

        Ok(adaptation_result)
    }

    /// Get performance metrics
    pub fn get_performance_metrics(&self) -> &FewShotMetrics<T> {
        &self.performance_tracker.overall_metrics
    }

    /// Update meta-parameters based on episode
    pub fn meta_update(&mut self, episode: Episode<T>) -> Result<()> {
        self.meta_learner.update_from_episode(episode)?;
        Ok(())
    }

    fn initialize_from_similar_tasks(
        &self,
        _similar_tasks: &[String],
    ) -> Result<HashMap<String, Array1<T>>> {
        // Simplified implementation
        Ok(HashMap::new())
    }
}

// Implementation stubs for complex components
impl<T: Float + Debug + Send + Sync + 'static> SupportSetManager<T> {
    fn new(config: &FewShotConfig<T>) -> Result<Self> {
        Ok(Self {
            support_sets: HashMap::new(),
            statistics: SupportSetStatistics::default(),
            selection_strategy: SupportSetSelectionStrategy::Diverse,
            quality_assessor: SupportSetQualityAssessor::new(),
            processed_cache: HashMap::new(),
        })
    }

    fn add_support_set(&mut self, _taskid: String, supportset: SupportSet<T>) -> Result<()> {
        self.support_sets.insert(_taskid, supportset);
        Ok(())
    }
}

impl<T: Float + Debug + Send + Sync + 'static> FewShotMetaLearner<T> {
    fn new(config: &FewShotConfig<T>) -> Result<Self> {
        Ok(Self {
            meta_parameters: MetaParameters::default(),
            episode_memory: EpisodeMemory::new(1000),
            learning_algorithm: FewShotLearningAlgorithm::MAML,
            gradient_computer: MetaGradientComputer::new(),
            adaptation_engine: FastAdaptationEngine::new(),
        })
    }

    fn update_from_episode(&mut self, episode: Episode<T>) -> Result<()> {
        self.episode_memory.add_episode(episode)?;
        // Update meta-parameters based on episode
        Ok(())
    }
}

impl<T: Float + Debug + Send + Sync + 'static> PrototypeNetwork<T> {
    fn new(config: &FewShotConfig<T>) -> Result<Self> {
        Ok(Self {
            prototypes: Array2::zeros((5, 64)), // n_way x feature_dim
            prototype_weights: Array1::ones(5),
            update_rule: PrototypeUpdateRule::new(PrototypeUpdateMethod::ExponentialMovingAverage),
            distance_computer: DistanceComputer::new(DistanceMetric::Euclidean),
            prototype_history: VecDeque::new(),
        })
    }
}

impl<T: Float + Debug + Send + Sync + 'static> SimilarityMatcher<T> {
    fn new(config: &FewShotConfig<T>) -> Result<Self> {
        Ok(Self {
            similarity_computer: SimilarityComputer::new(),
            task_embeddings: HashMap::new(),
            similarity_cache: SimilarityCache::new(1000),
            matching_threshold: scirs2_core::numeric::NumCast::from(0.8).unwrap_or_else(|| T::zero()),
            similarity_metrics: vec![SimilarityMetric::Cosine, SimilarityMetric::Pearson],
        })
    }

    fn find_similar_tasks(
        &self,
        _task_id: &str,
        _support_set: &SupportSet<T>,
    ) -> Result<Vec<String>> {
        // Simplified implementation
        Ok(vec![
            "similar_task_1".to_string(),
            "similar_task_2".to_string(),
        ])
    }
}

impl<T: Float + Debug + Send + Sync + 'static> TaskDistributionAnalyzer<T> {
    fn new(config: &FewShotConfig<T>) -> Result<Self> {
        Ok(Self {
            distribution_estimator: TaskDistributionEstimator::new(),
            novelty_detector: TaskNoveltyDetector::new(),
            difficulty_estimator: TaskDifficultyEstimator::new(),
            distribution_history: VecDeque::new(),
        })
    }

    fn analyze_task(&mut self, _supportset: &SupportSet<T>) -> Result<TaskDistribution<T>> {
        // Simplified implementation
        Ok(TaskDistribution {
            parameters: HashMap::new(),
            distribution_type: DistributionType::Gaussian,
            confidence_bounds: (scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()), scirs2_core::numeric::NumCast::from(0.9).unwrap_or_else(|| T::zero())),
            sample_size: 100,
        })
    }
}

impl<T: Float + Debug + Send + Sync + 'static> AdaptationController<T> {
    fn new(config: &FewShotConfig<T>) -> Result<Self> {
        Ok(Self {
            strategy: AdaptationStrategy::new(AdaptationStrategyType::Balanced),
            rate_controller: AdaptationRateController::new(scirs2_core::numeric::NumCast::from(0.01).unwrap_or_else(|| T::zero())),
            stopping_criterion: StoppingCriterion::default(),
            adaptation_memory: AdaptationMemory::new(1000),
            performance_monitor: AdaptationPerformanceMonitor::new(100),
        })
    }

    fn adapt(
        &mut self,
        _support_set: &SupportSet<T>,
        _initial_params: HashMap<String, Array1<T>>,
        config: &FewShotConfig<T>,
    ) -> Result<AdaptationResult<T>> {
        // Simplified implementation
        Ok(AdaptationResult {
            success: true,
            improvement: scirs2_core::numeric::NumCast::from(0.15).unwrap_or_else(|| T::zero()),
            adaptation_time: std::time::Duration::from_millis(100),
            final_performance: scirs2_core::numeric::NumCast::from(0.85).unwrap_or_else(|| T::zero()),
        })
    }
}

impl<T: Float + Debug + Send + Sync + 'static + std::iter::Sum> FewShotPerformanceTracker<T> {
    fn new(config: &FewShotConfig<T>) -> Result<Self> {
        Ok(Self {
            episode_performance: VecDeque::new(),
            task_performance: HashMap::new(),
            overall_metrics: FewShotMetrics::default(),
            performance_trends: PerformanceTrends::default(),
        })
    }

    fn record_adaptation(
        &mut self,
        _taskid: &str,
        result: &AdaptationResult<T>,
        _duration: std::time::Duration,
    ) -> Result<()> {
        // Update task-specific performance
        let task_perf = self
            .task_performance
            .entry(_taskid.to_string())
            .or_insert_with(|| TaskPerformance::new(_taskid.to_string()));

        task_perf.update_with_result(result);

        // Update overall metrics
        self.update_overall_metrics();

        Ok(())
    }

    fn update_overall_metrics(&mut self) {
        // Simplified metric computation
        if !self.task_performance.is_empty() {
            let performances: Vec<T> = self
                .task_performance
                .values()
                .map(|tp| tp.metrics.get("performance").copied().unwrap_or(T::zero()))
                .collect();

            let sum: T = performances.iter().cloned().sum();
            let count = T::from(performances.len()).expect("unwrap failed");
            self.overall_metrics.avg_performance = sum / count;
        }
    }
}

// Additional implementation stubs
impl<T: Float + Debug + Send + Sync + 'static> Default for SupportSetStatistics<T> {
    fn default() -> Self {
        Self {
            total_sets: 0,
            average_quality: scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()),
            quality_variance: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
            size_distribution: vec![],
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> SupportSetQualityAssessor<T> {
    fn new() -> Self {
        Self {
            metrics: vec![QualityMetric::Diversity, QualityMetric::Representativeness],
            method: QualityAssessmentMethod::Statistical,
            thresholds: HashMap::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> Default for MetaParameters<T> {
    fn default() -> Self {
        Self {
            initial_params: HashMap::new(),
            meta_init: HashMap::new(),
            lr_params: HashMap::new(),
            adaptation_params: HashMap::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> EpisodeMemory<T> {
    fn new(capacity: usize) -> Self {
        Self {
            episodes: VecDeque::new(),
            episode_features: HashMap::new(),
            capacity,
            retrieval_mechanism: MemoryRetrievalMechanism::MostSimilar,
        }
    }

    fn add_episode(&mut self, episode: Episode<T>) -> Result<()> {
        if self.episodes.len() >= self.capacity {
            self.episodes.pop_front();
        }
        self.episodes.push_back(episode);
        Ok(())
    }
}

impl<T: Float + Debug + Send + Sync + 'static> MetaGradientComputer<T> {
    fn new() -> Self {
        Self {
            computation_method: GradientComputationMethod::Automatic,
            second_order_support: false,
            gradient_cache: HashMap::new(),
            computational_graph: ComputationalGraph::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> FastAdaptationEngine<T> {
    fn new() -> Self {
        Self {
            algorithm: FastAdaptationAlgorithm::Adam,
            optimization_trajectory: Vec::new(),
            convergence_detector: ConvergenceDetector::new(),
            early_stopping: EarlyStoppingMechanism::new(10),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> PrototypeUpdateRule<T> {
    fn new(method: PrototypeUpdateMethod) -> Self {
        Self {
            method,
            parameters: HashMap::new(),
            update_history: VecDeque::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> DistanceComputer<T> {
    fn new(metric: DistanceMetric) -> Self {
        Self {
            metric,
            parameters: HashMap::new(),
            distance_cache: HashMap::new(),
            normalization: DistanceNormalization::L2,
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> SimilarityComputer<T> {
    fn new() -> Self {
        Self {
            metrics: vec![SimilarityMetric::Cosine],
            metric_weights: Array1::ones(1),
            cache: HashMap::new(),
            parameters: SimilarityParameters::default(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> SimilarityCache<T> {
    fn new(capacity: usize) -> Self {
        Self {
            cache: HashMap::new(),
            hit_rate: 0.0,
            capacity,
            eviction_policy: CacheEvictionPolicy::LRU,
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> TaskDistributionEstimator<T> {
    fn new() -> Self {
        Self {
            distribution_model: DistributionModel::Gaussian(T::zero(), T::one()),
            parameter_estimates: HashMap::new(),
            confidence: scirs2_core::numeric::NumCast::from(0.8).unwrap_or_else(|| T::zero()),
            sample_history: VecDeque::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> TaskNoveltyDetector<T> {
    fn new() -> Self {
        Self {
            novelty_threshold: scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()),
            reference_distribution: TaskDistribution {
                parameters: HashMap::new(),
                distribution_type: DistributionType::Gaussian,
                confidence_bounds: (T::zero(), T::one()),
                sample_size: 100,
            },
            novelty_history: VecDeque::new(),
            detection_algorithm: NoveltyDetectionAlgorithm::OneClassSVM,
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> TaskDifficultyEstimator<T> {
    fn new() -> Self {
        Self {
            difficulty_model: DifficultyModel::new(),
            feature_extractor: DifficultyFeatureExtractor::new(64),
            difficulty_cache: HashMap::new(),
            estimation_history: VecDeque::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> ComputationalGraph<T> {
    fn new() -> Self {
        Self {
            nodes: Vec::new(),
            edges: Vec::new(),
            execution_order: Vec::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> ConvergenceDetector<T> {
    fn new() -> Self {
        Self {
            criteria: vec![ConvergenceCriterion {
                criterion_type: ConvergenceCriterionType::GradientNorm,
                threshold: scirs2_core::numeric::NumCast::from(1e-6).unwrap_or_else(|| T::zero()),
                _windowsize: 10,
                weight: T::one(),
            }],
            threshold: scirs2_core::numeric::NumCast::from(1e-6).unwrap_or_else(|| T::zero()),
            history_window: 10,
            detection_history: VecDeque::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> EarlyStoppingMechanism<T> {
    fn new(patience: usize) -> Self {
        Self {
            patience,
            best_performance: T::neg_infinity(),
            steps_since_improvement: 0,
            stopping_criterion: StoppingCriterion::default(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> AdaptationStrategy<T> {
    fn new(_strategytype: AdaptationStrategyType) -> Self {
        Self {
            _strategytype,
            parameters: HashMap::new(),
            history: VecDeque::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> AdaptationRateController<T> {
    fn new(_baserate: T) -> Self {
        Self {
            _baserate,
            current_rate: _baserate,
            schedule: LearningRateSchedule::Constant,
            adaptive_control: false,
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> AdaptationMemory<T> {
    fn new(capacity: usize) -> Self {
        Self {
            entries: VecDeque::new(),
            capacity,
            access_patterns: HashMap::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> AdaptationPerformanceMonitor<T> {
    fn new(_windowsize: usize) -> Self {
        Self {
            performance_history: VecDeque::new(),
            _windowsize,
            trends: PerformanceTrends::default(),
            alert_thresholds: HashMap::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> TaskPerformance<T> {
    fn new(_taskid: String) -> Self {
        Self {
            _taskid,
            metrics: HashMap::new(),
            history: VecDeque::new(),
            adaptation_stats: AdaptationStatistics::default(),
        }
    }

    fn update_with_result(&mut self, result: &AdaptationResult<T>) {
        self.metrics
            .insert("performance".to_string(), result.final_performance);
        self.history.push_back(result.final_performance);

        // Maintain history size
        if self.history.len() > 100 {
            self.history.pop_front();
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> DifficultyModel<T> {
    fn new() -> Self {
        Self {
            parameters: HashMap::new(),
            model_type: DifficultyModelType::Linear,
            training_history: Vec::new(),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> DifficultyFeatureExtractor<T> {
    fn new(dims: usize) -> Self {
        Self {
            feature_dims: dims,
            method: FeatureExtractionMethod::Statistical,
            cache: HashMap::new(),
        }
    }
}

// Default implementations
impl<T: Float + Debug + Send + Sync + 'static> Default for FewShotMetrics<T> {
    fn default() -> Self {
        Self {
            avg_performance: scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()),
            performance_variance: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
            avg_adaptation_speed: scirs2_core::numeric::NumCast::from(1.0).unwrap_or_else(|| T::zero()),
            success_rate: scirs2_core::numeric::NumCast::from(0.8).unwrap_or_else(|| T::zero()),
            generalization_score: scirs2_core::numeric::NumCast::from(0.7).unwrap_or_else(|| T::zero()),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> Default for PerformanceTrends<T> {
    fn default() -> Self {
        Self {
            trend_direction: TrendDirection::Stable,
            trend_strength: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
            volatility: scirs2_core::numeric::NumCast::from(0.05).unwrap_or_else(|| T::zero()),
            confidence: scirs2_core::numeric::NumCast::from(0.8).unwrap_or_else(|| T::zero()),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> Default for StoppingCriterion<T> {
    fn default() -> Self {
        Self {
            max_iterations: 1000,
            performance_threshold: scirs2_core::numeric::NumCast::from(0.95).unwrap_or_else(|| T::zero()),
            improvement_threshold: scirs2_core::numeric::NumCast::from(0.001).unwrap_or_else(|| T::zero()),
            time_budget: Some(std::time::Duration::from_secs(300)),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> Default for SimilarityParameters<T> {
    fn default() -> Self {
        Self {
            temperature: T::one(),
            scaling_factors: Array1::ones(1),
            bias_terms: Array1::zeros(1),
        }
    }
}

impl<T: Float + Debug + Send + Sync + 'static> Default for AdaptationStatistics<T> {
    fn default() -> Self {
        Self {
            avg_adaptation_time: std::time::Duration::from_millis(100),
            success_rate: scirs2_core::numeric::NumCast::from(0.8).unwrap_or_else(|| T::zero()),
            avg_improvement: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
            adaptation_variance: scirs2_core::numeric::NumCast::from(0.05).unwrap_or_else(|| T::zero()),
        }
    }
}

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

    #[test]
    fn test_few_shot_config_default() {
        let config = FewShotConfig::<f64>::default();
        assert_eq!(config.n_way, 5);
        assert_eq!(config.n_shot, 1);
        assert_eq!(config.support_size, 5);
        assert!(config.episodic_training);
    }

    #[test]
    fn test_few_shot_learning_enhancement_creation() {
        let config = FewShotConfig::<f64>::default();
        let enhancement = FewShotLearningEnhancement::new(config);
        assert!(enhancement.is_ok());
    }

    #[test]
    fn test_support_set_creation() {
        let examples = vec![Example {
            features: Array1::zeros(10),
            context: None,
            weight: 1.0,
            difficulty: None,
            augmented: false,
        }];

        let supportset = SupportSet {
            examples,
            labels: vec![0],
            task_metadata: TaskMetadata {
                _taskid: "test".to_string(),
                task_type: FewShotTaskType::Classification,
                domain: "test_domain".to_string(),
                complexity: 0.5,
                creation_time: Instant::now(),
            },
            quality_metrics: SupportSetQuality {
                diversity: 0.5,
                representativeness: 0.5,
                difficulty_balance: 0.5,
                coverage: 0.5,
                overall_quality: 0.5,
            },
            timestamp: Instant::now(),
        };

        assert_eq!(supportset.examples.len(), 1);
        assert_eq!(supportset.labels.len(), 1);
    }
}