Modifier and Type | Class and Description |
---|---|
class |
PropNogoods
A propagator to store and propagate no-goods.
|
class |
PropSat
A propagator to deal with clauses and interface a
SatSolver . |
Modifier and Type | Field and Description |
---|---|
protected Propagator[] |
Constraint.propagators
Propagators of the constraint (they will filter domains and eventually check solutions)
|
Modifier and Type | Method and Description |
---|---|
Propagator |
Constraint.getPropagator(int i) |
Propagator[] |
Constraint.getPropagators()
Return an array which contains the propagators declared in
this . |
Modifier and Type | Method and Description |
---|---|
int |
Propagator.compareTo(Propagator o) |
Constructor and Description |
---|
Constraint(String name,
Propagator... propagators)
Make a new constraint defined as a set of given propagators
|
Modifier and Type | Class and Description |
---|---|
class |
PropAbsolute
Enforces X = |Y|
|
class |
PropDistanceXYC
| X - Y | op C
op = {"==", "<", ">", "=/="} |
class |
PropEqualX_Y
X = Y
Ensures Arc-Consistency
|
class |
PropEqualX_YC
X = Y + C
|
class |
PropEqualXY_C
X + Y = C
|
class |
PropGreaterOrEqualX_Y
X >= Y
|
class |
PropGreaterOrEqualX_YC
X >= Y + C
|
class |
PropGreaterOrEqualXY_C
X + Y >= C
|
class |
PropLessOrEqualXY_C
X + Y <= C
|
class |
PropNotEqualX_Y
A specific
Propagator extension defining filtering algorithm for:
X =/= Y where X and Y are Variable objects. |
class |
PropNotEqualX_YC
A specific
Propagator extension defining filtering algorithm for:
X =/= Y + C where X and Y are Variable objects and C a constant. |
class |
PropNotEqualXY_C
A specific
Propagator extension defining filtering algorithm for:
X + Y =/= C where X and Y are Variable objects and C a constant. |
class |
PropScale
Scale propagator : ensures x * y = z
With y a constant greater than one
Ensures AC
|
class |
PropSquare
Enforces X = Y^2
|
Modifier and Type | Class and Description |
---|---|
class |
PropElement
VALUE = TABLE[INDEX-OFFSET], ensuring arc consistency on result and index.
|
Modifier and Type | Class and Description |
---|---|
class |
PropBinAC2001
AC2001 algorithm for binary table constraint
|
class |
PropBinAC3
|
class |
PropBinAC3bitrm
AC3 bit rm algorithm for binary table constraint
|
class |
PropBinAC3rm
|
class |
PropBinCSP
|
class |
PropBinFC
Forward checking algorithm for table constraint
|
Modifier and Type | Class and Description |
---|---|
class |
PropCompactTable
Propagator for table constraint based on
"Compact-Table: Efficiently Filtering Table Constraints with Reversible Sparse Bit-Sets"
Only for feasible Tuples
|
class |
PropLargeCSP<R extends LargeRelation>
|
class |
PropLargeFC
|
class |
PropLargeGAC2001
|
class |
PropLargeGAC2001Positive
|
class |
PropLargeGAC3rm
|
class |
PropLargeGAC3rmPositive
|
class |
PropLargeGACSTRPos
GAC maintaind by STR
|
class |
PropLargeMDDC
Implementation based on "Maintaining GAC on adhoc r-ary constraints", Cheng and Yap, CP12.
|
class |
PropTableStr2
STR2 Propagator for table constraints (only positive tuples)
|
Modifier and Type | Class and Description |
---|---|
class |
PropDiffN |
class |
PropIntValuePrecedeChain
A propagator for the IntValuePrecede constraint, based on:
"Y.
|
class |
PropKLoops
Incremental propagator which restricts the number of loops:
|{succs[i]=i+offSet}| = nbLoops
|
class |
PropKnapsack
Propagator for the Knapsack constraint
based on Dantzig-Wolfe relaxation
|
Modifier and Type | Class and Description |
---|---|
class |
PropAllDiffAC
Propagator for AllDifferent AC constraint for integer variables
Uses Regin algorithm
Runs in O(m.n) worst case time for the initial propagation
but has a good average behavior in practice
Runs incrementally for maintaining a matching
|
class |
PropAllDiffAdaptative
Probabilistic Propagator for AllDifferent AC constraint for integer variables introduced
to avoid loosing too much time in AC propagation when BC is sufficientss
The more this propagator triggers filtering and failure, the more likely it will be called
If it does not bring improvement, this propagator will be called less during search
|
class |
PropAllDiffBC
Based on:
"A Fast and Simple Algorithm for Bounds Consistency of the AllDifferent Constraint"
A.
|
class |
PropAllDiffInst
Propagator for AllDifferent that only reacts on instantiation
|
Constructor and Description |
---|
AlgoAllDiffBC(Propagator cause) |
Modifier and Type | Class and Description |
---|---|
class |
PropCondAllDiff_AC
Propagator for AllDifferent AC constraint for integer variables
subject to conditions (e.g. allDifferent_except_0)
AllDiff only applies on the subset of variables satisfying the given condition
|
class |
PropCondAllDiffInst
Propagator for ConditionnalAllDifferent that only reacts on instantiation
|
Modifier and Type | Class and Description |
---|---|
class |
PropAmongGAC
Incremental propagator for Among Constraint:
Counts the number of decision variables which take a value in the input value set
GCCAT:
NVAR is the number of variables of the collection VARIABLES that take their value in VALUES.
|
Modifier and Type | Class and Description |
---|---|
class |
PropCostRegular
|
class |
PropMultiCostRegular
Created by IntelliJ IDEA.
|
class |
PropRegular
|
Modifier and Type | Method and Description |
---|---|
void |
StoredValuedDirectedMultiGraph.removeArc(int arcId,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator,
ICause aCause) |
void |
StoredValuedDirectedMultiGraph.updateLeft(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator) |
void |
StoredValuedDirectedMultiGraph.updateLPFS(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator)
Deprecated.
|
void |
StoredValuedDirectedMultiGraph.updateLPFT(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator)
Deprecated.
|
void |
StoredValuedDirectedMultiGraph.updateRight(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator) |
void |
StoredValuedDirectedMultiGraph.updateSPFS(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator)
Deprecated.
|
void |
StoredValuedDirectedMultiGraph.updateSPFT(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
boolean |
StoredDirectedMultiGraph.removeArc(int arcId,
gnu.trove.stack.TIntStack toRemove,
gnu.trove.stack.TIntStack[] updateLeft,
gnu.trove.stack.TIntStack[] updateRight,
Propagator<IntVar> propagator) |
void |
StoredDirectedMultiGraph.updateLeft(gnu.trove.stack.TIntStack updateLeft,
gnu.trove.stack.TIntStack toRemove,
int dim,
boolean[] modBound,
Propagator<IntVar> propagator) |
void |
StoredDirectedMultiGraph.updateRight(gnu.trove.stack.TIntStack updateRight,
gnu.trove.stack.TIntStack toRemove,
int dim,
boolean[] modBound,
Propagator<IntVar> propagator) |
Modifier and Type | Method and Description |
---|---|
void |
StoredDirectedMultiGraph.clearSupports(int idxVar,
int val,
Propagator<IntVar> p) |
Modifier and Type | Class and Description |
---|---|
class |
PropItemToLoad
Propagator for a Bin Packing constraint
Propagates item/bin allocations to bin loads
Reacts to item/bin allocation variables only
Should be used together with PropLoadToItem
|
class |
PropLoadToItem
Incremental propagator for a Bin Packing constraint
Propagates bin loads to item/bin allocations
Reacts to load modifications AND allocation assignments
Should be used together with PropItemToLoad
|
Modifier and Type | Class and Description |
---|---|
class |
PropBitChanneling
A propagator which ensures that OCTET = 20*BIT_1 + 21*BIT_2 + ... 2n-1*BIT_n.
|
class |
PropClauseChanneling
A propagator which links an IntVar with two arrays of BoolVar, one for EQ relations, the other for LQ relations.
|
class |
PropEnumDomainChanneling
Constraints that map the boolean assignments variables (bvars) with the standard assignment variables (var).
|
class |
PropInverseChannelAC
X[i] = j+Ox <=> Y[j] = i+Oy
AC propagator for enumerated domain variables
|
class |
PropInverseChannelBC
X[i] = j+Ox <=> Y[j] = i+Oy
Propagator for bounded variables
it ensures :
LB(X[i]) = j+Ox => Y[j].contains(i+Oy)
UB(X[i]) = j+Ox => Y[j].contains(i+Oy)
and reciprocally for Y
It however does not performs BC on the conjunction
of this and the allDifferent constraint implied by InverseChanneling constraint
Such a consistency would require to know somehow holes in (bounded) domains
Again, AC is strongly advised
|
Modifier and Type | Class and Description |
---|---|
class |
PropCircuit_AntiArboFiltering
Propagator for circuit constraint based on dominators
Redundant propagator
|
class |
PropCircuit_ArboFiltering
Propagator for sub-circuit constraint based on dominators
Redundant propagator
|
class |
PropCircuitSCC
Filters circuit based on strongly connected components
(see the TechReport "Improving the Asymmetric TSP by considering graph structure", Fages & Lorca, 2012)
|
class |
PropNoSubtour
Simple nocircuit contraint (from NoSubtour of Pesant or noCycle of Caseaux/Laburthe)
|
class |
PropSubcircuit
Subcircuit propagator (one circuit and several loops)
|
class |
PropSubcircuitDominatorFilter
Propagator for sub-circuit constraint based on dominators
Redundant propagator
|
Modifier and Type | Class and Description |
---|---|
class |
PropFalse
|
class |
PropTrue
|
Modifier and Type | Class and Description |
---|---|
class |
PropCount_AC
Define a COUNT constraint setting size{forall v in lvars | v = occval} = occVar
assumes the occVar variable to be the last of the variables of the constraint:
vars = [lvars | occVar]
Arc Consistent algorithm
with lvars = list of variables for which the occurrence of occval in their domain is constrained
|
class |
PropCountVar
Define a COUNT constraint setting size{forall v in lvars | v = occval} = occVar
assumes the occVar variable to be the last of the variables of the constraint:
vars = [lvars | occVar]
Arc Consistent algorithm
with lvars = list of variables for which the occurrence of occval in their domain is constrained
|
Modifier and Type | Class and Description |
---|---|
class |
PropCumulative
Cumulative propagator
Performs energy checking and mandatory part based filtering
BEWARE : not idempotent, use two propagators to get the fix point
|
class |
PropGraphCumulative
Graph based cumulative
Maintains incrementally overlapping tasks
Performs energy checking and mandatory part based filtering
BEWARE : not idempotent, use two propagators to get the fix point
|
Modifier and Type | Field and Description |
---|---|
protected Propagator<IntVar> |
CumulFilter.aCause |
Modifier and Type | Method and Description |
---|---|
abstract CumulFilter |
Cumulative.Filter.make(int n,
Propagator<IntVar> cause)
Create an instance of the filtering algorithm
|
Constructor and Description |
---|
CumulFilter(int nbMaxTasks,
Propagator<IntVar> cause)
An object which can filter subset of tasks for the cumulative constraint
|
DefaultCumulFilter(int nbMaxTasks,
Propagator<IntVar> cause) |
DisjunctiveTaskIntervalFilter(int nbMaxTasks,
Propagator<IntVar> cause) |
HeightCumulFilter(int n,
Propagator<IntVar> cause) |
NRJCumulFilter(int n,
Propagator<IntVar> cause) |
SweepCumulFilter(int n,
Propagator<IntVar> cause) |
SweepHeiSortCumulFilter(int n,
Propagator<IntVar> cause) |
TimeCumulFilter(int nbMaxTasks,
Propagator<IntVar> cause) |
Modifier and Type | Class and Description |
---|---|
class |
PropElementV_fast
Fast Element constraint
|
Modifier and Type | Class and Description |
---|---|
class |
PropFastGCC
Propagator for Global Cardinality Constraint (GCC) for integer variables
Basic filter: no particular consistency but fast and with a correct checker
|
Modifier and Type | Class and Description |
---|---|
class |
PropLex
Enforce a lexicographic ordering on two vectors of integer
variables x <_lex y with x =
|
class |
PropLexChain
Solver constraint of the LexChain constraint.
|
class |
PropLexInt
Enforce a lexicographic ordering on one vector of integer
variables x <_lex y with x =
|
Modifier and Type | Class and Description |
---|---|
class |
PropBoolMax
|
class |
PropBoolMin
|
class |
PropMax
|
class |
PropMin
|
Modifier and Type | Class and Description |
---|---|
class |
PropAMNV
Propagator for the atMostNValues constraint
The number of distinct values in the set of variables vars is at most equal to nValues
|
class |
PropAtLeastNValues
Propagator for the atMostNValues constraint
The number of distinct values in the set of variables vars is at most equal to nValues
No level of consistency but better than BC in general (for enumerated domains with holes)
|
class |
PropAtLeastNValues_AC
AtLeastNValues Propagator (similar to SoftAllDiff)
The number of distinct values in vars is at least nValues
Performs Generalized Arc Consistency based on Maximum Bipartite Matching
The worst case time complexity is O(nm) but this is very pessimistic
In practice it is more like O(m) where m is the number of variable-value pairs
BEWARE UNSAFE : BUG DETECTED THROUGH DOBBLE(3,4,6)
!
|
class |
PropAtMostNValues
Propagator for the atMostNValues constraint
The number of distinct values in the set of variables vars is at most equal to nValues
No level of consistency but better than BC in general (for enumerated domains with holes)
|
class |
PropAtMostNValues_BC
Propagator for the atMostNValues constraint
The number of distinct values in the set of variables vars is at most equal to nValues
Performs Bound Consistency in O(n+d) with
n = |vars|
d = maxValue - minValue (from initial domains)
=> very appropriate when d <= n It is indeed much better than the usual time complexity of O(n.log(n))
=> not appropriate when d >> n (you should encode another data structure and a quick sort algorithm)
!
|
Modifier and Type | Method and Description |
---|---|
protected void |
R3.enforceEq(int i,
int j,
IntVar[] vars,
Propagator aCause) |
void |
R4.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
void |
R3.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
void |
R2.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
void |
R1.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
void |
R.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
Modifier and Type | Class and Description |
---|---|
class |
PropKeysorting
Based on Technical Report from Mats Carlsson: "Propagating THE KEYSORTING Constraint" - Sept. 15, 2014.
|
class |
PropSort
SortingConstraint is a constraint that ensures
that a vector is the sorted version of a second one. |
Modifier and Type | Class and Description |
---|---|
class |
PropScalar
A propagator for SUM(x_i*c_i) = b
Based on "Bounds Consistency Techniques for Long Linear Constraint" W. |
class |
PropSum
A propagator for SUM(x_i) o b
Based on "Bounds Consistency Techniques for Long Linear Constraint" W. |
class |
PropSumBool
A propagator for SUM(x_i) = y + b, where x_i are boolean variables
Based on "Bounds Consistency Techniques for Long Linear Constraint" W. |
class |
PropSumBoolIncr
A propagator for SUM(x_i) = y + b, where x_i are boolean variables, maintained incrementally.
|
class |
PropSumFullBool
A propagator for SUM(x_i) = y + b, where x_i are boolean variables
Based on "Bounds Consistency Techniques for Long Linear Constraint" W. |
class |
PropSumFullBoolIncr
A propagator for SUM(x_i) = y + b, where x_i are boolean variables, maintained incrementally.
|
Constructor and Description |
---|
SumConstraint(String name,
Propagator propagator)
Make a new constraint defined as a set of given propagators
|
Modifier and Type | Class and Description |
---|---|
class |
PropAntiArborescences
AntiArborescences propagation (simplification from tree constraint) based on dominators
loops (i.e., variables such that x[i]=i) are considered as roots
Can use the simple LT algorithm which runs in O(m.log(n)) worst case time
Or a slightly more sophisticated one, linear in theory but not necessarily faster in practice
|
Modifier and Type | Class and Description |
---|---|
class |
RealPropagator
A propagator for real variables.
|
Modifier and Type | Class and Description |
---|---|
class |
PropConditionnal
A specific propagator which posts constraint on condition.
|
class |
PropLocalConDis
A propagator for constructive disjunction, with local deductions.
|
class |
PropOpposite
Constraint representing the negation of a given constraint
does not filter but fails if the given constraint is satisfied
Can be used within any constraint
Should not be called by the user
|
class |
PropReif
Implication propagator
|
class |
PropXeqCReif
A propagator dedicated to express in a compact way: (x = c) ⇔ b
|
class |
PropXeqYReif
A propagator dedicated to express in a compact way: (x = y) ⇔ b
|
class |
PropXgtCReif
A propagator dedicated to express in a compact way: (x > c) ⇔ b
|
class |
PropXinSReif
A propagator dedicated to express in a compact way: (x = c) ⇔ b
|
class |
PropXltCReif
A propagator dedicated to express in a compact way: (x < c) ⇔ b
|
class |
PropXltYCReif
A propagator dedicated to express in a compact way: (x < y + c) ⇔ b
|
class |
PropXltYReif
A propagator dedicated to express in a compact way: (x < y) ⇔ b
|
class |
PropXneCReif
A propagator dedicated to express in a compact way: (x ≠ c) ⇔ b
|
class |
PropXneYReif
A propagator dedicated to express in a compact way: (x ≠ y) ⇔ b
|
Constructor and Description |
---|
PropLocalConDis(IntVar[] vars,
Propagator<IntVar>[][] propagators)
A propagator to deal with constructive disjunction
|
Modifier and Type | Class and Description |
---|---|
class |
PropAllDiff
Ensures that all sets are different
|
class |
PropAllDisjoint
Ensures that all non-empty sets are disjoint
In order to forbid multiple empty set, use propagator PropAtMost1Empty in addition
|
class |
PropAllEqual
Ensures that all sets are equal
|
class |
PropAtMost1Empty
At most one set can be empty
|
class |
PropBoolChannel
Channeling between a set variable and boolean variables
|
class |
PropCardinality
A propagator ensuring that |set| = card
|
class |
PropIntBoundedMemberSet
Propagator for Member constraint: iv is in set
|
class |
PropIntChannel
Channeling between set variables and integer variables
x in sets[y-offSet1] <=> ints[x-offSet2] = y
|
class |
PropIntCstMemberSet
Propagator for Member constraint: int cst is in set
|
class |
PropIntCstNotMemberSet
Propagator for Member constraint: int cst is not in set
|
class |
PropIntEnumMemberSet
Propagator for Member constraint: iv is in set
|
class |
PropIntersection |
class |
PropIntersectionFilterSets |
class |
PropInverse
Inverse set propagator
x in sets[y-offSet1] <=> y in inverses[x-offSet2]
|
class |
PropMaxElement
Retrieves the maximum element of the set
the set must not be empty
|
class |
PropMinElement
Retrieves the minimum element of the set
the set must not be empty
|
class |
PropNbEmpty
Restricts the number of empty sets
|{s in sets such that |s|=0}| = nbEmpty
|
class |
PropNotEmpty
Restricts the set var not to be empty
|
class |
PropNotMemberIntSet
Not Member propagator filtering Int->Set
|
class |
PropNotMemberSetInt
Not Member propagator filtering Set->Int
|
class |
PropOffSet
set2 is an offSet view of set1
x in set1 <=> x+offSet in set2
|
class |
PropSetIntValuesUnion
Maintain a link between a set variable and the union of values taken by an array of
integer variables
Not idempotent (use two of them)
|
class |
PropSubsetEq
Ensures that X subseteq Y
|
class |
PropSumOfElements
Sums elements given by a set variable
|
class |
PropSymmetric
Propagator for symmetric sets
x in set[y-offSet] <=> y in set[x-offSet]
|
class |
PropUnion |
Modifier and Type | Class and Description |
---|---|
class |
PropDistanceXYZ
A constraint to state |x0 - x1| operator x2
where operator can be =, <=, >= and x1, x2, x3 are variables
Warning: only achieves BoundConsistency for the moment !
|
class |
PropDivXYZ
X/Y = Z
A propagator for the constraint Z = X / Y where X, Y and Z are integer, possibly negative, variables
The filtering algorithm both supports bounded and enumerated integer variables
|
class |
PropMaxBC
X = MAX(Y,Z)
ensures bound consistency |
class |
PropMinBC
X = MIN(Y,Z)
ensures bound consistency |
class |
PropTimesNaive
V0 * V1 = V2
|
class |
PropXplusYeqZ
A propagator to ensure that X + Y = Z holds, where X, Y and Z are IntVar.
|
Modifier and Type | Class and Description |
---|---|
class |
PropEqualXC
Unary propagator ensuring:
X = C, where X is a variable and C is a constant |
class |
PropGreaterOrEqualXC
X >= C
|
class |
PropLessOrEqualXC
X <= C
|
class |
PropMemberBound
|
class |
PropMemberEnum
|
class |
PropNotEqualXC
A propagator ensuring that:
X =/= C, where X is a variable and C a constant
|
class |
PropNotMemberBound
|
class |
PropNotMemberEnum
|
Modifier and Type | Method and Description |
---|---|
default void |
IExplanationEngine.activePropagator(BoolVar var,
Propagator propagator)
Explain the activation of a propagator involved in a reified constraint
|
void |
ExplanationEngine.activePropagator(BoolVar var,
Propagator propagator)
Explain the activation of a propagator involved in a reified constraint
|
boolean |
RuleStore.addPropagatorActivationRule(Propagator propagator)
Add a propagator activation rule
|
Modifier and Type | Method and Description |
---|---|
void |
PropagationTrigger.addAll(Propagator... propagators) |
default void |
IPropagationEngine.delayedPropagation(Propagator propagator,
PropagatorEventType type)
Exeucte a delayed propagator
|
default void |
IPropagationEngine.desactivatePropagator(Propagator propagator)
Set the propagator as inactivated within the propagation engine
|
void |
PropagationTrigger.dynAdd(Propagator propagator,
boolean permanent) |
default void |
IPropagationEngine.dynamicAddition(boolean permanent,
Propagator... ps)
Add a constraint to the propagation engine
|
default void |
IPropagationEngine.dynamicDeletion(Propagator... ps)
Delete the list of propagators in input from the engine
|
static void |
PropagationTrigger.execute(Propagator toPropagate,
IPropagationEngine engine) |
default void |
IPropagationEngine.onPropagatorExecution(Propagator propagator)
Action to do when a propagator is executed
|
static void |
IPropagationEngine.Trace.printCoarseSchedule(Propagator p) |
static void |
IPropagationEngine.Trace.printFineSchedule(Propagator p) |
static void |
IPropagationEngine.Trace.printFirstPropagation(Propagator p) |
static void |
IPropagationEngine.Trace.printPropagation(Variable v,
Propagator p) |
void |
PropagationTrigger.propagateOnBacktrack(Propagator propagator) |
default void |
IPropagationEngine.propagateOnBacktrack(Propagator p)
State that the propagator needs to be propagated (coarse event) on backtrack.
|
void |
PropagationTrigger.remove(Propagator propagator) |
default void |
IPropagationEngine.updateInvolvedVariables(Propagator p)
Update the scope of variable of a propagator (addition or deletion are allowed -- p.vars are scanned)
|
Modifier and Type | Method and Description |
---|---|
void |
TwoBucketPropagationEngine.delayedPropagation(Propagator propagator,
PropagatorEventType type) |
void |
SevenQueuesPropagatorEngine.delayedPropagation(Propagator propagator,
PropagatorEventType type) |
void |
TwoBucketPropagationEngine.desactivatePropagator(Propagator propagator) |
void |
SevenQueuesPropagatorEngine.desactivatePropagator(Propagator propagator) |
void |
TwoBucketPropagationEngine.dynamicAddition(boolean permanent,
Propagator... ps) |
void |
SevenQueuesPropagatorEngine.dynamicAddition(boolean permanent,
Propagator... ps) |
void |
TwoBucketPropagationEngine.dynamicDeletion(Propagator... ps) |
void |
SevenQueuesPropagatorEngine.dynamicDeletion(Propagator... ps) |
void |
TwoBucketPropagationEngine.onPropagatorExecution(Propagator propagator) |
void |
SevenQueuesPropagatorEngine.onPropagatorExecution(Propagator propagator) |
void |
TwoBucketPropagationEngine.propagateOnBacktrack(Propagator p) |
void |
SevenQueuesPropagatorEngine.propagateOnBacktrack(Propagator p) |
void |
TwoBucketPropagationEngine.updateInvolvedVariables(Propagator p) |
void |
SevenQueuesPropagatorEngine.updateInvolvedVariables(Propagator p) |
Modifier and Type | Method and Description |
---|---|
int |
FailPerPropagator.getFails(Propagator p)
Gets, for a given propagator, the number of times it has failed during the resolution
|
Modifier and Type | Method and Description |
---|---|
Propagator |
Variable.getPropagator(int idx)
Return the "idx" th propagator of this
|
Propagator[] |
Variable.getPropagators()
Return the array of propagators this
|
Modifier and Type | Method and Description |
---|---|
int |
Variable.link(Propagator propagator,
int idxInProp)
Link the propagator to this
|
void |
Variable.unlink(Propagator propagator,
int idxInProp)
Remove a propagator from the list of propagator of
this . |
Modifier and Type | Field and Description |
---|---|
protected Propagator[] |
AbstractVariable.propagators
List of propagators of this variable.
|
Modifier and Type | Method and Description |
---|---|
Propagator |
AbstractVariable.getPropagator(int idx) |
Propagator[] |
AbstractVariable.getPropagators() |
Modifier and Type | Method and Description |
---|---|
int |
AbstractVariable.link(Propagator propagator,
int idxInProp) |
void |
AbstractVariable.unlink(Propagator propagator,
int idxInProp) |
Copyright © 2017. All rights reserved.