Modifier and Type | Method and Description |
---|---|
void |
XplusYplusQgtC.consistency(Store store) |
void |
NoGood.consistency(Store store) |
void |
ElementVariable.consistency(Store store) |
void |
XmulCeqZ.consistency(Store store) |
void |
XlteqY.consistency(Store store) |
void |
GCC.consistency(Store store) |
void |
XgteqY.consistency(Store store) |
void |
AmongVar.consistency(Store store) |
void |
XplusYplusCeqZ.consistency(Store store) |
void |
XeqY.consistency(Store store) |
void |
Alldifferent.consistency(Store store) |
abstract void |
Constraint.consistency(Store store)
It is a (most probably incomplete) consistency function which removes the
values from variables domains.
|
void |
XltY.consistency(Store store) |
void |
Distance.consistency(Store store) |
void |
IfThenElse.consistency(Store store) |
void |
ExtensionalConflictVA.consistency(Store store) |
void |
XmodYeqZ.consistency(Store store) |
void |
Max.consistency(Store store) |
void |
Circuit.consistency(Store store) |
void |
Reified.consistency(Store store) |
void |
Cumulative.consistency(Store store) |
void |
XltC.consistency(Store store) |
void |
AndBool.consistency(Store store) |
void |
IfThen.consistency(Store store) |
void |
Element.consistency(Store store) |
void |
Count.consistency(Store store) |
void |
AbsXeqY.consistency(Store store) |
void |
XgteqC.consistency(Store store) |
void |
ExtensionalSupportMDD.consistency(Store s) |
void |
Among.consistency(Store store) |
void |
Sum.consistency(Store store) |
void |
XplusCeqZ.consistency(Store store) |
void |
Or.consistency(Store store) |
void |
XplusYplusQeqZ.consistency(Store store) |
void |
Eq.consistency(Store store) |
void |
Xor.consistency(Store store) |
void |
Linear.consistency(Store store) |
void |
Assignment.consistency(Store store) |
void |
SumWeightDom.consistency(Store store) |
void |
Diff.consistency(Store store) |
void |
XeqC.consistency(Store store) |
void |
XplusYeqZ.consistency(Store store) |
void |
XgtY.consistency(Store store) |
void |
Alldiff.consistency(Store store) |
void |
Values.consistency(Store store) |
void |
XplusYgtC.consistency(Store store) |
void |
XorBool.consistency(Store store) |
void |
SumWeight.consistency(Store store) |
void |
In.consistency(Store store) |
void |
XexpYeqZ.consistency(Store store) |
void |
XneqC.consistency(Store store) |
void |
XneqY.consistency(Store store) |
void |
OrBool.consistency(Store store) |
void |
LexOrder.consistency(Store store) |
void |
ExtensionalSupportSTR.consistency(Store store) |
void |
And.consistency(Store store) |
void |
Not.consistency(Store store) |
void |
Min.consistency(Store store) |
void |
EqBool.consistency(Store store) |
void |
XplusClteqZ.consistency(Store store) |
void |
XplusYeqC.consistency(Store store) |
void |
XmulYeqC.consistency(Store store) |
void |
XlteqC.consistency(Store store) |
void |
XdivYeqZ.consistency(Store store) |
void |
XgtC.consistency(Store store) |
void |
Subcircuit.consistency(Store store) |
void |
Alldistinct.consistency(Store store) |
void |
IfThenBool.consistency(Store store) |
void |
ElementInteger.consistency(Store store) |
void |
XmulYeqZ.consistency(Store store) |
void |
ExtensionalSupportVA.consistency(Store store) |
void |
XplusYlteqZ.consistency(Store store) |
void |
AmongVar.consistencyForX(Store store)
Is called when all y are grounded and amongForSet is equivalent to simple version of Among.
|
void |
AmongVar.consistencyForY(Store store)
It is a function which makes Y consistent if all X's are grounded.
|
void |
AmongVar.consistencyWhen_LB0_EQ_UB0(Store store)
The number of x in lbsDom is equal to the number of X intersecting ubSDom.
|
ArrayList<Constraint> |
Constraint.decompose(Store store)
It returns an array list of constraint which are used to decompose this
constraint.
|
ArrayList<Constraint> |
SoftGCC.decompose(Store store) |
ArrayList<Constraint> |
AndBool.decompose(Store store) |
ArrayList<Constraint> |
OrBool.decompose(Store store) |
ArrayList<Constraint> |
Stretch.decompose(Store store) |
ArrayList<Constraint> |
Lex.decompose(Store store) |
abstract ArrayList<Constraint> |
DecomposedConstraint.decompose(Store store)
It returns an array list of constraint which are used to decompose this
constraint.
|
ArrayList<Constraint> |
EqBool.decompose(Store store) |
ArrayList<Constraint> |
SoftAlldifferent.decompose(Store store) |
ArrayList<Constraint> |
Sequence.decompose(Store store) |
ArrayList<Constraint> |
Lex.decomposeLE(Store store) |
ArrayList<Constraint> |
Lex.decomposeLERegular(Store store) |
ArrayList<Constraint> |
Lex.decomposeLT(Store store) |
ArrayList<Constraint> |
Lex.decomposeLTRegular(Store store) |
FloatVar |
DecomposedConstraint.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
void |
XplusYplusQgtC.impose(Store store) |
void |
NoGood.impose(Store store) |
void |
ElementVariable.impose(Store store) |
void |
XmulCeqZ.impose(Store store) |
void |
XlteqY.impose(Store store) |
void |
GCC.impose(Store store) |
void |
XgteqY.impose(Store store) |
void |
AmongVar.impose(Store store) |
void |
XplusYplusCeqZ.impose(Store store) |
void |
XeqY.impose(Store store) |
void |
Alldifferent.impose(Store store) |
abstract void |
Constraint.impose(Store store)
It imposes the constraint in a given store.
|
void |
XltY.impose(Store store) |
void |
Distance.impose(Store store) |
void |
IfThenElse.impose(Store store) |
void |
ExtensionalConflictVA.impose(Store store) |
void |
XmodYeqZ.impose(Store store) |
void |
Max.impose(Store store) |
void |
Circuit.impose(Store store) |
void |
Reified.impose(Store store) |
void |
Cumulative.impose(Store store) |
void |
XltC.impose(Store store) |
void |
AndBool.impose(Store store) |
void |
Diff2.impose(Store store) |
void |
IfThen.impose(Store store) |
void |
Element.impose(Store store) |
void |
Count.impose(Store store) |
void |
AbsXeqY.impose(Store store) |
void |
XgteqC.impose(Store store) |
void |
ExtensionalSupportMDD.impose(Store store) |
void |
Among.impose(Store store) |
void |
Sum.impose(Store store) |
void |
XplusCeqZ.impose(Store store) |
void |
Or.impose(Store store) |
void |
XplusYplusQeqZ.impose(Store store) |
void |
Eq.impose(Store store) |
void |
Xor.impose(Store store) |
void |
Linear.impose(Store store) |
void |
Assignment.impose(Store store) |
void |
SumWeightDom.impose(Store store) |
void |
Diff.impose(Store store) |
void |
XeqC.impose(Store store) |
void |
XplusYeqZ.impose(Store store) |
void |
XgtY.impose(Store store) |
void |
Alldiff.impose(Store store) |
void |
Disjoint.impose(Store store) |
void |
Values.impose(Store store) |
void |
XplusYgtC.impose(Store store) |
void |
XorBool.impose(Store store) |
void |
SumWeight.impose(Store store) |
void |
In.impose(Store store) |
void |
XexpYeqZ.impose(Store Store) |
void |
XneqC.impose(Store store) |
void |
XneqY.impose(Store store) |
void |
OrBool.impose(Store store) |
void |
DisjointConditional.impose(Store store) |
void |
LexOrder.impose(Store store) |
void |
ExtensionalSupportSTR.impose(Store store) |
void |
And.impose(Store store) |
void |
Not.impose(Store store) |
void |
Min.impose(Store store) |
void |
EqBool.impose(Store store) |
void |
XplusClteqZ.impose(Store store) |
void |
XplusYeqC.impose(Store store) |
void |
XmulYeqC.impose(Store store) |
void |
XlteqC.impose(Store store) |
void |
XdivYeqZ.impose(Store store) |
void |
XgtC.impose(Store store) |
void |
Subcircuit.impose(Store store) |
void |
Alldistinct.impose(Store store) |
void |
IfThenBool.impose(Store store) |
void |
ElementInteger.impose(Store store) |
void |
XmulYeqZ.impose(Store store) |
void |
ExtensionalSupportVA.impose(Store store) |
void |
XplusYlteqZ.impose(Store store) |
void |
Constraint.impose(Store store,
int queueIndex)
It imposes the constraint and adjusts the queue index.
|
void |
Constraint.imposeDecomposition(Store store)
It imposes the decomposition of the given constraint in a given store.
|
void |
SoftGCC.imposeDecomposition(Store store) |
void |
AndBool.imposeDecomposition(Store store) |
void |
OrBool.imposeDecomposition(Store store) |
void |
Stretch.imposeDecomposition(Store store) |
void |
Lex.imposeDecomposition(Store store) |
abstract void |
DecomposedConstraint.imposeDecomposition(Store store)
It imposes the constraint in a given store.
|
void |
EqBool.imposeDecomposition(Store store) |
void |
SoftAlldifferent.imposeDecomposition(Store store) |
void |
Sequence.imposeDecomposition(Store store) |
void |
DecomposedConstraint.imposeDecomposition(Store store,
int queueIndex)
It imposes the constraint and adjusts the queue index.
|
void |
IfThenElse.include(Store store) |
void |
AndBool.include(Store store) |
void |
IfThen.include(Store store) |
void |
Or.include(Store store) |
void |
Eq.include(Store store) |
void |
Xor.include(Store store) |
void |
OrBool.include(Store store) |
void |
PrimitiveConstraint.include(Store store)
It provide store for constraints that are not imposed but called from ather constraints.
|
void |
And.include(Store store) |
void |
Not.include(Store store) |
void |
XplusYplusQgtC.notConsistency(Store store) |
void |
NoGood.notConsistency(Store store) |
void |
XmulCeqZ.notConsistency(Store store) |
void |
XlteqY.notConsistency(Store store) |
void |
XgteqY.notConsistency(Store store) |
void |
XplusYplusCeqZ.notConsistency(Store store) |
void |
XeqY.notConsistency(Store store) |
void |
XltY.notConsistency(Store store) |
void |
Distance.notConsistency(Store store) |
void |
IfThenElse.notConsistency(Store store) |
void |
XltC.notConsistency(Store store) |
void |
AndBool.notConsistency(Store store) |
void |
IfThen.notConsistency(Store store) |
void |
AbsXeqY.notConsistency(Store store) |
void |
XgteqC.notConsistency(Store store) |
void |
XplusCeqZ.notConsistency(Store store) |
void |
Or.notConsistency(Store store) |
void |
XplusYplusQeqZ.notConsistency(Store store) |
void |
Eq.notConsistency(Store store) |
void |
Xor.notConsistency(Store store) |
void |
Linear.notConsistency(Store store) |
void |
XeqC.notConsistency(Store store) |
void |
XplusYeqZ.notConsistency(Store store) |
void |
XgtY.notConsistency(Store store) |
void |
XplusYgtC.notConsistency(Store store) |
void |
XorBool.notConsistency(Store store) |
void |
In.notConsistency(Store store) |
void |
XneqC.notConsistency(Store store) |
void |
XneqY.notConsistency(Store store) |
void |
OrBool.notConsistency(Store store) |
abstract void |
PrimitiveConstraint.notConsistency(Store store)
It makes pruning in such a way that constraint is notConsistent.
|
void |
And.notConsistency(Store store) |
void |
Not.notConsistency(Store store) |
void |
EqBool.notConsistency(Store store) |
void |
XplusClteqZ.notConsistency(Store store) |
void |
XplusYeqC.notConsistency(Store store) |
void |
XmulYeqC.notConsistency(Store store) |
void |
XlteqC.notConsistency(Store store) |
void |
XgtC.notConsistency(Store store) |
void |
IfThenBool.notConsistency(Store store) |
void |
XplusYlteqZ.notConsistency(Store store) |
ArrayList<Constraint> |
SoftGCC.primitiveDecomposition(Store store) |
ArrayList<Constraint> |
SoftAlldifferent.primitiveDecomposition(Store store) |
Constructor and Description |
---|
Disjoint(Store store,
IntVar[][] rectangles)
It creates a diff2 constraint.
|
Linear(Store store,
ArrayList<? extends IntVar> variables,
ArrayList<Integer> weights,
String rel,
int sum)
It constructs the constraint Linear.
|
Linear(Store store,
IntVar[] list,
int[] weights,
String rel,
int sum) |
Modifier and Type | Method and Description |
---|---|
void |
Binpacking.consistency(Store store) |
void |
Binpacking.impose(Store store) |
Modifier and Type | Field and Description |
---|---|
protected Store |
Geost.store
It keeps a reference to the store.
|
Modifier and Type | Method and Description |
---|---|
void |
Geost.consistency(Store store) |
boolean |
GeostObject.TimeBoundConstraint.consistencyDurationGtZero(Store store)
It applies constraint enforcing that duration > 0
|
boolean |
GeostObject.TimeBoundConstraint.consistencyStartPlusDurationEqEnd(Store store)
It evaluates part of the constraint that ensures that start + duration = end
|
void |
Geost.impose(Store store) |
protected int |
Geost.pruneMax(Store store,
GeostObject o,
int currentShape,
int d,
int limit)
the sweeping routine for minimal bounds.
|
protected int |
Geost.pruneMin(Store store,
GeostObject o,
int currentShape,
int d,
int limit)
the sweeping routine for minimal bounds.
|
Modifier and Type | Method and Description |
---|---|
void |
Knapsack.consistency(Store store) |
void |
Knapsack.impose(Store store) |
Modifier and Type | Field and Description |
---|---|
Store |
Network.store
The store
|
Modifier and Type | Method and Description |
---|---|
void |
NetworkFlow.consistency(Store store) |
ArrayList<Constraint> |
Arithmetic.decompose(Store store) |
void |
NetworkFlow.impose(Store store) |
void |
Arithmetic.imposeDecomposition(Store store) |
void |
Network.initialize(Store store) |
ArrayList<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.
|
ArrayList<Constraint> |
Arithmetic.primitiveDecomposition(Store store) |
Modifier and Type | Method and Description |
---|---|
void |
Regular.consistency(Store store) |
ArrayList<Constraint> |
Regular.decompose(Store store) |
void |
Regular.impose(Store store) |
void |
Regular.imposeDecomposition(Store store) |
Modifier and Type | Field and Description |
---|---|
Store |
Var.store
Each variable is created in a store.
|
Modifier and Type | Method and Description |
---|---|
static void |
XMLSaveSupport.save(Store store,
String filename) |
Constructor and Description |
---|
BooleanVar(Store store)
This constructor creates a variable with empty domain (standard FD
domain), automatically generated name, and empty attached constraint
list.
|
BooleanVar(Store store,
BoundDomain dom)
It creates a Boolean variable.
|
BooleanVar(Store store,
String name)
Boolean variable constructor.
|
BooleanVar(Store store,
String name,
BoundDomain dom)
It creates a Boolean variable.
|
BooleanVar(Store store,
String name,
int min,
int max)
Boolean variable constructor.
|
IntVar(Store store)
This constructor creates a variable with empty domain (standard
IntervalDomain domain), automatically generated name, and empty attached
constraint list.
|
IntVar(Store store,
IntDomain dom)
It creates a variable in a given store, with a given name and
a given domain.
|
IntVar(Store store,
int min,
int max)
This constructor creates a variable with a domain between min..max,
automatically generated name, and empty attached constraint list.
|
IntVar(Store store,
String name)
This constructor creates a variable with an empty domain (standard
IntervalDomain domain), the specified name, and an empty attached
constraint list.
|
IntVar(Store store,
String name,
IntDomain dom)
It creates a variable in a given store, with a given name and
a given domain.
|
IntVar(Store store,
String name,
int min,
int max)
This constructor creates a variable in a given store, with
the domain specified by min..max and with the given name.
|
MutableDomain(Store store) |
MutableDomain(Store store,
IntDomain domain) |
TimeStamp(Store store,
T input)
The constructor.
|
Modifier and Type | Field and Description |
---|---|
Store |
ExampleFD.store
It specifies the constraint store responsible for holding information
about constraints and variables.
|
Modifier and Type | Method and Description |
---|---|
Store |
ExampleFD.getStore()
It specifies the constraint store used within an example.
|
Modifier and Type | Method and Description |
---|---|
static void |
FilterBenchmark.experiment1(Store store,
Filter filter,
int addNum,
int mulNum)
It optimizes scheduling of filter operations.
|
static void |
FilterBenchmark.experiment1C(Store store,
Filter filter,
int addNum,
int mulNum,
int clock)
It optimizes scheduling of filter operation in fashion allowing
chaining of operations within one clock cycle.
|
static void |
FilterBenchmark.experiment1P(Store store,
Filter filter,
int addNum,
int mulNum)
It optimizes scheduling of filter operations.
|
static void |
FilterBenchmark.experiment1PM(Store store,
Filter filter,
int addNum,
int mulNum)
It optimizes scheduling of filter operations in a fashion allowing
pipelining of multiplication operations.
|
static void |
FilterBenchmark.experiment2(Store store,
Filter filter,
int addNum,
int mulNum)
It optimizes scheduling of filter operations.
|
static void |
FilterBenchmark.experiment2C(Store store,
Filter filter,
int addNum,
int mulNum,
int clock)
It optimizes scheduling of filter operation in fashion allowing
chaining of operations within one clock cycle.
|
static void |
FilterBenchmark.experiment2P(Store store,
Filter filter,
int addNum,
int mulNum)
It optimizes scheduling of filter operations.
|
static void |
FilterBenchmark.experiment2PM(Store store,
Filter filter,
int addNum,
int mulNum)
It optimizes scheduling of filter operation in fashion allowing
pipelining of multiplication operations.
|
static ArrayList<ArrayList<IntVar>> |
FilterBenchmark.makeConstraints(Store store,
Filter filter,
int addNum,
int mulNum)
It creates constraint model for scheduling of filter operations.
|
static ArrayList<ArrayList<IntVar>> |
FilterBenchmark.makeConstraintsChain(Store store,
Filter filter,
int addNum,
int mulNum,
int clk)
It creates constraint model for scheduling of filter operation in fashion allowing
chaining of operations within one clock cycle.
|
static ArrayList<ArrayList<IntVar>> |
FilterBenchmark.makeConstraintsPipeline(Store store,
Filter filter,
int addNum,
int mulNum)
It creates a model for optimization of scheduling of operations of a given filter.
|
static ArrayList<ArrayList<IntVar>> |
FilterBenchmark.makeConstraintsPipeMultiplier(Store store,
Filter filter,
int addNum,
int mulNum)
It creates constraint model for scheduling of filter operation in fashion allowing
pipelining of multiplication operations.
|
Modifier and Type | Field and Description |
---|---|
Store |
ExampleSet.store
It specifies the constraint store responsible for holding information
about constraints and variables.
|
Modifier and Type | Method and Description |
---|---|
Store |
ExampleSet.getStore()
It specifies the constraint store used within an example.
|
Modifier and Type | Method and Description |
---|---|
void |
TanPeqR.consistency(Store store) |
void |
PneqQ.consistency(Store store) |
void |
CosPeqR_decomposed.consistency(Store store) |
void |
PeqQ.consistency(Store store) |
void |
PeqC.consistency(Store store) |
void |
PltC.consistency(Store store) |
void |
PlteqQ.consistency(Store store) |
void |
PplusQeqR.consistency(Store store) |
void |
Max.consistency(Store store) |
void |
SinPeqR.consistency(Store store) |
void |
CosPeqR.consistency(Store store) |
void |
PplusCeqR.consistency(Store store) |
void |
AbsPeqR.consistency(Store store) |
void |
ElementFloat.consistency(Store store) |
void |
EquationSystem.consistency(Store store) |
void |
PgteqC.consistency(Store store) |
void |
PgtQ.consistency(Store store) |
void |
SqrtPeqR.consistency(Store store) |
void |
PmulCeqR.consistency(Store store) |
void |
PltQ.consistency(Store store) |
void |
PneqC.consistency(Store store) |
void |
PlteqC.consistency(Store store) |
void |
PgtC.consistency(Store store) |
void |
PgteqQ.consistency(Store store) |
void |
Min.consistency(Store store) |
void |
PmulQeqR.consistency(Store store) |
void |
XeqP.consistency(Store store) |
void |
ExpPeqR.consistency(Store store) |
FloatVar |
PplusQeqR.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
FloatVar |
SinPeqR.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
FloatVar |
CosPeqR.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
FloatVar |
PplusCeqR.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
FloatVar |
SqrtPeqR.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
FloatVar |
PmulCeqR.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
FloatVar |
LinearFloat.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
FloatVar |
PmulQeqR.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
FloatVar |
ExpPeqR.derivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
static FloatVar |
Derivative.getDerivative(Store store,
FloatVar f,
Set<FloatVar> vars,
FloatVar x) |
void |
TanPeqR.impose(Store store) |
void |
PneqQ.impose(Store store) |
void |
CosPeqR_decomposed.impose(Store store) |
void |
PeqQ.impose(Store store) |
void |
PeqC.impose(Store store) |
void |
PltC.impose(Store store) |
void |
PlteqQ.impose(Store store) |
void |
PplusQeqR.impose(Store store) |
void |
Max.impose(Store store) |
void |
SinPeqR.impose(Store store) |
void |
CosPeqR.impose(Store store) |
void |
PplusCeqR.impose(Store store) |
void |
AbsPeqR.impose(Store store) |
void |
ElementFloat.impose(Store store) |
void |
EquationSystem.impose(Store store) |
void |
PgteqC.impose(Store store) |
void |
PgtQ.impose(Store store) |
void |
PmulCeqR.impose(Store store) |
void |
PltQ.impose(Store store) |
void |
PneqC.impose(Store store) |
void |
PlteqC.impose(Store store) |
void |
PgtC.impose(Store store) |
void |
PgteqQ.impose(Store store) |
void |
Min.impose(Store store) |
void |
PmulQeqR.impose(Store store) |
void |
XeqP.impose(Store store) |
void |
ExpPeqR.impose(Store store) |
static void |
Derivative.init(Store s) |
void |
PneqQ.notConsistency(Store store) |
void |
PeqQ.notConsistency(Store store) |
void |
PeqC.notConsistency(Store store) |
void |
PltC.notConsistency(Store store) |
void |
PlteqQ.notConsistency(Store store) |
void |
PplusQeqR.notConsistency(Store store) |
void |
PplusCeqR.notConsistency(Store store) |
void |
PgteqC.notConsistency(Store store) |
void |
PgtQ.notConsistency(Store store) |
void |
PltQ.notConsistency(Store store) |
void |
PneqC.notConsistency(Store store) |
void |
PlteqC.notConsistency(Store store) |
void |
PgtC.notConsistency(Store store) |
void |
PgteqQ.notConsistency(Store store) |
Constructor and Description |
---|
EquationSystem(Store store,
FloatVar[] f,
FloatVar[] x)
It constructs the constraint EquationSystem.
|
LinearFloat(Store store,
ArrayList<? extends FloatVar> variables,
ArrayList<Double> weights,
String rel,
double sum)
It constructs the constraint LinearFloat.
|
LinearFloat(Store store,
FloatVar[] list,
double[] weights,
String rel,
double sum) |
MultivariateIntervalNewton(Store store,
FloatVar[] f,
FloatVar[] x) |
Modifier and Type | Method and Description |
---|---|
void |
Linear.consistency(Store store) |
void |
Linear.impose(Store store) |
void |
Linear.notConsistency(Store store) |
Constructor and Description |
---|
BNode(Store store) |
BNode(Store store,
double min,
double max) |
BNode(Store store,
double min,
double max,
double lb,
double ub) |
Linear(Store store,
ArrayList<? extends FloatVar> variables,
ArrayList<Double> weights,
String rel,
double sum)
It constructs the constraint Linear.
|
Linear(Store store,
FloatVar[] list,
double[] weights,
String rel,
double sum) |
RootBNode(Store store) |
RootBNode(Store store,
double min,
double max) |
VarNode(Store store,
FloatVar v) |
VarWeightNode(Store store,
FloatVar v,
double w) |
Constructor and Description |
---|
FloatVar(Store store)
This constructor creates a variable with empty domain (standard
FloatIntervalDomain domain), automatically generated name, and empty attached
constraint list.
|
FloatVar(Store store,
double min,
double max)
This constructor creates a variable with a domain between min..max,
automatically generated name, and empty attached constraint list.
|
FloatVar(Store store,
FloatDomain dom)
It creates a variable in a given store, with a given name and
a given domain.
|
FloatVar(Store store,
String name)
This constructor creates a variable with an empty domain (standard
IntervalDomain domain), the specified name, and an empty attached
constraint list.
|
FloatVar(Store store,
String name,
double min,
double max)
This constructor creates a variable in a given store, with
the domain specified by min..max and with the given name.
|
FloatVar(Store store,
String name,
FloatDomain dom)
It creates a variable in a given store, with a given name and
a given domain.
|
Constructor and Description |
---|
Optimize(Store store,
DepthFirstSearch search,
SelectChoicePoint select,
FloatVar cost) |
SplitSelectFloat(Store store,
T[] variables,
ComparatorVariable<T> varSelect)
The constructor to create a simple choice select mechanism.
|
SplitSelectFloat(Store store,
T[] variables,
ComparatorVariable<T> varSelect,
ComparatorVariable<T> tieBreakerVarSelect)
It constructs a simple selection mechanism for choice points.
|
Modifier and Type | Method and Description |
---|---|
Store |
FlatzincLoader.getStore() |
Modifier and Type | Method and Description |
---|---|
void |
Solve.PrecisionSetting.executedAtInitialize(Store store) |
Constructor and Description |
---|
Constraints(Store store)
It creates an object to parse the constraint part of the flatzinc file.
|
SearchItem(Store store,
Tables table)
It constructs search part parsing object based on dictionaries
provided as well as store object within which the search will take place.
|
Solve(Store store)
It creates a parser for the solve part of the flatzinc file.
|
Tables(Store s) |
Modifier and Type | Field and Description |
---|---|
Store |
DepthFirstSearch.store
It represents store within which a search is performed.
|
Modifier and Type | Method and Description |
---|---|
boolean |
SimpleSolutionListener.assignSolution(Store store)
It assigns the last found solution to the store.
|
boolean |
SolutionListener.assignSolution(Store store,
int no)
It imposes the constraints, so the last found solution is enforced.
|
boolean |
SimpleSolutionListener.assignSolution(Store store,
int number) |
void |
NoGoodsCollector.executedAtExit(Store store,
int solutionsNo) |
void |
ExitListener.executedAtExit(Store store,
int solutionsNo)
It is executed right after time out is determined.
|
void |
TraceGenerator.executedAtExit(Store store,
int solutionsNo) |
void |
OneSolution.executedAtInitialize(Store store) |
void |
TransformExtensional.executedAtInitialize(Store store) |
void |
InitializeListener.executedAtInitialize(Store store)
It is executed before the search starts labeling procedure.
|
boolean |
Search.labeling(Store store,
SelectChoicePoint<T> select)
It performs search using supplied choice point selection heuristic.
|
boolean |
DepthFirstSearch.labeling(Store store,
SelectChoicePoint<T> select) |
boolean |
Search.labeling(Store store,
SelectChoicePoint<T> select,
Var costVar)
It performs search using supplied choice point selection heuristic,
as well as costVariable as aim at finding an optimal solution.
|
boolean |
DepthFirstSearch.labeling(Store store,
SelectChoicePoint<T> select,
Var costVar) |
void |
Shaving.setStore(Store store)
It specifies the constraint store in which context the shaving will take place.
|
void |
Search.setStore(Store store)
It sets the reference to the store in the context of which the search operates.
|
void |
DepthFirstSearch.setStore(Store store) |
Constructor and Description |
---|
InputOrderSelect(Store store,
T[] variables,
Indomain<T> indomain)
It constructs an input order selection procedure.
|
Modifier and Type | Field and Description |
---|---|
Store |
SimpleImprovementSearch.store |
Store |
SGMPCSearch.store |
Constructor and Description |
---|
SGMPCSearch(Store store,
IntVar[] vars,
IntVar cost) |
SGMPCSearch(Store store,
IntVar[] vars,
IntVar cost,
ImproveSolution search) |
SimpleImprovementSearch(Store store,
IntVar[] vars,
IntVar cost) |
Modifier and Type | Method and Description |
---|---|
void |
CardAeqX.consistency(Store store) |
void |
AeqS.consistency(Store store) |
void |
XeqA.consistency(Store store) |
void |
CardA.consistency(Store store) |
void |
AintersectBeqC.consistency(Store store) |
void |
Match.consistency(Store store) |
void |
AeqB.consistency(Store store) |
void |
AunionBeqC.consistency(Store store) |
void |
ElementSet.consistency(Store store) |
void |
XinA.consistency(Store store) |
void |
AinS.consistency(Store store) |
void |
AdiffBeqC.consistency(Store store) |
void |
EinA.consistency(Store store) |
void |
Lex.consistency(Store store) |
void |
SinA.consistency(Store store) |
void |
AinB.consistency(Store store) |
void |
AdisjointB.consistency(Store store) |
void |
SumWeightedSet.consistency(Store store) |
void |
CardAeqX.impose(Store store) |
void |
AeqS.impose(Store store) |
void |
XeqA.impose(Store store) |
void |
CardA.impose(Store store) |
void |
AintersectBeqC.impose(Store store) |
void |
Match.impose(Store store) |
void |
AeqB.impose(Store store) |
void |
AunionBeqC.impose(Store store) |
void |
ElementSet.impose(Store store) |
void |
XinA.impose(Store store) |
void |
AinS.impose(Store store) |
void |
AdiffBeqC.impose(Store store) |
void |
EinA.impose(Store store) |
void |
Lex.impose(Store store) |
void |
SinA.impose(Store store) |
void |
AinB.impose(Store store) |
void |
AdisjointB.impose(Store store) |
void |
SumWeightedSet.impose(Store store) |
void |
AeqS.notConsistency(Store store) |
void |
XeqA.notConsistency(Store store) |
void |
AeqB.notConsistency(Store store) |
void |
XinA.notConsistency(Store store) |
void |
AinS.notConsistency(Store store) |
void |
EinA.notConsistency(Store store) |
void |
SinA.notConsistency(Store store) |
void |
AinB.notConsistency(Store store) |
Constructor and Description |
---|
SetVar(Store store)
This constructor creates a variable with empty domain (standard
IntervalDomain domain), automatically generated name, and empty attached
constraint list.
|
SetVar(Store store,
int min,
int max)
This constructor creates a set variable with domain a set min..max
automatically generated name, and empty attached constraint list.
|
SetVar(Store store,
SetDomain dom)
It creates a variable in a given store, with a given name and
a given domain.
|
SetVar(Store store,
String name)
This constructor creates a variable with an empty domain (standard
IntervalDomain domain), the specified name, and an empty attached
constraint list.
|
SetVar(Store store,
String name,
int min,
int max)
This constructor creates a variable in a given store, with
the domain specified by min..max and with the given name.
|
SetVar(Store store,
String name,
SetDomain dom)
It creates a variable in a given store, with a given name and
a given domain.
|
Modifier and Type | Method and Description |
---|---|
void |
IndexDomainView.removeUnSupportedValues(Store store)
It removes all values for which no support was found since the initialization of
the support sweep.
|
Copyright © 2015. All rights reserved.