scirs2-metrics 0.3.2

//! Core configuration and fundamental types for neuromorphic computing
//!
//! This module contains the basic configuration structures and core types
//! used throughout the neuromorphic computing system.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use scirs2_core::ndarray::Array2;
use scirs2_core::numeric::Float;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{Duration, Instant};

/// Configuration for neuromorphic computing
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NeuromorphicConfig {
    /// Number of input neurons
    pub input_neurons: usize,
    /// Number of hidden layers
    pub hidden_layers: usize,
    /// Neurons per hidden layer
    pub neurons_per_layer: usize,
    /// Number of output neurons
    pub output_neurons: usize,
    /// Membrane potential threshold
    pub spike_threshold: f64,
    /// Refractory period (milliseconds)
    pub refractory_period: Duration,
    /// Synaptic delay range
    pub synaptic_delay_range: (Duration, Duration),
    /// Learning rate for plasticity
    pub learning_rate: f64,
    /// Decay rate for membrane potentials
    pub membrane_decay: f64,
    /// Enable STDP (Spike-Timing-Dependent Plasticity)
    pub enable_stdp: bool,
    /// Enable homeostatic plasticity
    pub enable_homeostasis: bool,
    /// Enable memory consolidation
    pub enable_memory_consolidation: bool,
    /// Enable quantum processing
    pub enable_quantum_processing: bool,
    /// Simulation time step (microseconds)
    pub timestep: Duration,
    /// Maximum simulation time
    pub max_simulation_time: Duration,
}

impl Default for NeuromorphicConfig {
    fn default() -> Self {
        Self {
            input_neurons: 100,
            hidden_layers: 3,
            neurons_per_layer: 500,
            output_neurons: 10,
            spike_threshold: -55.0, // Typical neuronal threshold potential in mV
            refractory_period: Duration::from_millis(2),
            synaptic_delay_range: (Duration::from_micros(100), Duration::from_millis(10)),
            learning_rate: 0.01,
            membrane_decay: 0.95,
            enable_stdp: true,
            enable_homeostasis: true,
            enable_memory_consolidation: true,
            enable_quantum_processing: false,
            timestep: Duration::from_micros(100),
            max_simulation_time: Duration::from_secs(10),
        }
    }
}

/// Network topology definition
#[derive(Debug, Clone)]
pub struct NetworkTopology {
    /// Layer sizes
    pub layer_sizes: Vec<usize>,
    /// Connection patterns between layers
    pub connection_patterns: Vec<ConnectionPattern>,
    /// Recurrent connections
    pub recurrent_connections: Vec<RecurrentConnection>,
}

/// Connection pattern between layers
#[derive(Debug, Clone)]
pub enum ConnectionPattern {
    /// Fully connected
    FullyConnected,
    /// Sparse random connections
    SparseRandom { probability: f64 },
    /// Convolutional-like patterns
    Convolutional { kernel_size: usize, stride: usize },
    /// Custom connectivity matrix
    Custom { matrix: Array2<bool> },
}

/// Recurrent connection definition
#[derive(Debug, Clone)]
pub struct RecurrentConnection {
    pub from_layer: usize,
    pub to_layer: usize,
    pub delay: Duration,
    pub strength: f64,
}

/// Types of neurons
#[derive(Debug, Clone)]
pub enum NeuronType {
    /// Excitatory neuron
    Excitatory,
    /// Inhibitory neuron
    Inhibitory,
    /// Modulatory neuron
    Modulatory,
    /// Input neuron
    Input,
    /// Output neuron
    Output,
}

/// Learning rules for synaptic plasticity
#[derive(Debug, Clone)]
pub enum LearningRule {
    /// Spike-Timing-Dependent Plasticity
    STDP {
        window_size: Duration,
        ltp_amplitude: f64,
        ltd_amplitude: f64,
    },
    /// Rate-based Hebbian learning
    Hebbian { learning_rate: f64 },
    /// Homeostatic scaling
    Homeostatic { target_rate: f64 },
    /// Reward-modulated plasticity
    RewardModulated { dopamine_sensitivity: f64 },
    /// Meta-plasticity
    MetaPlasticity { history_length: usize },
}

/// Inhibition patterns
#[derive(Debug, Clone)]
pub enum InhibitionPattern {
    /// Uniform inhibition
    Uniform,
    /// Distance-based inhibition
    DistanceBased,
    /// Winner-take-all
    WinnerTakeAll,
    /// Mexican hat
    MexicanHat,
}

/// Layer-specific parameters
#[derive(Debug)]
pub struct LayerParameters<F: Float> {
    /// Excitatory/inhibitory ratio
    pub excitatory_ratio: F,
    /// Background noise level
    pub noise_level: F,
    /// Neuromodulator concentrations
    pub neuromodulators: HashMap<String, F>,
    /// Layer-specific learning rules
    pub learning_rules: Vec<LearningRule>,
}

impl<F: Float> Default for LayerParameters<F> {
    fn default() -> Self {
        Self {
            excitatory_ratio: F::from(0.8).expect("Failed to convert constant to float"),
            noise_level: F::from(0.01).expect("Failed to convert constant to float"),
            neuromodulators: HashMap::new(),
            learning_rules: vec![LearningRule::STDP {
                window_size: Duration::from_millis(20),
                ltp_amplitude: 0.1,
                ltd_amplitude: -0.05,
            }],
        }
    }
}

/// Lateral inhibition within layer
#[derive(Debug)]
pub struct LateralInhibition<F: Float> {
    /// Inhibition strength
    pub strength: F,
    /// Inhibition radius
    pub radius: usize,
    /// Inhibition pattern
    pub pattern: InhibitionPattern,
}

impl<F: Float> Default for LateralInhibition<F> {
    fn default() -> Self {
        Self {
            strength: F::from(0.1).expect("Failed to convert constant to float"),
            radius: 3,
            pattern: InhibitionPattern::DistanceBased,
        }
    }
}

/// Connection topology
#[derive(Debug, Clone)]
pub struct ConnectionTopology {
    /// Adjacency matrix
    pub adjacency_matrix: Array2<bool>,
    /// Connection weights
    pub weight_matrix: Array2<f64>,
    /// Small-world properties
    pub small_world: SmallWorldProperties,
}

/// Small-world network properties
#[derive(Debug, Clone)]
pub struct SmallWorldProperties {
    /// Clustering coefficient
    pub clustering_coefficient: f64,
    /// Average path length
    pub average_path_length: f64,
    /// Small-world index
    pub small_world_index: f64,
}

/// Synchrony measures for network analysis
#[derive(Debug, Clone)]
pub struct SynchronyMeasures {
    /// Global synchrony
    pub global_synchrony: f64,
    /// Local synchrony
    pub local_synchrony: Vec<f64>,
    /// Phase coherence
    pub phase_coherence: f64,
    /// Metastability index
    pub metastability: f64,
}

/// Network oscillations analysis
#[derive(Debug, Clone)]
pub struct NetworkOscillations<F: Float> {
    /// Dominant frequencies
    pub dominant_frequencies: Vec<F>,
    /// Power spectral density
    pub power_spectrum: Vec<F>,
    /// Gamma oscillations (30-100 Hz)
    pub gamma_power: F,
    /// Beta oscillations (13-30 Hz)
    pub beta_power: F,
    /// Alpha oscillations (8-13 Hz)
    pub alpha_power: F,
    /// Theta oscillations (4-8 Hz)
    pub theta_power: F,
}

/// Criticality measures for self-organized criticality
#[derive(Debug, Clone)]
pub struct CriticalityMeasures<F: Float> {
    /// Avalanche size distribution
    pub avalanche_distribution: Vec<F>,
    /// Branching parameter
    pub branching_parameter: F,
    /// Critical exponent
    pub critical_exponent: F,
    /// Activity variance
    pub activity_variance: F,
}

/// Information-theoretic metrics
#[derive(Debug, Clone)]
pub struct InformationMetrics<F: Float> {
    /// Mutual information
    pub mutual_information: F,
    /// Transfer entropy
    pub transfer_entropy: F,
    /// Integrated information
    pub integrated_information: F,
    /// Complexity measures
    pub complexity: F,
}

/// Types of synapses
#[derive(Debug, Clone)]
pub enum SynapseType {
    /// Chemical synapse
    Chemical,
    /// Electrical synapse (gap junction)
    Electrical,
    /// Modulatory synapse
    Modulatory,
    /// Plastic synapse
    Plastic,
}

/// Homeostatic controller for maintaining network stability
#[derive(Debug)]
pub struct HomeostaticController<F: Float> {
    /// Target firing rates
    pub target_rates: HashMap<usize, F>,
    /// Adaptation time constants
    pub adaptation_constants: HashMap<usize, F>,
    /// Scaling factors
    pub scaling_factors: HashMap<usize, F>,
    /// Intrinsic excitability parameters
    pub intrinsic_excitability: HashMap<usize, F>,
}

impl<F: Float> HomeostaticController<F> {
    /// Create new homeostatic controller
    pub fn new(config: &NeuromorphicConfig) -> crate::error::Result<Self> {
        let mut target_rates = HashMap::new();
        let mut adaptation_constants = HashMap::new();
        let mut scaling_factors = HashMap::new();
        let mut intrinsic_excitability = HashMap::new();

        // Initialize with default values for all neurons
        let total_neurons = config.input_neurons
            + (config.hidden_layers * config.neurons_per_layer)
            + config.output_neurons;

        for i in 0..total_neurons {
            target_rates.insert(
                i,
                F::from(5.0).expect("Failed to convert constant to float"),
            ); // 5 Hz target
            adaptation_constants.insert(
                i,
                F::from(0.01).expect("Failed to convert constant to float"),
            );
            scaling_factors.insert(i, F::one());
            intrinsic_excitability.insert(i, F::one());
        }

        Ok(Self {
            target_rates,
            adaptation_constants,
            scaling_factors,
            intrinsic_excitability,
        })
    }

    /// Regulate network activity
    pub fn regulate<T>(&mut self, _network: &mut T) -> crate::error::Result<()> {
        // Simplified homeostatic regulation
        // In practice, this would adjust synaptic weights and intrinsic properties
        // based on deviation from target firing rates
        Ok(())
    }

    /// Update configuration
    pub fn update_config(&mut self, _config: &NeuromorphicConfig) -> crate::error::Result<()> {
        Ok(())
    }
}