Uses of Class
choco.kernel.model.variables.integer.IntegerVariable

Packages that use IntegerVariable
choco   
choco.cp.common.util.preprocessor   
choco.cp.common.util.preprocessor.detector   
choco.cp.common.util.preprocessor.merger   
choco.cp.model   
choco.cp.model.managers return new ComponentConstraint(ConstraintType.ALLDIFFERENT, null, vars); * soit un type => dans ce cas il faut mettre ? 
choco.cp.model.managers.constraints.expressions   
choco.cp.model.managers.constraints.global   
choco.cp.model.managers.constraints.integer   
choco.cp.model.managers.variables   
choco.cp.solver   
choco.cp.solver.constraints.global.automata.fast_multicostregular.example   
choco.cp.solver.constraints.global.ordered   
choco.cp.solver.constraints.global.softscheduling   
choco.cp.solver.constraints.reified   
choco.cp.solver.constraints.reified.leaves   
choco.cp.solver.constraints.set   
choco.cp.solver.constraints.strong   
choco.cp.solver.preprocessor   
choco.kernel.common.util.tools   
choco.kernel.model The root package for the Constraint Programming Kernel.
choco.kernel.model.constraints   
choco.kernel.model.constraints.automaton.FA   
choco.kernel.model.constraints.cnf   
choco.kernel.model.constraints.geost.externalConstraints   
choco.kernel.model.constraints.pack   
choco.kernel.model.variables.geost   
choco.kernel.model.variables.integer   
choco.kernel.model.variables.scheduling   
choco.kernel.model.variables.set   
choco.kernel.model.variables.tree   
choco.kernel.solver   
choco.kernel.solver.constraints.global.scheduling   
choco.kernel.solver.constraints.reified   
parser.absconparseur.components   
parser.chocogen   
parser.flatzinc.ast.expression   
parser.instances   
samples   
samples.fastregular   
samples.jobshop   
samples.multicostregular   
samples.multicostregular.asap   
samples.multicostregular.asap.heuristics   
samples.multicostregular.carsequencing   
samples.multicostregular.nsp   
samples.multicostregular.planner   
samples.rackconfig   
samples.random   
samples.tutorials   
samples.tutorials.lns.lns   
samples.tutorials.puzzles   
samples.tutorials.scheduling   
samples.tutorials.to_sort   
samples.tutorials.to_sort.scheduling   
samples.tutorials.to_sort.socialgolfer   
samples.tutorials.to_sort.tsp   
 

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 = , and y = .
static Constraint Choco.lex(IntegerVariable[] v1, IntegerVariable[] v2)
          Enforce a strict lexicographic ordering on two vectors of integer variables x <_lex y with x = , and y = .
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 = , and y = .
static Constraint Choco.lexEq(IntegerVariable[] v1, IntegerVariable[] v2)
          Enforce a lexicographic ordering on two vectors of integer variables x <_lex y with x = , and y = .
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()
           
 

Constructors in choco.kernel.model.constraints.pack with parameters of type IntegerVariable
PackModel(IntegerVariable[] bins, IntegerConstantVariable[] sizes, int capacity)
           
PackModel(IntegerVariable[] bins, IntegerConstantVariable[] sizes, IntegerVariable[] loads)
           
PackModel(IntegerVariable[] bins, IntegerConstantVariable[] sizes, IntegerVariable[] loads)
           
PackModel(IntegerVariable[] bins, IntegerConstantVariable[] sizes, SetVariable[] items, IntegerVariable[] loads)
           
PackModel(IntegerVariable[] bins, IntegerConstantVariable[] sizes, SetVariable[] items, IntegerVariable[] loads)
           
PackModel(IntegerVariable[] bins, IntegerConstantVariable[] sizes, SetVariable[] items, IntegerVariable[] loads, IntegerVariable nbNonEmpty)
           
PackModel(IntegerVariable[] bins, IntegerConstantVariable[] sizes, SetVariable[] items, IntegerVariable[] loads, IntegerVariable nbNonEmpty)
           
PackModel(IntegerVariable[] bins, IntegerConstantVariable[] sizes, SetVariable[] items, IntegerVariable[] loads, IntegerVariable nbNonEmpty)
           
 

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)
           
 



Copyright © 2012. All Rights Reserved.