Struct ListClarkeWrightPhase 

pub struct ListClarkeWrightPhase<S, E>
where
    S: PlanningSolution,
    E: Copy + Send + Sync + 'static,
{ /* private fields */ }

List construction phase using Clarke-Wright savings algorithm.

Builds routes by computing a savings value for every pair of elements, then greedily merges singleton routes in descending savings order, subject to a capacity constraint. All domain knowledge is supplied by the caller via function pointers — no time-window feasibility or post-processing is performed inside the phase.

Algorithm

1. For every pair (i, j) where i < j (depot excluded):
       savings(i, j) = dist(depot, i) + dist(depot, j) - dist(i, j)
2. Sort savings descending.
3. Start with each element in its own singleton route.
4. For each (i, j) in savings order:
       - Skip if i or j are in the same route.
       - Skip if merged load exceeds capacity.
       - Skip if i is not an endpoint of its route, or j is not.
       - Orient and merge the two routes.
5. Assign each non-empty route to an entity via assign_route.

Example

use solverforge_solver::ListClarkeWrightPhase;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SoftScore;

#[derive(Clone)]
struct Vehicle { route: Vec<usize> }

#[derive(Clone)]
struct Plan {
    vehicles: Vec<Vehicle>,
    n_stops: usize,
    score: Option<SoftScore>,
}

impl PlanningSolution for Plan {
    type Score = SoftScore;
    fn score(&self) -> Option<Self::Score> { self.score }
    fn set_score(&mut self, score: Option<Self::Score>) { self.score = score; }
}

let phase = ListClarkeWrightPhase::<Plan, usize>::new(
    |p| p.n_stops,
    |p| p.vehicles.iter().flat_map(|v| v.route.iter().copied()).collect(),
    |p| p.vehicles.len(),
    |p, entity_idx, route| {
        if let Some(v) = p.vehicles.get_mut(entity_idx) {
            v.route = route;
        }
    },
    |_p, idx| idx,
    |_p| 0,            // depot index
    |_p, i, j| (i as i64 - j as i64).abs(),  // distance fn
    |_p, _idx| 1,      // unit load per element
    |_p| 10,           // capacity per route
    None,              // merge_feasible_fn: no extra feasibility check
    0,
);

Implementations

impl<S, E> ListClarkeWrightPhase<S, E>

where S: PlanningSolution, E: Copy + Send + Sync + 'static,

pub fn new( element_count: fn(&S) -> usize, get_assigned: fn(&S) -> Vec<E>, entity_count: fn(&S) -> usize, assign_route: fn(&mut S, usize, Vec<E>), index_to_element: fn(&S, usize) -> E, depot_fn: fn(&S) -> usize, distance_fn: fn(&S, usize, usize) -> i64, element_load_fn: fn(&S, usize) -> i64, capacity_fn: fn(&S) -> i64, merge_feasible_fn: Option<fn(&S, &[usize]) -> bool>, descriptor_index: usize, ) -> Self

Creates a new Clarke-Wright savings construction phase.

Arguments

• element_count — Total number of elements (stops) to assign
• get_assigned — Returns currently assigned elements
• entity_count — Number of entities (vehicles/routes)
• assign_route — Assigns a complete route Vec<E> to entity at index
• index_to_element — Converts an element index to its domain value
• depot_fn — Returns the depot element index (excluded from savings pairs)
• distance_fn — Distance between two element indices
• element_load_fn — Load contributed by element at given index
• capacity_fn — Maximum load per route
• merge_feasible_fn — Optional feasibility gate called after capacity and endpoint checks. Receives the solution and the candidate merged route (as element indices); return false to skip the merge.
• descriptor_index — Entity descriptor index for change notification

Trait Implementations

impl<S, E> Debug for ListClarkeWrightPhase<S, E>

where S: PlanningSolution, E: Copy + Send + Sync + 'static,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S, E, D, BestCb> Phase<S, D, BestCb> for ListClarkeWrightPhase<S, E>

where S: PlanningSolution, E: Copy + Send + Sync + 'static, D: Director<S>, BestCb: BestSolutionCallback<S>,

fn solve(&mut self, solver_scope: &mut SolverScope<'_, S, D, BestCb>)

Executes this phase.

fn phase_type_name(&self) -> &'static str

Returns the name of this phase type.