Skip to main content

ConstraintSet

Trait ConstraintSet 

Source
pub trait ConstraintSet<S, Sc: Score>: Send + Sync {
Show 17 methods // Required methods fn evaluate_all(&self, solution: &S) -> Sc; fn constraint_count(&self) -> usize; fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>; fn evaluate_each<'a>( &'a self, solution: &S, ) -> Vec<ConstraintResult<'a, Sc>>; fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>; fn initialize_all(&mut self, solution: &S) -> Sc; fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc; fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc; fn reset_all(&mut self); fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>); fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc; fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>; fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>; fn initialize_all_weighted( &mut self, solution: &S, multipliers: &[u32], ) -> Sc; fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc; fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc; // Provided method fn constraint_metadata(&self) -> Vec<ConstraintMetadata<'_>> { ... }
}
Expand description

A set of constraints that can be evaluated together.

ConstraintSet is implemented for each IncrementalConstraint as a singleton set and for tuples of nested ConstraintSet values. This keeps composition fully monomorphized without virtual dispatch.

Required Methods§

Source

fn evaluate_all(&self, solution: &S) -> Sc

Evaluates all constraints and returns the total score.

Source

fn constraint_count(&self) -> usize

Returns the number of constraints in this set.

Source

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Returns one metadata entry per constraint in authored order, keeping duplicates.

This is the method an implementation provides: tuples and chains build their entries from their members’ entries, and constraint_metadata deduplicates the result. A set of one constraint returns its single entry; a set that scores several named constraints returns one entry per name, in the order its terminals were authored.

Source

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Evaluates each constraint individually and returns per-constraint results.

Useful for score explanation and debugging.

Source

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Evaluates each constraint with detailed match information.

Returns per-constraint analysis including all matches with entity justifications. This enables full score explanation features.

Source

fn initialize_all(&mut self, solution: &S) -> Sc

Initializes all constraints by inserting all entities.

Must be called before using incremental methods. Returns the total score from initialization.

Source

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Called when an entity is inserted.

Returns the total score delta from all constraints.

§Arguments
  • solution - The planning solution
  • entity_index - Index of the entity within its class
  • descriptor_index - Index of the entity class (descriptor) being modified
Source

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Called when an entity is retracted.

Returns the total score delta from all constraints.

§Arguments
  • solution - The planning solution
  • entity_index - Index of the entity within its class
  • descriptor_index - Index of the entity class (descriptor) being modified
Source

fn reset_all(&mut self)

Resets all constraints for a new solving session.

Source

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Runtime constraint weights.

A set exposes constraint_count() weight slots: one per independently scored named constraint, in structural order (tuple and chain children left to right, shared-terminal scorers in authored order). constraint_weight_refs pushes each slot’s constraint reference; every *_weighted method receives one multiplier per slot in that order and scales each slot’s contribution by its multiplier. Only WeightedMode score directors call these; UnweightedMode directors never name them, so the unweighted methods stay the whole scoring path of every other director.

Source

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Weighted evaluate_all: multipliers holds one multiplier per weight slot.

Source

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Weighted evaluate_each: weighted scores, with each result’s weight_multiplier set from its slot.

Source

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Weighted evaluate_detailed: weighted totals and match scores, with each analysis’s weight_multiplier set from its slot.

Source

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Weighted initialize_all.

Source

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Weighted on_insert_all.

Source

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Weighted on_retract_all.

Provided Methods§

Source

fn constraint_metadata(&self) -> Vec<ConstraintMetadata<'_>>

Returns deduplicated immutable metadata for constraints in this set.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types§

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>, C24: ConstraintSet<S, Sc>, C25: ConstraintSet<S, Sc>, C26: ConstraintSet<S, Sc>, C27: ConstraintSet<S, Sc>, C28: ConstraintSet<S, Sc>, C29: ConstraintSet<S, Sc>, C30: ConstraintSet<S, Sc>, C31: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>, C24: ConstraintSet<S, Sc>, C25: ConstraintSet<S, Sc>, C26: ConstraintSet<S, Sc>, C27: ConstraintSet<S, Sc>, C28: ConstraintSet<S, Sc>, C29: ConstraintSet<S, Sc>, C30: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>, C24: ConstraintSet<S, Sc>, C25: ConstraintSet<S, Sc>, C26: ConstraintSet<S, Sc>, C27: ConstraintSet<S, Sc>, C28: ConstraintSet<S, Sc>, C29: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>, C24: ConstraintSet<S, Sc>, C25: ConstraintSet<S, Sc>, C26: ConstraintSet<S, Sc>, C27: ConstraintSet<S, Sc>, C28: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>, C24: ConstraintSet<S, Sc>, C25: ConstraintSet<S, Sc>, C26: ConstraintSet<S, Sc>, C27: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>, C24: ConstraintSet<S, Sc>, C25: ConstraintSet<S, Sc>, C26: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>, C24: ConstraintSet<S, Sc>, C25: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>, C24: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>, C23: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>, C22: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>, C21: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>, C20: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>, C19: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>, C18: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>, C17: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>, C16: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>, C15: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>, C14: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>, C13: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>, C12: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>, C11: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>, C10: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>, C9: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7, C8> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>, C8: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6, C7> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6, C7)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>, C7: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5, C6> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5, C6)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>, C6: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4, C5> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4, C5)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>, C5: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3, C4> ConstraintSet<S, Sc> for (C0, C1, C2, C3, C4)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>, C4: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2, C3> ConstraintSet<S, Sc> for (C0, C1, C2, C3)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>, C3: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1, C2> ConstraintSet<S, Sc> for (C0, C1, C2)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>, C2: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0, C1> ConstraintSet<S, Sc> for (C0, C1)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>, C1: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S, Sc, C0> ConstraintSet<S, Sc> for (C0,)
where S: Send + Sync, Sc: Score, C0: ConstraintSet<S, Sc>,

Source§

fn evaluate_all(&self, solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, solution: &S, multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, solution: &S, entity_index: usize, descriptor_index: usize, multipliers: &[u32], ) -> Sc

Source§

impl<S: Send + Sync, Sc: Score> ConstraintSet<S, Sc> for ()

Implement ConstraintSet for an empty tuple (no constraints).

Source§

fn evaluate_all(&self, _solution: &S) -> Sc

Source§

fn constraint_count(&self) -> usize

Source§

fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>

Source§

fn evaluate_each<'a>(&'a self, _solution: &S) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed<'a>( &'a self, _solution: &S, ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all(&mut self, _solution: &S) -> Sc

Source§

fn on_insert_all( &mut self, _solution: &S, _entity_index: usize, _descriptor_index: usize, ) -> Sc

Source§

fn on_retract_all( &mut self, _solution: &S, _entity_index: usize, _descriptor_index: usize, ) -> Sc

Source§

fn reset_all(&mut self)

Source§

fn constraint_weight_refs<'a>(&'a self, _refs: &mut Vec<&'a ConstraintRef>)

Source§

fn evaluate_all_weighted(&self, _solution: &S, _multipliers: &[u32]) -> Sc

Source§

fn evaluate_each_weighted<'a>( &'a self, _solution: &S, _multipliers: &[u32], ) -> Vec<ConstraintResult<'a, Sc>>

Source§

fn evaluate_detailed_weighted<'a>( &'a self, _solution: &S, _multipliers: &[u32], ) -> Vec<ConstraintAnalysis<'a, Sc>>

Source§

fn initialize_all_weighted(&mut self, _solution: &S, _multipliers: &[u32]) -> Sc

Source§

fn on_insert_all_weighted( &mut self, _solution: &S, _entity_index: usize, _descriptor_index: usize, _multipliers: &[u32], ) -> Sc

Source§

fn on_retract_all_weighted( &mut self, _solution: &S, _entity_index: usize, _descriptor_index: usize, _multipliers: &[u32], ) -> Sc

Implementors§

Source§

impl<S, O, A, Left, Right, Sc> ConstraintSet<S, Sc> for SharedOperatorTerminal<S, O, A, ScorerChain<(Left, Right)>, Sc>
where S: Send + Sync + 'static, O: GroupedOperator<S> + Send + Sync, A: Send + Sync, Left: OperatorScorerSet<S, O, Sc>, Right: OperatorScorerSet<S, O, Sc>, Sc: Score,

Source§

impl<S, Sc, C> ConstraintSet<S, Sc> for C
where S: Send + Sync, Sc: Score, C: IncrementalConstraint<S, Sc>,

Source§

impl<S, Sc, Left, Right> ConstraintSet<S, Sc> for ConstraintSetChain<Left, Right>
where S: Send + Sync, Sc: Score, Left: ConstraintSet<S, Sc>, Right: ConstraintSet<S, Sc>,

Source§

impl<S, Sc, Left, Right> ConstraintSet<S, Sc> for OrderedConstraintSetChain<Left, Right>
where S: Send + Sync, Sc: Score, Left: ConstraintSet<S, Sc>, Right: ConstraintSet<S, Sc>,