|
OptaPlanner core 6.2.0.Beta2 | |||||||||
PREV NEXT | FRAMES NO FRAMES |
Acceptor
.Termination
s.CountableValueRange
(and therefore ValueRange
).DeciderScoreComparatorFactory
.EntityPlacer
.EntitySelector
.FeasibilityScoreDefinition
.FinalistPodium
.Forager
.IncrementalScoreCalculator
.Move
MoveSelector
.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 MoveSelector
s.ScoreDirector
and its workingSolution
.
MoveSelector
.IncrementalScoreCalculator
to report ConstraintMatchTotal
s
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.
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()
.LocalSearchMoveScope
s which might win) and picks the winner.HardSoftScore
s 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.
MoveSelector
s
s(uch as ChangeMoveSelector
and SwapMoveSelector
) already handle 1-sized chains.
ProblemFactChange
s 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
.ValueSelector
applies to) is uninitialized.Score
s for a Solution
as more and more variables are initialized
(while the already initialized variables don't change).Score
s 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
.
ProblemFactChange
s 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.
Iterable
interface that supports ListIterable.listIterator()
and ListIterable.listIterator(int)
.List.listIterator()
List.listIterator()
LocalSearchPhase
is a Phase
which uses a local search algorithm,
such as tabu search, simulated annealing, ...DefaultPillarSelector.minimumSubPillarSize
and DefaultPillarSelector.maximumSubPillarSize
,
the sub selection here is a sequence.
DefaultSubChainSelector.minimumSubChainSize
and DefaultSubChainSelector.maximumSubChainSize
,
the sub selection here is any sub set.
Solution
.Iterator
of custom Move
s.MoveIteratorFactory
to a MoveSelector
.List
of custom Move
s.MoveListFactory
to a MoveSelector
.Move
s.ChangeMoveSelectorConfig
, etc.DeciderScoreComparatorFactory
.Random.nextInt(int)
for doubles.
Random.nextInt(int)
for longs.
PlanningVariable.nullable()
.String
and returns a Score
.
Solver
.Forager.pickMove(LocalSearchStepScope)
.
List
of entities that have the same planning value for each (or a subset)
of their planning values.Solution
that implements its own planning cloning
instead of letting the default or a custom SolutionCloner
do it.Solution
is a collection of planning entities.Solution
is a planning entity.Solution
.PropertyDescriptor
for faster and easier access.Score
s and what the perfect maximum/minimum Score
is.workingSolution
and calculates the Score
for that Solution
.ScoreDirector
.DroolsScoreDirector
into the Drools DRL.ValueSelector
decorations,
this one works for an entity dependent ValueSelector
too.
PlanningEntity
, a planningValue, a Move
or a Selector
).PlanningEntity
, a planningValue, a Move
or a Selector
).List
of selection
(which is a PlanningEntity
, a planningValue, a Move
or a Selector
).PlanningEntity
, a planningValue, a Move
or a Selector
).MoveSelector
, EntitySelector
and ValueSelector
which generates Move
s or parts of them.MoveSelectorConfig
, EntitySelectorConfig
and ValueSelectorConfig
.Solver
when the Score
of this Solution has been calculated.
workingSolution
must never be the same instance as the bestSolution
,
it should be a (un)changed clone.
Score
is based on 1 level of BigDecimal
constraints.Score
is based on 1 level of double constraints.Score
is based on 1 level of long constraints.Score
is based on 1 level of int constraints.Solution
during planning.Solver
instances.BasicPlumbingTermination.waitForRestartSolverDecision()
Solver
or a Phase
should stop.CompositeMoveSelector
that unions 2 or more MoveSelector
s.Selector
's Iterator.hasNext()
or Iterator.next()
methods,
because that can cause descendant Selector
s to be selected too early
(which breaks MimicReplayingEntitySelector
).FieldAccessingSolutionCloner.isFieldAnEntityPropertyOnSolution(java.lang.reflect.Field)
assumptions were wrong.
BendableScore
.
BendableBigDecimalScore
.
PlanningVariable
.ValueRange
.PlanningVariable
.Solver
with XStream
.
|
OptaPlanner core 6.2.0.Beta2 | |||||||||
PREV NEXT | FRAMES NO FRAMES |