Struct ListKOptPhase 

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

Per-route k-opt polishing phase for list variable problems.

Runs 2-opt local search on each entity’s route to local optimum after construction. All domain knowledge is supplied via function pointers.

Algorithm (k=2, 2-opt)

For each entity:

1. Read the current route as a sequence of element indices.
2. Try every segment reversal [i..=j].
3. Accept if distance improves AND feasible_fn passes (if provided).
4. Repeat until no improving reversal exists.

Example

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

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

#[derive(Clone)]
struct Plan {
    vehicles: Vec<Vehicle>,
    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 = ListKOptPhase::<Plan, usize>::new(
    2,
    |p| p.vehicles.len(),
    |p, entity_idx| p.vehicles[entity_idx].route.clone(),
    |p, entity_idx, route| { p.vehicles[entity_idx].route = route; },
    |_p, entity_idx| 0,   // depot index
    |_p, i, j| (i as i64 - j as i64).abs(),
    None,                  // no extra feasibility check
    0,
);

Implementations

impl<S, E> ListKOptPhase<S, E>

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

pub fn new( k: usize, entity_count: fn(&S) -> usize, get_route: fn(&S, usize) -> Vec<usize>, set_route: fn(&mut S, usize, Vec<usize>), depot_fn: fn(&S, usize) -> usize, distance_fn: fn(&S, usize, usize) -> i64, feasible_fn: Option<fn(&S, usize, &[usize]) -> bool>, descriptor_index: usize, ) -> Self

Creates a new k-opt polishing phase.

Arguments

• k — k value; only k=2 (2-opt) is implemented; k>2 logs a warning and is a no-op
• entity_count — number of entities (routes) in the solution
• get_route — returns the route for entity at given index as element indices
• set_route — replaces the route for entity at given index
• depot_fn — returns the depot element index for a given entity
• distance_fn — distance between two element indices
• feasible_fn — optional feasibility gate; receives solution, entity index, and candidate route after tentative reversal; return false to reject the move
• descriptor_index — entity descriptor index for change notification

Trait Implementations

impl<S, E> Debug for ListKOptPhase<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 ListKOptPhase<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.