|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of IntegerVariable in choco |
---|
Fields in choco declared as IntegerVariable | |
---|---|
static IntegerVariable |
Choco.ONE
|
static IntegerVariable |
Choco.ZERO
|
Methods in choco that return IntegerVariable | |
---|---|
static IntegerVariable |
DeprecatedChoco.makeBinTreeIntVar(String name,
ArrayList<Integer> values)
Create a binary tree domain for integer variable |
static IntegerVariable |
DeprecatedChoco.makeBinTreeIntVar(String name,
int[] values)
Create a binary tree domain for integer variable |
static IntegerVariable |
DeprecatedChoco.makeBinTreeIntVar(String name,
int binf,
int bsup)
Create a binary tree domain for integer variable |
static IntegerVariable[] |
DeprecatedChoco.makeBinTreeIntVarArray(String name,
int size,
int binf,
int bsup)
Create an array of integer variable with a binary tree domain |
static IntegerVariable[][] |
DeprecatedChoco.makeBinTreeIntVarArray(String name,
int dim,
int dim2,
int binf,
int bsup)
Create an double array of integer variable with a binary tree domain |
static IntegerVariable |
Choco.makeBooleanVar(String name,
String... options)
Make a boolean variable |
static IntegerVariable[] |
Choco.makeBooleanVarArray(String name,
int dim,
String... options)
Make an array of boolean variables |
static IntegerVariable |
DeprecatedChoco.makeBoundIntVar(String name,
int binf,
int bsup)
Deprecated. |
static IntegerVariable[] |
DeprecatedChoco.makeBoundIntVarArray(String name,
int size,
int binf,
int bsup)
Deprecated. |
static IntegerVariable[][] |
DeprecatedChoco.makeBoundIntVarArray(String name,
int dim1,
int dim2,
int binf,
int bsup)
Deprecated. |
static IntegerVariable |
DeprecatedChoco.makeEnumIntVar(String name,
ArrayList<Integer> values)
Creates a new search variable with an enumerated domain |
static IntegerVariable |
DeprecatedChoco.makeEnumIntVar(String name,
int[] values)
Creates a new search variable with an enumerated domain |
static IntegerVariable |
DeprecatedChoco.makeEnumIntVar(String name,
int binf,
int bsup)
Deprecated. |
static IntegerVariable[] |
DeprecatedChoco.makeEnumIntVarArray(String name,
int size,
int binf,
int bsup)
Deprecated. |
static IntegerVariable[][] |
DeprecatedChoco.makeEnumIntVarArray(String name,
int dim,
int dim2,
int binf,
int bsup)
Deprecated. |
static IntegerVariable |
Choco.makeIntVar(String name,
int[] valuesArray,
String... options)
Make an integer variable |
static IntegerVariable |
Choco.makeIntVar(String name,
int lowB,
int uppB,
String... options)
Make an integer variable |
static IntegerVariable |
Choco.makeIntVar(String name,
List<Integer> valuesList,
String... options)
Make an integer variable |
static IntegerVariable |
Choco.makeIntVar(String name,
String... options)
Make an integer variable with undefined bounds Create an integer variable with the bounded domain [MIN_LOWER_BOUND,MAX_LOWER_BOUND] BEWARE: bigger domain have unexpected behaviour |
static IntegerVariable |
Choco.makeIntVar(String name,
gnu.trove.TIntArrayList valuesList,
String... options)
Make an integer variable |
static IntegerVariable |
DeprecatedChoco.makeIntVar(String name,
VariableType type,
int binf,
int bsup)
Deprecated. |
static IntegerVariable[] |
Choco.makeIntVarArray(String name,
int dim,
int[] valuesArray,
String... options)
Make an array of integer variable wih the same values |
static IntegerVariable[][] |
Choco.makeIntVarArray(String name,
int dim1,
int dim2,
int[] valuesArray,
String... options)
Make a matrix of integer variable with the same values |
static IntegerVariable[][] |
Choco.makeIntVarArray(String name,
int dim1,
int dim2,
int lowB,
int uppB,
String... options)
Make a matrix of integer variable with same lower and upper bound |
static IntegerVariable[] |
Choco.makeIntVarArray(String name,
int dim,
int lowB,
int uppB,
String... options)
Make a array of integer variable with same lower and upper bound |
static IntegerVariable[][] |
Choco.makeIntVarArray(String name,
int dim1,
int dim2,
List<Integer> valuesList,
String... options)
Make a matrix of integer variable with the same values |
static IntegerVariable[][] |
Choco.makeIntVarArray(String name,
int dim1,
int dim2,
String... options)
Make a matrix of integer variable with undefined bounds Create an integer variable matrix with the following bounded domain [MIN_LOWER_BOUND,MAX_LOWER_BOUND] BEWARE: bigger domain have unexpected behaviour |
static IntegerVariable[][] |
Choco.makeIntVarArray(String name,
int dim1,
int dim2,
gnu.trove.TIntArrayList valuesArray,
String... options)
Make a matrix of integer variable with the same values |
static IntegerVariable[] |
Choco.makeIntVarArray(String name,
int dim,
List<Integer> valuesList,
String... options)
Make an array of integer variable wih the same values |
static IntegerVariable[] |
Choco.makeIntVarArray(String name,
int dim,
String... options)
Make a array of integer variable with undefined bounds Create an integer variable array with the following bounded domain [MIN_LOWER_BOUND,MAX_LOWER_BOUND] BEWARE: bigger domain have unexpected behaviour |
static IntegerVariable[] |
Choco.makeIntVarArray(String name,
int dim,
gnu.trove.TIntArrayList valuesArray,
String... options)
Make an array of integer variable wih the same values |
protected static IntegerVariable[] |
DeprecatedChoco.makeIntVarArray(String name,
VariableType type,
int n,
int binf,
int bsup)
Deprecated. |
protected static IntegerVariable[][] |
DeprecatedChoco.makeIntVarArray(String name,
VariableType type,
int n,
int m,
int binf,
int bsup)
Deprecated. |
static IntegerVariable |
DeprecatedChoco.makeLinkedListIntVar(String name,
int[] values)
Deprecated. |
static IntegerVariable |
DeprecatedChoco.makeLinkedListIntVar(String name,
int binf,
int bsup)
Deprecated. |
Methods in choco with parameters of type IntegerVariable | |
---|---|
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[] |
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[] |
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,
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.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(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[] 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.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(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.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.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,
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[] 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,
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,
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 |
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,
int[] heights,
int capa,
String... options)
Deprecated. |
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[] ends,
IntegerVariable[] durations,
IntegerVariable[] heights,
IntegerVariable 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[] ends,
IntegerVariable[] durations,
IntegerVariable[] heights,
IntegerVariable 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(IntegerVariable[] starts,
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(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 |
DeprecatedChoco.cumulative(String name,
IntegerVariable[] starts,
IntegerVariable[] ends,
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 |
DeprecatedChoco.cumulative(String name,
IntegerVariable[] starts,
IntegerVariable[] ends,
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,
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,
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[] usages,
IntegerVariable consumption,
IntegerVariable capacity,
String... options)
Alternative Cumulative Min-Max : uppBound = null . |
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 |
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(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable 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[] usages,
IntegerVariable capacity,
String... options)
Alternative Cumulative Max : consumption=0, uppBound = null . |
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(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable 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[] usages,
IntegerVariable consumption,
String... options)
Alternative Cumulative Min : capacity=infinity, 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(String name,
TaskVariable[] tasks,
IntegerVariable[] heights,
IntegerVariable 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 |
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[] ends,
IntegerVariable[] 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(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 |
DeprecatedChoco.disjunctive(String name,
IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
IntegerVariable uppBound,
String... options)
Deprecated. |
static Constraint |
DeprecatedChoco.disjunctive(String name,
IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
IntegerVariable uppBound,
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,
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(TaskVariable[] tasks,
IntegerVariable[] usages,
String... options)
Alternative Disjunctive : name = 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.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.domainConstraint(IntegerVariable x,
IntegerVariable[] b)
Deprecated. see domainChannelling |
static Constraint |
Choco.eq(IntegerVariable i,
RealVariable r)
Return a constraint that ensures r == i |
static Constraint |
Choco.eq(RealVariable r,
IntegerVariable i)
Return a constraint that ensures r == i |
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(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,
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.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,
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,
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(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.increasing_nvalue(IntegerVariable nval,
IntegerVariable[] vars)
Deprecated. use increasingNValue |
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.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(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.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.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.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.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.knapsackProblem(IntegerVariable[] vars,
IntegerVariable costVar,
IntegerVariable weightVar,
int[] costs,
int[] weights)
Deprecated. reorder parameters |
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.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.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.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)
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.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.leximin(IntegerVariable[] v1,
IntegerVariable[] v2)
Let x and y be two vectors of n integers, and let x? |
static TaskVariable |
Choco.makeTaskVar(String name,
IntegerVariable start,
IntegerVariable end,
IntegerVariable duration,
String... options)
create a task variable. |
static TaskVariable |
Choco.makeTaskVar(String name,
IntegerVariable start,
IntegerVariable duration,
String... options)
create a task variable. |
static TaskVariable |
Choco.makeTaskVar(String name,
int bsup,
IntegerVariable duration,
String... options)
|
static TaskVariable |
Choco.makeTaskVar(String name,
int binf,
int bsup,
IntegerVariable duration,
String... options)
Make a task variable. |
static TaskVariable[] |
Choco.makeTaskVarArray(String name,
int[] binf,
int[] bsup,
IntegerVariable[] durations,
String... options)
Create an array of task variables. |
static TaskVariable[] |
Choco.makeTaskVarArray(String prefix,
IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
String... options)
Create an array of task variables. |
static TaskVariable[] |
Choco.makeTaskVarArray(String prefix,
IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
String... options)
Create an array of task variables. |
static TaskVariable[] |
Choco.makeTaskVarArray(String prefix,
IntegerVariable[] starts,
IntegerVariable[] ends,
IntegerVariable[] durations,
String... options)
Create an array of task variables. |
static TaskVariable[][] |
Choco.makeTaskVarArray(String name,
int binf,
int bsup,
IntegerVariable[][] durations,
String... options)
|
static TaskVariable[] |
Choco.makeTaskVarArray(String name,
int binf,
int bsup,
IntegerVariable[] durations,
String... options)
Create an array of task variables. |
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[] 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.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(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[] 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.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,
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.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(IntegerVariable... literals)
A constraint for logical conjunction between boolean variables lit1 NAND lit2 NAND ... |
static Constraint |
Choco.neqCard(SetVariable sv,
IntegerVariable v)
Return a constraint that ensures |sv| ! |
static Constraint |
Choco.nor(IntegerVariable... literals)
A constraint for logical conjunction between boolean variables lit1 NOR lit2 NOR ... |
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(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)
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[] 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 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 |
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.occurenceMax(int value,
IntegerVariable occurence,
IntegerVariable... vars)
Deprecated. |
static Constraint |
DeprecatedChoco.occurenceMin(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(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.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(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.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(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.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.or(IntegerVariable... literals)
A constraint for logical disjunction between boolean variables lit1 OR lit2 OR ... |
static Constraint |
Choco.pack(SetVariable[] itemSets,
IntegerVariable[] loads,
IntegerVariable[] bins,
IntegerConstantVariable[] sizes,
IntegerVariable nbNonEmpty,
String... options)
|
static Constraint |
Choco.pack(SetVariable[] itemSets,
IntegerVariable[] loads,
IntegerVariable[] bins,
IntegerConstantVariable[] sizes,
IntegerVariable nbNonEmpty,
String... options)
|
static Constraint |
Choco.pack(SetVariable[] itemSets,
IntegerVariable[] loads,
IntegerVariable[] bins,
IntegerConstantVariable[] sizes,
IntegerVariable nbNonEmpty,
String... options)
|
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,
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.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.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.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.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 IntegerExpressionVariable |
Choco.scalar(int[] lc,
IntegerVariable[] lv)
Building a term from a scalar product of coefficients and variables |
static IntegerExpressionVariable |
Choco.scalar(IntegerVariable[] lv,
int[] lc)
Building a term from a scalar product of coefficients and variables |
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)
|
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)
|
static Constraint |
Choco.softMultiCostRegular(IntegerVariable[] vars,
IntegerVariable[] counters,
IntegerVariable[] penaltyVars,
IntegerVariable globalPenalty,
IPenaltyFunction[] pfunction,
IAutomaton auto,
int[][][][] costs,
int... sumDimension)
|
static Constraint |
Choco.softMultiCostRegular(IntegerVariable[] vars,
IntegerVariable[] counters,
IntegerVariable[] penaltyVars,
IntegerVariable globalPenalty,
IPenaltyFunction[] pfunction,
IAutomaton auto,
int[][][][] costs,
int... sumDimension)
|
static Constraint |
Choco.softMultiCostRegular(IntegerVariable[] vars,
IntegerVariable[] counters,
IntegerVariable[] penaltyVars,
IntegerVariable globalPenalty,
IPenaltyFunction[] pfunction,
IAutomaton auto,
int[][][][] costs,
int... sumDimension)
|
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.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.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.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 IntegerVariable in choco.cp.common.util.preprocessor |
---|
Fields in choco.cp.common.util.preprocessor declared as IntegerVariable | |
---|---|
IntegerVariable |
ExpressionTools.SimplePrecedence.v1
|
IntegerVariable |
ExpressionTools.SimplePrecedence.v2
|
Constructors in choco.cp.common.util.preprocessor with parameters of type IntegerVariable | |
---|---|
ExpressionTools.SimplePrecedence(IntegerVariable v1,
int d1,
IntegerVariable v2,
int d2)
|
Uses of IntegerVariable in choco.cp.common.util.preprocessor.detector |
---|
Methods in choco.cp.common.util.preprocessor.detector that return IntegerVariable | |
---|---|
IntegerVariable[] |
AbstractGraphBasedDetector.CliqueIterator.next()
|
Uses of IntegerVariable in choco.cp.common.util.preprocessor.merger |
---|
Methods in choco.cp.common.util.preprocessor.merger that return IntegerVariable | |
---|---|
IntegerVariable |
IntegerVariableMerger.create()
|
Methods in choco.cp.common.util.preprocessor.merger with parameters of type IntegerVariable | |
---|---|
boolean |
IntegerVariableMerger.intersection(IntegerVariable v)
intersection of the current domain and v |
Constructors in choco.cp.common.util.preprocessor.merger with parameters of type IntegerVariable | |
---|---|
IntegerVariableMerger(IntegerVariable v)
|
Uses of IntegerVariable in choco.cp.model |
---|
Fields in choco.cp.model with type parameters of type IntegerVariable | |
---|---|
protected DeterministicIndicedList<IntegerVariable> |
CPModel.intVars
All the search intVars in the model. |
Methods in choco.cp.model that return IntegerVariable | |
---|---|
IntegerVariable |
CPModel.getIntVar(int i)
Network management: Retrieve a variable by its index (all integer variables of the model are numbered in sequence from 0 on) |
IntegerVariable |
CPModel2.makeIntVar(String name,
int lb,
int ub,
String... options)
|
Methods in choco.cp.model that return types with arguments of type IntegerVariable | |
---|---|
Iterator<IntegerVariable> |
CPModel.getIntVarIterator()
|
Methods in choco.cp.model with parameters of type IntegerVariable | |
---|---|
void |
CPModel2.allDifferent(String options,
IntegerVariable[] vars)
|
void |
CPModel2.feasTupleAC(List<int[]> tuples,
IntegerVariable... vars)
|
Uses of IntegerVariable in choco.cp.model.managers |
---|
Methods in choco.cp.model.managers with parameters of type IntegerVariable | |
---|---|
SConstraint[] |
IntConstraintManager.makeConstraintAndOpposite(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint and its opposite for the given solver and "model variables" |
Uses of IntegerVariable in choco.cp.model.managers.constraints.expressions |
---|
Methods in choco.cp.model.managers.constraints.expressions with parameters of type IntegerVariable | |
---|---|
SConstraint |
XorManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
XnorManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> optionsd)
Build a constraint for the given solver and "model variables" |
SConstraint |
OrManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
NotManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
NorManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
NandManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ImpliesManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
IfOnlyIfManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
AndManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
Uses of IntegerVariable in choco.cp.model.managers.constraints.global |
---|
Methods in choco.cp.model.managers.constraints.global with parameters of type IntegerVariable | |
---|---|
SConstraint |
RegularManager.knapsack(Solver s,
IntegerVariable[] vars,
int goal,
int[] coeffs)
|
SConstraint |
StretchPathManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
SortingManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
SoftMultiCostRegularManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
ReifiedXorManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ReifiedXnorManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ReifiedOrManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ReifiedNorManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ReifiedNandManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ReifiedImplicationManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ReifiedImplManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ReifiedAndManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
RegularManager.makeConstraint(Solver solver,
IntegerVariable[] vars,
Object parameters,
List<String> options)
|
SConstraint |
OccurrenceManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
MultiCostRegularManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
LeximinManager.makeConstraint(Solver solver,
IntegerVariable[] vars,
Object parameters,
List<String> options)
|
SConstraint |
LexManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
LexChainManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
KnapsackProblemManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
IncreasingNValueManager.makeConstraint(Solver solver,
IntegerVariable[] integerVariables,
Object parameters,
List<String> options)
|
SConstraint |
GlobalCardinalityManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
GeostManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
FastRegularManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
ElementManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
CostRegularManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
AtMostNValueManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
AllDifferentManager.makeConstraint(Solver solver,
IntegerVariable[] vars,
Object parameters,
List<String> options)
|
SConstraint[] |
OccurrenceManager.makeConstraintAndOpposite(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint and its opposite for the given solver and "model variables" |
SConstraint[] |
ElementManager.makeConstraintAndOpposite(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint and its opposite for the given solver and "model variables" |
Uses of IntegerVariable in choco.cp.model.managers.constraints.integer |
---|
Methods in choco.cp.model.managers.constraints.integer with parameters of type IntegerVariable | |
---|---|
SConstraint |
TimesManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
TableManager.makeConstraint(Solver solver,
IntegerVariable[] vars,
Object parameters,
List<String> options)
|
SConstraint |
NotMemberManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ModuloManager.makeConstraint(Solver solver,
IntegerVariable[] vars,
Object parameters,
List<String> options)
|
SConstraint |
MemberManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
IncreasingSumManager.makeConstraint(Solver solver,
IntegerVariable[] integerVariables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
ExactlyManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint |
EuclideanDivisionManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
DistanceManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
ChannelingManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
AbsoluteManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint for the given solver and "model variables" |
SConstraint[] |
DistanceManager.makeConstraintAndOpposite(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint and its opposite for the given solver and "model variables" |
Uses of IntegerVariable in choco.cp.model.managers.variables |
---|
Methods in choco.cp.model.managers.variables with parameters of type IntegerVariable | |
---|---|
static int |
IntegerVariableManager.getIntelligentDomain(Model model,
IntegerVariable v)
try to find the most suitable domain for v regarding constraints wish a simple heuristic is applied to rank the domains |
protected static IntDomainVar |
IntegerVariableManager.makeConstant(CPSolver solver,
IntegerVariable iv)
|
Var |
IntegerVariableManager.makeVariable(Solver solver,
IntegerVariable var)
Build a integer variable for the given solver |
Uses of IntegerVariable in choco.cp.solver |
---|
Methods in choco.cp.solver with parameters of type IntegerVariable | |
---|---|
IntDomainVar[] |
CPSolver.getVar(IntegerVariable... v)
|
IntDomainVar |
CPSolver.getVar(IntegerVariable v)
|
Uses of IntegerVariable in choco.cp.solver.constraints.global.automata.fast_multicostregular.example |
---|
Constructors in choco.cp.solver.constraints.global.automata.fast_multicostregular.example with parameters of type IntegerVariable | |
---|---|
CoverVarValSelector(Solver s,
IntegerVariable[][] mvars,
int[][] lowb)
|
Uses of IntegerVariable in choco.cp.solver.constraints.global.ordered |
---|
Methods in choco.cp.solver.constraints.global.ordered with parameters of type IntegerVariable | |
---|---|
SConstraint |
OrderedGccManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
Uses of IntegerVariable in choco.cp.solver.constraints.global.softscheduling |
---|
Methods in choco.cp.solver.constraints.global.softscheduling with parameters of type IntegerVariable | |
---|---|
SConstraint |
SoftCumulativeSumManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
SoftCumulativeManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
Uses of IntegerVariable in choco.cp.solver.constraints.reified |
---|
Methods in choco.cp.solver.constraints.reified that return types with arguments of type IntegerVariable | |
---|---|
Iterator<IntegerVariable> |
ExpressionSConstraint.getVariableIterator()
|
Uses of IntegerVariable in choco.cp.solver.constraints.reified.leaves |
---|
Fields in choco.cp.solver.constraints.reified.leaves declared as IntegerVariable | |
---|---|
IntegerVariable |
VariableLeaf.ivar
|
Methods in choco.cp.solver.constraints.reified.leaves that return IntegerVariable | |
---|---|
IntegerVariable[] |
VariableLeaf.getModelScope()
|
IntegerVariable[] |
ConstantLeaf.getModelScope()
|
Constructors in choco.cp.solver.constraints.reified.leaves with parameters of type IntegerVariable | |
---|---|
VariableLeaf(IntegerVariable ivar)
|
Uses of IntegerVariable in choco.cp.solver.constraints.set |
---|
Methods in choco.cp.solver.constraints.set with parameters of type IntegerVariable | |
---|---|
static Constraint |
MemberXiY.build(IntegerVariable[] ivars,
SetVariable svar)
|
Uses of IntegerVariable in choco.cp.solver.constraints.strong |
---|
Methods in choco.cp.solver.constraints.strong with parameters of type IntegerVariable | |
---|---|
SConstraint |
StrongConsistencyManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint[] |
StrongConsistencyManager.makeConstraintAndOpposite(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint and its opposite for the given solver and "model variables" |
Uses of IntegerVariable in choco.cp.solver.preprocessor |
---|
Methods in choco.cp.solver.preprocessor with parameters of type IntegerVariable | |
---|---|
void |
SymetryBreakingModelDetector.setMaxClique(IntegerVariable[] clique)
|
void |
SymetryBreakingModelDetector.EmptySymetryBreakingModelDetector.setMaxClique(IntegerVariable[] clique)
|
Uses of IntegerVariable in choco.kernel.common.util.tools |
---|
Methods in choco.kernel.common.util.tools that return IntegerVariable | |
---|---|
static IntegerVariable[] |
PermutationUtils.applyPermutation(IPermutation permutation,
IntegerVariable[] source)
|
static IntegerVariable |
VariableUtils.createDirVariable(TaskVariable t1,
TaskVariable t2,
String... boolOptions)
|
static IntegerVariable[] |
VariableUtils.getCardinalities(SetVariable... vars)
|
static IntegerVariable[] |
VariableUtils.getDurationVariables(List<TaskVariable> tasks)
|
static IntegerVariable[] |
VariableUtils.getDurationVariables(TaskVariable... tasks)
|
static IntegerVariable[] |
VariableUtils.getEndVariables(List<TaskVariable> tasks)
|
static IntegerVariable[] |
VariableUtils.getEndVariables(TaskVariable... tasks)
|
static IntegerVariable[] |
VariableUtils.getStartVariables(List<TaskVariable> tasks)
|
static IntegerVariable[] |
VariableUtils.getStartVariables(TaskVariable... tasks)
|
Methods in choco.kernel.common.util.tools with parameters of type IntegerVariable | |
---|---|
static IntegerVariable[] |
PermutationUtils.applyPermutation(IPermutation permutation,
IntegerVariable[] source)
|
static boolean |
VariableUtils.checkConstant(IntegerVariable v,
int value)
|
static String |
StringUtils.format(IntegerVariable iv)
|
static IntDomainVar[] |
VariableUtils.getVar(Solver solver,
IntegerVariable[] variables,
int begin,
int end)
|
Uses of IntegerVariable in choco.kernel.model |
---|
Methods in choco.kernel.model that return IntegerVariable | |
---|---|
IntegerVariable |
Model.getIntVar(int i)
Network management: Retrieve a variable by its index (all integer variables of the model are numbered in sequence from 0 on) |
IntegerVariable |
Model2.makeIntVar(String name,
int lb,
int ub,
String... options)
|
Methods in choco.kernel.model that return types with arguments of type IntegerVariable | |
---|---|
Iterator<IntegerVariable> |
Model.getIntVarIterator()
Retrieves an iterator over IntegerVariables of the model |
Methods in choco.kernel.model with parameters of type IntegerVariable | |
---|---|
void |
Model2.allDifferent(String string,
IntegerVariable[] vars)
|
void |
Model2.feasTupleAC(List<int[]> tuples,
IntegerVariable... vars)
|
Uses of IntegerVariable in choco.kernel.model.constraints |
---|
Methods in choco.kernel.model.constraints that return IntegerVariable | |
---|---|
IntegerVariable |
TemporalConstraint.getBackwardSetup()
|
IntegerVariable |
TemporalConstraint.getDirection()
|
IntegerVariable |
TemporalConstraint.getForwardSetup()
|
IntegerVariable[] |
AbstractConstraint.getIntVariableScope()
get rid of the constants within the returned scopes ! |
Uses of IntegerVariable in choco.kernel.model.constraints.automaton.FA |
---|
Methods in choco.kernel.model.constraints.automaton.FA with parameters of type IntegerVariable | |
---|---|
static ICostAutomaton |
CostAutomaton.makeMultiResources(IAutomaton auto,
int[][][][] c,
IntegerVariable[] z)
|
static ICostAutomaton |
CostAutomaton.makeMultiResources(IAutomaton auto,
int[][][] c,
IntegerVariable[] z)
|
Uses of IntegerVariable in choco.kernel.model.constraints.cnf |
---|
Methods in choco.kernel.model.constraints.cnf that return IntegerVariable | |
---|---|
IntegerVariable[] |
Singleton.flattenBoolVar()
|
IntegerVariable[] |
Node.flattenBoolVar()
|
IntegerVariable[] |
Literal.flattenBoolVar()
|
abstract IntegerVariable[] |
ALogicTree.flattenBoolVar()
Extracts and returns the flatten array of BoolVar contained in this . |
Methods in choco.kernel.model.constraints.cnf with parameters of type IntegerVariable | |
---|---|
static Literal |
Literal.neg(IntegerVariable var)
|
static Literal[] |
Literal.neg(IntegerVariable[] vars)
|
static Literal |
Literal.pos(IntegerVariable var)
|
static Literal[] |
Literal.pos(IntegerVariable[] vars)
|
Constructors in choco.kernel.model.constraints.cnf with parameters of type IntegerVariable | |
---|---|
Literal(IntegerVariable var,
ALogicTree.Type type)
|
Uses of IntegerVariable in choco.kernel.model.constraints.geost.externalConstraints |
---|
Fields in choco.kernel.model.constraints.geost.externalConstraints declared as IntegerVariable | |
---|---|
IntegerVariable |
DistLeqModel.modelDVar
|
IntegerVariable |
DistGeqModel.modelDVar
|
Methods in choco.kernel.model.constraints.geost.externalConstraints that return IntegerVariable | |
---|---|
IntegerVariable |
DistLeqModel.getDistanceVar()
|
IntegerVariable |
DistGeqModel.getDistanceVar()
|
Constructors in choco.kernel.model.constraints.geost.externalConstraints with parameters of type IntegerVariable | |
---|---|
DistGeqModel(int ectrID,
int[] dimensions,
int[] objectIdentifiers,
int D_,
int q_,
IntegerVariable var)
|
|
DistLeqModel(int ectrID,
int[] dimensions,
int[] objectIdentifiers,
int D_,
int q_,
IntegerVariable var)
|
Uses of IntegerVariable in choco.kernel.model.constraints.pack |
---|
Fields in choco.kernel.model.constraints.pack declared as IntegerVariable | |
---|---|
IntegerVariable[] |
PackModel.bins
|
IntegerVariable[] |
PackModel.loads
|
IntegerVariable |
PackModel.nbNonEmpty
|
Methods in choco.kernel.model.constraints.pack that return IntegerVariable | |
---|---|
IntegerVariable[] |
PackModel.getBins()
|
IntegerVariable[] |
PackModel.getLoads()
|
Uses of IntegerVariable in choco.kernel.model.variables.geost |
---|
Methods in choco.kernel.model.variables.geost that return IntegerVariable | |
---|---|
IntegerVariable[] |
GeostObject.getCoordinates()
|
IntegerVariable |
GeostObject.getDurationTime()
|
IntegerVariable |
GeostObject.getEndTime()
|
IntegerVariable |
GeostObject.getShapeId()
|
IntegerVariable |
GeostObject.getStartTime()
|
Constructors in choco.kernel.model.variables.geost with parameters of type IntegerVariable | |
---|---|
GeostObject(int dim,
int objectId,
IntegerVariable shapeId,
IntegerVariable[] coordinates,
IntegerVariable startTime,
IntegerVariable durationTime,
IntegerVariable endTime)
Creates an object with the given parameters |
|
GeostObject(int dim,
int objectId,
IntegerVariable shapeId,
IntegerVariable[] coordinates,
IntegerVariable startTime,
IntegerVariable durationTime,
IntegerVariable endTime)
Creates an object with the given parameters |
|
GeostObject(int dim,
int objectId,
IntegerVariable shapeId,
IntegerVariable[] coordinates,
IntegerVariable startTime,
IntegerVariable durationTime,
IntegerVariable endTime,
int radius)
|
|
GeostObject(int dim,
int objectId,
IntegerVariable shapeId,
IntegerVariable[] coordinates,
IntegerVariable startTime,
IntegerVariable durationTime,
IntegerVariable endTime,
int radius)
|
Uses of IntegerVariable in choco.kernel.model.variables.integer |
---|
Subclasses of IntegerVariable in choco.kernel.model.variables.integer | |
---|---|
class |
IntegerConstantVariable
|
Uses of IntegerVariable in choco.kernel.model.variables.scheduling |
---|
Methods in choco.kernel.model.variables.scheduling that return IntegerVariable | |
---|---|
IntegerVariable |
TaskVariable.duration()
Get the duration of the task |
IntegerVariable |
TaskVariable.end()
Get the end time of the task |
IntegerVariable |
TaskVariable.start()
Get the start time of the task |
Constructors in choco.kernel.model.variables.scheduling with parameters of type IntegerVariable | |
---|---|
TaskVariable(String name,
IntegerVariable start,
IntegerVariable end,
IntegerVariable duration)
|
Uses of IntegerVariable in choco.kernel.model.variables.set |
---|
Fields in choco.kernel.model.variables.set declared as IntegerVariable | |
---|---|
protected IntegerVariable |
SetVariable.card
|
Methods in choco.kernel.model.variables.set that return IntegerVariable | |
---|---|
IntegerVariable |
SetVariable.getCard()
|
Methods in choco.kernel.model.variables.set with parameters of type IntegerVariable | |
---|---|
void |
SetVariable.setCard(IntegerVariable card)
|
Constructors in choco.kernel.model.variables.set with parameters of type IntegerVariable | |
---|---|
SetVariable(String name,
int[] values,
IntegerVariable card)
|
|
SetVariable(String name,
int lowB,
int uppB,
IntegerVariable card)
|
|
SetVariable(VariableType variableType,
boolean enableOption,
int[] parameter,
IConstraintList constraints,
IntegerVariable card)
|
Uses of IntegerVariable in choco.kernel.model.variables.tree |
---|
Fields in choco.kernel.model.variables.tree declared as IntegerVariable | |
---|---|
protected IntegerVariable |
TreeNodeObject.inDegree
an integer variable that depicts the indegree of the current node |
protected IntegerVariable |
TreeNodeObject.successors
an integer variable that depicts the potential sucessor nodes of the current node (by indices) |
protected IntegerVariable |
TreeNodeObject.timeWindow
an integer variable that depicts the starting time from the current node |
Methods in choco.kernel.model.variables.tree that return IntegerVariable | |
---|---|
IntegerVariable |
TreeNodeObject.getInDegree()
|
IntegerVariable |
TreeParametersObject.getNproper()
|
IntegerVariable |
TreeParametersObject.getNTree()
|
IntegerVariable |
TreeParametersObject.getObjective()
|
IntegerVariable |
TreeNodeObject.getSuccessors()
|
IntegerVariable[] |
TreeParametersObject.getSuccVars()
|
IntegerVariable |
TreeNodeObject.getTimeWindow()
|
Constructors in choco.kernel.model.variables.tree with parameters of type IntegerVariable | |
---|---|
TreeParametersObject(int nbNodes,
IntegerVariable nTree,
IntegerVariable nproper,
IntegerVariable objective,
List<BitSet[]> graphs,
List<int[][]> matrix,
int[][] travel)
|
Uses of IntegerVariable in choco.kernel.solver |
---|
Methods in choco.kernel.solver with parameters of type IntegerVariable | |
---|---|
IntDomainVar[] |
Solver.getVar(IntegerVariable... v)
|
IntDomainVar |
Solver.getVar(IntegerVariable v)
|
Uses of IntegerVariable in choco.kernel.solver.constraints.global.scheduling |
---|
Constructors in choco.kernel.solver.constraints.global.scheduling with parameters of type IntegerVariable | |
---|---|
ResourceParameters(String name,
TaskVariable[] tasks,
IntegerVariable[] usages,
IntegerVariable uppBound)
|
|
ResourceParameters(String name,
TaskVariable[] tasks,
IntegerVariable[] usages,
IntegerVariable uppBound)
|
Uses of IntegerVariable in choco.kernel.solver.constraints.reified |
---|
Methods in choco.kernel.solver.constraints.reified that return IntegerVariable | |
---|---|
IntegerVariable[] |
INode.getModelScope()
Compute the set of model variable involved in this predicat |
Uses of IntegerVariable in parser.absconparseur.components |
---|
Fields in parser.absconparseur.components declared as IntegerVariable | |
---|---|
protected IntegerVariable |
PVariable.chocovar
|
Methods in parser.absconparseur.components that return IntegerVariable | |
---|---|
IntegerVariable |
PVariable.getChocovar()
|
Methods in parser.absconparseur.components with parameters of type IntegerVariable | |
---|---|
void |
PVariable.setChocovar(IntegerVariable chocovar)
|
Uses of IntegerVariable in parser.chocogen |
---|
Fields in parser.chocogen declared as IntegerVariable | |
---|---|
protected IntegerVariable[] |
ChocoFactory.vars
|
Methods in parser.chocogen that return IntegerVariable | |
---|---|
IntegerVariable |
VariableFactory.createVar(PVariable pvar)
Make the internal decision to create Bound, Enum, LinkedList var |
IntegerVariable |
VariableFactory.makeVariable(PVariable pvar)
Create a variable for pvar except if it is a fake variable (equal to another) |
Methods in parser.chocogen with parameters of type IntegerVariable | |
---|---|
static Constraint |
GloConstraintFactory.buildAllDiff(IntegerVariable[] vars)
|
static Constraint |
GloConstraintFactory.buildGcc(IntegerVariable[] vars,
Integer[] values,
IntegerVariable[] noccurrences)
|
static Constraint |
GloConstraintFactory.buildGcc(IntegerVariable[] vars,
Integer[] values,
IntegerVariable[] noccurrences)
|
Uses of IntegerVariable in parser.flatzinc.ast.expression |
---|
Methods in parser.flatzinc.ast.expression that return IntegerVariable | |
---|---|
abstract IntegerVariable |
Expression.intVarValue()
Get the IntegerVariable of the Expression |
IntegerVariable |
EString.intVarValue()
|
IntegerVariable |
ESet.intVarValue()
|
IntegerVariable |
EInt.intVarValue()
|
IntegerVariable |
EIdentifier.intVarValue()
|
IntegerVariable |
EIdArray.intVarValue()
|
IntegerVariable |
EBool.intVarValue()
|
IntegerVariable |
EArray.intVarValue()
|
IntegerVariable |
EAnnotation.intVarValue()
|
abstract IntegerVariable[] |
Expression.toIntVarArray()
Get an array of IntegerVariable of the Expression |
IntegerVariable[] |
EString.toIntVarArray()
|
IntegerVariable[] |
ESet.toIntVarArray()
|
IntegerVariable[] |
EInt.toIntVarArray()
|
IntegerVariable[] |
EIdentifier.toIntVarArray()
|
IntegerVariable[] |
EIdArray.toIntVarArray()
|
IntegerVariable[] |
EBool.toIntVarArray()
|
IntegerVariable[] |
EArray.toIntVarArray()
|
IntegerVariable[] |
EAnnotation.toIntVarArray()
|
Uses of IntegerVariable in parser.instances |
---|
Methods in parser.instances that return IntegerVariable | |
---|---|
protected IntegerVariable |
AbstractMinimizeModel.buildObjective(String name,
int defaultUpperBound)
|
Uses of IntegerVariable in samples |
---|
Fields in samples declared as IntegerVariable | |
---|---|
protected IntegerVariable[] |
AirPlaneLandingWithLNS.tardiness
Each plane has a tardiness (starting time - arrival time) |
protected IntegerVariable |
AirPlaneLandingWithLNS.weightedSumOfCompletionTimes
the objective to minimize |
Uses of IntegerVariable in samples.fastregular |
---|
Constructors in samples.fastregular with parameters of type IntegerVariable | |
---|---|
JunkerMinSet(IntegerVariable[] vars,
ArrayList<dk.brics.automaton.Automaton> allAutomata,
gnu.trove.TIntHashSet alpha)
|
Uses of IntegerVariable in samples.jobshop |
---|
Methods in samples.jobshop that return IntegerVariable | |
---|---|
IntegerVariable[] |
TaillardJobShopProblem.getVariables()
|
Methods in samples.jobshop with parameters of type IntegerVariable | |
---|---|
SConstraint |
SimpleDTConstraint.SimpleDTConstraintManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint[] |
SimpleDTConstraint.SimpleDTConstraintManager.makeConstraintAndOpposite(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
Build a constraint and its opposite for the given solver and "model variables" |
Uses of IntegerVariable in samples.multicostregular |
---|
Methods in samples.multicostregular with parameters of type IntegerVariable | |
---|---|
static void |
FilteringTest.swapCostAndVar(int idx,
int[][][] csts,
IntegerVariable[] z)
|
Uses of IntegerVariable in samples.multicostregular.asap |
---|
Fields in samples.multicostregular.asap declared as IntegerVariable | |
---|---|
IntegerVariable[][] |
ASAPCPModel.shifts
|
Uses of IntegerVariable in samples.multicostregular.asap.heuristics |
---|
Constructors in samples.multicostregular.asap.heuristics with parameters of type IntegerVariable | |
---|---|
ASAPValSelector(Solver s,
IntegerVariable[][] vars,
ASAPDataHandler d)
|
|
ASAPVarSelector(Solver s,
IntegerVariable[][] vars)
|
Uses of IntegerVariable in samples.multicostregular.carsequencing |
---|
Fields in samples.multicostregular.carsequencing declared as IntegerVariable | |
---|---|
IntegerVariable[] |
CarSeqModel.occVars
|
IntegerVariable[] |
CarSeqModel.seqVars
|
Uses of IntegerVariable in samples.multicostregular.nsp |
---|
Methods in samples.multicostregular.nsp with parameters of type IntegerVariable | |
---|---|
SConstraint |
NSPStruct.NSPStrucManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
Uses of IntegerVariable in samples.multicostregular.planner |
---|
Methods in samples.multicostregular.planner with parameters of type IntegerVariable | |
---|---|
SConstraint |
SubSetChannelling.SubSetManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
SimpleChannelling.SimpleManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
Uses of IntegerVariable in samples.rackconfig |
---|
Methods in samples.rackconfig that return IntegerVariable | |
---|---|
static IntegerVariable[] |
RackConfig.subset(IntegerVariable[] tab,
int start,
int end)
|
Methods in samples.rackconfig with parameters of type IntegerVariable | |
---|---|
static IntegerVariable[] |
RackConfig.subset(IntegerVariable[] tab,
int start,
int end)
|
Uses of IntegerVariable in samples.random |
---|
Methods in samples.random that return IntegerVariable | |
---|---|
IntegerVariable[] |
RandomProblem.getVariables()
|
Uses of IntegerVariable in samples.tutorials |
---|
Fields in samples.tutorials declared as IntegerVariable | |
---|---|
protected IntegerVariable[] |
AllIntervalSeries.dist
|
protected IntegerVariable[] |
Langford.position
|
protected IntegerVariable[] |
AllIntervalSeries.vars
|
Uses of IntegerVariable in samples.tutorials.lns.lns |
---|
Methods in samples.tutorials.lns.lns with parameters of type IntegerVariable | |
---|---|
IntDomainVar[] |
AbstractLNSSolver.getVar(IntegerVariable... v)
Deprecated. |
IntDomainVar |
AbstractLNSSolver.getVar(IntegerVariable v)
Deprecated. |
Uses of IntegerVariable in samples.tutorials.puzzles |
---|
Fields in samples.tutorials.puzzles declared as IntegerVariable | |
---|---|
static IntegerVariable |
DonaldGeraldRobert.A
|
static IntegerVariable |
DonaldGeraldRobert.B
|
static IntegerVariable |
DonaldGeraldRobert.D
|
static IntegerVariable |
DonaldGeraldRobert.E
|
static IntegerVariable |
DonaldGeraldRobert.G
|
static IntegerVariable |
DonaldGeraldRobert.L
|
static IntegerVariable |
DonaldGeraldRobert.N
|
static IntegerVariable |
DonaldGeraldRobert.O
|
static IntegerVariable |
DonaldGeraldRobert.R
|
static IntegerVariable |
DonaldGeraldRobert.T
|
protected IntegerVariable[][] |
MagicSquare.vars
|
protected IntegerVariable[] |
MagicSerie.vars
|
Methods in samples.tutorials.puzzles with parameters of type IntegerVariable | |
---|---|
void |
Sudoku.advanced(Model model,
IntegerVariable[][] rows,
int[][] instance)
|
static void |
Sudoku.printGrid(IntegerVariable[][] rows,
Solver s)
|
Uses of IntegerVariable in samples.tutorials.scheduling |
---|
Fields in samples.tutorials.scheduling declared as IntegerVariable | |
---|---|
protected IntegerVariable[] |
AirPlaneLanding.tardiness
Each plane has a tardiness (starting time - arrival time) |
protected IntegerVariable |
AirPlaneLanding.weightedSumOfCompletionTimes
the objective to minimize |
Uses of IntegerVariable in samples.tutorials.to_sort |
---|
Fields in samples.tutorials.to_sort declared as IntegerVariable | |
---|---|
protected IntegerVariable[] |
MinimumEdgeDeletion.boolVars
|
protected IntegerVariable |
MinimumEdgeDeletion.deletion
|
IntegerVariable[][] |
Picross.dualmyvars
|
IntegerVariable[][] |
Picross.myvars
The model variables. |
protected IntegerVariable[] |
MinimumEdgeDeletion.pairVars
|
Methods in samples.tutorials.to_sort that return IntegerVariable | |
---|---|
IntegerVariable |
SimpleSchedule.getCostVariable()
|
Uses of IntegerVariable in samples.tutorials.to_sort.scheduling |
---|
Fields in samples.tutorials.to_sort.scheduling declared as IntegerVariable | |
---|---|
protected IntegerVariable |
ResourceAllocation.objective
|
protected IntegerVariable[] |
ResourceAllocation.usages
|
Uses of IntegerVariable in samples.tutorials.to_sort.socialgolfer |
---|
Methods in samples.tutorials.to_sort.socialgolfer with parameters of type IntegerVariable | |
---|---|
SConstraint |
ScalarAtMost.ScalarAtMostManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
void |
ExSocialGolfer.printSol(IntegerVariable[][][] gvars,
Solver solver)
|
Uses of IntegerVariable in samples.tutorials.to_sort.tsp |
---|
Fields in samples.tutorials.to_sort.tsp declared as IntegerVariable | |
---|---|
protected IntegerVariable |
CycleMain.objective
|
Methods in samples.tutorials.to_sort.tsp with parameters of type IntegerVariable | |
---|---|
SConstraint |
SubTourConstraint.SubTourConstraintManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
SConstraint |
MinSpanningTree.MinSpanningTreeManager.makeConstraint(Solver solver,
IntegerVariable[] variables,
Object parameters,
List<String> options)
|
void |
CycleMain.solveProblem(samples.tutorials.to_sort.tsp.CycleMain.SolveType type,
IntegerVariable[] vars)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |