Struct BalanceConstraintStream 

pub struct BalanceConstraintStream<S, A, K, E, F, KF, Sc>
where
    Sc: Score,
{ /* private fields */ }

Zero-erasure stream for building balance constraints.

Created by UniConstraintStream::balance(). Provides penalize() and reward() methods to finalize the constraint.

Type Parameters

• S - Solution type
• A - Entity type
• K - Group key type
• E - Extractor function for entities
• F - Filter type
• KF - Key function (returns Option to skip unassigned entities)
• Sc - Score type

Example

use solverforge_scoring::stream::ConstraintFactory;
use solverforge_scoring::api::constraint_set::IncrementalConstraint;
use solverforge_core::score::SimpleScore;

#[derive(Clone)]
struct Shift { employee_id: Option<usize> }

#[derive(Clone)]
struct Solution { shifts: Vec<Shift> }

let constraint = ConstraintFactory::<Solution, SimpleScore>::new()
    .for_each(|s: &Solution| &s.shifts)
    .balance(|shift: &Shift| shift.employee_id)
    .penalize(SimpleScore::of(1000))
    .as_constraint("Balance workload");

let solution = Solution {
    shifts: vec![
        Shift { employee_id: Some(0) },
        Shift { employee_id: Some(0) },
        Shift { employee_id: Some(0) },
        Shift { employee_id: Some(1) },
    ],
};

// std_dev = 1.0, penalty = -1000
assert_eq!(constraint.evaluate(&solution), SimpleScore::of(-1000));

Implementations

impl<S, A, K, E, F, KF, Sc> BalanceConstraintStream<S, A, K, E, F, KF, Sc>

where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync + 'static, E: Fn(&S) -> &[A] + Send + Sync, F: UniFilter<S, A>, KF: Fn(&A) -> Option<K> + Send + Sync, Sc: Score + 'static,

pub fn penalize( self, base_score: Sc, ) -> BalanceConstraintBuilder<S, A, K, E, F, KF, Sc>

Penalizes imbalanced distribution with the given base score per unit std_dev.

The final score is base_score.multiply(std_dev), negated for penalty.

pub fn reward( self, base_score: Sc, ) -> BalanceConstraintBuilder<S, A, K, E, F, KF, Sc>

Rewards imbalanced distribution with the given base score per unit std_dev.

The final score is base_score.multiply(std_dev).

Trait Implementations

impl<S, A, K, E, F, KF, Sc: Score> Debug for BalanceConstraintStream<S, A, K, E, F, KF, Sc>

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

Formats the value using the given formatter.