Struct AnomalyGridConfig 

pub struct AnomalyGridConfig {
    pub max_order: usize,
    pub smoothing_alpha: f64,
    pub memory_limit: Option<usize>,
    pub min_probability: f64,
    pub likelihood_weight: f64,
    pub information_weight: f64,
    pub normalization_factor: f64,
    pub min_sequence_length: usize,
}

Configuration parameters for Anomaly Grid components

Fields

max_order: usize

Maximum context order for Markov model

smoothing_alpha: f64

Laplace smoothing parameter (alpha)

memory_limit: Option<usize>

Maximum number of contexts to store (None = unlimited)

min_probability: f64

Minimum probability for numerical stability

likelihood_weight: f64

Weight for likelihood component in anomaly strength calculation

information_weight: f64

Weight for information component in anomaly strength calculation

normalization_factor: f64

Normalization factor for tanh scaling in anomaly strength

min_sequence_length: usize

Minimum sequence length for training

Implementations

impl AnomalyGridConfig

pub fn new() -> Self

Create a new configuration with default values

pub fn for_small_alphabet() -> Self

Create a configuration optimized for small alphabets (≤ 10 states)

pub fn for_large_alphabet() -> Self

Create a configuration optimized for large alphabets (> 20 states)

pub fn for_low_memory() -> Self

Create a configuration optimized for memory-constrained environments

pub fn for_high_accuracy() -> Self

Create a configuration optimized for high accuracy

pub fn validate(&self) -> AnomalyGridResult<()>

Validate the configuration parameters

pub fn with_max_order(self, max_order: usize) -> AnomalyGridResult<Self>

Set max_order with validation

Examples found in repository

examples/network_security_monitoring.rs (line 92)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🛡️ Network Security Monitoring with Anomaly Grid");
    println!("Detecting APTs, DDoS, and network intrusions\n");

    // Generate 5 days of normal network traffic (reduced for performance)
    let normal_events = generate_enterprise_traffic(5);
    println!(
        "Generated {} normal network events (5 days)",
        normal_events.len()
    );

    // Initialize anomaly detection system
    let mut detector = AnomalyDetector::new(4)?; // Order 4 for complex patterns

    // Train on normal network patterns
    let train_start = Instant::now();
    detector.train(&normal_events)?;
    println!("Training completed in {:?}", train_start.elapsed());

    // Real-time monitoring simulation
    println!("\n🔍 Starting real-time network monitoring...");

    // Test various attack scenarios
    let attack_scenarios = vec![
        ("Advanced Persistent Threat", generate_apt_campaign()),
        ("DDoS Attack", generate_ddos_attack()),
        ("Port Scan", generate_port_scan()),
        ("SQL Injection", generate_sql_injection()),
        ("Lateral Movement", generate_lateral_movement()),
    ];

    for (attack_name, attack_sequence) in attack_scenarios {
        println!("\nTesting: {attack_name}");

        let detect_start = Instant::now();
        let anomalies = detector.detect_anomalies(&attack_sequence, 0.001)?;
        let detect_time = detect_start.elapsed();

        if !anomalies.is_empty() {
            let max_strength = anomalies
                .iter()
                .map(|a| a.anomaly_strength)
                .fold(0.0, f64::max);

            let min_likelihood = anomalies
                .iter()
                .map(|a| a.likelihood)
                .fold(f64::INFINITY, f64::min);

            println!("  ✅ THREAT DETECTED");
            println!("  📊 Anomalies found: {}", anomalies.len());
            println!("  Max anomaly strength: {max_strength:.3}");
            println!("  Min likelihood: {min_likelihood:.2e}");
            println!("  Detection time: {detect_time:?}");

            // Alert classification
            let threat_level = if max_strength > 0.9 {
                "CRITICAL"
            } else if max_strength > 0.7 {
                "HIGH"
            } else if max_strength > 0.5 {
                "MEDIUM"
            } else {
                "LOW"
            };

            println!("  Threat Level: {threat_level}");
        } else {
            println!("  ❌ No anomalies detected");
        }
    }

    // Batch processing demonstration
    println!("\n📦 Batch Processing Demonstration");
    let batch_sequences = vec![
        generate_normal_session(),
        generate_malware_communication(),
        generate_data_exfiltration(),
    ];

    let batch_start = Instant::now();
    let config = AnomalyGridConfig::default().with_max_order(5)?;
    let batch_results = batch_process_sequences(&batch_sequences, &config, 0.01)?;
    let batch_time = batch_start.elapsed();

    println!(
        "Processed {} sequences in {:?}",
        batch_sequences.len(),
        batch_time
    );
    for (i, results) in batch_results.iter().enumerate() {
        println!("  Sequence {}: {} anomalies detected", i + 1, results.len());
    }

    Ok(())
}

examples/industrial_iot_monitoring.rs (line 122)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🏭 Industrial IoT Monitoring with Anomaly Grid");
    println!("Predictive maintenance and equipment failure detection\n");

    // Generate 1 month of normal sensor data (reduced for performance)
    let normal_readings = generate_industrial_data(30);
    println!(
        "Generated {} sensor readings (1 month)",
        normal_readings.len()
    );

    // Initialize anomaly detection for IoT sensor data
    let mut detector = AnomalyDetector::new(4)?; // Order 4 for sensor patterns

    // Train on normal operational data
    // Train on normal operational patterns
    detector.train(&normal_readings)?;

    // Equipment monitoring scenarios
    println!("\n🔧 Equipment Health Monitoring");

    let equipment_scenarios = vec![
        ("Bearing Wear", generate_bearing_wear_pattern()),
        ("Vibration Anomaly", generate_vibration_anomaly()),
        ("Temperature Drift", generate_temperature_drift()),
        ("Pressure Fluctuation", generate_pressure_fluctuation()),
        ("Lubrication Failure", generate_lubrication_failure()),
        ("Motor Imbalance", generate_motor_imbalance()),
        ("Seal Degradation", generate_seal_degradation()),
    ];

    let mut maintenance_alerts = 0;
    let mut critical_failures_prevented = 0;

    for (equipment_issue, sensor_sequence) in equipment_scenarios {
        println!("\nMonitoring: {equipment_issue}");

        let detect_start = Instant::now();
        let anomalies = detector.detect_anomalies(&sensor_sequence, 0.005)?; // Sensitive for safety
        let detect_time = detect_start.elapsed();

        if !anomalies.is_empty() {
            maintenance_alerts += 1;

            let severity = calculate_severity(&anomalies);
            let time_to_failure = estimate_time_to_failure(&sensor_sequence);
            let maintenance_cost = estimate_maintenance_cost(equipment_issue);

            println!("  ⚠️ MAINTENANCE ALERT");
            println!("  📊 Anomalies detected: {}", anomalies.len());
            println!("  Severity: {severity}");
            println!("  Time to failure: {time_to_failure} hours");
            println!("  Estimated maintenance cost: ${maintenance_cost:.0}");
            println!("  Detection time: {detect_time:?}");

            if severity == "CRITICAL" {
                critical_failures_prevented += 1;
                println!("  🚨 IMMEDIATE SHUTDOWN RECOMMENDED");
            }

            generate_maintenance_recommendation(equipment_issue, &severity, time_to_failure);
        } else {
            println!("  ✅ Equipment operating normally");
        }
    }

    // Production line monitoring
    println!("\n🏭 Production Line Monitoring");
    let production_data = generate_production_line_data();

    let line_start = Instant::now();
    let line_anomalies = detector.detect_anomalies(&production_data, 0.01)?;
    let line_time = line_start.elapsed();

    if !line_anomalies.is_empty() {
        let efficiency_impact = calculate_efficiency_impact(&line_anomalies);
        println!("Production anomalies detected: {}", line_anomalies.len());
        println!("Efficiency impact: {efficiency_impact:.1}%");
        println!("Detection time: {line_time:?}");
    } else {
        println!("Production line operating normally");
    }

    // Energy consumption monitoring
    println!("\n⚡ Energy Consumption Monitoring");
    let energy_data = generate_energy_consumption_data();

    let energy_start = Instant::now();
    let energy_anomalies = detector.detect_anomalies(&energy_data, 0.02)?;
    let energy_time = energy_start.elapsed();

    if !energy_anomalies.is_empty() {
        let energy_waste = calculate_energy_waste(&energy_anomalies);
        println!("Energy anomalies detected: {}", energy_anomalies.len());
        println!("Estimated energy waste: {energy_waste:.0} kWh");
        println!("Cost impact: ${:.2}", energy_waste * 0.12); // $0.12/kWh
        println!("Detection time: {energy_time:?}");
    } else {
        println!("Energy consumption within normal parameters");
    }

    // Batch processing for multiple machines
    println!("\n📦 Multi-Machine Batch Processing");
    let machine_data = vec![
        generate_machine_data("CNC_001"),
        generate_machine_data("PRESS_002"),
        generate_machine_data("ROBOT_003"),
        generate_machine_data("CONVEYOR_004"),
        generate_machine_data("WELDER_005"),
    ];

    let batch_start = Instant::now();
    let config = AnomalyGridConfig::default().with_max_order(6)?;
    let batch_results = batch_process_sequences(&machine_data, &config, 0.01)?;
    let batch_time = batch_start.elapsed();

    println!(
        "Processed {} machines in {:?}",
        machine_data.len(),
        batch_time
    );
    for (i, results) in batch_results.iter().enumerate() {
        let machine_names = [
            "CNC_001",
            "PRESS_002",
            "ROBOT_003",
            "CONVEYOR_004",
            "WELDER_005",
        ];
        println!(
            "  {}: {} anomalies detected",
            machine_names[i],
            results.len()
        );
    }

    // Summary and ROI calculation
    println!("\n📊 Predictive Maintenance Summary");
    println!("Maintenance alerts generated: {maintenance_alerts}");
    println!("Critical failures prevented: {critical_failures_prevented}");

    let downtime_prevented = critical_failures_prevented * 8; // 8 hours per failure
    let cost_savings = downtime_prevented as f64 * 5000.0; // $5000/hour downtime cost
    let maintenance_costs = maintenance_alerts as f64 * 2000.0; // $2000 per maintenance
    let net_savings = cost_savings - maintenance_costs;

    println!("Downtime prevented: {downtime_prevented} hours");
    println!("Cost savings: ${cost_savings:.0}");
    println!("Maintenance costs: ${maintenance_costs:.0}");
    println!("Net savings: ${net_savings:.0}");
    println!("ROI: {:.1}%", (net_savings / maintenance_costs) * 100.0);

    Ok(())
}

pub fn with_smoothing_alpha(self, alpha: f64) -> AnomalyGridResult<Self>

Set smoothing_alpha with validation

pub fn with_memory_limit(self, limit: Option<usize>) -> AnomalyGridResult<Self>

Set memory_limit with validation

pub fn with_weights( self, likelihood_weight: f64, information_weight: f64, ) -> AnomalyGridResult<Self>

Set anomaly strength weights with validation

pub fn estimate_memory_usage(&self, alphabet_size: usize) -> usize

Get estimated memory usage for given alphabet size

pub fn is_suitable_for_alphabet(&self, alphabet_size: usize) -> bool

Check if configuration is suitable for given alphabet size

Trait Implementations

impl Clone for AnomalyGridConfig

fn clone(&self) -> AnomalyGridConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AnomalyGridConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AnomalyGridConfig

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for AnomalyGridConfig

fn eq(&self, other: &AnomalyGridConfig) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for AnomalyGridConfig