| Modifier and Type | Interface and Description |
|---|---|
interface |
Replaceable<T extends Constraint>
Interface that provides ability to configure constraint store to
replace a particular type of constraints into another one.
|
| Modifier and Type | Method and Description |
|---|---|
DecomposedConstraint<Constraint> |
Replaceable.replace(T constraint) |
| Modifier and Type | Class and Description |
|---|---|
class |
DecomposedConstraint<T extends Constraint>
Standard unified interface/abstract class for constraints, which can only be decomposed.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbsXeqY
Constraints |X| #= Y
|
class |
Alldiff
Alldiff constraint assures that all FDVs has different values.
|
class |
Alldifferent
Alldifferent constraint assures that all FDVs has differnet values.
|
class |
Alldistinct
Alldistinct constraint assures that all FDVs have different values.
|
class |
Among
Among constraint in its simplest form.
|
class |
AmongVar
Among constraint in its general form.
|
class |
And
Constraint c1 /\ c2 ...
|
class |
AndBoolSimple
If both a and b are equal 1 then result variable is equal 1 too.
|
class |
AndBoolVector |
class |
ArgMax
ArgMax constraint provides the index of the maximum
variable from all variables on the list.
|
class |
ArgMin
ArgMin constraint provides the index of the maximum
variable from all variables on the list.
|
class |
Assignment
Assignment constraint implements facility to improve channeling constraints
between dual viewpoints of permutation models.
|
class |
AtLeast |
class |
AtMost |
class |
BoolClause
I defines a boolean clause for 0/1 variables x_i and y_i.
|
class |
ChannelImply
ChannelImply constraints "B => constraint".
|
class |
ChannelReif
ChannelReif constraints "constraint" <=> B.
|
class |
Circuit
Circuit constraint assures that all variables build a Hamiltonian
circuit.
|
class |
Conditional
Conditional constraint implements conditional constraint
satisfiability.
|
class |
Count
Count constraint implements the counting over number of occurrences of
a given value in a list of variables.
|
class |
CountBounds
CountBounds constraint implements the counting over number of occurrences of
a given value in a list of variables.
|
class |
CountValues |
class |
CountValuesBounds
CountValuesBounds constraint implements the counting over numbers of occurrences of a given
vector of values in a list of variables.
|
class |
CountVar |
class |
Cumulative
Cumulative implements the cumulative/4 constraint using edge-finding
algorithm and profile information on the resource use.
|
class |
Decreasing
Decreasing constraint assures that all variables are in decreasing order.
|
class |
Diff
Diff constraint assures that any two rectangles from a vector of rectangles
does not overlap in at least one direction.
|
class |
Diff2
Diff2 constraint assures that any two rectangles from a vector of
rectangles does not overlap in at least one direction.
|
class |
Disjoint
Disjoint constraint assures that any two rectangles from a vector of
rectangles does not overlap in at least one direction.
|
class |
DisjointConditional
DisjointConditional constraint assures that any two rectangles from a vector
of rectangles does not overlap in at least one direction.
|
class |
Distance
Constraint |X - Y| #= Z
|
class |
Element
Element constraint implements the element/4 constraint (both with integer
list and variables list).
|
class |
ElementInteger
ElementInteger constraint defines a relation
list[index - indexOffset] = value.
|
class |
ElementIntegerFast |
class |
ElementVariable
ElementVariable constraint defines a relation
list[index - indexOffset] = value.
|
class |
ElementVariableFast |
class |
Eq
Constraint "constraint1"#<=> "constraint2"
|
class |
EqBool
If all x's are equal to each other then result variable is equal 1.
|
class |
ExtensionalConflictVA
Extensional constraint assures that none of the tuples explicitly given is enforced in the
relation.
|
class |
ExtensionalSupportMDD
Extensional constraint assures that one of the tuples is enforced in the
relation.
|
class |
ExtensionalSupportSTR
Extensional constraint assures that one of the tuples is enforced in the
relation.
|
class |
ExtensionalSupportVA
Extensional constraint assures that one of the tuples is enforced in the
relation.
|
class |
GCC
GCC constraint counts the number of occurences of given
values in x variables.
|
class |
IfThen
Constraint if constraint1 then constraint2
|
class |
IfThenBool
Constraint ( X => Y ) <=> Z.
|
class |
IfThenElse
Constraint if constraint1 then constraint2 else constraint3
*
|
class |
Implies |
class |
In
Constraints X to belong to a specified domain.
|
class |
Increasing
Increasing constraint assures that all variables are in increasing order.
|
class |
LexOrder
It constructs a LexOrder (lexicographical order) constraint.
|
class |
Linear
Deprecated.
As of release 4.3.1 replaced by LinearInt constraint.
|
class |
LinearInt |
class |
LinearIntDom
LinearIntDom constraint implements the weighted summation over several
variables.
|
class |
Max
Max constraint implements the Maximum/2 constraint.
|
class |
MaxSimple
MaxSimple constraint implements the Maximum/2 constraint.
|
class |
Member
Member constraint implements the membership of element e on list x.
|
class |
Min
Min constraint implements the minimum/2 constraint.
|
class |
MinSimple
MinSimple constraint implements the minimum/2 constraint.
|
class |
NoGood
NoGood constraints implements a constraint which disallows given combination
of values for given variables.
|
class |
Not
Constraint "not costraint"
|
class |
Or
Constraint c1 \/ c2 \/ ...
|
class |
OrBoolSimple
If at least one variable is equal 1 then result variable is equal 1 too.
|
class |
OrBoolVector
If at least one variable from the list is equal 1 then result variable is equal 1 too.
|
class |
PrimitiveConstraint
Standard unified interface for all primitive constraints.
|
class |
Reified |
class |
Subcircuit
Subcircuit constraint assures that all variables build a
subcircuit.
|
class |
Sum |
class |
SumBool |
class |
SumInt
SumInt constraint implements the summation over several variables.
|
class |
SumWeight |
class |
SumWeightDom
Deprecated.
As of release 4.3.1 replaced by LinearIntDom constraint.
|
class |
ValuePrecede |
class |
Values
Constraint Values counts number of different values on a list of Variables.
|
class |
VariableTrace
VariableTrace is a daemon that prints information on variables whenever they are changed.
|
class |
XdivYeqZ
Constraint X div Y #= Z
|
class |
XeqC |
class |
XeqY
Constraints X #= Y
|
class |
XexpYeqZ
Constraint X ^ Y #= Z
|
class |
XgtC
Constraint X > C
|
class |
XgteqC
Constraints X >= C
|
class |
XgteqY
Constraints X >= Y
|
class |
XgtY
Constraint X > Y
|
class |
XltC
Constraint X < C
|
class |
XlteqC
Constraint X <= C
|
class |
XlteqY
Constraint X <= Y
|
class |
XltY
Constraint X < Y
|
class |
XmodYeqZ |
class |
XmulCeqZ |
class |
XmulYeqC
Constraint X * Y #= C
|
class |
XmulYeqZ |
class |
XneqC |
class |
XneqY
Constraints X #\= Y
|
class |
Xor
Xor constraint - xor("constraint", B).
|
class |
XorBool
Constraint ( x_0 xor x_1 xor ...
|
class |
XplusCeqZ
Constraint X + C #= Z.
|
class |
XplusClteqZ
Constraints X + C<= Z.
|
class |
XplusYeqC
Constraint X + Y #= C
|
class |
XplusYeqZ
Constraint X + Y = Z
|
class |
XplusYgtC
Constraint X + Y> C
|
class |
XplusYlteqZ
Constraint X + Y=< Z
|
| Modifier and Type | Field and Description |
|---|---|
protected List<Constraint> |
Increasing.constraints |
List<Constraint> |
SoftAlldifferent.decomposition |
List<Constraint> |
SoftGCC.decomposition |
| Modifier and Type | Method and Description |
|---|---|
static Constraint |
Element.choose(IntVar index,
int[] values,
IntVar value)
It constructs element constraint based on variables.
|
static Constraint |
Element.choose(IntVar index,
int[] values,
IntVar value,
int shift)
It constructs element constraint based on variables.
|
static Constraint |
Element.choose(IntVar index,
IntVar[] variables,
IntVar value)
It constructs element constraint based on variables.
|
static Constraint |
Element.choose(IntVar index,
IntVar[] variables,
IntVar value,
int shift)
It constructs element constraint based on variables.
|
static Constraint |
Element.choose(IntVar index,
List<? extends IntVar> variables,
IntVar value)
It constructs element constraint based on variables.
|
static Constraint |
Element.choose(IntVar index,
List<? extends IntVar> variables,
IntVar value,
int shift)
It constructs element constraint based on variables.
|
Constraint |
Alldistinct.getGuideConstraint() |
Constraint |
Constraint.getGuideConstraint()
It specifies a constraint which if imposed by search will enhance
propagation of this constraint.
|
Constraint |
In.getGuideConstraint() |
Constraint |
Sum.getGuideConstraint() |
Constraint |
SumInt.getGuideConstraint() |
| Modifier and Type | Method and Description |
|---|---|
List<Constraint> |
AndBoolVector.decompose(Store store) |
List<Constraint> |
Constraint.decompose(Store store)
It returns an array list of constraint which are used to decompose this
constraint.
|
List<Constraint> |
EqBool.decompose(Store store) |
List<Constraint> |
Increasing.decompose(Store store) |
List<Constraint> |
Lex.decompose(Store store) |
List<Constraint> |
OrBoolVector.decompose(Store store) |
List<Constraint> |
Sequence.decompose(Store store) |
List<Constraint> |
SoftAlldifferent.decompose(Store store) |
List<Constraint> |
SoftGCC.decompose(Store store) |
List<Constraint> |
Stretch.decompose(Store store) |
static List<Constraint> |
Sequence.decomposeByRegular(Sequence sequence)
Preferred and default option of decomposing Sequence constraint.
|
List<Constraint> |
Lex.decomposeLE(Store store) |
List<Constraint> |
Lex.decomposeLERegular(Store store) |
List<Constraint> |
Lex.decomposeLT(Store store) |
List<Constraint> |
Lex.decomposeLTRegular(Store store) |
List<Constraint> |
SoftAlldifferent.primitiveDecomposition(Store store) |
List<Constraint> |
SoftGCC.primitiveDecomposition(Store store) |
| Modifier and Type | Method and Description |
|---|---|
void |
Constraint.updateAFC(Set<Constraint> allConstraints,
double decay) |
| Modifier and Type | Class and Description |
|---|---|
class |
Binpacking
Binpacking constraint implements bin packing problem.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CumulativeBasic |
class |
CumulativeUnary |
| Modifier and Type | Class and Description |
|---|---|
class |
Diffn
Diffn constraint assures that any two rectangles from a vector of rectangles
does not overlap in at least one direction.
|
class |
Nooverlap
Nooverlap constraint assures that any two rectangles from a vector of rectangles
does not overlap in at least one direction.
|
| Modifier and Type | Field and Description |
|---|---|
protected List<Constraint> |
Diffn.constraints |
protected List<Constraint> |
DiffnDecomposed.constraints |
| Modifier and Type | Method and Description |
|---|---|
List<Constraint> |
Diffn.decompose(Store store) |
List<Constraint> |
DiffnDecomposed.decompose(Store store) |
| Modifier and Type | Class and Description |
|---|---|
class |
Geost |
| Modifier and Type | Class and Description |
|---|---|
class |
Knapsack
It specifies a knapsack constraint.
|
| Modifier and Type | Class and Description |
|---|---|
class |
NetworkFlow
The network flow constraint.
|
| Modifier and Type | Method and Description |
|---|---|
List<Constraint> |
Arithmetic.decompose(Store store) |
List<Constraint> |
Arithmetic.primitiveDecomposition(Store store) |
List<Constraint> |
NetworkBuilder.primitiveDecomposition(Store store)
Generally speaking, especially in case of multiple arcs between
two nodes and structure constraints imposed on arcs makes it hard
to decompose network flow constraint into primitive ones.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Regular
Regular constraint accepts only the assignment to variables which is accepted by
an automaton.
|
| Modifier and Type | Method and Description |
|---|---|
List<Constraint> |
Regular.decompose(Store store) |
| Modifier and Type | Method and Description |
|---|---|
DecomposedConstraint<Constraint> |
ReifiedIfThen.replace(Reified constraint) |
| Modifier and Type | Class and Description |
|---|---|
class |
SimpleTable
SimpleTable implements the table constraint using a method presented in
|
class |
Table
Table implements the table constraint using a method presented in
|
| Modifier and Type | Field and Description |
|---|---|
Constraint |
Store.currentConstraint
It stores constraint which is currently re-evaluated.
|
Constraint[][] |
Domain.modelConstraints
It specifies constraints which are attached to current domain, each array
has different pruning event.
|
Constraint |
Store.recentlyFailedConstraint
It stores constraint that has recently failed during store.consistency() execution.
|
| Modifier and Type | Field and Description |
|---|---|
List<Constraint> |
Domain.searchConstraints
It specifies constraints which are attached to current domain.
|
Map<Var,Set<Constraint>> |
Store.watchedConstraints
This keeps information about watched constraints by given variable.
|
| Modifier and Type | Method and Description |
|---|---|
Constraint |
Store.getCurrentConstraint()
This function returns the constraint which is currently reevaluated.
|
Constraint |
Store.getFirstChanged()
This function returns the constraint scheduled for re-evaluation.
|
| Modifier and Type | Method and Description |
|---|---|
List<Constraint> |
Domain.constraints()
It returns all the constraints attached currently to the domain.
|
Set<Constraint> |
Store.getConstraints() |
List<Constraint> |
Domain.searchConstraints() |
| Modifier and Type | Method and Description |
|---|---|
void |
Store.addChanged(Constraint c)
This function schedules given constraint for re-evaluation.
|
void |
Store.deregisterWatchedLiteralConstraint(Constraint c)
Watched constraint given as parameter is being removed, no variable will
be watching it.
|
void |
Store.deregisterWatchedLiteralConstraint(Var v,
Constraint c)
Variable given as a parameter no longer watches constraint given as
parameter.
|
void |
Store.impose(Constraint c)
This function imposes a constraint to a store.
|
void |
Store.impose(Constraint c,
int queueIndex)
This function imposes a constraint to a store.
|
void |
Store.imposeWithConsistency(Constraint c)
In some special cases it may be beneficial to compute consistency of
constraint store immediately after the constraint is imposed.
|
void |
Store.imposeWithConsistency(Constraint c,
int queueIndex)
In some special cases it may be beneficial to compute consistency of
constraint store immediately after the constraint is imposed.
|
void |
BooleanVar.putConstraint(Constraint c) |
void |
IntVar.putConstraint(Constraint c) |
abstract void |
Var.putConstraint(Constraint c)
It registers constraint with current variable, so anytime this variable
is changed the constraint is reevaluated.
|
void |
BooleanVar.putModelConstraint(Constraint constraint,
int pruningEvent)
It registers constraint with current variable, so anytime this variable
is changed the constraint is reevaluated.
|
void |
IntVar.putModelConstraint(Constraint c,
int pruningEvent)
It registers constraint with current variable, so anytime this variable
is changed the constraint is reevaluated.
|
abstract void |
Var.putModelConstraint(Constraint c,
int pruningEvent)
It registers constraint with current variable, so anytime this variable
is changed the constraint is reevaluated.
|
abstract void |
Domain.putModelConstraint(int storeLevel,
Var var,
Constraint C,
int pruningEvent)
It adds a constraint to a domain, it should only be called by
putConstraint function of Variable object.
|
void |
IntDomain.putModelConstraint(int storeLevel,
Var var,
Constraint c,
int pruningEvent)
It adds a constraint to a domain, it should only be called by
putConstraint function of Variable object.
|
void |
BooleanVar.putSearchConstraint(Constraint constraint)
It registers constraint with current variable, so anytime this variable
is changed the constraint is reevaluated.
|
void |
IntVar.putSearchConstraint(Constraint c)
It registers constraint with current variable, so always when this variable
is changed the constraint is reevaluated.
|
abstract void |
Var.putSearchConstraint(Constraint c)
It registers constraint with current variable, so always when this variable
is changed the constraint is reevaluated.
|
abstract void |
Domain.putSearchConstraint(int storeLevel,
Var var,
Constraint C)
It adds a constraint to a domain, it should only be called by
putConstraint function of Variable object.
|
void |
IntDomain.putSearchConstraint(int storeLevel,
Var var,
Constraint c)
It adds a constraint to a domain, it should only be called by
putConstraint function of Variable object.
|
void |
Store.registerWatchedLiteralConstraint(Var v,
Constraint c)
It register variable to watch given constraint.
|
void |
BooleanVar.removeConstraint(Constraint constraint)
It unregisters constraint with current variable, so change in variable
will not cause constraint reevaluation.
|
void |
IntVar.removeConstraint(Constraint c)
It detaches constraint from the current variable, so change in variable
will not cause constraint reevaluation.
|
abstract void |
Var.removeConstraint(Constraint c)
It detaches constraint from the current variable, so change in variable
will not cause constraint reevaluation.
|
abstract void |
Domain.removeModelConstraint(int storeLevel,
Var var,
Constraint c)
It removes a constraint from a domain, it should only be called by
removeConstraint function of Variable object.
|
void |
IntDomain.removeModelConstraint(int storeLevel,
Var var,
Constraint c) |
void |
IntDomain.removeSearchConstraint(int storeLevel,
Var var,
Constraint c)
It removes a constraint from a domain, it should only be called by
removeConstraint function of Variable object.
|
abstract void |
Domain.removeSearchConstraint(int storeLevel,
Var var,
int position,
Constraint c)
It removes a constraint from a domain, it should only be called by
removeConstraint function of Variable object.
|
void |
IntDomain.removeSearchConstraint(int storeLevel,
Var var,
int position,
Constraint c)
It removes a constraint from a domain, it should only be called by
removeConstraint function of Variable object.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
Store.deregisterReplacement(Replaceable<? extends Constraint> replacement)
It makes it possible to deregister the replacement.
|
boolean |
Store.registerReplacement(Replaceable<? extends Constraint> replacement)
It makes it possible to register replacement for a particular constraint
type.
|
| Modifier and Type | Field and Description |
|---|---|
List<Constraint> |
MagicSquares.guidingShaving
It specifies the list of constraints which can be used for guiding shaving.
|
List<Constraint> |
NonTransitiveDice.shavingConstraints
It contains constraints which can be used for shaving guidance.
|
| Modifier and Type | Method and Description |
|---|---|
static Constraint |
Gates.tableConstraintProviderUsingExtensionalSTR(IntVar[] vars,
int[][] tuples) |
static Constraint |
Gates.tableConstraintProviderUsingSimpleTable(IntVar[] vars,
int[][] tuples) |
| Modifier and Type | Method and Description |
|---|---|
void |
Gates.and(BooleanVar in1,
BooleanVar in2,
BooleanVar out,
BiFunction<IntVar[],int[][],Constraint> tableConstraintProvider)
It imposes an extensional constraint enforcing an and relationship
between two input parameters and an output parameter.
|
void |
Gates.model(BiFunction<IntVar[],int[][],Constraint> tableConstraintProvider) |
void |
Gates.not(BooleanVar in,
BooleanVar out,
BiFunction<IntVar[],int[][],Constraint> tableConstraintProvider)
It imposes an extensional constraint enforcing an not relationship
between input parameter and an output parameter.
|
void |
Gates.or(BooleanVar in1,
BooleanVar in2,
BooleanVar out,
BiFunction<IntVar[],int[][],Constraint> tableConstraintProvider)
It imposes an extensional constraint enforcing an or relationship
between two input parameters and an output parameter.
|
boolean |
ExampleFD.shavingSearch(List<Constraint> guidingShaving,
boolean printInfo)
It searches with shaving which is guided by supplied constraints.
|
void |
Gates.xor(BooleanVar in1,
BooleanVar in2,
BooleanVar out,
BiFunction<IntVar[],int[][],Constraint> tableConstraintProvider)
It imposes an extensional constraint enforcing an xor relationship
between two input parameters and an output parameter.
|
| Modifier and Type | Field and Description |
|---|---|
List<Constraint> |
QCP.shavingConstraints
It contains constraints which can be used to guide shaving.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbsPeqR
Constraints |P| #= R
|
class |
AcosPeqR
Constraints acos(P) = R
|
class |
AsinPeqR
Constraints asin(P) = R
|
class |
AtanPeqR
Constraints atan(P) = R
|
class |
CosPeqR
Constraints cos(P) = R
|
class |
ElementFloat
ElementFloat constraint defines a relation
list[index - indexOffset] = value.
|
class |
ElementFloatVariable
ElementFloatVariable constraint defines a relation
list[index - indexOffset] = value.
|
class |
EquationSystem
EquationSystem constraint implements the multivariate interval
Newton method for pruning domains of variables in a system of
non-linear equations.
|
class |
ExpPeqR
Constraints exp(P) #= Q for P and Q floats
|
class |
LinearFloat
LinearFloat constraint implements the weighted summation over several
Variable's .
|
class |
LnPeqR
Constraints Ln(P) #= Q for P and Q floats
|
class |
PdivCeqR
Constraint P / C = R for floats
|
class |
PdivQeqR
Constraint P / Q = R for floats
|
class |
PeqC
Constraints P #= C
|
class |
PeqQ
Constraints P #= Q for P and Q floats
|
class |
PgtC
Constraint P > C
|
class |
PgteqC
Constraints P >= C for floats
|
class |
PgteqQ
Constraints P >= Q for floats
|
class |
PgtQ
Constraint P > Q for floats
|
class |
PltC
Constraint P < C for floats
|
class |
PlteqC
Constraint X <= C for floats
|
class |
PlteqQ
Constraint P <= Q for floats
|
class |
PltQ
Constraint P < Q for floats
|
class |
PminusCeqR
Constraint P - C = R
|
class |
PminusQeqR
Constraint P - Q = R
|
class |
PmulCeqR
Constraint P * C = R for floats
|
class |
PmulQeqR
Constraint P * Q = R for floats
|
class |
PneqC
Constraints P != C
|
class |
PneqQ
Constraints P #= Q for P and Q floats
|
class |
PplusCeqR
Constraint P + C #= R
|
class |
PplusQeqR
Constraint P + Q = R
|
class |
SinPeqR
Constraints sin(P) = R
|
class |
SqrtPeqR
Constraint sqrt(P) = R for floats
|
class |
SumFloat
SumFloat constraint implements the weighted summation over several
Variable's .
|
class |
TanPeqR
Constraints sin(P) = R
|
class |
XeqP
Constraints X #= P for X and P floats
|
| Modifier and Type | Method and Description |
|---|---|
List<Constraint> |
CosPeqR_decomposed.decompose(Store store) |
static Set<Constraint> |
Derivative.derivativeConstraints() |
| Modifier and Type | Method and Description |
|---|---|
static void |
Derivative.defineConstraint(FloatVar f,
Constraint c) |
| Modifier and Type | Method and Description |
|---|---|
void |
FloatVar.putConstraint(Constraint c) |
void |
FloatVar.putModelConstraint(Constraint c,
int pruningEvent)
It registers constraint with current variable, so anytime this variable
is changed the constraint is reevaluated.
|
void |
FloatDomain.putModelConstraint(int storeLevel,
Var var,
Constraint C,
int pruningEvent)
It adds a constraint to a domain, it should only be called by
putConstraint function of Variable object.
|
void |
FloatVar.putSearchConstraint(Constraint c)
It registers constraint with current variable, so always when this variable
is changed the constraint is reevaluated.
|
void |
FloatIntervalDomain.putSearchConstraint(int storeLevel,
Var var,
Constraint C)
It adds a constraint to a domain, it should only be called by
putConstraint function of Variable object.
|
void |
FloatVar.removeConstraint(Constraint c)
It detaches constraint from the current variable, so change in variable
will not cause constraint reevaluation.
|
void |
FloatDomain.removeModelConstraint(int storeLevel,
Var var,
Constraint C) |
void |
FloatIntervalDomain.removeSearchConstraint(int storeLevel,
Var var,
Constraint C)
It removes a constraint from a domain, it should only be called by
removeConstraint function of Variable object.
|
void |
FloatIntervalDomain.removeSearchConstraint(int storeLevel,
Var var,
int position,
Constraint C)
It removes a constraint from a domain, it should only be called by
removeConstraint function of Variable object.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SatWrapper
wrapper to communicate between SAT solver and CP solver.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SatWrapper.impose(Constraint constraint)
add the constraint to the wrapper (ie, constraint.imposeToSat(this))
|
| Modifier and Type | Method and Description |
|---|---|
void |
Shaving.addShavingConstraint(Constraint c)
It adds shaving constraint to the list of constraints guiding shaving.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AdiffBeqC
It creates a constraints that subtracts from set variable A the
elements from of the set variable B and assigns the result to set
variable C.
|
class |
AdisjointB
The disjoint set constraint makes sure that two set variables
do not contain any common element.
|
class |
AeqB
It creates an equality constraint to make sure that two set variables
have the same value.
|
class |
AeqS
It creates an equality constraint to make sure that a set variable
is equal to a given set.
|
class |
AinB
It creates a constraint that makes sure that the set value of set variable A is included
in the set value of set variable B.
|
class |
AinS
It creates a constraint that makes sure that value of the variable A is included within
a provided set.
|
class |
AintersectBeqC
It creates a constraint that makes sure that A intersected with B
is equal to C.
|
class |
AleB
It creates a <= b constraint on two set variables.
|
class |
AltB
It creates a < b constraint on two set variables.
|
class |
AunionBeqC
It creates a constraint that makes sure that A union B is equal to C.
|
class |
CardA
The set cardinality constraint.
|
class |
CardAeqX
The set cardinality constraint.
|
class |
EinA
It constructs a constraint which makes sure that a given element is
in the domain of the set variable.
|
class |
ElementSet
It is an element constraint that make sure that set variable value has a domain equal to
the index-th element of the supplied list of sets.
|
class |
ElementSetVariable
ElementSetVariable constraint defines a relation
list[index - indexOffset] = value.
|
class |
Lex
Deprecated.
As of release 4.5.1 replaced by AltB and AleB constraints.
|
class |
Match
This constraint matches the elements of the given set variable
onto a list of integer variables.
|
class |
SinA
It creates an inclusion set constraint to make sure that provided set is
included in a set variable a.
|
class |
SumWeightedSet
It computes a weighted sum of the elements in the domain of the given set variable.
|
class |
XeqA
It creates a constraint that makes sure that the value assigned to the integer variable x
is the only element of the set assigned to a set variable a.
|
class |
XinA
It creates a constraint that makes sure that the value assigned to integer variable x is
included in the set assigned to the set variable a.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SetVar.putConstraint(Constraint c) |
void |
SetVar.putModelConstraint(Constraint c,
int pruningEvent)
It registers constraint with current variable, so anytime this variable
is changed the constraint is reevaluated.
|
void |
SetDomain.putModelConstraint(int storeLevel,
Var var,
Constraint C,
int pruningEvent)
It adds a constraint to a domain, it should only be called by
putConstraint function of Variable object.
|
void |
SetVar.putSearchConstraint(Constraint c)
It registers constraint with current variable, so always when this variable
is changed the constraint is reevaluated.
|
void |
SetDomain.putSearchConstraint(int storeLevel,
Var var,
Constraint C)
It adds a constraint to a domain, it should only be called by
putConstraint function of Variable object.
|
void |
SetVar.removeConstraint(Constraint c)
It detaches constraint from the current variable, so change in variable
will not cause constraint reevaluation.
|
void |
SetDomain.removeModelConstraint(int storeLevel,
Var var,
Constraint C)
It removes a constraint from a domain, it should only be called by
removeConstraint function of Variable object.
|
void |
SetDomain.removeSearchConstraint(int storeLevel,
Var var,
int position,
Constraint C)
It removes a constraint from a domain, it should only be called by
removeConstraint function of Variable object.
|
| Modifier and Type | Class and Description |
|---|---|
class |
QueueForward<T extends Constraint>
Utility class that allows for constraints like Xor, Reified, etc that take other constraints
as parameters to forward any changes of variables to the constraints that were provided as arguments.
|
| Constructor and Description |
|---|
QueueForward(T[] constraints,
Collection<Var> vars) |
QueueForward(T[] constraints,
Var[] vars) |
Copyright © 2022. All rights reserved.