solverforge-solver 0.12.1

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
138
139

fn assignment_config_with_heuristic(
    heuristic: ConstructionHeuristicType,
) -> ConstructionHeuristicConfig {
    ConstructionHeuristicConfig {
        construction_heuristic_type: heuristic,
        ..assignment_config()
    }
}

fn assignment_model_without_value_order(
) -> RuntimeModel<CoveragePlan, usize, DefaultMeter, DefaultMeter> {
    assignment_model_with_order_hooks(true, false)
}

fn assignment_model_without_entity_order(
) -> RuntimeModel<CoveragePlan, usize, DefaultMeter, DefaultMeter> {
    assignment_model_with_order_hooks(false, true)
}

fn assignment_model_with_order_hooks(
    include_entity_order: bool,
    include_value_order: bool,
) -> RuntimeModel<CoveragePlan, usize, DefaultMeter, DefaultMeter> {
    let scalar_slot = ScalarVariableSlot::new(
        0,
        0,
        "CoverageSlot",
        |solution: &CoveragePlan| solution.slots.len(),
        "worker",
        |solution, entity_index, _variable_index| solution.slots[entity_index].assigned,
        |solution, entity_index, _variable_index, value| {
            solution.slots[entity_index].assigned = value;
        },
        ValueSource::EntitySlice {
            values_for_entity: coverage_values,
        },
        true,
    );
    let mut group = ScalarGroup::assignment(
        "slot_assignment",
        ScalarTarget::from_descriptor_index(0, "worker"),
    )
    .with_required_entity(coverage_required)
    .with_capacity_key(coverage_capacity_key)
    .with_position_key(coverage_position_key)
    .with_sequence_key(coverage_sequence_key);
    if include_entity_order {
        group = group.with_entity_order(coverage_entity_order);
    }
    if include_value_order {
        group = group.with_value_order(coverage_value_order);
    }
    RuntimeModel::new(vec![VariableSlot::Scalar(scalar_slot)]).with_scalar_groups(
        bind_scalar_groups(vec![group], &[scalar_slot]),
    )
}

#[test]
fn scalar_assignment_cheapest_insertion_scores_required_assignment_values() {
    let solver_scope = solve_assignment_with_config_and_model(
        coverage_plan(
            2,
            vec![
                coverage_slot(true, 0, None, &[0, 1]),
                coverage_slot(false, 0, Some(0), &[0]),
            ],
        ),
        assignment_config_with_heuristic(ConstructionHeuristicType::CheapestInsertion),
        assignment_model(),
    );

    let slots = &solver_scope.working_solution().slots;
    assert_eq!(slots[0].assigned, Some(1));
    assert_eq!(slots[1].assigned, Some(0));
    assert_eq!(
        solver_scope.current_score().copied(),
        Some(HardSoftScore::of(0, 0))
    );
}

#[test]
fn scalar_assignment_weakest_fit_uses_assignment_value_order() {
    let solver_scope = solve_assignment_with_config_and_model(
        coverage_plan(2, vec![coverage_slot(true, 0, None, &[0, 1])]),
        assignment_config_with_heuristic(ConstructionHeuristicType::WeakestFit),
        assignment_model(),
    );

    assert_eq!(solver_scope.working_solution().slots[0].assigned, Some(0));
}

#[test]
fn scalar_assignment_strongest_fit_uses_assignment_value_order() {
    let solver_scope = solve_assignment_with_config_and_model(
        coverage_plan(2, vec![coverage_slot(true, 0, None, &[0, 1])]),
        assignment_config_with_heuristic(ConstructionHeuristicType::StrongestFit),
        assignment_model(),
    );

    assert_eq!(solver_scope.working_solution().slots[0].assigned, Some(1));
}

#[test]
#[should_panic(expected = "requires ScalarGroup::with_value_order")]
fn scalar_assignment_strength_heuristics_validate_value_order_hook() {
    let _ = solve_assignment_with_config_and_model(
        coverage_plan(2, vec![coverage_slot(true, 0, None, &[0, 1])]),
        assignment_config_with_heuristic(ConstructionHeuristicType::WeakestFit),
        assignment_model_without_value_order(),
    );
}

#[test]
#[should_panic(expected = "requires ScalarGroup::with_entity_order")]
fn scalar_assignment_decreasing_heuristics_validate_entity_order_hook() {
    let _ = solve_assignment_with_config_and_model(
        coverage_plan(2, vec![coverage_slot(true, 0, None, &[0, 1])]),
        assignment_config_with_heuristic(ConstructionHeuristicType::FirstFitDecreasing),
        assignment_model_without_entity_order(),
    );
}

#[test]
fn scalar_assignment_optional_construction_remains_score_improving_only() {
    let solver_scope = solve_assignment_with_config_and_model(
        coverage_plan(
            1,
            vec![coverage_slot_with_penalty(false, 0, None, &[0], 5)],
        ),
        assignment_config(),
        assignment_model(),
    );

    assert_eq!(solver_scope.working_solution().slots[0].assigned, None);
    assert_eq!(
        solver_scope.current_score().copied(),
        Some(HardSoftScore::of(0, -1))
    );
}