solverforge-solver 0.18.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

//! Public static facade for canonical multi-list-swap mechanics.

use std::fmt::Debug;

use smallvec::SmallVec;
use solverforge_core::domain::PlanningSolution;
use solverforge_scoring::Director;

use super::list_kernel::{
    multi_swap_do_move, multi_swap_entity_indices, multi_swap_is_doable, multi_swap_tabu_signature,
    multi_swap_undo_move, MultiSwapCoordinates, StaticListSwapAccess,
};
use super::{Move, MoveTabuSignature};

/// Multiple independent intra-list swaps, one per entity.
///
/// The public move keeps its historic constructor and score-improvement flag;
/// shared list-kernel mechanics own doability, notifications, mutation, undo,
/// and tabu identity for static and runtime carriers alike.
pub struct ListMultiSwapMove<S, V> {
    swaps: MultiSwapCoordinates,
    access: StaticListSwapAccess<S, V>,
    indices: SmallVec<[usize; 4]>,
    require_score_improvement: bool,
}

impl<S, V> Clone for ListMultiSwapMove<S, V> {
    fn clone(&self) -> Self {
        Self {
            swaps: self.swaps.clone(),
            access: self.access,
            indices: self.indices.clone(),
            require_score_improvement: self.require_score_improvement,
        }
    }
}

impl<S, V: Debug> Debug for ListMultiSwapMove<S, V> {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("ListMultiSwapMove")
            .field("swaps", &self.swaps)
            .field("variable_name", &self.access.variable_name)
            .field("require_score_improvement", &self.require_score_improvement)
            .finish()
    }
}

impl<S, V> ListMultiSwapMove<S, V> {
    pub fn new(
        swaps: &[(usize, usize, usize)],
        list_len: fn(&S, usize) -> usize,
        list_get: fn(&S, usize, usize) -> Option<V>,
        list_set: fn(&mut S, usize, usize, V),
        variable_name: &'static str,
        descriptor_index: usize,
    ) -> Self {
        Self {
            swaps: swaps.iter().copied().collect(),
            access: StaticListSwapAccess {
                list_len,
                list_get,
                list_set,
                variable_name,
                descriptor_index,
            },
            indices: multi_swap_entity_indices(swaps),
            require_score_improvement: false,
        }
    }

    pub fn with_require_score_improvement(mut self, require_score_improvement: bool) -> Self {
        self.require_score_improvement = require_score_improvement;
        self
    }

    pub fn swaps(&self) -> &[(usize, usize, usize)] {
        &self.swaps
    }
}

impl<S, V> Move<S> for ListMultiSwapMove<S, V>
where
    S: PlanningSolution,
    V: Clone + PartialEq + Send + Sync + Debug + 'static,
{
    type Undo = ();

    fn is_doable<D: Director<S>>(&self, score_director: &D) -> bool {
        multi_swap_is_doable(&self.access, &self.swaps, score_director)
    }

    fn do_move<D: Director<S>>(&self, score_director: &mut D) -> Self::Undo {
        multi_swap_do_move(&self.access, &self.swaps, &self.indices, score_director)
    }

    fn undo_move<D: Director<S>>(&self, score_director: &mut D, (): Self::Undo) {
        multi_swap_undo_move(&self.access, &self.swaps, &self.indices, score_director);
    }

    fn descriptor_index(&self) -> usize {
        self.access.descriptor_index
    }

    fn entity_indices(&self) -> &[usize] {
        &self.indices
    }

    fn variable_name(&self) -> &str {
        self.access.variable_name
    }

    fn telemetry_label(&self) -> &'static str {
        "list_multi_swap"
    }

    fn requires_score_improvement(&self) -> bool {
        self.require_score_improvement
    }

    fn tabu_signature<D: Director<S>>(&self, score_director: &D) -> MoveTabuSignature {
        multi_swap_tabu_signature(&self.access, &self.swaps, &self.indices, score_director)
    }
}