| Modifier and Type | Field and Description |
|---|---|
protected Propagator |
Propagator.aCause |
protected Propagator[] |
Constraint.propagators |
| 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 |
PropElement
VALUE = TABLE[INDEX]
Bound consistency. |
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 |
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 |
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 |
PropKLoops
Incremental propagator which restricts the number of loops:
|{succs[i]=i+offSet}| = nbLoops
|
class |
PropKnapsack
!
|
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 |
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
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 |
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
GCCAT:
NVAR is the number of variables of the collection VARIABLES that take their value in VALUES.
|
class |
PropAmongGAC_GoodImpl
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) |
void |
StoredValuedDirectedMultiGraph.updateLPFT(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator) |
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) |
void |
StoredValuedDirectedMultiGraph.updateSPFT(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator) |
| 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 p) |
protected void |
StoredDirectedMultiGraph.clearSupports(StoredIndexedBipartiteSet supports,
Propagator p) |
protected void |
StoredDirectedMultiGraph.removeArc(Propagator<IntVar> propagator) |
| 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 |
class |
PropCircuit_ArboFiltering |
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 |
PropSubcircuit_AntiArboFiltering |
class |
PropSubCircuitSCC
Filters subcircuit based on strongly connected components
|
| Modifier and Type | Class and Description |
|---|---|
class |
PropClause
Deprecated.
replaced by
PropSat, a miniSat solver |
class |
PropFalse
|
class |
PropNogoods
Created by cprudhom on 20/01/15.
|
class |
PropSat
|
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 |
PropFullCumulative
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 |
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 cause)
An object which can filter subset of tasks for the cumulative constraint
|
HeightCumulFilter(int n,
Propagator cause) |
NRJCumulFilter(int n,
Propagator cause) |
SweepCumulFilter(int n,
Propagator cause) |
SweepHeiSortCumulFilter(int n,
Propagator cause) |
TimeCumulFilter(int nbMaxTasks,
Propagator 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.
|
| 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 |
PropBoolSumCoarse
Constraint that state that the sum of boolean variables vars is equal to the integer variable sum
|
class |
PropBoolSumIncremental
Constraint that state that the sum of boolean variables vars is equal to the integer variable sum
Works incrementally in O(1) per instantiation event
|
class |
PropScalarEq
A propagator for SUM(x_i) = b
Based on "Bounds Consistency Techniques for Long Linear Constraint" W. |
class |
PropSumEq
A propagator for SUM(x_i) = y
|
| 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 |
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
|
| 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 |
PropIntEnumMemberSet
Propagator for Member constraint: iv is in set
|
class |
PropIntersection |
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 |
PropTimesXY
X*Y=Z filters from left to right
|
class |
PropTimesZ
X*Y=Z filters from right to left
|
| 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 |
|---|---|
void |
ExplanationEngine.activePropagator(BoolVar var,
Propagator propagator) |
boolean |
RuleStore.addPropagatorActivationRule(Propagator propagator)
Add a propagator activation rule
|
| Modifier and Type | Method and Description |
|---|---|
void |
PropagationTrigger.addAll(Propagator... propagators) |
void |
IPropagationEngine.delayedPropagation(Propagator propagator,
PropagatorEventType type) |
void |
IPropagationEngine.desactivatePropagator(Propagator propagator)
Set the propagator as inactivated within the propagation engine
|
void |
PropagationTrigger.dynAdd(Propagator propagator,
boolean permanent) |
void |
IPropagationEngine.dynamicAddition(boolean permanent,
Propagator... ps)
Add a constraint to the propagation engine
|
void |
IPropagationEngine.dynamicDeletion(Propagator... ps)
Delete the list of propagators in input from the engine
|
static void |
PropagationTrigger.execute(Propagator toPropagate,
IPropagationEngine engine) |
void |
IPropagationEngine.onPropagatorExecution(Propagator propagator) |
static void |
IPropagationEngine.Trace.printAlreadySchedule(Propagator p) |
static void |
IPropagationEngine.Trace.printPropagation(Variable v,
Propagator p) |
static void |
IPropagationEngine.Trace.printSchedule(Propagator p) |
void |
IPropagationEngine.propagateOnBacktrack(Propagator p)
State that the propagator needs to be propagated (coarse event) on backtrack.
|
void |
PropagationTrigger.remove(Propagator propagator) |
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 | Field and Description |
|---|---|
protected Propagator |
TwoBucketPropagationEngine.lastProp |
protected Propagator |
SevenQueuesPropagatorEngine.lastProp |
protected Propagator[] |
TwoBucketPropagationEngine.propagators |
protected Propagator[] |
SevenQueuesPropagatorEngine.propagators |
| 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) |
| 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 |
|---|---|
void |
FilteringMonitor.activePropagator(BoolVar var,
Propagator propagator)
Explain the activation of a propagator involved in a reified constraint
|
int |
Variable.link(Propagator propagator,
int idxInProp)
Link the propagator to this
|
void |
Variable.unlink(Propagator propagator)
Remove a propagator from the list of propagator of
this. |
| 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) |
| Modifier and Type | Method and Description |
|---|---|
void |
FilteringMonitorList.activePropagator(BoolVar var,
Propagator propagator) |
Copyright © 2015. All rights reserved.