h2lang 0.5.4

H2 Language - A Herbert Online Judge compatible programming language with multi-agent support
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

//! Parallel scheduling for multiple agents.

use crate::expander::Command;

/// A command for a specific agent at a specific step.
#[derive(Debug, Clone)]
pub struct AgentCommand {
    /// Agent ID
    pub agent_id: u32,
    /// Command to execute
    pub command: Command,
}

/// A single step in the timeline (all agents' commands at this step).
#[derive(Debug, Clone)]
pub struct TimelineStep {
    /// Step number (0-based)
    pub step: usize,
    /// Commands for all agents at this step
    pub agent_commands: Vec<AgentCommand>,
}

/// Scheduler for parallel execution of multiple agents.
pub struct Scheduler;

impl Scheduler {
    /// Schedule multiple agents' commands into a timeline.
    ///
    /// Each step in the timeline contains all agents' commands for that step.
    /// If an agent has fewer commands than the maximum, it won't have a command
    /// for the remaining steps (wait state).
    pub fn schedule(agents: &[(u32, Vec<Command>)]) -> Vec<TimelineStep> {
        if agents.is_empty() {
            return Vec::new();
        }

        // Find maximum number of steps
        let max_len = agents.iter().map(|(_, cmds)| cmds.len()).max().unwrap_or(0);

        let mut timeline = Vec::with_capacity(max_len);

        for step in 0..max_len {
            let mut agent_commands = Vec::new();

            for (agent_id, commands) in agents {
                if let Some(cmd) = commands.get(step) {
                    agent_commands.push(AgentCommand {
                        agent_id: *agent_id,
                        command: *cmd,
                    });
                }
                // If no command for this step, agent waits (not included in timeline)
            }

            timeline.push(TimelineStep {
                step,
                agent_commands,
            });
        }

        timeline
    }

    /// Get the maximum number of steps across all agents.
    pub fn max_steps(agents: &[(u32, Vec<Command>)]) -> usize {
        agents.iter().map(|(_, cmds)| cmds.len()).max().unwrap_or(0)
    }
}

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

    #[test]
    fn test_single_agent() {
        let agents = vec![(0, vec![Command::Straight, Command::Right, Command::Left])];

        let timeline = Scheduler::schedule(&agents);

        assert_eq!(timeline.len(), 3);
        assert_eq!(timeline[0].agent_commands.len(), 1);
        assert_eq!(timeline[0].agent_commands[0].agent_id, 0);
        assert_eq!(timeline[0].agent_commands[0].command, Command::Straight);
    }

    #[test]
    fn test_multiple_agents_same_length() {
        let agents = vec![
            (0, vec![Command::Straight, Command::Right]),
            (1, vec![Command::Left, Command::Straight]),
        ];

        let timeline = Scheduler::schedule(&agents);

        assert_eq!(timeline.len(), 2);
        assert_eq!(timeline[0].agent_commands.len(), 2);
        assert_eq!(timeline[1].agent_commands.len(), 2);
    }

    #[test]
    fn test_multiple_agents_different_length() {
        let agents = vec![
            (0, vec![Command::Straight, Command::Right, Command::Left]),
            (1, vec![Command::Left]),
        ];

        let timeline = Scheduler::schedule(&agents);

        assert_eq!(timeline.len(), 3);
        assert_eq!(timeline[0].agent_commands.len(), 2);
        assert_eq!(timeline[1].agent_commands.len(), 1); // Agent 1 is done
        assert_eq!(timeline[2].agent_commands.len(), 1); // Only agent 0
    }

    #[test]
    fn test_empty_agents() {
        let agents: Vec<(u32, Vec<Command>)> = vec![];
        let timeline = Scheduler::schedule(&agents);
        assert!(timeline.is_empty());
    }

    #[test]
    fn test_max_steps() {
        let agents = vec![
            (0, vec![Command::Straight, Command::Right, Command::Left]),
            (1, vec![Command::Left]),
        ];

        assert_eq!(Scheduler::max_steps(&agents), 3);
    }
}