solverforge-solver 0.21.0

Solver engine for SolverForge
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
133
134
135
136
137


fn director_cursor_indices<C>(cursor: &mut C, director: &mut ScoreDirector<Plan, ()>) -> Vec<crate::heuristic::selector::move_selector::CandidateId>
where
    C: MoveCursor<Plan, super::DescriptorMoveUnion<Plan>>,
{
    let mut indices = Vec::new();
    while let Some(id) = cursor.next_candidate_with_director(director) {
        indices.push(id);
    }
    indices
}

#[test]
fn descriptor_cartesian_builds_composite_moves() {
    let descriptor = descriptor();
    let plan = Plan {
        workers: vec![Worker, Worker, Worker],
        tasks: vec![
            Task {
                worker_idx: Some(0),
            },
            Task {
                worker_idx: Some(1),
            },
        ],
        score: None,
    };
    let mut director = ScoreDirector::simple(plan, descriptor.clone(), |s, _| s.tasks.len());
    let config = MoveSelectorConfig::CartesianProductMoveSelector(CartesianProductConfig {
        require_hard_improvement: false,
        selectors: vec![
            MoveSelectorConfig::ChangeMoveSelector(ChangeMoveConfig {
                selection_order: None,
                selection_metric: None,
                value_candidate_limit: None,
                target: VariableTargetConfig::default(),
            }),
            MoveSelectorConfig::SwapMoveSelector(SwapMoveConfig {
                selection_order: None,
                selection_metric: None,
                target: VariableTargetConfig::default(),
            }),
        ],
    });

    let selector = build_descriptor_move_selector::<Plan>(Some(&config), &descriptor, None);
    let mut cursor = selector.open_cursor(&director);
    let indices = director_cursor_indices(&mut cursor, &mut director);

    assert!(!indices.is_empty());
    assert!(indices.iter().all(|&index| matches!(
        cursor.candidate(index),
        Some(MoveCandidateRef::Sequential(_))
    )));
    let signature = cursor
        .candidate(indices[0])
        .expect("descriptor cartesian candidate must remain valid")
        .tabu_signature(&director);
    assert!(!signature.move_id.is_empty());
    assert!(!signature.entity_tokens.is_empty());
}

fn keep_all_descriptor_cartesian_candidates(
    candidate: MoveCandidateRef<'_, Plan, super::DescriptorMoveUnion<Plan>>,
) -> bool {
    matches!(candidate, MoveCandidateRef::Sequential(_))
}

#[test]
fn descriptor_cartesian_selector_survives_filtering_wrapper() {
    let descriptor = descriptor();
    let plan = Plan {
        workers: vec![Worker, Worker, Worker],
        tasks: vec![
            Task {
                worker_idx: Some(0),
            },
            Task {
                worker_idx: Some(1),
            },
        ],
        score: None,
    };
    let mut director = ScoreDirector::simple(plan, descriptor.clone(), |s, _| s.tasks.len());
    let config = MoveSelectorConfig::CartesianProductMoveSelector(CartesianProductConfig {
        require_hard_improvement: false,
        selectors: vec![
            MoveSelectorConfig::ChangeMoveSelector(ChangeMoveConfig {
                selection_order: None,
                selection_metric: None,
                value_candidate_limit: None,
                target: VariableTargetConfig::default(),
            }),
            MoveSelectorConfig::SwapMoveSelector(SwapMoveConfig {
                selection_order: None,
                selection_metric: None,
                target: VariableTargetConfig::default(),
            }),
        ],
    });

    let selector = build_descriptor_move_selector::<Plan>(Some(&config), &descriptor, None);
    let filtered = FilteringMoveSelector::new(selector, keep_all_descriptor_cartesian_candidates);
    let mut cursor = filtered.open_cursor(&director);
    let indices = director_cursor_indices(&mut cursor, &mut director);

    assert!(!indices.is_empty());
    assert!(indices.iter().all(|&index| matches!(
        cursor.candidate(index),
        Some(MoveCandidateRef::Sequential(_))
    )));
    assert!(cursor
        .candidate(indices[0])
        .is_some_and(|mov| mov.is_doable(&director)));
}

#[test]
#[should_panic(
    expected = "cartesian_product left child cannot contain ruin_recreate_move_selector"
)]
fn descriptor_cartesian_rejects_score_seeking_left_child() {
    let descriptor = descriptor();
    let config = MoveSelectorConfig::CartesianProductMoveSelector(CartesianProductConfig {
        require_hard_improvement: false,
        selectors: vec![
            MoveSelectorConfig::RuinRecreateMoveSelector(RuinRecreateMoveSelectorConfig::default()),
            MoveSelectorConfig::ChangeMoveSelector(ChangeMoveConfig {
                selection_order: None,
                selection_metric: None,
                value_candidate_limit: None,
                target: VariableTargetConfig::default(),
            }),
        ],
    });

    let _ = build_descriptor_move_selector::<Plan>(Some(&config), &descriptor, None);
}