schedulr 0.8.0

Scheduling framework (activity/resource/interval DSL) built on unifier
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

use crate::{
    CompiledProblem, ScoreLevel, ScoreRule, ScoreRuleKind, Solution, SolveResult, compile,
};
use std::time::Duration;
use unifier::{LnsSolver, SolverOptions};

#[derive(Debug, Clone)]
pub struct RepairOptions {
    pub change_penalty: i64,
    pub destroy_fraction: f64,
    pub time_limit: Duration,
}

impl Default for RepairOptions {
    fn default() -> Self {
        Self {
            change_penalty: 1_000_000,
            destroy_fraction: 0.3,
            time_limit: Duration::from_secs(1),
        }
    }
}

impl CompiledProblem {
    /// Re-solves around a baseline using a strong penalty per changed assignment and LNS.
    pub fn repair(&self, baseline: &Solution, options: &RepairOptions) -> SolveResult {
        let mut problem = self.problem.clone();
        problem
            .score_rules
            .extend(baseline.assignments.iter().map(|assignment| ScoreRule {
                category: "stability".to_string(),
                level: ScoreLevel::Strong,
                activity: assignment.activity,
                weight: options.change_penalty,
                kind: ScoreRuleKind::KeepStart(assignment.window.start),
            }));
        let Ok(compiled) = compile(&problem) else {
            return self.solve();
        };
        let baseline_assignment = compiled.internal.assignment_map(baseline);
        let outcome = LnsSolver::new(options.destroy_fraction).solve_from(
            &compiled.internal.graph,
            &baseline_assignment,
            &SolverOptions {
                time_limit: Some(options.time_limit),
                ..SolverOptions::default()
            },
        );
        compiled.internal.solve_result(outcome)
    }
}