Skip to main content

ConstraintWeight

Trait ConstraintWeight 

Source
pub trait ConstraintWeight<Args, Sc: Score>: Send + Sync {
    // Required methods
    fn score(&self, args: Args) -> Sc;
    fn is_hard(&self) -> bool;
}
Expand description

The weight a penalize or reward call scores each match with.

Args is the tuple of borrowed rows one match carries, (&A,) for a uni stream up to (&A, &B, &C, &D, &E) for a penta stream; grouped streams pass the key and the collector result. Implemented for:

  • every built-in score type (SoftScore, HardSoftScore, HardMediumSoftScore, HardSoftDecimalScore, BendableScore), scoring each match with that fixed value;
  • FixedWeight, wrapping any other fixed score;
  • closures Fn(&A, ...) -> Sc over the matched rows;
  • HardWeight, wrapping another weight and marking it hard.

Implement it for a custom weight type to compute a match’s score from state of your own.

§Examples

use solverforge_core::score::SoftScore;
use solverforge_scoring::api::constraint_set::IncrementalConstraint;
use solverforge_scoring::stream::{
    source, ChangeSource, ConstraintFactory, ConstraintWeight,
};

/// Scores each late minute past a deadline.
struct MinutesLate {
    deadline: i64,
}

impl<'a> ConstraintWeight<(&'a i64,), SoftScore> for MinutesLate {
    fn score(&self, (end,): (&'a i64,)) -> SoftScore {
        SoftScore::of((*end - self.deadline).max(0))
    }

    fn is_hard(&self) -> bool {
        false
    }
}

#[derive(Clone)]
struct Plan {
    ends: Vec<i64>,
}

fn ends(plan: &Plan) -> &[i64] {
    plan.ends.as_slice()
}

let constraint = ConstraintFactory::<Plan, SoftScore>::new()
    .for_each(source(ends as fn(&Plan) -> &[i64], ChangeSource::Descriptor(0)))
    .penalize(MinutesLate { deadline: 10 })
    .named("late");

let plan = Plan { ends: vec![8, 13, 15] };
assert_eq!(constraint.evaluate(&plan), SoftScore::of(-8));
assert!(!constraint.is_hard());

Required Methods§

Source

fn score(&self, args: Args) -> Sc

The score one match with rows args contributes, before the constraint’s penalty or reward sign is applied.

Source

fn is_hard(&self) -> bool

Whether the constraint this weight scores is hard. Built-in fixed scores are hard when their first (hard) level is non-zero; closures are soft unless wrapped in HardWeight.

Dyn Compatibility§

This trait is dyn compatible.

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

Implementations on Foreign Types§

Source§

impl<'a, A, B, C, D, E, const H: usize, const S: usize> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), BendableScore<H, S>> for BendableScore<H, S>

Source§

fn score( &self, _args: (&'a A, &'a B, &'a C, &'a D, &'a E), ) -> BendableScore<H, S>

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, C, D, E> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), HardMediumSoftScore> for HardMediumSoftScore

Source§

impl<'a, A, B, C, D, E> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), HardSoftDecimalScore> for HardSoftDecimalScore

Source§

impl<'a, A, B, C, D, E> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), HardSoftScore> for HardSoftScore

Source§

fn score(&self, _args: (&'a A, &'a B, &'a C, &'a D, &'a E)) -> HardSoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, C, D, E> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), SoftScore> for SoftScore

Source§

fn score(&self, _args: (&'a A, &'a B, &'a C, &'a D, &'a E)) -> SoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, C, D, const H: usize, const S: usize> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), BendableScore<H, S>> for BendableScore<H, S>

Source§

fn score(&self, _args: (&'a A, &'a B, &'a C, &'a D)) -> BendableScore<H, S>

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, C, D> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), HardMediumSoftScore> for HardMediumSoftScore

Source§

impl<'a, A, B, C, D> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), HardSoftDecimalScore> for HardSoftDecimalScore

Source§

impl<'a, A, B, C, D> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), HardSoftScore> for HardSoftScore

Source§

fn score(&self, _args: (&'a A, &'a B, &'a C, &'a D)) -> HardSoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, C, D> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), SoftScore> for SoftScore

Source§

fn score(&self, _args: (&'a A, &'a B, &'a C, &'a D)) -> SoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, C, const H: usize, const S: usize> ConstraintWeight<(&'a A, &'a B, &'a C), BendableScore<H, S>> for BendableScore<H, S>

Source§

fn score(&self, _args: (&'a A, &'a B, &'a C)) -> BendableScore<H, S>

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, C> ConstraintWeight<(&'a A, &'a B, &'a C), HardMediumSoftScore> for HardMediumSoftScore

Source§

impl<'a, A, B, C> ConstraintWeight<(&'a A, &'a B, &'a C), HardSoftDecimalScore> for HardSoftDecimalScore

Source§

impl<'a, A, B, C> ConstraintWeight<(&'a A, &'a B, &'a C), HardSoftScore> for HardSoftScore

Source§

fn score(&self, _args: (&'a A, &'a B, &'a C)) -> HardSoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, C> ConstraintWeight<(&'a A, &'a B, &'a C), SoftScore> for SoftScore

Source§

fn score(&self, _args: (&'a A, &'a B, &'a C)) -> SoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B, const H: usize, const S: usize> ConstraintWeight<(&'a A, &'a B), BendableScore<H, S>> for BendableScore<H, S>

Source§

fn score(&self, _args: (&'a A, &'a B)) -> BendableScore<H, S>

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B> ConstraintWeight<(&'a A, &'a B), HardMediumSoftScore> for HardMediumSoftScore

Source§

fn score(&self, _args: (&'a A, &'a B)) -> HardMediumSoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B> ConstraintWeight<(&'a A, &'a B), HardSoftDecimalScore> for HardSoftDecimalScore

Source§

impl<'a, A, B> ConstraintWeight<(&'a A, &'a B), HardSoftScore> for HardSoftScore

Source§

fn score(&self, _args: (&'a A, &'a B)) -> HardSoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, B> ConstraintWeight<(&'a A, &'a B), SoftScore> for SoftScore

Source§

fn score(&self, _args: (&'a A, &'a B)) -> SoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A, const H: usize, const S: usize> ConstraintWeight<(&'a A,), BendableScore<H, S>> for BendableScore<H, S>

Source§

fn score(&self, _args: (&'a A,)) -> BendableScore<H, S>

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A> ConstraintWeight<(&'a A,), HardMediumSoftScore> for HardMediumSoftScore

Source§

fn score(&self, _args: (&'a A,)) -> HardMediumSoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A> ConstraintWeight<(&'a A,), HardSoftDecimalScore> for HardSoftDecimalScore

Source§

fn score(&self, _args: (&'a A,)) -> HardSoftDecimalScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A> ConstraintWeight<(&'a A,), HardSoftScore> for HardSoftScore

Source§

fn score(&self, _args: (&'a A,)) -> HardSoftScore

Source§

fn is_hard(&self) -> bool

Source§

impl<'a, A> ConstraintWeight<(&'a A,), SoftScore> for SoftScore

Source§

fn score(&self, _args: (&'a A,)) -> SoftScore

Source§

fn is_hard(&self) -> bool

Implementors§

Source§

impl<'a, A, B, C, D, E, Sc, F> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), Sc> for F
where F: Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc: Score,

Source§

impl<'a, A, B, C, D, E, Sc: Score + Copy> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), Sc> for FixedWeight<Sc>

Source§

impl<'a, A, B, C, D, E, W, Sc> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), Sc> for HardWeight<W>
where W: ConstraintWeight<(&'a A, &'a B, &'a C, &'a D, &'a E), Sc>, Sc: Score,

Source§

impl<'a, A, B, C, D, Sc, F> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), Sc> for F
where F: Fn(&A, &B, &C, &D) -> Sc + Send + Sync, Sc: Score,

Source§

impl<'a, A, B, C, D, Sc: Score + Copy> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), Sc> for FixedWeight<Sc>

Source§

impl<'a, A, B, C, D, W, Sc> ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), Sc> for HardWeight<W>
where W: ConstraintWeight<(&'a A, &'a B, &'a C, &'a D), Sc>, Sc: Score,

Source§

impl<'a, A, B, C, Sc, F> ConstraintWeight<(&'a A, &'a B, &'a C), Sc> for F
where F: Fn(&A, &B, &C) -> Sc + Send + Sync, Sc: Score,

Source§

impl<'a, A, B, C, Sc: Score + Copy> ConstraintWeight<(&'a A, &'a B, &'a C), Sc> for FixedWeight<Sc>

Source§

impl<'a, A, B, C, W, Sc> ConstraintWeight<(&'a A, &'a B, &'a C), Sc> for HardWeight<W>
where W: ConstraintWeight<(&'a A, &'a B, &'a C), Sc>, Sc: Score,

Source§

impl<'a, A, B, Sc, F> ConstraintWeight<(&'a A, &'a B), Sc> for F
where F: Fn(&A, &B) -> Sc + Send + Sync, Sc: Score,

Source§

impl<'a, A, B, Sc: Score + Copy> ConstraintWeight<(&'a A, &'a B), Sc> for FixedWeight<Sc>

Source§

impl<'a, A, B, W, Sc> ConstraintWeight<(&'a A, &'a B), Sc> for HardWeight<W>
where W: ConstraintWeight<(&'a A, &'a B), Sc>, Sc: Score,

Source§

impl<'a, A, Sc, F> ConstraintWeight<(&'a A,), Sc> for F
where F: Fn(&A) -> Sc + Send + Sync, Sc: Score,

Source§

impl<'a, A, Sc: Score + Copy> ConstraintWeight<(&'a A,), Sc> for FixedWeight<Sc>

Source§

impl<'a, A, W, Sc> ConstraintWeight<(&'a A,), Sc> for HardWeight<W>
where W: ConstraintWeight<(&'a A,), Sc>, Sc: Score,