Struct RuinMove 

pub struct RuinMove<S, V> { /* private fields */ }

A move that unassigns multiple entities for Large Neighborhood Search.

This move sets the planning variable to None for a set of entities, creating “gaps” that a construction heuristic can fill. Combined with construction, this enables exploring distant regions of the search space.

Type Parameters

• S - The planning solution type
• V - The variable value type

Example

use solverforge_solver::heuristic::r#move::RuinMove;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

#[derive(Clone, Debug)]
struct Task { assigned_to: Option<i32>, score: Option<SimpleScore> }
#[derive(Clone, Debug)]
struct Schedule { tasks: Vec<Task>, score: Option<SimpleScore> }

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

fn get_task(s: &Schedule, idx: usize) -> Option<i32> {
    s.tasks.get(idx).and_then(|t| t.assigned_to)
}
fn set_task(s: &mut Schedule, idx: usize, v: Option<i32>) {
    if let Some(t) = s.tasks.get_mut(idx) { t.assigned_to = v; }
}

// Ruin entities 0, 2, and 4
let m = RuinMove::<Schedule, i32>::new(
    &[0, 2, 4],
    get_task, set_task,
    "assigned_to", 0,
);

Implementations

impl<S, V> RuinMove<S, V>

pub fn new( entity_indices: &[usize], getter: fn(&S, usize) -> Option<V>, setter: fn(&mut S, usize, Option<V>), variable_name: &'static str, descriptor_index: usize, ) -> Self

Creates a new ruin move with typed function pointers.

Arguments

• entity_indices - Indices of entities to unassign
• getter - Function to get current value
• setter - Function to set value
• variable_name - Name of the planning variable
• descriptor_index - Entity descriptor index

pub fn entity_indices_slice(&self) -> &[usize]

Returns the entity indices being ruined.

pub fn ruin_count(&self) -> usize

Returns the number of entities being ruined.

Trait Implementations

impl<S, V> Clone for RuinMove<S, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, V: Debug> Debug for RuinMove<S, V>

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

Formats the value using the given formatter.

impl<S, V> Move<S> for RuinMove<S, V>

where S: PlanningSolution, V: Clone + Send + Sync + Debug + 'static,

fn is_doable<D: ScoreDirector<S>>(&self, score_director: &D) -> bool

Returns true if this move can be executed in the current state.

fn do_move<D: ScoreDirector<S>>(&self, score_director: &mut D)

Executes this move, modifying the working solution.

fn descriptor_index(&self) -> usize

Returns the descriptor index of the entity type this move affects.

fn entity_indices(&self) -> &[usize]

Returns the entity indices involved in this move.

fn variable_name(&self) -> &str

Returns the variable name this move affects.

impl<S, V> MoveSelector<S, RuinMove<S, V>> for RuinMoveSelector<S, V>

where S: PlanningSolution, V: Clone + Send + Sync + Debug + 'static,

fn iter_moves<'a, D: ScoreDirector<S>>( &'a self, score_director: &'a D, ) -> Box<dyn Iterator<Item = RuinMove<S, V>> + 'a>

Returns an iterator over typed moves.

fn size<D: ScoreDirector<S>>(&self, score_director: &D) -> usize

Returns the approximate number of moves.

fn is_never_ending(&self) -> bool

Returns true if this selector may return the same move multiple times.