scirs2-metrics 0.3.0

Machine Learning evaluation metrics module for SciRS2 (scirs2-metrics)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Multi-robot coordination metrics
//!
//! This module provides metrics for evaluating multi-robot systems,
//! including formation control, task allocation, and collective behavior.

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

use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Multi-robot coordination metrics
#[derive(Debug, Clone)]
pub struct MultiRobotMetrics {
    /// Formation control performance
    pub formation_control: FormationControlMetrics,
    /// Task allocation efficiency
    pub task_allocation: TaskAllocationMetrics,
    /// Network performance
    pub network_performance: NetworkPerformanceMetrics,
    /// Collective behavior assessment
    pub collective_behavior: CollectiveBehaviorMetrics,
}

/// Formation control evaluation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FormationControlMetrics {
    /// Formation maintenance accuracy
    pub formation_accuracy: f64,
    /// Convergence time to formation
    pub convergence_time: Duration,
    /// Formation stability
    pub stability: f64,
    /// Leader-follower coordination
    pub coordination_quality: f64,
}

/// Task allocation performance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskAllocationMetrics {
    /// Allocation optimality
    pub allocation_optimality: f64,
    /// Load balancing efficiency
    pub load_balancing: f64,
    /// Adaptation to failures
    pub failure_adaptation: f64,
    /// Communication overhead
    pub communication_overhead: f64,
}

/// Network performance metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetworkPerformanceMetrics {
    /// Communication latency
    pub latency: Duration,
    /// Message loss rate
    pub message_loss_rate: f64,
    /// Bandwidth utilization
    pub bandwidth_utilization: f64,
    /// Network reliability
    pub network_reliability: f64,
}

/// Collective behavior assessment
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CollectiveBehaviorMetrics {
    /// Swarm cohesion
    pub swarm_cohesion: f64,
    /// Emergent behavior quality
    pub emergent_behavior: f64,
    /// Scalability factor
    pub scalability: f64,
    /// Fault tolerance
    pub fault_tolerance: f64,
}

impl MultiRobotMetrics {
    /// Create new multi-robot metrics
    pub fn new() -> Self {
        Self {
            formation_control: FormationControlMetrics::default(),
            task_allocation: TaskAllocationMetrics::default(),
            network_performance: NetworkPerformanceMetrics::default(),
            collective_behavior: CollectiveBehaviorMetrics::default(),
        }
    }
}

// Default implementations
impl Default for FormationControlMetrics {
    fn default() -> Self {
        Self {
            formation_accuracy: 1.0,
            convergence_time: Duration::from_secs(0),
            stability: 1.0,
            coordination_quality: 1.0,
        }
    }
}

impl Default for TaskAllocationMetrics {
    fn default() -> Self {
        Self {
            allocation_optimality: 1.0,
            load_balancing: 1.0,
            failure_adaptation: 1.0,
            communication_overhead: 0.0,
        }
    }
}

impl Default for NetworkPerformanceMetrics {
    fn default() -> Self {
        Self {
            latency: Duration::from_millis(0),
            message_loss_rate: 0.0,
            bandwidth_utilization: 0.5,
            network_reliability: 1.0,
        }
    }
}

impl Default for CollectiveBehaviorMetrics {
    fn default() -> Self {
        Self {
            swarm_cohesion: 1.0,
            emergent_behavior: 1.0,
            scalability: 1.0,
            fault_tolerance: 1.0,
        }
    }
}