|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of Constraint in choco |
---|
Fields in choco declared as Constraint | |
---|---|
static Constraint |
Choco.FALSE
|
static Constraint |
Choco.TRUE
|
Methods in choco that return Constraint | |
---|---|
static Constraint |
Choco.abs(IntegerVariable x,
IntegerVariable y)
Ensures x = Math.abs(y); |
static Constraint |
Choco.allDifferent(IntegerVariable... vars)
All different constraints with a global filtering : v1 ! |
static Constraint |
Choco.allDifferent(String options,
IntegerVariable... vars)
All different constraints with a global filtering : v1 ! |
static Constraint[] |
Reformulation.among(IntegerVariable[] variables,
SetVariable s,
IntegerVariable nvar)
AMONG constraint reformulated like: introducing BOOL variable for each VARIABLE, adding following constraints: for each VARIABLE : REIFIED(BOOL_i, MEMBER(VARIABLE_i, S)), EQ(SUM(BOOL), N), |
static Constraint |
Choco.among(IntegerVariable var,
int[] values)
Deprecated. use member |
static Constraint[] |
Reformulation.among(IntegerVariable nvar,
IntegerVariable[] variables,
int[] values)
AMONG constraint reformulated like: introducing BOOL variable for each VARIABLE, adding following constraints: for each VARIABLE : REIFIED(BOOL_i, AMONG(VARIABLE_i, VALUES)), EQ(SUM(BOOL), N), |
static Constraint |
Choco.among(IntegerVariable nvar,
IntegerVariable[] variables,
int[] values)
NVAR is the number of variables of the collection VARIABLES that take their value in VALUES. |
static Constraint |
Choco.among(IntegerVariable nvar,
IntegerVariable[] variables,
SetVariable svar)
NVAR is the number of variables of the collection VARIABLES that take their value in SVAR. |
static Constraint |
Choco.and(Constraint... n)
|
static Constraint |
Choco.and(IntegerVariable... literals)
A constraint for logical conjunction between boolean variables lit1 AND lit2 AND ... |
static Constraint |
Choco.atMostNValue(IntegerVariable[] vars,
IntegerVariable nvalue)
Deprecated. reorder parameters |
static Constraint |
Choco.atMostNValue(IntegerVariable nvalue,
IntegerVariable[] vars)
Enforce the number of distinct values among vars to be less than nvalue; |
static Constraint |
Choco.boolChanneling(IntegerVariable b,
IntegerVariable x,
int j)
State a simple channeling bewteen a boolean variable and an interger variable Ensures for that b = 1 iff x = j |
static Constraint |
Choco.clause(IntegerVariable[] positiveLiterals,
IntegerVariable[] negativeLiterals)
A global constraint to store and propagate all clauses |
static Constraint |
Choco.clause(String option,
IntegerVariable[] positiveLiterals,
IntegerVariable[] negativeLiterals)
A global constraint to store and propagate all clauses The option can contain the folowing String : cp:entail ensure quick entailment tests |
static Constraint[] |
Choco.clauses(ALogicTree tree)
A global constraint to store and propagate all clauses extracted from a logic tree |
static Constraint[] |
Choco.clauses(String option,
ALogicTree tree)
A global constraint to store and propagate all clauses extracted from a logic tree The option can contain the folowing String : cp:entail ensure quick entailment tests |
static Constraint |
Choco.complementSet(SetVariable x,
SetVariable y)
complement(X) == Y i.e. |
static Constraint |
Choco.costRegular(IntegerVariable[] vars,
IntegerVariable costVar,
org.jgrapht.graph.DirectedMultigraph<Node,Arc> graph,
Node source)
Deprecated. reorder parameters |
static Constraint |
Choco.costRegular(IntegerVariable[] vars,
IntegerVariable costVar,
IAutomaton auto,
int[][][] costs)
Deprecated. reorder parameters |
static Constraint |
Choco.costRegular(IntegerVariable costVar,
IntegerVariable[] vars,
org.jgrapht.graph.DirectedMultigraph<Node,Arc> graph,
Node source)
costRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the costs associated to each assignment is bounded by the cost variable. |
static Constraint |
Choco.costRegular(IntegerVariable costVar,
IntegerVariable[] vars,
IAutomaton auto,
int[][] costs)
costRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the costs associated to each assignment is bounded by the cost variable. |
static Constraint |
Choco.costRegular(IntegerVariable costVar,
IntegerVariable[] vars,
IAutomaton auto,
int[][][] costs)
costRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the costs associated to each assignment is bounded by the cost variable. |
static Constraint |
Choco.costRegular(IntegerVariable costVar,
IntegerVariable[] vars,
ICostAutomaton auto)
costRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the costs associated to each assignment is bounded by the cost variable. |
static Constraint |
DeprecatedChoco.cumulative(IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
int[] heights,
int capa,
String... options)
Deprecated. |
static Constraint |
DeprecatedChoco.cumulative(IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
IntegerVariable[] heights,
IntegerVariable capa,
String... options)
Deprecated. |
static Constraint |
DeprecatedChoco.cumulative(IntegerVariable[] starts,
IntegerVariable[] durations,
IntegerVariable[] heights,
IntegerVariable capa,
String... options)
Deprecated. |
static Constraint |
DeprecatedChoco.cumulative(String name,
IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
IntegerVariable[] heights,
IntegerVariable capa,
String... options)
Deprecated. |
static Constraint |
Choco.cumulative(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable[] usages,
IntegerVariable consumption,
IntegerVariable capacity,
IntegerVariable uppBound,
String... options)
Builds Alternative cumulative Min-Max. |
static Constraint |
Choco.cumulative(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable[] usages,
IntegerVariable consumption,
IntegerVariable capacity,
String... options)
Alternative Cumulative Min-Max : uppBound = null . |
static Constraint |
Choco.cumulative(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable consumption,
IntegerVariable capacity,
String... options)
Cumulative Min-Max : usages = null , uppBound = null . |
static Constraint |
DeprecatedChoco.cumulative(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable capa,
String... options)
Deprecated. |
static Constraint |
DeprecatedChoco.cumulative(TaskVariable[] tasks,
int[] heights,
int capa,
String... options)
Deprecated. |
static Constraint |
Choco.cumulativeMax(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable[] usages,
IntegerVariable capacity,
String... options)
Alternative Cumulative Max : consumption=0, uppBound = null . |
static Constraint |
Choco.cumulativeMax(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable capacity,
String... options)
Cumulative Max : consumption=0, usages = null , uppBound = null . |
static Constraint |
Choco.cumulativeMax(TaskVariable[] tasks,
int[] heights,
int capacity,
String... options)
Cumulative Max : consumption=0, usages = null , uppBound = null . |
static Constraint |
Choco.cumulativeMin(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable[] usages,
IntegerVariable consumption,
String... options)
Alternative Cumulative Min : capacity=infinity, uppBound = null . |
static Constraint |
Choco.cumulativeMin(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable consumption,
String... options)
Cumulative Min : capacity=infinity, usages = null , uppBound = null . |
static Constraint |
Choco.cumulativeMin(TaskVariable[] tasks,
int[] heights,
int consumption,
String... options)
Cumulative Min : capacity=infinity, usages = null , uppBound = null . |
static Constraint |
Choco.disjoint(IntegerVariable var,
int[] values)
Deprecated. rename as notMember |
static Constraint[] |
Choco.disjoint(TaskVariable[] tasks1,
TaskVariable[] tasks2)
Each task of the collection tasks1 should not overlap any task of the collection tasks2. |
static Constraint |
DeprecatedChoco.disjunctive(IntegerVariable[] starts,
int[] durations,
String... options)
Deprecated. |
static Constraint |
DeprecatedChoco.disjunctive(IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
String... options)
Deprecated. |
static Constraint |
DeprecatedChoco.disjunctive(IntegerVariable[] starts,
IntegerVariable[] durations,
String... options)
Deprecated. |
static Constraint |
DeprecatedChoco.disjunctive(String name,
IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
IntegerVariable uppBound,
String... options)
Deprecated. |
static Constraint |
Choco.disjunctive(String name,
TaskVariable[] tasks,
IntegerVariable[] usages,
IntegerVariable uppBound,
String... options)
Builds Alternative disjunctive. |
static Constraint |
Choco.disjunctive(String name,
TaskVariable[] tasks,
IntegerVariable[] usages,
String... options)
Alternative Disjunctive : uppBound = null . |
static Constraint |
Choco.disjunctive(String name,
TaskVariable[] tasks,
String... options)
Disjunctive : usages = null , uppBound = null . |
static Constraint |
Choco.disjunctive(TaskVariable[] tasks,
IntegerVariable[] usages,
String... options)
Alternative Disjunctive : name = null , uppBound = null . |
static Constraint[] |
Reformulation.disjunctive(TaskVariable[] clique,
String... boolvarOptions)
AMONG constraint reformulated like: introducing BOOL variable for each VARIABLE, adding following constraints: for each VARIABLE : REIFIED(BOOL_i, AMONG(VARIABLE_i, VALUES)), EQ(SUM(BOOL), N), |
static Constraint |
Choco.disjunctive(TaskVariable[] tasks,
String... options)
Disjunctive : name = null , usages = null , uppBound = null . |
static Constraint |
Choco.distanceEQ(IntegerVariable x,
IntegerVariable y,
int c)
Ensures |x-y| = c; |
static Constraint |
Choco.distanceEQ(IntegerVariable x,
IntegerVariable y,
IntegerVariable z)
Ensures |x-y| = z; |
static Constraint |
Choco.distanceEQ(IntegerVariable x,
IntegerVariable y,
IntegerVariable z,
int c)
Ensures |x-y| = z + c; |
static Constraint |
Choco.distanceGT(IntegerVariable x,
IntegerVariable y,
int c)
Ensures |x-y| > c; |
static Constraint |
Choco.distanceGT(IntegerVariable x,
IntegerVariable y,
IntegerVariable z)
Ensures |x-y| > z; |
static Constraint |
Choco.distanceGT(IntegerVariable x,
IntegerVariable y,
IntegerVariable z,
int c)
Ensures |x-y| > z + c; |
static Constraint |
Choco.distanceLT(IntegerVariable x,
IntegerVariable y,
int c)
Ensures |x-y| < c; |
static Constraint |
Choco.distanceLT(IntegerVariable x,
IntegerVariable y,
IntegerVariable z)
Ensures |x-y| < z; |
static Constraint |
Choco.distanceLT(IntegerVariable x,
IntegerVariable y,
IntegerVariable z,
int c)
Ensures |x-y| < z + c; |
static Constraint |
Choco.distanceNEQ(IntegerVariable x,
IntegerVariable y,
int c)
Ensures |x-y| ! |
static Constraint |
Choco.domainChanneling(IntegerVariable x,
IntegerVariable[] b)
state a channeling between the domain of the variable x and the array of boolean variables b which enforce: x = i <=> b[i] = 1 |
static Constraint |
Choco.domainConstraint(IntegerVariable x,
IntegerVariable[] b)
Deprecated. see domainChannelling |
static Constraint |
Choco.endsAfter(TaskVariable t,
int min)
This task ends after min |
static Constraint |
Choco.endsAfterBegin(TaskVariable t1,
TaskVariable t2)
This task ends after the start of the task 2 |
static Constraint |
Choco.endsAfterBegin(TaskVariable t1,
TaskVariable t2,
int delta)
Temporal constraint: end(t1) >= start(t2) + delta |
static Constraint |
Choco.endsAfterEnd(TaskVariable t1,
TaskVariable t2)
Temporal constraint: end(t1) >= end(t2) |
static Constraint |
Choco.endsAfterEnd(TaskVariable t1,
TaskVariable t2,
int delta)
Temporal constraint: end(t1) >= end(t2) + delta |
static Constraint |
Choco.endsAt(TaskVariable t,
int time)
This task ends at time. |
static Constraint |
Choco.endsBefore(TaskVariable t,
int max)
This task ends before max |
static Constraint |
Choco.endsBeforeBegin(TaskVariable t1,
TaskVariable t2)
Temporal constraint: end(t1)<= start(t2) |
static Constraint |
Choco.endsBeforeBegin(TaskVariable t1,
TaskVariable t2,
int delta)
Temporal constraint: end(t1) + delta <= start(t2) |
static Constraint |
Choco.endsBeforeEnd(TaskVariable t1,
TaskVariable t2)
Temporal constraint: end(t1) <= end(t2) |
static Constraint |
Choco.endsBeforeEnd(TaskVariable t1,
TaskVariable t2,
int delta)
Temporal constraint: end(t1) + delta <= end(t2) |
static Constraint |
Choco.endsBetween(TaskVariable t,
int min,
int max)
This task ends between min and max |
static Constraint |
Choco.eq(double c,
RealExpressionVariable x)
Return a constraint that ensures x == c |
static Constraint |
Choco.eq(IntegerExpressionVariable x,
int c)
Return a constraint that ensure x == c |
static Constraint |
Choco.eq(IntegerExpressionVariable x,
IntegerExpressionVariable y)
Return a constraint that ensure x == y |
static Constraint |
Choco.eq(IntegerVariable i,
RealVariable r)
Return a constraint that ensures r == i |
static Constraint |
Choco.eq(int c,
IntegerExpressionVariable x)
Return a constraint that ensure x == c |
static Constraint |
Choco.eq(RealExpressionVariable x,
double c)
Return a constraint that ensures x == c |
static Constraint |
Choco.eq(RealExpressionVariable x,
RealExpressionVariable y)
Return a constraint that ensures x == y |
static Constraint |
Choco.eq(RealVariable r,
IntegerVariable i)
Return a constraint that ensures r == i |
static Constraint |
Choco.eq(SetVariable sv1,
SetVariable sv2)
Return a constraint that ensures sv1 == sv2 |
static Constraint |
Choco.eqCard(SetVariable sv,
int val)
Return a constraint that ensures |sv| = val |
static Constraint |
Choco.eqCard(SetVariable sv,
IntegerVariable v)
Return a constraint that ensures |sv| = v |
static Constraint |
Choco.equation(IntegerVariable[] vars,
int[] coeffs,
int val)
Deprecated. reorder parameters |
static Constraint |
Choco.equation(IntegerVariable z,
IntegerVariable[] vars,
int[] coeffs)
State a constraint to enforce GAC on Sum_i coeffs[i] * vars[i] = z. |
static Constraint |
Choco.equation(int val,
IntegerVariable[] vars,
int[] coeffs)
State a constraint to enforce GAC on Sum_i coeffs[i] * vars[i] = val. |
static Constraint |
Choco.equation(String option,
IntegerVariable z,
IntegerVariable[] vars,
int[] coeffs)
State constraint Sum_i coeffs[i] * vars[i] = z. |
static Constraint |
Choco.equation(String option,
int val,
IntegerVariable[] vars,
int[] coeffs)
State constraint Sum_i coeffs[i] * vars[i] = val. |
static Constraint |
Choco.exactly(int occurrence,
IntegerVariable[] variables,
int value)
Deprecated. see among |
static Constraint |
Choco.feasPairAC(IntegerVariable v1,
IntegerVariable v2,
boolean[][] mat)
Build a Table constraint defined extensionnaly by the set of feasibles pairs of values for the corresponding variables. |
static Constraint |
Choco.feasPairAC(IntegerVariable v1,
IntegerVariable v2,
List<int[]> mat)
Build a Table constraint defined extensionnaly by the set of feasibles pairs of values for the corresponding variables. |
static Constraint |
Choco.feasPairAC(String options,
IntegerVariable v1,
IntegerVariable v2,
boolean[][] mat)
Build a Table constraint defined extensionnaly by the set of feasibles pairs of values for the corresponding variables |
static Constraint |
Choco.feasPairAC(String options,
IntegerVariable v1,
IntegerVariable v2,
List<int[]> mat)
Build a Table constraint defined extensionnaly by the set of feasibles pairs of values for the corresponding variables |
static Constraint |
Choco.feasTupleAC(List<int[]> tuples,
IntegerVariable... vars)
Create a constraint enforcing Arc Consistency on a given a given list of feasible tuples |
static Constraint |
Choco.feasTupleAC(String options,
List<int[]> tuples,
IntegerVariable... vars)
Create a constraint enforcing Arc Consistency on a given a given list of feasible tuples |
static Constraint |
Choco.feasTupleFC(List<int[]> tuples,
IntegerVariable... vars)
Create a constraint enforcing Forward Checking on a given a given list of feasible tuples |
static Constraint |
Choco.forbiddenIntervals(String name,
TaskVariable[] tasks)
This redundant constraints applies additional search tree reduction based on Time intervals are in which no operation can start or end in an optimal solution. |
static Constraint |
Choco.geost(int dim,
List<GeostObject> objects,
List<ShiftedBox> shiftedBoxes,
List<IExternalConstraint> eCtrs)
|
static Constraint |
Choco.geost(int dim,
List<GeostObject> objects,
List<ShiftedBox> shiftedBoxes,
List<IExternalConstraint> eCtrs,
List<int[]> ctrlVs)
|
static Constraint |
Choco.geost(int dim,
List<GeostObject> objects,
List<ShiftedBox> shiftedBoxes,
List<IExternalConstraint> eCtrs,
List<int[]> ctrlVs,
GeostOptions opt)
|
static Constraint |
Choco.geost(int dim,
Vector<GeostObject> objects,
Vector<ShiftedBox> shiftedBoxes,
Vector<IExternalConstraint> eCtrs)
Deprecated. |
static Constraint |
Choco.geost(int dim,
Vector<GeostObject> objects,
Vector<ShiftedBox> shiftedBoxes,
Vector<IExternalConstraint> eCtrs,
Vector<int[]> ctrlVs)
Deprecated. |
static Constraint |
Choco.geost(int dim,
Vector<GeostObject> objects,
Vector<ShiftedBox> shiftedBoxes,
Vector<IExternalConstraint> eCtrs,
Vector<int[]> ctrlVs,
GeostOptions opt)
Deprecated. |
static Constraint |
Choco.geq(double c,
RealExpressionVariable x)
|
static Constraint |
Choco.geq(IntegerExpressionVariable x,
int c)
|
static Constraint |
Choco.geq(IntegerExpressionVariable x,
IntegerExpressionVariable y)
|
static Constraint |
Choco.geq(int c,
IntegerExpressionVariable x)
|
static Constraint |
Choco.geq(RealExpressionVariable x,
double c)
|
static Constraint |
Choco.geq(RealExpressionVariable x,
RealExpressionVariable y)
|
static Constraint |
Choco.geqCard(SetVariable sv,
int val)
|
static Constraint |
Choco.geqCard(SetVariable sv,
IntegerVariable v)
|
static Constraint |
Choco.globalCardinality(IntegerVariable[] vars,
int[] low,
int[] up,
int offset)
Concerns GCC and boundGCC Global cardinality : Given an array of variables vars, the constraint ensures that the number of occurences of the value i among the variables is between low[i - min] and up[i - min]. |
static Constraint |
Choco.globalCardinality(IntegerVariable[] vars,
int[] values,
int[] low,
int[] up)
Concerns GCC and boundGCC Global cardinality : Given an array of variables vars, and an array of values, the constraint ensures that the number of occurences of the value i among the variables is between low[i] and up[i]. |
static Constraint |
Choco.globalCardinality(IntegerVariable[] vars,
int[] values,
IntegerVariable[] cards)
* Bound Global cardinality : Given an array of variables vars, an array of values, an array of variables card to represent the cardinalities, the constraint ensures that the number of occurences of the value i among the variables is equal to card[i]. |
static Constraint |
Choco.globalCardinality(IntegerVariable[] vars,
IntegerVariable[] card,
int offset)
* Bound Global cardinality : Given an array of variables vars, an array of variables card to represent the cardinalities, the constraint ensures that the number of occurences of the value i among the variables is equal to card[i]. |
static Constraint |
Choco.globalCardinality(IntegerVariable[] vars,
int min,
int max,
int[] low,
int[] up)
Deprecated. |
static Constraint |
Choco.globalCardinality(IntegerVariable[] vars,
int min,
int max,
IntegerVariable[] card)
Deprecated. |
static Constraint |
Choco.globalCardinality(String options,
IntegerVariable[] vars,
int[] low,
int[] up,
int offset)
Concerns GCC and boundGCC Global cardinality : Given an array of variables vars, the constraint ensures that the number of occurences of the value i among the variables is between low[i - min] and up[i - min]. |
static Constraint |
Choco.globalCardinality(String options,
IntegerVariable[] vars,
int min,
int max,
int[] low,
int[] up)
Deprecated. |
static Constraint |
Choco.gt(IntegerExpressionVariable x,
int c)
Return a constraint that ensures x > c |
static Constraint |
Choco.gt(IntegerExpressionVariable x,
IntegerExpressionVariable y)
Return a constraint that ensures x > y |
static Constraint |
Choco.gt(int c,
IntegerExpressionVariable x)
Return a constraint that ensures c > x |
static Constraint |
Choco.ifOnlyIf(Constraint n1,
Constraint n2)
|
static Constraint |
Choco.ifThenElse(Constraint n1,
Constraint n2,
Constraint n3)
|
static Constraint |
Choco.implies(Constraint n1,
Constraint n2)
|
static Constraint |
Choco.increasing_nvalue(IntegerVariable nval,
IntegerVariable[] vars)
Deprecated. use increasingNValue |
static Constraint |
Choco.increasing_nvalue(String option,
IntegerVariable nval,
IntegerVariable[] vars)
Deprecated. use increasingNValue |
static Constraint |
Choco.increasingNValue(IntegerVariable nval,
IntegerVariable[] vars)
The variables of the collection VARIABLES are increasing. |
static Constraint |
Choco.increasingNValue(String option,
IntegerVariable nval,
IntegerVariable[] vars)
The variables of the collection VARIABLES are increasing. |
static Constraint |
Choco.increasingSum(IntegerVariable[] variables,
IntegerVariable sum)
A sum constraint with increasing variables s = x_0 + x_1 + ... + x_(n-1) and x_0 <= x_1 <= ... <= x_(n-1) Bounds-consistency algorithm linear in n (the number of variables) |
static Constraint |
Choco.infeasPairAC(IntegerVariable v1,
IntegerVariable v2,
boolean[][] mat)
Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables. |
static Constraint |
Choco.infeasPairAC(IntegerVariable v1,
IntegerVariable v2,
List<int[]> mat)
Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables. |
static Constraint |
Choco.infeasPairAC(String options,
IntegerVariable v1,
IntegerVariable v2,
boolean[][] mat)
Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables |
static Constraint |
Choco.infeasPairAC(String options,
IntegerVariable v1,
IntegerVariable v2,
List<int[]> mat)
Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables |
static Constraint |
Choco.infeasTupleAC(List<int[]> tuples,
IntegerVariable... vars)
Create a constraint enforcing Arc Consistency on a given a given list of infeasible tuples |
static Constraint |
Choco.infeasTupleAC(String options,
List<int[]> tuples,
IntegerVariable... vars)
Create a constraint enforcing Arc Consistency on a given a given list of infeasible tuples |
static Constraint |
Choco.infeasTupleFC(List<int[]> tuples,
IntegerVariable... vars)
Create a constraint enforcing Forward Checking on a given a given list of infeasible tuples |
static Constraint |
Choco.intDiv(IntegerVariable x,
IntegerVariable y,
IntegerVariable z)
Enforce z = x / y |
static Constraint |
Choco.inverseChanneling(IntegerVariable[] x,
IntegerVariable[] y)
State a channeling bewteen two arrays of integer variables x and y with the same domain which enforces x[i] = j <=> y[j] = i |
static Constraint |
Choco.inverseChannelingWithinRange(IntegerVariable[] x,
IntegerVariable[] y)
State a channeling bewteen two arrays of integer variables x and y with the same domain which enforces: - if the ith variable of the collection X is assigned to j and if j is less than or equal to the number of items of the collection Y then the jth variable of the collection Y is assigned to i. |
static Constraint |
Choco.inverseSet(IntegerVariable[] iv,
SetVariable[] sv)
A constraint stating that value j belongs to the sv[i] set variable iff integer variable iv[j] equals to i. |
static Constraint |
Choco.inverseSet(SetVariable[] xs,
SetVariable[] ys)
X collection set-variable Y collection set-variable Y should have enough slots to handle X domain size (ie. |
static Constraint |
Choco.isIncluded(SetVariable sv1,
SetVariable sv2)
Checks that variable sv1 is included in sv2 |
static Constraint |
Choco.isNotIncluded(SetVariable sv1,
SetVariable sv2)
Checks that variable sv1 is not included in sv2 |
static Constraint |
Choco.knapsackProblem(IntegerVariable[] vars,
IntegerVariable costVar,
IntegerVariable weightVar,
int[] costs,
int[] weights)
Deprecated. reorder parameters |
static Constraint |
Choco.knapsackProblem(IntegerVariable costVar,
IntegerVariable weightVar,
IntegerVariable[] vars,
int[] costs,
int[] weights)
The knapsack problem constraint ensures that costVar is the sum of the vars weighted by the costs and that weightVar is the sum of vars weighted by the weights Based on costRegular, it simulates Tricks's dynamic programming approach. |
static Constraint |
Choco.leq(double c,
RealExpressionVariable x)
|
static Constraint |
Choco.leq(IntegerExpressionVariable x,
int c)
|
static Constraint |
Choco.leq(IntegerExpressionVariable x,
IntegerExpressionVariable y)
|
static Constraint |
Choco.leq(int c,
IntegerExpressionVariable x)
|
static Constraint |
Choco.leq(RealExpressionVariable x,
double c)
|
static Constraint |
Choco.leq(RealExpressionVariable x,
RealExpressionVariable y)
|
static Constraint |
Choco.leqCard(SetVariable sv,
int val)
|
static Constraint |
Choco.leqCard(SetVariable sv,
IntegerVariable v)
|
static Constraint |
Choco.lex(IntegerVariable[] v1,
IntegerVariable[] v2)
Enforce a strict lexicographic ordering on two vectors of integer variables x <_lex y with x = |
static Constraint |
Choco.lexChain(IntegerVariable[]... arrayOfVectors)
Enforce a strict lexicographic ordering on a chain of integer vectors (X1 ,X2 ,X3,......) with X1 < lex X2 < lex X3 .... |
static Constraint |
Choco.lexChainEq(IntegerVariable[]... arrayOfVectors)
Enforce a lexicographic ordering on a chain of integer vectors (X1 ,X2 ,X3,......) with X1 <= lex X2 <= lex X3 .... |
static Constraint |
Choco.lexeq(IntegerVariable[] v1,
IntegerVariable[] v2)
Deprecated. see lexEq |
static Constraint |
Choco.lexEq(IntegerVariable[] v1,
IntegerVariable[] v2)
Enforce a lexicographic ordering on two vectors of integer variables x <_lex y with x = |
static Constraint |
Choco.leximin(int[] v1,
IntegerVariable[] v2)
Let x and y be two vectors of n integers, and let x? |
static Constraint |
Choco.leximin(IntegerVariable[] v1,
IntegerVariable[] v2)
Let x and y be two vectors of n integers, and let x? |
static Constraint |
Choco.lt(IntegerExpressionVariable x,
int c)
Return a constraint that ensures x < c |
static Constraint |
Choco.lt(IntegerExpressionVariable x,
IntegerExpressionVariable y)
Return a constraint that ensures x < y |
static Constraint |
Choco.lt(int c,
IntegerExpressionVariable x)
Return a constraint that ensures x < c |
static Constraint |
Choco.max(IntegerVariable[] vars,
IntegerVariable max)
Ensures the variable "max" to represent the maximum value that occurs in the list vars |
static Constraint |
Choco.max(IntegerVariable x,
IntegerVariable y,
IntegerVariable max)
Ensures the variable "max" to represent the maximum value of x and y. |
static Constraint |
Choco.max(IntegerVariable x,
int y,
IntegerVariable max)
Ensures the variable "max" to represent the maximum value of x and y. |
static Constraint |
Choco.max(int x,
IntegerVariable y,
IntegerVariable max)
Ensures the variable "max" to represent the maximum value of x and y. |
static Constraint |
Choco.max(SetVariable svar,
IntegerVariable[] ivars,
IntegerVariable min,
String... options)
Ensures the variable min to represent the maximum value in ivars that occurs in the sublist associated with set. |
static Constraint |
Choco.member(IntegerVariable var,
int[] values)
VAR takes it value in VALUES |
static Constraint |
Choco.member(IntegerVariable var,
int lower,
int upper)
VAR takes it value between LOWER and UPPER |
static Constraint |
Choco.member(IntegerVariable var,
SetVariable sv1)
Ensures that the value of an integer variable is contained in a set variable. |
static Constraint |
Choco.member(int val,
SetVariable sv1)
Ensures that a value is contained in a set variable. |
static Constraint |
Choco.member(SetVariable sv1,
int val)
Ensures that a value is contained in a set variable. |
static Constraint |
Choco.member(SetVariable sv,
IntegerVariable... vars)
Ensures that the values of integer variables are contained in a set variable. |
static Constraint |
Choco.member(SetVariable sv1,
IntegerVariable var)
Ensures that the value of an integer variable is contained in a set variable. |
static Constraint |
Choco.min(IntegerVariable[] vars,
IntegerVariable min)
Ensures the variable "min" to represent the minimum value that occurs in the list vars |
static Constraint |
Choco.min(IntegerVariable x,
IntegerVariable y,
IntegerVariable min)
Ensures the variable "min" to represent the minimum value of x and y. |
static Constraint |
Choco.min(IntegerVariable x,
int y,
IntegerVariable min)
Ensures the variable "min" to represent the minimum value of x and y. |
static Constraint |
Choco.min(int x,
IntegerVariable y,
IntegerVariable min)
Ensures the variable "min" to represent the minimum value of x and y. |
static Constraint |
Choco.min(SetVariable svar,
IntegerVariable[] ivars,
IntegerVariable min,
String... options)
Ensures the variable min to represent the minimum value in ivars that occurs in the sublist associated with set. |
static Constraint |
Choco.mod(IntegerVariable v0,
IntegerVariable v1,
int c)
|
static Constraint |
Choco.multiCostRegular(IntegerVariable[] costVars,
IntegerVariable[] vars,
IAutomaton auto,
int[][][] costs)
multiCostRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the cost vectors associated to each assignment is bounded by the cost variable vector |
static Constraint |
Choco.multiCostRegular(IntegerVariable[] costVars,
IntegerVariable[] vars,
IAutomaton auto,
int[][][][] costs)
multiCostRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the cost vectors associated to each assignment is bounded by the cost variable vector. |
static Constraint |
Choco.multiCostRegular(IntegerVariable[] costVars,
IntegerVariable[] vars,
ICostAutomaton auto)
multiCostRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the cost vectors associated to each assignment is bounded by the cost variable vector. |
static Constraint |
Choco.nand(Constraint... n)
|
static Constraint |
Choco.nand(IntegerVariable... literals)
A constraint for logical conjunction between boolean variables lit1 NAND lit2 NAND ... |
static Constraint |
Choco.neq(IntegerExpressionVariable x,
int c)
Creates a constraint by stating that a term is not equal than a constant |
static Constraint |
Choco.neq(IntegerExpressionVariable x,
IntegerExpressionVariable y)
|
static Constraint |
Choco.neq(int c,
IntegerExpressionVariable x)
|
static Constraint |
Choco.neq(SetVariable sv1,
SetVariable sv2)
Ensure that the two variables are not equal (not exactly the same values in the set) |
static Constraint |
Choco.neqCard(SetVariable sv,
int val)
Return a constraint that ensures |sv| ! |
static Constraint |
Choco.neqCard(SetVariable sv,
IntegerVariable v)
Return a constraint that ensures |sv| ! |
static Constraint |
Choco.nor(Constraint... n)
|
static Constraint |
Choco.nor(IntegerVariable... literals)
A constraint for logical conjunction between boolean variables lit1 NOR lit2 NOR ... |
static Constraint |
Choco.not(Constraint n)
|
static Constraint |
Choco.notMember(IntegerVariable var,
int[] values)
VAR takes it value out of VALUES |
static Constraint |
Choco.notMember(IntegerVariable var,
int lower,
int upper)
VAR does not take it value between LOWER and UPPER |
static Constraint |
Choco.notMember(IntegerVariable var,
SetVariable sv1)
Ensures that the value of an integer variable is not contained in a set variable. |
static Constraint |
Choco.notMember(int val,
SetVariable sv1)
Ensures that a value is not contained ina set variable. |
static Constraint |
Choco.notMember(SetVariable sv1,
int val)
Ensures that a value is not contained ina set variable. |
static Constraint |
Choco.notMember(SetVariable sv1,
IntegerVariable var)
Ensures that the value of an integer variable is not contained in a set variable. |
static Constraint |
Choco.nth(IntegerVariable index,
int[] values,
IntegerVariable val)
subscript constraint: accessing an array with a variable index |
static Constraint |
Choco.nth(IntegerVariable index,
int[] values,
IntegerVariable val,
int offset)
subscript constraint: accessing an array with a variable index The offset can be used when the index variable needs to be shifted of a given value (the offset) |
static Constraint |
Choco.nth(IntegerVariable index,
IntegerVariable[] varArray,
IntegerVariable val)
subscript constraint: accessing an array of variables with a variable index |
static Constraint |
Choco.nth(IntegerVariable index,
IntegerVariable[] varArray,
IntegerVariable val,
int offset)
subscript constraint: accessing an array of variables with a variable index The offset can be used when the index variable needs to be shifted of a given value (the offset) |
static Constraint |
Choco.nth(IntegerVariable index,
IntegerVariable index2,
int[][] varArray,
IntegerVariable val)
subscript constraint: accessing a matix of variables with two variables indexes |
static Constraint |
Choco.nth(String options,
IntegerVariable index,
int[] values,
IntegerVariable val)
subscript constraint: accessing an array with a variable index |
static Constraint |
Choco.nth(String options,
IntegerVariable index,
int[] values,
IntegerVariable val,
int offset)
subscript constraint: accessing an array with a variable index The offset can be used when the index variable needs to be shifted of a given value (the offset) |
static Constraint |
Choco.nth(String option,
IntegerVariable index,
IntegerVariable[] varArray,
IntegerVariable val)
subscript constraint: accessing an array of variables with a variable index |
static Constraint |
Choco.nth(String options,
IntegerVariable index,
IntegerVariable[] varArray,
IntegerVariable val,
int offset)
subscript constraint: accessing an array of variables with a variable index The offset can be used when the index variable needs to be shifted of a given value (the offset) |
static Constraint |
DeprecatedChoco.occurenceMax(int value,
IntegerVariable occurence,
IntegerVariable... vars)
Deprecated. |
static Constraint |
DeprecatedChoco.occurenceMin(int value,
IntegerVariable occurence,
IntegerVariable... vars)
Deprecated. |
static Constraint |
Choco.occurrence(IntegerVariable occurrence,
IntegerVariable[] vars,
int value)
Ensures that the occurrence variable contains the number of occurrences of the given value in the list of variables |
static Constraint |
Choco.occurrence(int occurrence,
IntegerVariable[] variables,
int value)
Ensures that N variables of the VARIABLES collection are assigned to value VALUE. |
static Constraint |
Choco.occurrence(int value,
IntegerVariable occurrence,
IntegerVariable... vars)
Ensures that the occurrence variable contains the number of occurrences of the given value in the list of variables |
static Constraint |
Choco.occurrenceMax(IntegerVariable occurrence,
IntegerVariable[] vars,
int value)
Ensures that the upper bound of occurrence is at least equal to the number of occurrences size{forall v in vars | v = value} <= occurrence |
static Constraint |
Choco.occurrenceMax(int value,
IntegerVariable occurrence,
IntegerVariable... vars)
Ensures that the upper bound of occurrence is at least equal to the number of occurrences size{forall v in vars | v = value} <= occurrence |
static Constraint |
Choco.occurrenceMin(IntegerVariable occurrence,
IntegerVariable[] vars,
int value)
Ensures that the lower bound of occurrence is at most equal to the number of occurrences size{forall v in vars | v = value} >= occurrence |
static Constraint |
Choco.occurrenceMin(int value,
IntegerVariable occurrence,
IntegerVariable... vars)
Ensures that the lower bound of occurrence is at most equal to the number of occurrences size{forall v in vars | v = value} >= occurrence |
static Constraint |
Choco.oppositeSign(IntegerExpressionVariable n1,
IntegerExpressionVariable n2)
|
static Constraint |
Choco.or(Constraint... n)
|
static Constraint |
Choco.or(IntegerVariable... literals)
A constraint for logical disjunction between boolean variables lit1 OR lit2 OR ... |
static Constraint |
Choco.pack(PackModel packMod,
String... options)
|
static Constraint |
Choco.pack(SetVariable[] itemSets,
IntegerVariable[] loads,
IntegerVariable[] bins,
IntegerConstantVariable[] sizes,
IntegerVariable nbNonEmpty,
String... options)
|
static Constraint |
Choco.precedence(TaskVariable t1,
TaskVariable t2)
T1 ends before t2 starts or t1 precedes t2. |
static Constraint |
Choco.precedence(TaskVariable t1,
TaskVariable t2,
int delta)
T1 ends before t2 starts or t1 precedes t2. |
static Constraint |
Choco.precedenceDisjoint(IntegerVariable v1,
int dur1,
IntegerVariable v2,
int dur2,
IntegerVariable bool)
direction = 1 => v1 + dur1 <= v2 (T1 << T2); direction = 0 => v2 + dur2 <= v1 (T2 << T1); |
static Constraint |
Choco.precedenceDisjoint(TaskVariable t1,
TaskVariable t2,
IntegerVariable direction)
represents a disjunction without setup times |
static Constraint |
Choco.precedenceDisjoint(TaskVariable t1,
TaskVariable t2,
IntegerVariable direction,
int forwardSetup,
int backwardSetup)
precedence disjoint with setup times: direction = 1 => t1.end() + forwardSetup <= t2.start() (T1 << T2); direction = 0 => t2.end() + backwardSetup <= t1.start() (T2 << T1); |
static Constraint |
Choco.precedenceImplied(IntegerVariable x1,
int k1,
IntegerVariable x2,
IntegerVariable b)
represents an implied precedence: b = 1 => x1 + k1 <= x2 b = 0 => TRUE |
static Constraint |
Choco.precedenceImplied(TaskVariable t1,
int delta,
TaskVariable t2,
IntegerVariable b)
represents a reidied precedence with setup times between a pair of tasks: b = 1 => e1 + delta <= s2 b = 0 => TRUE; |
static Constraint |
Choco.precedenceReified(IntegerVariable x1,
int k1,
IntegerVariable x2,
IntegerVariable b)
represents a reidied precedence: b = 1 => x1 + k1 <= x2 b = 0 => x1 + k1 > x2 |
static Constraint |
Choco.precedenceReified(TaskVariable t1,
int delta,
TaskVariable t2,
IntegerVariable b)
represents a reidied precedence with setup times between a pair of tasks: b = 1 => e1 + delta <= s2 b = 0 => e1 + delta > s2 |
static Constraint |
DeprecatedChoco.preceding(IntegerVariable v1,
int dur1,
IntegerVariable v2,
int dur2,
IntegerVariable bool)
Deprecated. |
static Constraint |
DeprecatedChoco.preceding(TaskVariable t1,
TaskVariable t2)
Deprecated. |
static Constraint |
DeprecatedChoco.preceding(TaskVariable t1,
TaskVariable t2,
IntegerVariable direction)
Deprecated. |
static Constraint |
Choco.regular(DFA auto,
IntegerVariable[] vars)
Deprecated. reorder parameters |
static Constraint |
Choco.regular(IAutomaton auto,
IntegerVariable[] vars)
Deprecated. reorder parameters |
static Constraint |
Choco.regular(IntegerVariable[] vars,
DFA auto)
Create a Regular constraint that enforce the sequence of variables to be a word recognized by the dfa auto. |
static Constraint |
Choco.regular(IntegerVariable[] vars,
IAutomaton auto)
Create a Regular constraint that enforce the sequence of variables to be a word recognized by the dfa auto. |
static Constraint |
Choco.regular(IntegerVariable[] vars,
List<int[]> tuples)
A Regular constraint based on a DFA which is built from a list of FEASIBLE tuples. |
static Constraint |
Choco.regular(IntegerVariable[] vars,
List<int[]> tuples,
int[] min,
int[] max)
A Regular constraint based on a DFA which is built from a list of INFEASIBLE tuples As the relation is defined by infeasible tuples and we build the feasible automaton, we need to know the range of values by the max and min fields... |
static Constraint |
Choco.regular(IntegerVariable[] vars,
String regexp)
Create a Regular constraint that enforce the sequence of variables to match the regular expression. |
static Constraint |
Choco.regular(String regexp,
IntegerVariable[] vars)
Deprecated. reorder parameters |
static Constraint |
Choco.reifiedAnd(IntegerVariable binVar,
IntegerVariable... literals)
A reified constraint for logical conjunction between boolean variables binVar = lit1 AND lit2 AND ... |
static Constraint |
Choco.reifiedConstraint(IntegerVariable binVar,
Constraint cst)
|
static Constraint |
Choco.reifiedConstraint(IntegerVariable binVar,
Constraint cst,
Constraint oppCst)
|
static Constraint |
Choco.reifiedIntConstraint(IntegerVariable binVar,
Constraint cst)
Deprecated. |
static Constraint |
Choco.reifiedIntConstraint(IntegerVariable binVar,
Constraint cst,
Constraint oppCst)
Deprecated. |
static Constraint |
Choco.reifiedLeftImp(IntegerVariable binVar,
IntegerVariable lit1,
IntegerVariable lit2)
A reified constraint for reverse implication binVar = lit1 implies lit2 |
static Constraint |
Choco.reifiedNand(IntegerVariable binVar,
IntegerVariable... literals)
A reified constraint for logical conjunction between boolean variables binVar = lit1 NAND lit2 NAND ... |
static Constraint |
Choco.reifiedNor(IntegerVariable binVar,
IntegerVariable... literals)
A reified constraint for logical conjunction between boolean variables binVar = lit1 NOR lit2 NOR ... |
static Constraint |
Choco.reifiedNot(IntegerVariable binVar,
IntegerVariable lit)
A reified constraint for logical negation binVar = NOT(lit) |
static Constraint |
Choco.reifiedOr(IntegerVariable binVar,
IntegerVariable... literals)
A reified constraint for logical disjunction between boolean variables binVar = lit1 OR lit2 OR ... |
static Constraint |
Choco.reifiedRightImp(IntegerVariable binVar,
IntegerVariable lit1,
IntegerVariable lit2)
A reified constraint for forward implication binVar = lit2 implies lit1 |
static Constraint |
Choco.reifiedXnor(IntegerVariable binVar,
IntegerVariable lit1,
IntegerVariable lit2)
A reified constraint for logical equality binVar = lit1 XNOR lit2 |
static Constraint |
Choco.reifiedXor(IntegerVariable binVar,
IntegerVariable lit1,
IntegerVariable lit2)
A reified constraint for logical exclusive disjunction between boolean variables binVar = lit1 XOR lit2 |
static Constraint |
Choco.relationPairAC(IntegerVariable v1,
IntegerVariable v2,
BinRelation binR)
Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables. |
static Constraint |
Choco.relationPairAC(String options,
IntegerVariable v1,
IntegerVariable v2,
BinRelation binR)
Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables |
static Constraint |
Choco.relationTupleAC(IntegerVariable[] vs,
LargeRelation rela)
Create a constraint enforcing Arc Consistency on a given consistency relation defined by infeasible tuples. |
static Constraint |
Choco.relationTupleAC(String options,
IntegerVariable[] vs,
LargeRelation rela)
|
static Constraint |
Choco.relationTupleFC(IntegerVariable[] vs,
LargeRelation rela)
Create a constraint enforcing Forward Checking on a given consistency relation |
static Constraint |
Choco.sameSign(IntegerExpressionVariable n1,
IntegerExpressionVariable n2)
|
static Constraint |
Choco.setDisjoint(SetVariable... sv)
Ensure every set of sv are disjoints from each other. |
static Constraint |
Choco.setInter(SetVariable sv1,
SetVariable sv2,
SetVariable inter)
Enforce a set to be the intersection of two others. |
static Constraint |
Choco.setLex(SetVariable x,
SetVariable y)
X <=lex Y |
static Constraint |
Choco.setUnion(SetVariable[] sv,
SetVariable union)
Enforce a set to be the union of n others |
static Constraint |
Choco.setUnion(SetVariable sv1,
SetVariable sv2,
SetVariable union)
Enforce a set to be the union of two others |
static Constraint |
Choco.setValuePrecede(SetVariable[] sv,
int s,
int t)
If there exists a set variable v1 of VARIABLES such that S does not belong to v1 and T does, then there also exists a set variable v2 preceding v1 such that S belongs to v2 and T does not. |
static Constraint |
Choco.softMultiCostRegular(IntegerVariable[] vars,
IntegerVariable[] counters,
IntegerVariable[] penaltyVars,
IntegerVariable globalPenalty,
IPenaltyFunction[] pfunction,
IAutomaton auto,
int[][][][] costs)
|
static Constraint |
Choco.softMultiCostRegular(IntegerVariable[] vars,
IntegerVariable[] counters,
IntegerVariable[] penaltyVars,
IntegerVariable globalPenalty,
IPenaltyFunction[] pfunction,
IAutomaton auto,
int[][][][] costs,
int... sumDimension)
|
static Constraint |
Choco.sorting(IntegerVariable[] v1,
IntegerVariable[] v2)
Let x and x' be two vectors of variables of the same length, and v be an instantiation. |
static Constraint |
Choco.startsAfter(TaskVariable t,
int min)
This task begins before max |
static Constraint |
Choco.startsAfterBegin(TaskVariable t1,
TaskVariable t2)
Temporal constraint : start(t1) >= start(t2) |
static Constraint |
Choco.startsAfterBegin(TaskVariable t1,
TaskVariable t2,
int delta)
Temporal constraint : start(t1) >= start(t2) +delta |
static Constraint |
Choco.startsAfterEnd(TaskVariable t1,
TaskVariable t2)
Temporal constraint: start(t1) >= end(t2) |
static Constraint |
Choco.startsAfterEnd(TaskVariable t1,
TaskVariable t2,
int delta)
Temporal constraint: start(t1) >= end(t2) + delta |
static Constraint |
Choco.startsAt(TaskVariable t,
int time)
This task starts at time. |
static Constraint |
Choco.startsBefore(TaskVariable t,
int max)
This task starts before max |
static Constraint |
Choco.startsBeforeBegin(TaskVariable t1,
TaskVariable t2)
Temporal constraint : start(t1) <= start(s2) |
static Constraint |
Choco.startsBeforeBegin(TaskVariable t1,
TaskVariable t2,
int delta)
Temporal constraint : start(t1) +delta <= start(s2) |
static Constraint |
Choco.startsBeforeEnd(TaskVariable t1,
TaskVariable t2)
Temporal constraint : start(t1) + delta <= end(t2) |
static Constraint |
Choco.startsBeforeEnd(TaskVariable t1,
TaskVariable t2,
int delta)
Temporal constraint : start(t1) + delta <= end(t2) |
static Constraint |
Choco.startsBetween(TaskVariable t,
int min,
int max)
This task ends between min and max |
static Constraint |
Choco.stretchPath(List<int[]> stretchesParameters,
IntegerVariable... vars)
Enforce the minimal and maximal sizes of the streches of any value given in strechesParameters. |
static Constraint |
Choco.times(IntegerVariable x,
IntegerVariable y,
IntegerVariable z)
Enforce z = x * y |
static Constraint |
Choco.times(IntegerVariable x,
int y,
IntegerVariable z)
Enforce z = x * y |
static Constraint |
Choco.times(int x,
IntegerVariable y,
IntegerVariable z)
Enforce z = x * y |
protected static Constraint |
Choco.timeWindow(IntegerVariable var,
int min,
int max)
|
static Constraint |
Choco.tree(TreeParametersObject param)
|
static Constraint |
ChocoContrib.useResource(TaskVariable task,
Constraint... resources)
|
static Constraint |
ChocoContrib.useResourceGeq(TaskVariable task,
Constraint... resources)
|
static Constraint |
ChocoContrib.useResources(TaskVariable task,
int k,
Constraint... resources)
|
static Constraint |
ChocoContrib.useResourcesGeq(TaskVariable task,
int k,
Constraint... resources)
|
static Constraint |
Choco.xnor(IntegerVariable lit1,
IntegerVariable lit2)
A reified constraint for logical equality lit1 XNOR lit2 |
static Constraint |
Choco.xor(IntegerVariable lit1,
IntegerVariable lit2)
A reified constraint for logical exclusive disjunctive lit1 XOR lit2 |
Uses of Constraint in choco.cp.common.util.preprocessor |
---|
Fields in choco.cp.common.util.preprocessor with type parameters of type Constraint | |
---|---|
protected gnu.trove.TLongObjectHashMap<Constraint> |
AbstractAdvancedDetector.constraintsToAdd
Internal structure to store constraint addition instructions |
protected gnu.trove.TLongObjectHashMap<Constraint> |
AbstractAdvancedDetector.constraintsToDelete
Internal structure to store constraint deletion instructions |
Methods in choco.cp.common.util.preprocessor with parameters of type Constraint | |
---|---|
protected void |
AbstractAdvancedDetector.add(Constraint c)
Add a constraint c to the model which is currently treated by the detector. |
protected void |
AbstractAdvancedDetector.delete(Constraint c)
Delete a constraint c to the model which is currently treated by the detector. |
protected void |
AbstractAdvancedDetector.forget(Constraint c)
Remove addition instruction on c . |
protected void |
AbstractAdvancedDetector.keep(Constraint c)
Remove deletion instruction on c . |
Uses of Constraint in choco.cp.common.util.preprocessor.detector |
---|
Methods in choco.cp.common.util.preprocessor.detector with parameters of type Constraint | |
---|---|
protected abstract void |
AbstractIntegerVariableEqualitiesDetector.action(Constraint c)
Do an action on c , depending on implementation. |
protected void |
AbstractIntegerVariableEqualitiesDetector.IntegerVariableEqualitiesSolverDetector.action(Constraint c)
Delete link between Model object and Solver object. |
protected void |
AbstractIntegerVariableEqualitiesDetector.IntegerVariableEqualitiesModelDetector.action(Constraint c)
Store deletion instruction of c |
void |
AbstractGraphBasedDetector.addEdge(Variable a,
Variable b,
Constraint c)
|
Uses of Constraint in choco.cp.common.util.preprocessor.detector.scheduling |
---|
Methods in choco.cp.common.util.preprocessor.detector.scheduling with parameters of type Constraint | |
---|---|
protected void |
AbstractTemporalDetector.apply(Constraint c)
|
protected void |
AbstractRscDetector.apply(Constraint ct)
|
protected boolean |
AbstractTemporalDetector.isInPreprocess(Constraint c)
|
protected boolean |
AbstractRscDetector.isInPreprocess(Constraint c)
|
Uses of Constraint in choco.cp.common.util.preprocessor.graph |
---|
Fields in choco.cp.common.util.preprocessor.graph with type parameters of type Constraint | |
---|---|
gnu.trove.THashMap<ArrayGraph.Edge,Constraint> |
ArrayGraph.storeEdges
|
Methods in choco.cp.common.util.preprocessor.graph that return Constraint | |
---|---|
Constraint |
ArrayGraph.getConstraintEdge(int a,
int b)
|
Methods in choco.cp.common.util.preprocessor.graph with parameters of type Constraint | |
---|---|
void |
ArrayGraph.storeEdge(Constraint c,
int a,
int b)
|
Uses of Constraint in choco.cp.model |
---|
Fields in choco.cp.model with type parameters of type Constraint | |
---|---|
protected TIHIterator<Constraint> |
CPModel._iterator
|
protected DeterministicIndicedList<Constraint> |
CPModel.constraints
All the constraint of the model |
Methods in choco.cp.model that return Constraint | |
---|---|
Constraint |
CPModel.getConstraint(int i)
Network management: Retrieve a constraint by its index. |
Methods in choco.cp.model that return types with arguments of type Constraint | |
---|---|
DisposableIterator<Constraint> |
CPModel.getConstraintByType(ConstraintType t)
|
Iterator<Constraint> |
CPModel.getConstraintIterator()
Return an iterator over the constraints of the model |
Iterator<Constraint> |
CPModel.getIntConstraintIterator()
Deprecated. |
Methods in choco.cp.model with parameters of type Constraint | |
---|---|
void |
CPModel.addConstraint(Constraint... c)
Deprecated. |
void |
CPModel.addConstraint(Constraint c)
Add one constraint to the model. |
void |
CPModel.addConstraint(String options,
Constraint... c)
Deprecated. |
void |
CPModel.addConstraint(String options,
Constraint c)
Add one constraint to the model. |
void |
CPModel.addConstraints(Constraint... c)
Add one or more constraint to the model. |
void |
CPModel.addConstraints(String options,
Constraint... tabc)
Add constraints to the model |
boolean |
CPModel.contains(Constraint c)
|
void |
CPModel.removeConstraint(Constraint c)
|
Uses of Constraint in choco.cp.model.managers |
---|
Methods in choco.cp.model.managers with parameters of type Constraint | |
---|---|
INode |
UseResourcesManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
|
INode |
SetConstraintManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build a expression node |
INode |
MixedConstraintManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build a expression node |
INode |
IntConstraintManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
Uses of Constraint in choco.cp.model.managers.constraints |
---|
Methods in choco.cp.model.managers.constraints with parameters of type Constraint | |
---|---|
INode |
EqManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
BooleanManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
Uses of Constraint in choco.cp.model.managers.constraints.expressions |
---|
Methods in choco.cp.model.managers.constraints.expressions with parameters of type Constraint | |
---|---|
INode |
XorManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
XnorManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
OrManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
NotManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
NorManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
NandManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
ImpliesManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
IfThenElseManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
IfOnlyIfManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
AndManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
Uses of Constraint in choco.cp.model.managers.constraints.global |
---|
Methods in choco.cp.model.managers.constraints.global with parameters of type Constraint | |
---|---|
INode |
TreeManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
Uses of Constraint in choco.cp.model.managers.constraints.integer |
---|
Methods in choco.cp.model.managers.constraints.integer with parameters of type Constraint | |
---|---|
INode |
SignOpManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
ModuloManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
AbsoluteManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Make a solver expression variable from a model expression variable |
Uses of Constraint in choco.cp.model.managers.operators |
---|
Methods in choco.cp.model.managers.operators with parameters of type Constraint | |
---|---|
INode |
DoubleManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
|
INode |
SumManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
SqrtManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Make a solver expression variable from a model expression variable |
INode |
SinManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
ScalarManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
PowerManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
PlusManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
NegManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
MultManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
MinusManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
MinManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
MaxManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
DivManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Make a solver expression variable from a model expression variable |
INode |
DistanceNEQManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Make a solver expression variable from a model expression variable |
INode |
DistanceLTManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Make a solver expression variable from a model expression variable |
INode |
DistanceGTManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Make a solver expression variable from a model expression variable |
INode |
DistanceEQManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Make a solver expression variable from a model expression variable |
INode |
CosManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build arithm node from a IntegerExpressionVariable |
INode |
AbsManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Make a solver expression variable from a model expression variable |
Uses of Constraint in choco.cp.model.managers.variables |
---|
Methods in choco.cp.model.managers.variables with parameters of type Constraint | |
---|---|
INode |
TaskVariableManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build a expression node |
INode |
SetVariableManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build a expression node |
INode |
RealVariableManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build a expression node |
INode |
IntegerVariableManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build a expression node |
INode |
IntegerExpressionManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] variables)
Build arithm node from a IntegerExpressionVariable |
Uses of Constraint in choco.cp.solver |
---|
Uses of Constraint in choco.cp.solver.constraints.set |
---|
Methods in choco.cp.solver.constraints.set that return Constraint | |
---|---|
static Constraint |
MemberXiY.build(IntegerVariable[] ivars,
SetVariable svar)
|
Uses of Constraint in choco.cp.solver.constraints.strong |
---|
Methods in choco.cp.solver.constraints.strong with parameters of type Constraint | |
---|---|
protected BoolNode |
StrongConsistencyManager.buildBoolNode(Constraint ic,
Solver cpsolver)
|
protected ExpressionSConstraint |
StrongConsistencyManager.createMetaConstraint(Constraint ic,
Solver cpsolver)
|
INode |
StrongConsistencyManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
|
Uses of Constraint in choco.cp.solver.constraints.strong.xmlmodel |
---|
Methods in choco.cp.solver.constraints.strong.xmlmodel that return Constraint | |
---|---|
static Constraint[] |
ChocoFactoryRPC.makeModelConstraint(PConstraint pc)
|
Uses of Constraint in choco.cp.solver.preprocessor |
---|
Methods in choco.cp.solver.preprocessor with type parameters of type Constraint | ||
---|---|---|
|
PreProcessCPSolver.setCstr(MC c,
SC sc)
|
Methods in choco.cp.solver.preprocessor with parameters of type Constraint | |
---|---|
BoolNode |
PPModelToCPSolver.buildNode(Constraint ic)
|
boolean |
PreProcessCPSolver.contains(Constraint c)
|
protected SConstraint |
PPModelToCPSolver.createMetaConstraint(Constraint ic,
Boolean decomp)
Override the creation of Expression Constraint as in the preprocessing they might have been built earlier or identified as an intensional constraint. |
void |
PPModelToCPSolver.storeExpressionSConstraint(Constraint c,
ExpressionSConstraint ic)
|
Uses of Constraint in choco.kernel.common.util.tools |
---|
Methods in choco.kernel.common.util.tools that return types with arguments of type Constraint | |
---|---|
static Iterator<Constraint> |
IteratorUtils.iterator(Model m,
Collection<Constraint> constraints)
|
Methods in choco.kernel.common.util.tools with parameters of type Constraint | |
---|---|
static IResource<TaskVar> |
TaskUtils.createFakeResource(Solver s,
Constraint c)
|
static IResource<?>[] |
TaskUtils.createFakeResources(Solver s,
Constraint... c)
|
Method parameters in choco.kernel.common.util.tools with type arguments of type Constraint | |
---|---|
static Iterator<Constraint> |
IteratorUtils.iterator(Model m,
Collection<Constraint> constraints)
|
Uses of Constraint in choco.kernel.model |
---|
Fields in choco.kernel.model declared as Constraint | |
---|---|
protected static Constraint[] |
VariableArray.NO_CONSTRAINTS
|
Methods in choco.kernel.model that return Constraint | |
---|---|
Constraint |
VariableArray.VConstraintsDataStructure.getConstraint(int i)
|
Constraint |
Model.getConstraint(int i)
Network management: Retrieve a constraint by its index. |
Constraint |
IConstraintList.getConstraint(int i)
|
Constraint[] |
VariableArray.VConstraintsDataStructure.getConstraints()
|
Constraint[] |
IConstraintList.getConstraints()
|
Methods in choco.kernel.model that return types with arguments of type Constraint | |
---|---|
Iterator<Constraint> |
Model.getConstraintByType(ConstraintType t)
Return an iterator over constraint of a certain type |
Iterator<Constraint> |
Model.getConstraintIterator()
Return an iterator over the constraints of the model |
Iterator<Constraint> |
VariableArray.VConstraintsDataStructure.getConstraintIterator(Model m)
|
Iterator<Constraint> |
IConstraintList.getConstraintIterator(Model m)
|
Iterator<Constraint> |
Model.getIntConstraintIterator()
Deprecated. |
Methods in choco.kernel.model with parameters of type Constraint | |
---|---|
void |
VariableArray.VConstraintsDataStructure._addConstraint(Constraint c)
|
void |
IConstraintList._addConstraint(Constraint c)
|
boolean |
VariableArray.VConstraintsDataStructure._contains(Constraint c)
|
boolean |
IConstraintList._contains(Constraint c)
|
void |
VariableArray.VConstraintsDataStructure._removeConstraint(Constraint c)
|
void |
IConstraintList._removeConstraint(Constraint c)
|
void |
Model.addConstraint(Constraint... c)
Deprecated. |
void |
Model.addConstraint(Constraint c)
Add one constraint to the model. |
void |
Model.addConstraint(String options,
Constraint... c)
Deprecated. |
void |
Model.addConstraint(String options,
Constraint c)
Add one constraint to the model. |
void |
Model.addConstraints(Constraint... c)
Add one or more constraint to the model. |
void |
Model.addConstraints(String options,
Constraint... c)
Add one or more constraint to the model. |
boolean |
Model.contains(Constraint c)
|
void |
Model.removeConstraint(Constraint c)
Remove a constraint from the model. |
Uses of Constraint in choco.kernel.model.constraints |
---|
Classes in choco.kernel.model.constraints with type parameters of type Constraint | |
---|---|
class |
MetaConstraint<E extends Constraint>
|
Classes in choco.kernel.model.constraints that implement Constraint | |
---|---|
class |
AbstractConstraint
|
class |
ComponentConstraint
|
class |
ComponentConstraintWithSubConstraints
|
class |
MetaConstraint<E extends Constraint>
|
class |
MetaTaskConstraint
An wrapper for constraint involving some Taskvariable. |
class |
TemporalConstraint
|
Fields in choco.kernel.model.constraints declared as Constraint | |
---|---|
protected Constraint |
MetaTaskConstraint.constraint
|
protected E[] |
MetaConstraint.constraints
|
Methods in choco.kernel.model.constraints that return Constraint | |
---|---|
E[] |
MetaConstraint.getConstraints()
|
Methods in choco.kernel.model.constraints with parameters of type Constraint | |
---|---|
void |
ComponentConstraintWithSubConstraints.addElements(Variable[] vars,
Constraint... cstrs)
|
INode |
ExpressionManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
Build a expression node |
Constructors in choco.kernel.model.constraints with parameters of type Constraint | |
---|---|
ComponentConstraintWithSubConstraints(Class componentClass,
Variable[] variables,
Object params,
Constraint... constraints)
|
|
ComponentConstraintWithSubConstraints(ConstraintType constraintType,
Variable[] variables,
Object params,
Constraint... constraints)
|
|
ComponentConstraintWithSubConstraints(String componentClassName,
Variable[] variables,
Object params,
Constraint... constraints)
|
|
MetaConstraint(Class metaManager,
E... constraints)
|
|
MetaConstraint(ConstraintType type,
E... constraints)
|
|
MetaConstraint(String metaManager,
E... constraints)
|
|
MetaTaskConstraint(TaskVariable[] taskvariables,
Constraint constraint)
|
Uses of Constraint in choco.kernel.model.constraints.pack |
---|
Methods in choco.kernel.model.constraints.pack that return Constraint | |
---|---|
Constraint |
PackModel.allDiffLargeItems()
Redundant Constraint : allDifferent on the k-th largest items |
Constraint[] |
PackModel.decreasingCardinalities(int fromIndex)
Deprecated. |
Constraint[] |
PackModel.decreasingLoads(int fromIndex)
Deprecated. |
Constraint[] |
PackModel.orderEqualSizedItems(int fromIndex)
Deprecated. |
Constraint[] |
PackModel.packLargeItems()
Deprecated. |
Uses of Constraint in choco.kernel.model.factories |
---|
Methods in choco.kernel.model.factories that return Constraint | |
---|---|
static Constraint |
ConstraintListFactory.get(int i)
|
Methods in choco.kernel.model.factories that return types with arguments of type Constraint | |
---|---|
static ArrayList<Constraint> |
ConstraintListFactory.getConstraintList()
|
Methods in choco.kernel.model.factories with parameters of type Constraint | |
---|---|
static int |
ConstraintListFactory.add(Constraint c)
|
static boolean |
ConstraintListFactory.remove(int i,
Constraint removeOne)
|
Uses of Constraint in choco.kernel.model.variables |
---|
Methods in choco.kernel.model.variables that return Constraint | |
---|---|
Constraint |
ComponentVariable.ConstraintsDataStructure.getConstraint(int i)
|
Constraint |
AbstractVariable.getConstraint(int idx)
|
Constraint[] |
ComponentVariable.ConstraintsDataStructure.getConstraints()
|
Constraint[] |
AbstractVariable.getConstraints()
|
Methods in choco.kernel.model.variables that return types with arguments of type Constraint | |
---|---|
Iterator<Constraint> |
Variable.getConstraintIterator()
Deprecated. |
Iterator<Constraint> |
AbstractVariable.getConstraintIterator()
Deprecated. |
Iterator<Constraint> |
ComponentVariable.ConstraintsDataStructure.getConstraintIterator(Model m)
|
Iterator<Constraint> |
AbstractVariable.getConstraintIterator(Model m)
|
Methods in choco.kernel.model.variables with parameters of type Constraint | |
---|---|
void |
ComponentVariable.ConstraintsDataStructure._addConstraint(Constraint c)
|
void |
AbstractVariable._addConstraint(Constraint c)
|
boolean |
ComponentVariable.ConstraintsDataStructure._contains(Constraint c)
|
boolean |
AbstractVariable._contains(Constraint c)
|
void |
ComponentVariable.ConstraintsDataStructure._removeConstraint(Constraint c)
|
void |
AbstractVariable._removeConstraint(Constraint c)
|
Uses of Constraint in choco.kernel.model.variables.integer |
---|
Fields in choco.kernel.model.variables.integer declared as Constraint | |
---|---|
protected Constraint[] |
MetaIntegerExpressionVariable.constraints
|
Methods in choco.kernel.model.variables.integer that return Constraint | |
---|---|
Constraint[] |
MetaIntegerExpressionVariable.getConstraints()
|
Constructors in choco.kernel.model.variables.integer with parameters of type Constraint | |
---|---|
MetaIntegerExpressionVariable(Operator operator,
Constraint c,
IntegerExpressionVariable... variables)
|
Uses of Constraint in choco.kernel.solver |
---|
Methods in choco.kernel.solver with parameters of type Constraint | |
---|---|
SConstraint |
Solver.getCstr(Constraint ic)
|
Uses of Constraint in choco.visu.components.chart |
---|
Methods in choco.visu.components.chart with parameters of type Constraint | |
---|---|
static org.jfree.chart.JFreeChart |
ChocoChartFactory.createCumulativeChart(String title,
CPSolver s,
Constraint rsc,
boolean legend)
|
static org.jfree.chart.JFreeChart |
ChocoChartFactory.createUnaryHChart(String title,
Solver scheduler,
Constraint... resources)
|
Method parameters in choco.visu.components.chart with type arguments of type Constraint | |
---|---|
static org.jfree.data.gantt.TaskSeriesCollection |
ChocoDatasetFactory.createTaskCollection(Solver s,
Iterator<Constraint> iter)
|
Uses of Constraint in choco.visu.components.chart.ui |
---|
Method parameters in choco.visu.components.chart.ui with type arguments of type Constraint | |
---|---|
protected void |
ChocoChartPanel.createNodes(DefaultMutableTreeNode father,
Iterator<Constraint> iter)
|
Uses of Constraint in parser.absconparseur.components |
---|
Fields in parser.absconparseur.components declared as Constraint | |
---|---|
protected Constraint |
PConstraint.chocoCstr
|
Methods in parser.absconparseur.components that return Constraint | |
---|---|
Constraint |
PConstraint.getChocoCstr()
|
Methods in parser.absconparseur.components with parameters of type Constraint | |
---|---|
void |
PConstraint.setChocoCstr(Constraint chocoCstr)
|
Uses of Constraint in parser.chocogen |
---|
Uses of Constraint in samples.jobshop |
---|
Methods in samples.jobshop that return types with arguments of type Constraint | |
---|---|
Collection<Collection<Constraint>> |
TaillardJobShopProblem.getDisjConstraints()
|
Collection<Collection<Constraint>> |
TaillardJobShopProblem.getPrecConstraints()
|
Methods in samples.jobshop with parameters of type Constraint | |
---|---|
INode |
SimpleDTConstraint.SimpleDTConstraintManager.makeNode(Solver solver,
Constraint[] cstrs,
Variable[] vars)
|
Uses of Constraint in samples.random |
---|
Methods in samples.random that return types with arguments of type Constraint | |
---|---|
Collection<Constraint> |
RandomProblem.getConstraints()
|
Uses of Constraint in samples.tutorials.lns.lns |
---|
Methods in samples.tutorials.lns.lns with parameters of type Constraint | |
---|---|
SConstraint |
AbstractLNSSolver.getCstr(Constraint ic)
Deprecated. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |