|
OptaPlanner core 6.2.0.CR2 | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
Acceptor.Terminations.CountableValueRange (and therefore ValueRange).DeciderScoreComparatorFactory.EntityPlacer.EntitySelector.FeasibilityScoreDefinition.FinalistPodium.Forager.IncrementalScoreCalculator.MoveMoveSelector.Score.ScoreDefinition.ScoreDirector.ScoreDirectorFactory.ScoreHolder.Selector.Termination.ValueRange that is not a CountableValueRange).ValueSelector.Forager which forages accepted moves and ignores unaccepted moves.Move.Forager.addMove(LocalSearchMoveScope).
ProblemFactChange to be processed.
BasicPlumbingTermination.waitForRestartSolverDecision()
Score is calculated for the current workingSolution
in the current ScoreDirector (with possibly incremental calculation residue),
it is equal to the parameter expectedWorkingScore.
Score is calculated for the parameter solution,
it would be equal to the Solution.getScore() of that parameter.
Score is calculated for the current workingSolution
in a fresh ScoreDirector (with no incremental calculation residue),
it is equal to the parameter workingScore.
BasicPlumbingTermination.problemFactChangeQueue is not empty or BasicPlumbingTermination.terminatedEarly is true)Score is based on n levels of BigDecimal constraints.Score is based on n levels of int constraints.Solution is found.
Solution changes during solving.Solver encounters.BigDecimal.scale().
BigDecimal.scale().
Score which is equal or better than any other Score with more variables initialized
(while the already variables don't change).
Score which is equal or worse than any other Score with more variables initialized
(while the already variables don't change).
InnerScoreDirectorFactory.buildScoreDirector(), but optionally disables ConstraintMatch tracking
for more performance (presuming the ScoreDirector implementation actually supports it to begin with).
ScoreDirector instance.
DroolsScoreDirector.
Solver instance.
XStream setup which is used to read/write solver configs and benchmark configs.
Iterator does not shuffle and is never ending.EntitySelector that caches the result of its child EntitySelector.MoveSelector that caches the result of its child MoveSelector.ValueSelector that caches the result of its child ValueSelector.Termination.calculateSolverTimeGradient(DefaultSolverScope).
Score and updates the workingSolution accordingly.
CompositeMoveSelector that cartesian products 2 or more MoveSelectors.ScoreDirector and its workingSolution.
MoveSelector.IncrementalScoreCalculator to report ConstraintMatchTotals
for explaining a score (= which score constraints match for how much)
and also for score corruption analysis.ConstructionHeuristicPhase is a Phase which uses a construction heuristic algorithm,
such as First Fit, First Fit Decreasing, Cheapest Insertion, ...AbstractCountableValueRange
to ensure backwards compatibility in future versions.BigDecimal.scale().
BigDecimal.scale().
SelectionCacheType.
SelectionCacheType.
SelectionCacheType.
CustomPhase is a Phase which uses the brute force algorithmPlanningVariable's.ConstructionHeuristicPhase.CustomPhase.ExhaustiveSearchPhase.LocalSearchPhase.PropertyDescriptor for faster and easier access.Solver.SubChainSelector implementation.Solution of the ScoreDirector
and notifies the ScoreDirector accordingly.
Solution and its ScoreDirector accordingly.
ScoreDirector, which directs the Rule Engine to calculate the Score
of the Solution workingSolution.ScoreDirectorFactory.Score calculation.ScoreDirector, which recalculates the Score
of the Solution workingSolution every time.ScoreDirectorFactory.Selector.isNeverEnding() is true, then Iterable.iterator() will never end.
Selector.isNeverEnding() is true, then ValueSelector.iterator(Object) will never end.
QueuedEntityPlacerConfig and PooledEntityPlacerConfig.PlanningEntity annotated class.PlanningEntity instances.ExhaustiveSearchPhase is a Phase which uses an exhaustive algorithm.Score, calculated by the KieSession for DroolsScoreDirector.
ValueRangeDescriptor.extractValueRange(Solution, Object).
Score that supports FeasibilityScore.isFeasible().LocalSearchMoveScopes which might win) and picks the winner.HardSoftScores based on the calculation of the hard multiplied by a weight, summed with the soft.String representation of the Score.
ValueSelector implementation.EntitySelector implementation.ValueSelector implementation.MoveSelector.SelectionCacheType.JUST_IN_TIME,
even if a selector child caches.
Score of ScoreHolder.extractScore().
Score.toLevelNumbers().
Score.toLevelNumbers() for every Score of this definition.
MoveSelectors
s(uch as ChangeMoveSelector and SwapMoveSelector) already handle 1-sized chains.
ProblemFactChanges might be processed:
check BestSolutionChangedEvent.isEveryProblemFactChangeProcessed()
this Solution might be uninitialized: check BestSolutionChangedEvent.isNewBestSolutionInitialized()
this Solution might be infeasible: check FeasibilityScore.isFeasible()
DroolsScoreDirector when the Solution needs to be inserted
into an empty KieSession.
Score of this Solution.
Class of the actual Score implementation
Selector with Selector.isNeverEnding() true should return a size
as if it would be able to return each distinct element only once,
because the size can be used in SelectionProbabilityWeightFactory.
IterableSelector.getSize(), but requires an entity.
SolverConfig at runtime before building the Solver.
Solution that is used to calculate the Score.
Score is based on 3 levels of long constraints: hard, medium and soft.Score is based on 3 levels of int constraints: hard, medium and soft.Score is based on 2 levels of BigDecimal constraints: hard and soft.Score is based on 2 levels of double constraints: hard and soft.Score is based on 2 levels of long constraints: hard and soft.Score is based on 2 levels of int constraints: hard and soft.FinalistPodium.Score calculation.ScoreDirector, which only recalculates the Score
of the part of the Solution workingSolution that changed,
instead of the going through the entire Solution.ScoreDirectorFactory.Scores for a Solution as more and more variables are initialized
(while the already initialized variables don't change).Scores for a Solution as more and more variables are initialized
(while the already initialized variables don't change).PlanningVariable, which implies it's a shadow variable.ScoreDirector.isConstraintMatchEnabled()
for the ScoreDirector which contains this ScoreHolder.
Selector.isNeverEnding() is true.
EntityIndependentValueRangeDescriptor,
otherwise it requires an entity to determine the ValueRange.
ProblemFactChanges have been processed.
Solution is feasible if it has no broken hard constraints.
Solution is feasible if it has no broken hard constraints.
Solution is feasible if it has no broken hard constraints.
PlanningVariable.nullable() value is always considered initialized, but it can still be reinitialized
with PlanningVariable.reinitializeVariableEntityFilter().
Selector.isCountable() is false
or if this selector is in random order (for most cases).
Phase after every step and every move to determine if the search should stop.
Solver after every phase to determine if the search should stop.
Iterable.iterator(), but requires an entity.