ferroplan 0.9.0

A fast, data-parallel PDDL planner in Rust — FF heuristic with ADL, numeric, derived axioms, PDDL3 preferences, PDDL2.1 temporal, and a goal decomposer
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

//! Output rendering. Default = classic Metric-FF format (drop-in for the planner
//! crate + the differential validator); `-ipc` = SGPlan6's IPC temporal format.

use crate::packed::PackedTask;

use crate::resolve::Stats;

/// Classic-FF plan body: `step    0: NAME ARGS` framing + trailing 5-space line.
pub fn ff_plan(task: &PackedTask, ops: &[usize]) -> String {
    let mut s = String::from("\nff: found legal plan as follows\n\nstep ");
    for (i, &oi) in ops.iter().enumerate() {
        s.push_str(&format!("{:4}: {}", i, task.op_display[oi]));
        s.push_str("\n     ");
    }
    s
}

/// SGPlan6 IPC temporal format: `0.001: (NAME ARGS) [1]` + `; ` headers.
/// `metric` fills the `; MetricValue` line when present (PDDL3 optimization).
pub fn ipc_plan(task: &PackedTask, ops: &[usize], metric: Option<f64>) -> String {
    let mv = match metric {
        Some(v) => format!("; MetricValue {}\n", v),
        None => "; MetricValue\n".to_string(),
    };
    let mut s = format!(
        "\n; Time 0.00\n; ParsingTime 0.00\n; NrActions {}\n; MakeSpan\n{}\
         ; PlanningTechnique partition-and-resolve over modified-FF (ffdp) subplanner\n\n",
        ops.len(),
        mv
    );
    for (i, &oi) in ops.iter().enumerate() {
        // start times mirror sgplan6: 0.001, 1.002, 2.003, ... (carry-correct for
        // plans >= 1000 steps, unlike a naive "{i}.{i+1:03}").
        let t = i as f64 * 1.001 + 0.001;
        s.push_str(&format!("{:.3}: ({}) [1]\n", t, task.op_display[oi]));
    }
    s
}

pub fn timing(stats: &Stats, threads: usize) -> String {
    format!(
        "\ntime spent:    0.00 seconds partition-and-resolve ({} threads)\n\
         \x20              {} initial groups, {} final groups, {} merges{}\n\
         \x20              0.00 seconds total time\n\n",
        threads,
        stats.init_groups,
        stats.final_groups,
        stats.merges,
        if stats.fallback {
            " (monolithic fallback)"
        } else {
            ""
        },
    )
}

/// Footer for the PDDL3 metric-optimization path (classic-FF mode).
pub fn metric_footer(
    cost: f64,
    iterations: usize,
    n_prefs: usize,
    threads: usize,
    warn_other: bool,
) -> String {
    let warn = if warn_other {
        "\n               note: metric has terms beyond is-violated/total-cost; optimized the supported part"
    } else {
        ""
    };
    format!(
        "\ntime spent:    0.00 seconds PDDL3 metric optimization ({} threads)\n\
         \x20              metric value {}, {} preferences, {} branch-and-bound iterations{}\n\
         \x20              0.00 seconds total time\n\n",
        threads, cost, n_prefs, iterations, warn
    )
}

/// The post-parse search-config banner.
pub fn preamble(threads: usize) -> String {
    format!(
        "\n\nno metric specified. plan length assumed.\n\n\
         checking for cyclic := effects --- OK.\n\n\
         ff: search configuration is SGPlan partition-and-resolve over the ffdp subplanner [{} threads]\n",
        threads
    )
}