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 edgefinding
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 reevaluated.

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 reevaluation.

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 reevaluation.

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
nonlinear 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 indexth 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.