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 | Class and Description |
---|---|
class |
Propagator<V extends Variable>
A
Propagator class defines methods to react on a Variable objects modifications. |
Modifier and Type | Class and Description |
---|---|
class |
PropAbsolute
Enforces X = |Y|
|
class |
PropDistanceXYC
| X - Y | op C
op = {"==", "<", ">", "=/="} |
class |
PropEqualX_Y
X = Y
|
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 |
PropCompactTable
Propagator for table constraint based on "Compact-Table: Efficiently Filtering Table Constraints
with Reversible Sparse Bit-Sets" Only for feasible Tuples
|
class |
PropCompactTableStar
Propagator for table constraint based on
"Extending Compact-Table to Negative and Short Tables",
H.
|
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
|
Modifier and Type | Class and Description |
---|---|
class |
PropCondAllDiff_AC
Propagator for AllDifferent AC constraint for integer variables
subject to conditions (e.g.
|
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 | 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 + ...
|
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
|
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 |
ClauseStore
A class to manage life of sclauses during resolution.
|
class |
ClauseStore.SignedClause |
class |
PropSignedClause
This propagator manages a signed clause: a disjunction of unary membership constraints.
|
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 | 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)
!redundant propagator!
|
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)
!redundant propagator!
|
Modifier and Type | Class and Description |
---|---|
class |
PropKeysorting
Based on Technical Report from Mats Carlsson: "Propagating THE KEYSORTING Constraint" - Sept.
|
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.
|
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 |
PropScalarMixed
A propagator for SUM(x_i*c_i) = b
Based on "Bounds Consistency Techniques for Long Linear Constraint" W. |
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 |
PropXeqYCReif
A propagator dedicated to express in a compact way: (x = y + 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
|
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 |
PropElement
Propagator for element constraint over sets
states that
array[index-offSet] = set
|
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 |
AbstractPropDistanceXYZ
A constraint to state |X - Y| operator Z
where operator can be =, <=, <, >=, > and X, Y, and Z 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 |
PropEQDistanceXYZ |
class |
PropGEDistanceXYZ |
class |
PropGTDistanceXYZ |
class |
PropLEDistanceXYZ |
class |
PropLTDistanceXYZ |
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 |
PropMember
This propagator manages a singleton nogood.
|
class |
PropNotEqualXC
A propagator ensuring that:
X =/= C, where X is a variable and C a constant
|
class |
PropNotMember
This propagator manages a singleton nogood.
|
Modifier and Type | Interface and Description |
---|---|
interface |
BoolVar
CPRU r544: remove default implementation |
interface |
IntVar
Interface for integer variables.
|
interface |
RealVar
An interface to declare variable for continuous constraints (solved using IBEX).
|
interface |
SetVar
A Set Variable is defined by a domain which is a set interval [LB,UB], where:
LB is the set of integers that must belong to every single solution.
|
interface |
Variable
To developers: any constructor of variable must pass in parameter
the back-end ISolver, that is, in decreasing order:
- the model portfolio,
- the model (or portfolio workers but fes).
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractVariable
Class used to factorise code The subclass must implement Variable interface
|
class |
BitsetArrayIntVarImpl
IntVar implementation for quite small domains bit with very distant values e.g. |
class |
BitsetIntVarImpl
|
class |
BoolVarImpl
|
class |
FixedBoolVarImpl
A constant view specific to boolean variable
Based on "Views and Iterators for Generic Constraint Implementations",
C.
|
class |
FixedIntVarImpl
A IntVar with one domain value.
|
class |
FixedRealVarImpl
Project: choco-solver.
|
class |
IntervalIntVarImpl
|
class |
RealVarImpl
An implementation of RealVar, variable for continuous constraints (solved using IBEX).
|
class |
SetVarImpl
Set variable to represent a set of integers, i.e.
|
Modifier and Type | Interface and Description |
---|---|
interface |
IView
An interface to define views.
|
Modifier and Type | Class and Description |
---|---|
class |
BoolNotView
A view for boolean variable, that enforce not(b).
|
class |
EqView
declare an BoolVar based on X and C, such as (X = C) is reified by this.
|
class |
IntBoolView
An abstract class for boolean views over
IntVar . |
class |
IntView<I extends IntVar>
"A view implements the same operations as a variable.
|
class |
LeqView
declare an BoolVar based on X and C, such as (X <= C) is reified by this.
|
class |
MinusView
View for -V, where V is a IntVar or view
|
class |
OffsetView
declare an IntVar based on X and C, such as X + C
Based on "Views and Iterators for Generic Constraint Implementations" C. |
class |
RealView
|
class |
ScaleView
declare an IntVar based on X and C, such as X * C
|
Copyright © 2018. All rights reserved.