@Override public HardSoftScoreHolder buildScoreHolder(boolean constraintMatchEnabled) { return new HardSoftScoreHolder(constraintMatchEnabled); }
/** * Penalize a match by the {@link ConstraintWeight} negated and multiplied with the specific weightMultiplier per score level. * Slower than {@link #penalize(RuleContext, int)}. * @param kcontext never null, the magic variable in DRL * @param hardWeightMultiplier at least 0 * @param softWeightMultiplier at least 0 */ public void penalize(RuleContext kcontext, int hardWeightMultiplier, int softWeightMultiplier) { reward(kcontext, -hardWeightMultiplier, -softWeightMultiplier); }
public void addConstraintMatch(boolean constraintMatchEnabled) { HardSoftScoreHolder scoreHolder = new HardSoftScoreHolder(constraintMatchEnabled); scoreHolder.addHardConstraintMatch(hard1, -1); assertEquals(HardSoftScore.of(-1, 0), scoreHolder.extractScore(0)); scoreHolder.addHardConstraintMatch(hard2Undo, -8); assertEquals(HardSoftScore.of(-9, 0), scoreHolder.extractScore(0)); callOnDelete(hard2Undo); assertEquals(HardSoftScore.of(-1, 0), scoreHolder.extractScore(0)); scoreHolder.addSoftConstraintMatch(soft1, -10); callOnUpdate(soft1); scoreHolder.addSoftConstraintMatch(soft1, -20); // Overwrite existing scoreHolder.addMultiConstraintMatch(multi1, -100, -1000); callOnUpdate(multi1); scoreHolder.addMultiConstraintMatch(multi1, -300, -4000); // Overwrite existing scoreHolder.addHardConstraintMatch(hard3, -10000); callOnUpdate(hard3); scoreHolder.addHardConstraintMatch(hard3, -50000); // Overwrite existing scoreHolder.addSoftConstraintMatch(soft2Undo, -99); callOnDelete(soft2Undo); scoreHolder.addMultiConstraintMatch(multi2Undo, -999, -999); callOnDelete(multi2Undo); assertEquals(HardSoftScore.of(-50301, -4020), scoreHolder.extractScore(0));
public void rewardPenalize(boolean constraintMatchEnabled) { HardSoftScoreHolder scoreHolder = new HardSoftScoreHolder(constraintMatchEnabled); Rule hard1 = mockRule("hard1"); scoreHolder.configureConstraintWeight(hard1, HardSoftScore.ofHard(10)); Rule hard2 = mockRule("hard2"); scoreHolder.configureConstraintWeight(hard2, HardSoftScore.ofHard(100)); Rule soft1 = mockRule("soft1"); scoreHolder.configureConstraintWeight(soft1, HardSoftScore.ofSoft(10)); Rule soft2 = mockRule("soft2"); scoreHolder.configureConstraintWeight(soft2, HardSoftScore.ofSoft(100)); scoreHolder.penalize(mockRuleContext(hard1)); assertEquals(HardSoftScore.of(-10, 0), scoreHolder.extractScore(0)); scoreHolder.penalize(mockRuleContext(hard2), 2); assertEquals(HardSoftScore.of(-210, 0), scoreHolder.extractScore(0)); scoreHolder.reward(mockRuleContext(soft1)); assertEquals(HardSoftScore.of(-210, 10), scoreHolder.extractScore(0)); scoreHolder.reward(mockRuleContext(soft2), 3); assertEquals(HardSoftScore.of(-210, 310), scoreHolder.extractScore(0)); }
@Override public void configureConstraintWeight(Rule rule, HardSoftScore constraintWeight) { super.configureConstraintWeight(rule, constraintWeight); BiConsumer<RuleContext, Integer> matchExecutor; if (constraintWeight.equals(HardSoftScore.ZERO)) { matchExecutor = (RuleContext kcontext, Integer matchWeight) -> {}; } else if (constraintWeight.getSoftScore() == 0) { matchExecutor = (RuleContext kcontext, Integer matchWeight) -> addHardConstraintMatch(kcontext, constraintWeight.getHardScore() * matchWeight); } else if (constraintWeight.getHardScore() == 0) { matchExecutor = (RuleContext kcontext, Integer matchWeight) -> addSoftConstraintMatch(kcontext, constraintWeight.getSoftScore() * matchWeight); } else { matchExecutor = (RuleContext kcontext, Integer matchWeight) -> addMultiConstraintMatch(kcontext, constraintWeight.getHardScore() * matchWeight, constraintWeight.getSoftScore() * matchWeight); } matchExecutorByNumberMap.put(rule, matchExecutor); matchExecutorByScoreMap.put(rule, (RuleContext kcontext, HardSoftScore weightMultiplier) -> addMultiConstraintMatch(kcontext, constraintWeight.getHardScore() * weightMultiplier.getHardScore(), constraintWeight.getSoftScore() * weightMultiplier.getSoftScore())); }
/** * @param kcontext never null, the magic variable in DRL * @param hardWeight higher is better, negative for a penalty, positive for a reward */ public void addHardConstraintMatch(RuleContext kcontext, int hardWeight) { hardScore += hardWeight; registerConstraintMatch(kcontext, () -> hardScore -= hardWeight, () -> HardSoftScore.of(hardWeight, 0)); }
/** * @param kcontext never null, the magic variable in DRL * @param softWeight higher is better, negative for a penalty, positive for a reward */ public void addSoftConstraintMatch(RuleContext kcontext, int softWeight) { softScore += softWeight; registerConstraintMatch(kcontext, () -> softScore -= softWeight, () -> HardSoftScore.of(0, softWeight)); }
/** * Penalize a match by the {@link ConstraintWeight} negated. * @param kcontext never null, the magic variable in DRL */ public void penalize(RuleContext kcontext) { reward(kcontext, -1); }
/** * @param kcontext never null, the magic variable in DRL * @param hardWeight higher is better, negative for a penalty, positive for a reward * @param softWeight higher is better, negative for a penalty, positive for a reward */ public void addMultiConstraintMatch(RuleContext kcontext, int hardWeight, int softWeight) { hardScore += hardWeight; softScore += softWeight; registerConstraintMatch(kcontext, () -> { hardScore -= hardWeight; softScore -= softWeight; }, () -> HardSoftScore.of(hardWeight, softWeight)); }
/** * Penalize a match by the {@link ConstraintWeight} negated and multiplied with the weightMultiplier for all score levels. * @param kcontext never null, the magic variable in DRL * @param weightMultiplier at least 0 */ public void penalize(RuleContext kcontext, int weightMultiplier) { reward(kcontext, -weightMultiplier); }
/** * Reward a match by the {@link ConstraintWeight}. * @param kcontext never null, the magic variable in DRL */ public void reward(RuleContext kcontext) { reward(kcontext, 1); }