Uses of Interface
choco.kernel.model.constraints.Constraint

Packages that use Constraint
choco   
choco.cp.common.util.preprocessor   
choco.cp.common.util.preprocessor.detector   
choco.cp.common.util.preprocessor.detector.scheduling   
choco.cp.common.util.preprocessor.graph   
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   
choco.cp.model.managers.constraints.expressions   
choco.cp.model.managers.constraints.global   
choco.cp.model.managers.constraints.integer   
choco.cp.model.managers.operators   
choco.cp.model.managers.variables   
choco.cp.solver   
choco.cp.solver.constraints.set   
choco.cp.solver.constraints.strong   
choco.cp.solver.constraints.strong.xmlmodel   
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.pack   
choco.kernel.model.factories   
choco.kernel.model.variables   
choco.kernel.model.variables.integer   
choco.kernel.solver   
choco.visu.components.chart   
choco.visu.components.chart.ui   
parser.absconparseur.components   
parser.chocogen   
samples.jobshop   
samples.random   
samples.tutorials.lns.lns   
 

Uses of Constraint in choco
 

Fields in choco declared as Constraint
static Constraint Choco.FALSE
           
static Constraint Choco.TRUE
           
 

Methods in choco that return Constraint
static Constraint Choco.abs(IntegerVariable x, IntegerVariable y)
          Ensures x = Math.abs(y);
static Constraint Choco.allDifferent(IntegerVariable... vars)
          All different constraints with a global filtering : v1 !
static Constraint Choco.allDifferent(String options, IntegerVariable... vars)
          All different constraints with a global filtering : v1 !
static Constraint[] Reformulation.among(IntegerVariable[] variables, SetVariable s, IntegerVariable nvar)
          AMONG constraint reformulated like:
introducing BOOL variable for each VARIABLE, adding following constraints: for each VARIABLE : REIFIED(BOOL_i, MEMBER(VARIABLE_i, S)), EQ(SUM(BOOL), N),
static Constraint Choco.among(IntegerVariable var, int[] values)
          Deprecated. use member
static Constraint[] Reformulation.among(IntegerVariable nvar, IntegerVariable[] variables, int[] values)
          AMONG constraint reformulated like:
introducing BOOL variable for each VARIABLE, adding following constraints: for each VARIABLE : REIFIED(BOOL_i, AMONG(VARIABLE_i, VALUES)), EQ(SUM(BOOL), N),
static Constraint Choco.among(IntegerVariable nvar, IntegerVariable[] variables, int[] values)
          NVAR is the number of variables of the collection VARIABLES that take their value in VALUES.
static Constraint Choco.among(IntegerVariable nvar, IntegerVariable[] variables, SetVariable svar)
          NVAR is the number of variables of the collection VARIABLES that take their value in SVAR.
static Constraint Choco.and(Constraint... n)
           
static Constraint Choco.and(IntegerVariable... literals)
          A constraint for logical conjunction between boolean variables lit1 AND lit2 AND ...
static Constraint Choco.atMostNValue(IntegerVariable[] vars, IntegerVariable nvalue)
          Deprecated. reorder parameters
static Constraint Choco.atMostNValue(IntegerVariable nvalue, IntegerVariable[] vars)
          Enforce the number of distinct values among vars to be less than nvalue;
static Constraint Choco.boolChanneling(IntegerVariable b, IntegerVariable x, int j)
          State a simple channeling bewteen a boolean variable and an interger variable Ensures for that b = 1 iff x = j
static Constraint Choco.clause(IntegerVariable[] positiveLiterals, IntegerVariable[] negativeLiterals)
          A global constraint to store and propagate all clauses
static Constraint Choco.clause(String option, IntegerVariable[] positiveLiterals, IntegerVariable[] negativeLiterals)
          A global constraint to store and propagate all clauses The option can contain the folowing String : cp:entail ensure quick entailment tests
static Constraint[] Choco.clauses(ALogicTree tree)
          A global constraint to store and propagate all clauses extracted from a logic tree
static Constraint[] Choco.clauses(String option, ALogicTree tree)
          A global constraint to store and propagate all clauses extracted from a logic tree The option can contain the folowing String : cp:entail ensure quick entailment tests
static Constraint Choco.complementSet(SetVariable x, SetVariable y)
          complement(X) == Y
i.e.
static Constraint Choco.costRegular(IntegerVariable[] vars, IntegerVariable costVar, org.jgrapht.graph.DirectedMultigraph<Node,Arc> graph, Node source)
          Deprecated. reorder parameters
static Constraint Choco.costRegular(IntegerVariable[] vars, IntegerVariable costVar, IAutomaton auto, int[][][] costs)
          Deprecated. reorder parameters
static Constraint Choco.costRegular(IntegerVariable costVar, IntegerVariable[] vars, org.jgrapht.graph.DirectedMultigraph<Node,Arc> graph, Node source)
          costRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the costs associated to each assignment is bounded by the cost variable.
static Constraint Choco.costRegular(IntegerVariable costVar, IntegerVariable[] vars, IAutomaton auto, int[][] costs)
          costRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the costs associated to each assignment is bounded by the cost variable.
static Constraint Choco.costRegular(IntegerVariable costVar, IntegerVariable[] vars, IAutomaton auto, int[][][] costs)
          costRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the costs associated to each assignment is bounded by the cost variable.
static Constraint Choco.costRegular(IntegerVariable costVar, IntegerVariable[] vars, ICostAutomaton auto)
          costRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the costs associated to each assignment is bounded by the cost variable.
static Constraint DeprecatedChoco.cumulative(IntegerVariable[] starts, IntegerVariable[] ends, IntegerVariable[] durations, int[] heights, int capa, String... options)
          Deprecated. 
static Constraint DeprecatedChoco.cumulative(IntegerVariable[] starts, IntegerVariable[] ends, IntegerVariable[] durations, IntegerVariable[] heights, IntegerVariable capa, String... options)
          Deprecated. 
static Constraint DeprecatedChoco.cumulative(IntegerVariable[] starts, IntegerVariable[] durations, IntegerVariable[] heights, IntegerVariable capa, String... options)
          Deprecated. 
static Constraint DeprecatedChoco.cumulative(String name, IntegerVariable[] starts, IntegerVariable[] ends, IntegerVariable[] durations, IntegerVariable[] heights, IntegerVariable capa, String... options)
          Deprecated. 
static Constraint Choco.cumulative(String name, TaskVariable[] tasks, IntegerVariable[] heights, IntegerVariable[] usages, IntegerVariable consumption, IntegerVariable capacity, IntegerVariable uppBound, String... options)
          Builds Alternative cumulative Min-Max.
static Constraint Choco.cumulative(String name, TaskVariable[] tasks, IntegerVariable[] heights, IntegerVariable[] usages, IntegerVariable consumption, IntegerVariable capacity, String... options)
          Alternative Cumulative Min-Max : uppBound = null.
static Constraint Choco.cumulative(String name, TaskVariable[] tasks, IntegerVariable[] heights, IntegerVariable consumption, IntegerVariable capacity, String... options)
          Cumulative Min-Max : usages = null, uppBound = null.
static Constraint DeprecatedChoco.cumulative(String name, TaskVariable[] tasks, IntegerVariable[] heights, IntegerVariable capa, String... options)
          Deprecated. 
static Constraint DeprecatedChoco.cumulative(TaskVariable[] tasks, int[] heights, int capa, String... options)
          Deprecated. 
static Constraint Choco.cumulativeMax(String name, TaskVariable[] tasks, IntegerVariable[] heights, IntegerVariable[] usages, IntegerVariable capacity, String... options)
          Alternative Cumulative Max : consumption=0, uppBound = null.
static Constraint Choco.cumulativeMax(String name, TaskVariable[] tasks, IntegerVariable[] heights, IntegerVariable capacity, String... options)
          Cumulative Max : consumption=0, usages = null, uppBound = null.
static Constraint Choco.cumulativeMax(TaskVariable[] tasks, int[] heights, int capacity, String... options)
          Cumulative Max : consumption=0, usages = null, uppBound = null.
static Constraint Choco.cumulativeMin(String name, TaskVariable[] tasks, IntegerVariable[] heights, IntegerVariable[] usages, IntegerVariable consumption, String... options)
          Alternative Cumulative Min : capacity=infinity, uppBound = null.
static Constraint Choco.cumulativeMin(String name, TaskVariable[] tasks, IntegerVariable[] heights, IntegerVariable consumption, String... options)
          Cumulative Min : capacity=infinity, usages = null, uppBound = null.
static Constraint Choco.cumulativeMin(TaskVariable[] tasks, int[] heights, int consumption, String... options)
          Cumulative Min : capacity=infinity, usages = null, uppBound = null.
static Constraint Choco.disjoint(IntegerVariable var, int[] values)
          Deprecated. rename as notMember
static Constraint[] Choco.disjoint(TaskVariable[] tasks1, TaskVariable[] tasks2)
          Each task of the collection tasks1 should not overlap any task of the collection tasks2.
static Constraint DeprecatedChoco.disjunctive(IntegerVariable[] starts, int[] durations, String... options)
          Deprecated. 
static Constraint DeprecatedChoco.disjunctive(IntegerVariable[] starts, IntegerVariable[] ends, IntegerVariable[] durations, String... options)
          Deprecated. 
static Constraint DeprecatedChoco.disjunctive(IntegerVariable[] starts, IntegerVariable[] durations, String... options)
          Deprecated. 
static Constraint DeprecatedChoco.disjunctive(String name, IntegerVariable[] starts, IntegerVariable[] ends, IntegerVariable[] durations, IntegerVariable uppBound, String... options)
          Deprecated. 
static Constraint Choco.disjunctive(String name, TaskVariable[] tasks, IntegerVariable[] usages, IntegerVariable uppBound, String... options)
          Builds Alternative disjunctive.
static Constraint Choco.disjunctive(String name, TaskVariable[] tasks, IntegerVariable[] usages, String... options)
          Alternative Disjunctive : uppBound = null.
static Constraint Choco.disjunctive(String name, TaskVariable[] tasks, String... options)
          Disjunctive : usages = null, uppBound = null.
static Constraint Choco.disjunctive(TaskVariable[] tasks, IntegerVariable[] usages, String... options)
          Alternative Disjunctive : name = null, uppBound = null.
static Constraint[] Reformulation.disjunctive(TaskVariable[] clique, String... boolvarOptions)
          AMONG constraint reformulated like:
introducing BOOL variable for each VARIABLE, adding following constraints: for each VARIABLE : REIFIED(BOOL_i, AMONG(VARIABLE_i, VALUES)), EQ(SUM(BOOL), N),
static Constraint Choco.disjunctive(TaskVariable[] tasks, String... options)
          Disjunctive : name = null, usages = null, uppBound = null.
static Constraint Choco.distanceEQ(IntegerVariable x, IntegerVariable y, int c)
          Ensures |x-y| = c;
static Constraint Choco.distanceEQ(IntegerVariable x, IntegerVariable y, IntegerVariable z)
          Ensures |x-y| = z;
static Constraint Choco.distanceEQ(IntegerVariable x, IntegerVariable y, IntegerVariable z, int c)
          Ensures |x-y| = z + c;
static Constraint Choco.distanceGT(IntegerVariable x, IntegerVariable y, int c)
          Ensures |x-y| > c;
static Constraint Choco.distanceGT(IntegerVariable x, IntegerVariable y, IntegerVariable z)
          Ensures |x-y| > z;
static Constraint Choco.distanceGT(IntegerVariable x, IntegerVariable y, IntegerVariable z, int c)
          Ensures |x-y| > z + c;
static Constraint Choco.distanceLT(IntegerVariable x, IntegerVariable y, int c)
          Ensures |x-y| < c;
static Constraint Choco.distanceLT(IntegerVariable x, IntegerVariable y, IntegerVariable z)
          Ensures |x-y| < z;
static Constraint Choco.distanceLT(IntegerVariable x, IntegerVariable y, IntegerVariable z, int c)
          Ensures |x-y| < z + c;
static Constraint Choco.distanceNEQ(IntegerVariable x, IntegerVariable y, int c)
          Ensures |x-y| !
static Constraint Choco.domainChanneling(IntegerVariable x, IntegerVariable[] b)
          state a channeling between the domain of the variable x and the array of boolean variables b which enforce: x = i <=> b[i] = 1
static Constraint Choco.domainConstraint(IntegerVariable x, IntegerVariable[] b)
          Deprecated. see domainChannelling
static Constraint Choco.endsAfter(TaskVariable t, int min)
          This task ends after min
static Constraint Choco.endsAfterBegin(TaskVariable t1, TaskVariable t2)
          This task ends after the start of the task 2
static Constraint Choco.endsAfterBegin(TaskVariable t1, TaskVariable t2, int delta)
          Temporal constraint: end(t1) >= start(t2) + delta
static Constraint Choco.endsAfterEnd(TaskVariable t1, TaskVariable t2)
          Temporal constraint: end(t1) >= end(t2)
static Constraint Choco.endsAfterEnd(TaskVariable t1, TaskVariable t2, int delta)
          Temporal constraint: end(t1) >= end(t2) + delta
static Constraint Choco.endsAt(TaskVariable t, int time)
          This task ends at time.
static Constraint Choco.endsBefore(TaskVariable t, int max)
          This task ends before max
static Constraint Choco.endsBeforeBegin(TaskVariable t1, TaskVariable t2)
          Temporal constraint: end(t1)<= start(t2)
static Constraint Choco.endsBeforeBegin(TaskVariable t1, TaskVariable t2, int delta)
          Temporal constraint: end(t1) + delta <= start(t2)
static Constraint Choco.endsBeforeEnd(TaskVariable t1, TaskVariable t2)
          Temporal constraint: end(t1) <= end(t2)
static Constraint Choco.endsBeforeEnd(TaskVariable t1, TaskVariable t2, int delta)
          Temporal constraint: end(t1) + delta <= end(t2)
static Constraint Choco.endsBetween(TaskVariable t, int min, int max)
          This task ends between min and max
static Constraint Choco.eq(double c, RealExpressionVariable x)
          Return a constraint that ensures x == c
static Constraint Choco.eq(IntegerExpressionVariable x, int c)
          Return a constraint that ensure x == c
static Constraint Choco.eq(IntegerExpressionVariable x, IntegerExpressionVariable y)
          Return a constraint that ensure x == y
static Constraint Choco.eq(IntegerVariable i, RealVariable r)
          Return a constraint that ensures r == i
static Constraint Choco.eq(int c, IntegerExpressionVariable x)
          Return a constraint that ensure x == c
static Constraint Choco.eq(RealExpressionVariable x, double c)
          Return a constraint that ensures x == c
static Constraint Choco.eq(RealExpressionVariable x, RealExpressionVariable y)
          Return a constraint that ensures x == y
static Constraint Choco.eq(RealVariable r, IntegerVariable i)
          Return a constraint that ensures r == i
static Constraint Choco.eq(SetVariable sv1, SetVariable sv2)
          Return a constraint that ensures sv1 == sv2
static Constraint Choco.eqCard(SetVariable sv, int val)
          Return a constraint that ensures |sv| = val
static Constraint Choco.eqCard(SetVariable sv, IntegerVariable v)
          Return a constraint that ensures |sv| = v
static Constraint Choco.equation(IntegerVariable[] vars, int[] coeffs, int val)
          Deprecated. reorder parameters
static Constraint Choco.equation(IntegerVariable z, IntegerVariable[] vars, int[] coeffs)
          State a constraint to enforce GAC on Sum_i coeffs[i] * vars[i] = z.
static Constraint Choco.equation(int val, IntegerVariable[] vars, int[] coeffs)
          State a constraint to enforce GAC on Sum_i coeffs[i] * vars[i] = val.
static Constraint Choco.equation(String option, IntegerVariable z, IntegerVariable[] vars, int[] coeffs)
          State constraint Sum_i coeffs[i] * vars[i] = z.
static Constraint Choco.equation(String option, int val, IntegerVariable[] vars, int[] coeffs)
          State constraint Sum_i coeffs[i] * vars[i] = val.
static Constraint Choco.exactly(int occurrence, IntegerVariable[] variables, int value)
          Deprecated. see among
static Constraint Choco.feasPairAC(IntegerVariable v1, IntegerVariable v2, boolean[][] mat)
          Build a Table constraint defined extensionnaly by the set of feasibles pairs of values for the corresponding variables.
static Constraint Choco.feasPairAC(IntegerVariable v1, IntegerVariable v2, List<int[]> mat)
          Build a Table constraint defined extensionnaly by the set of feasibles pairs of values for the corresponding variables.
static Constraint Choco.feasPairAC(String options, IntegerVariable v1, IntegerVariable v2, boolean[][] mat)
          Build a Table constraint defined extensionnaly by the set of feasibles pairs of values for the corresponding variables
static Constraint Choco.feasPairAC(String options, IntegerVariable v1, IntegerVariable v2, List<int[]> mat)
          Build a Table constraint defined extensionnaly by the set of feasibles pairs of values for the corresponding variables
static Constraint Choco.feasTupleAC(List<int[]> tuples, IntegerVariable... vars)
          Create a constraint enforcing Arc Consistency on a given a given list of feasible tuples
static Constraint Choco.feasTupleAC(String options, List<int[]> tuples, IntegerVariable... vars)
          Create a constraint enforcing Arc Consistency on a given a given list of feasible tuples
static Constraint Choco.feasTupleFC(List<int[]> tuples, IntegerVariable... vars)
          Create a constraint enforcing Forward Checking on a given a given list of feasible tuples
static Constraint Choco.forbiddenIntervals(String name, TaskVariable[] tasks)
          This redundant constraints applies additional search tree reduction based on Time intervals are in which no operation can start or end in an optimal solution.
static Constraint Choco.geost(int dim, List<GeostObject> objects, List<ShiftedBox> shiftedBoxes, List<IExternalConstraint> eCtrs)
           
static Constraint Choco.geost(int dim, List<GeostObject> objects, List<ShiftedBox> shiftedBoxes, List<IExternalConstraint> eCtrs, List<int[]> ctrlVs)
           
static Constraint Choco.geost(int dim, List<GeostObject> objects, List<ShiftedBox> shiftedBoxes, List<IExternalConstraint> eCtrs, List<int[]> ctrlVs, GeostOptions opt)
           
static Constraint Choco.geost(int dim, Vector<GeostObject> objects, Vector<ShiftedBox> shiftedBoxes, Vector<IExternalConstraint> eCtrs)
          Deprecated. 
static Constraint Choco.geost(int dim, Vector<GeostObject> objects, Vector<ShiftedBox> shiftedBoxes, Vector<IExternalConstraint> eCtrs, Vector<int[]> ctrlVs)
          Deprecated. 
static Constraint Choco.geost(int dim, Vector<GeostObject> objects, Vector<ShiftedBox> shiftedBoxes, Vector<IExternalConstraint> eCtrs, Vector<int[]> ctrlVs, GeostOptions opt)
          Deprecated. 
static Constraint Choco.geq(double c, RealExpressionVariable x)
           
static Constraint Choco.geq(IntegerExpressionVariable x, int c)
           
static Constraint Choco.geq(IntegerExpressionVariable x, IntegerExpressionVariable y)
           
static Constraint Choco.geq(int c, IntegerExpressionVariable x)
           
static Constraint Choco.geq(RealExpressionVariable x, double c)
           
static Constraint Choco.geq(RealExpressionVariable x, RealExpressionVariable y)
           
static Constraint Choco.geqCard(SetVariable sv, int val)
           
static Constraint Choco.geqCard(SetVariable sv, IntegerVariable v)
           
static Constraint Choco.globalCardinality(IntegerVariable[] vars, int[] low, int[] up, int offset)
          Concerns GCC and boundGCC

Global cardinality : Given an array of variables vars, the constraint ensures that the number of occurences of the value i among the variables is between low[i - min] and up[i - min].

static Constraint Choco.globalCardinality(IntegerVariable[] vars, int[] values, int[] low, int[] up)
          Concerns GCC and boundGCC

Global cardinality : Given an array of variables vars, and an array of values, the constraint ensures that the number of occurences of the value i among the variables is between low[i] and up[i].

static Constraint Choco.globalCardinality(IntegerVariable[] vars, int[] values, IntegerVariable[] cards)
          * Bound Global cardinality : Given an array of variables vars, an array of values, an array of variables card to represent the cardinalities, the constraint ensures that the number of occurences of the value i among the variables is equal to card[i].
static Constraint Choco.globalCardinality(IntegerVariable[] vars, IntegerVariable[] card, int offset)
          * Bound Global cardinality : Given an array of variables vars, an array of variables card to represent the cardinalities, the constraint ensures that the number of occurences of the value i among the variables is equal to card[i].
static Constraint Choco.globalCardinality(IntegerVariable[] vars, int min, int max, int[] low, int[] up)
          Deprecated.  
static Constraint Choco.globalCardinality(IntegerVariable[] vars, int min, int max, IntegerVariable[] card)
          Deprecated.  
static Constraint Choco.globalCardinality(String options, IntegerVariable[] vars, int[] low, int[] up, int offset)
          Concerns GCC and boundGCC

Global cardinality : Given an array of variables vars, the constraint ensures that the number of occurences of the value i among the variables is between low[i - min] and up[i - min].

static Constraint Choco.globalCardinality(String options, IntegerVariable[] vars, int min, int max, int[] low, int[] up)
          Deprecated.  
static Constraint Choco.gt(IntegerExpressionVariable x, int c)
          Return a constraint that ensures x > c
static Constraint Choco.gt(IntegerExpressionVariable x, IntegerExpressionVariable y)
          Return a constraint that ensures x > y
static Constraint Choco.gt(int c, IntegerExpressionVariable x)
          Return a constraint that ensures c > x
static Constraint Choco.ifOnlyIf(Constraint n1, Constraint n2)
           
static Constraint Choco.ifThenElse(Constraint n1, Constraint n2, Constraint n3)
           
static Constraint Choco.implies(Constraint n1, Constraint n2)
           
static Constraint Choco.increasing_nvalue(IntegerVariable nval, IntegerVariable[] vars)
          Deprecated. use increasingNValue
static Constraint Choco.increasing_nvalue(String option, IntegerVariable nval, IntegerVariable[] vars)
          Deprecated. use increasingNValue
static Constraint Choco.increasingNValue(IntegerVariable nval, IntegerVariable[] vars)
          The variables of the collection VARIABLES are increasing.
static Constraint Choco.increasingNValue(String option, IntegerVariable nval, IntegerVariable[] vars)
          The variables of the collection VARIABLES are increasing.
static Constraint Choco.increasingSum(IntegerVariable[] variables, IntegerVariable sum)
          A sum constraint with increasing variables
s = x_0 + x_1 + ... + x_(n-1)
and x_0 <= x_1 <= ... <= x_(n-1)

Bounds-consistency algorithm linear in n (the number of variables)

static Constraint Choco.infeasPairAC(IntegerVariable v1, IntegerVariable v2, boolean[][] mat)
          Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables.
static Constraint Choco.infeasPairAC(IntegerVariable v1, IntegerVariable v2, List<int[]> mat)
          Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables.
static Constraint Choco.infeasPairAC(String options, IntegerVariable v1, IntegerVariable v2, boolean[][] mat)
          Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables
static Constraint Choco.infeasPairAC(String options, IntegerVariable v1, IntegerVariable v2, List<int[]> mat)
          Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables
static Constraint Choco.infeasTupleAC(List<int[]> tuples, IntegerVariable... vars)
          Create a constraint enforcing Arc Consistency on a given a given list of infeasible tuples
static Constraint Choco.infeasTupleAC(String options, List<int[]> tuples, IntegerVariable... vars)
          Create a constraint enforcing Arc Consistency on a given a given list of infeasible tuples
static Constraint Choco.infeasTupleFC(List<int[]> tuples, IntegerVariable... vars)
          Create a constraint enforcing Forward Checking on a given a given list of infeasible tuples
static Constraint Choco.intDiv(IntegerVariable x, IntegerVariable y, IntegerVariable z)
          Enforce z = x / y
static Constraint Choco.inverseChanneling(IntegerVariable[] x, IntegerVariable[] y)
          State a channeling bewteen two arrays of integer variables x and y with the same domain which enforces x[i] = j <=> y[j] = i
static Constraint Choco.inverseChannelingWithinRange(IntegerVariable[] x, IntegerVariable[] y)
          State a channeling bewteen two arrays of integer variables x and y with the same domain which enforces:
- if the ith variable of the collection X is assigned to j and if j is less than or equal to the number of items of the collection Y then the jth variable of the collection Y is assigned to i.
static Constraint Choco.inverseSet(IntegerVariable[] iv, SetVariable[] sv)
          A constraint stating that value j belongs to the sv[i] set variable iff integer variable iv[j] equals to i.
static Constraint Choco.inverseSet(SetVariable[] xs, SetVariable[] ys)
          X collection set-variable
Y collection set-variable

Y should have enough slots to handle X domain size (ie.

static Constraint Choco.isIncluded(SetVariable sv1, SetVariable sv2)
          Checks that variable sv1 is included in sv2
static Constraint Choco.isNotIncluded(SetVariable sv1, SetVariable sv2)
          Checks that variable sv1 is not included in sv2
static Constraint Choco.knapsackProblem(IntegerVariable[] vars, IntegerVariable costVar, IntegerVariable weightVar, int[] costs, int[] weights)
          Deprecated. reorder parameters
static Constraint Choco.knapsackProblem(IntegerVariable costVar, IntegerVariable weightVar, IntegerVariable[] vars, int[] costs, int[] weights)
          The knapsack problem constraint ensures that costVar is the sum of the vars weighted by the costs and that weightVar is the sum of vars weighted by the weights Based on costRegular, it simulates Tricks's dynamic programming approach.
static Constraint Choco.leq(double c, RealExpressionVariable x)
           
static Constraint Choco.leq(IntegerExpressionVariable x, int c)
           
static Constraint Choco.leq(IntegerExpressionVariable x, IntegerExpressionVariable y)
           
static Constraint Choco.leq(int c, IntegerExpressionVariable x)
           
static Constraint Choco.leq(RealExpressionVariable x, double c)
           
static Constraint Choco.leq(RealExpressionVariable x, RealExpressionVariable y)
           
static Constraint Choco.leqCard(SetVariable sv, int val)
           
static Constraint Choco.leqCard(SetVariable sv, IntegerVariable v)
           
static Constraint Choco.lex(IntegerVariable[] v1, IntegerVariable[] v2)
          Enforce a strict lexicographic ordering on two vectors of integer variables x <_lex y with x = , 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)
          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.lt(IntegerExpressionVariable x, int c)
          Return a constraint that ensures x < c
static Constraint Choco.lt(IntegerExpressionVariable x, IntegerExpressionVariable y)
          Return a constraint that ensures x < y
static Constraint Choco.lt(int c, IntegerExpressionVariable x)
          Return a constraint that ensures x < c
static Constraint Choco.max(IntegerVariable[] vars, IntegerVariable max)
          Ensures the variable "max" to represent the maximum value that occurs in the list vars
static Constraint Choco.max(IntegerVariable x, IntegerVariable y, IntegerVariable max)
          Ensures the variable "max" to represent the maximum value of x and y.
static Constraint Choco.max(IntegerVariable x, int y, IntegerVariable max)
          Ensures the variable "max" to represent the maximum value of x and y.
static Constraint Choco.max(int x, IntegerVariable y, IntegerVariable max)
          Ensures the variable "max" to represent the maximum value of x and y.
static Constraint Choco.max(SetVariable svar, IntegerVariable[] ivars, IntegerVariable min, String... options)
          Ensures the variable min to represent the maximum value in ivars that occurs in the sublist associated with set.
static Constraint Choco.member(IntegerVariable var, int[] values)
          VAR takes it value in VALUES
static Constraint Choco.member(IntegerVariable var, int lower, int upper)
          VAR takes it value between LOWER and UPPER
static Constraint Choco.member(IntegerVariable var, SetVariable sv1)
          Ensures that the value of an integer variable is contained in a set variable.
static Constraint Choco.member(int val, SetVariable sv1)
          Ensures that a value is contained in a set variable.
static Constraint Choco.member(SetVariable sv1, int val)
          Ensures that a value is contained in a set variable.
static Constraint Choco.member(SetVariable sv, IntegerVariable... vars)
          Ensures that the values of integer variables are contained in a set variable.
static Constraint Choco.member(SetVariable sv1, IntegerVariable var)
          Ensures that the value of an integer variable is contained in a set variable.
static Constraint Choco.min(IntegerVariable[] vars, IntegerVariable min)
          Ensures the variable "min" to represent the minimum value that occurs in the list vars
static Constraint Choco.min(IntegerVariable x, IntegerVariable y, IntegerVariable min)
          Ensures the variable "min" to represent the minimum value of x and y.
static Constraint Choco.min(IntegerVariable x, int y, IntegerVariable min)
          Ensures the variable "min" to represent the minimum value of x and y.
static Constraint Choco.min(int x, IntegerVariable y, IntegerVariable min)
          Ensures the variable "min" to represent the minimum value of x and y.
static Constraint Choco.min(SetVariable svar, IntegerVariable[] ivars, IntegerVariable min, String... options)
          Ensures the variable min to represent the minimum value in ivars that occurs in the sublist associated with set.
static Constraint Choco.mod(IntegerVariable v0, IntegerVariable v1, int c)
           
static Constraint Choco.multiCostRegular(IntegerVariable[] costVars, IntegerVariable[] vars, IAutomaton auto, int[][][] costs)
          multiCostRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the cost vectors associated to each assignment is bounded by the cost variable vector
static Constraint Choco.multiCostRegular(IntegerVariable[] costVars, IntegerVariable[] vars, IAutomaton auto, int[][][][] costs)
          multiCostRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the cost vectors associated to each assignment is bounded by the cost variable vector.
static Constraint Choco.multiCostRegular(IntegerVariable[] costVars, IntegerVariable[] vars, ICostAutomaton auto)
          multiCostRegular constraint ensures that the assignment of a sequence of variables is recognized by a DFA and that the sum of the cost vectors associated to each assignment is bounded by the cost variable vector.
static Constraint Choco.nand(Constraint... n)
           
static Constraint Choco.nand(IntegerVariable... literals)
          A constraint for logical conjunction between boolean variables lit1 NAND lit2 NAND ...
static Constraint Choco.neq(IntegerExpressionVariable x, int c)
          Creates a constraint by stating that a term is not equal than a constant
static Constraint Choco.neq(IntegerExpressionVariable x, IntegerExpressionVariable y)
           
static Constraint Choco.neq(int c, IntegerExpressionVariable x)
           
static Constraint Choco.neq(SetVariable sv1, SetVariable sv2)
          Ensure that the two variables are not equal (not exactly the same values in the set)
static Constraint Choco.neqCard(SetVariable sv, int val)
          Return a constraint that ensures |sv| !
static Constraint Choco.neqCard(SetVariable sv, IntegerVariable v)
          Return a constraint that ensures |sv| !
static Constraint Choco.nor(Constraint... n)
           
static Constraint Choco.nor(IntegerVariable... literals)
          A constraint for logical conjunction between boolean variables lit1 NOR lit2 NOR ...
static Constraint Choco.not(Constraint n)
           
static Constraint Choco.notMember(IntegerVariable var, int[] values)
          VAR takes it value out of VALUES
static Constraint Choco.notMember(IntegerVariable var, int lower, int upper)
          VAR does not take it value between LOWER and UPPER
static Constraint Choco.notMember(IntegerVariable var, SetVariable sv1)
          Ensures that the value of an integer variable is not contained in a set variable.
static Constraint Choco.notMember(int val, SetVariable sv1)
          Ensures that a value is not contained ina set variable.
static Constraint Choco.notMember(SetVariable sv1, int val)
          Ensures that a value is not contained ina set variable.
static Constraint Choco.notMember(SetVariable sv1, IntegerVariable var)
          Ensures that the value of an integer variable is not contained in a set variable.
static Constraint Choco.nth(IntegerVariable index, int[] values, IntegerVariable val)
          subscript constraint: accessing an array with a variable index
static Constraint Choco.nth(IntegerVariable index, int[] values, IntegerVariable val, int offset)
          subscript constraint: accessing an array with a variable index The offset can be used when the index variable needs to be shifted of a given value (the offset)
static Constraint Choco.nth(IntegerVariable index, IntegerVariable[] varArray, IntegerVariable val)
          subscript constraint: accessing an array of variables with a variable index
static Constraint Choco.nth(IntegerVariable index, IntegerVariable[] varArray, IntegerVariable val, int offset)
          subscript constraint: accessing an array of variables with a variable index The offset can be used when the index variable needs to be shifted of a given value (the offset)
static Constraint Choco.nth(IntegerVariable index, IntegerVariable index2, int[][] varArray, IntegerVariable val)
          subscript constraint: accessing a matix of variables with two variables indexes
static Constraint Choco.nth(String options, IntegerVariable index, int[] values, IntegerVariable val)
          subscript constraint: accessing an array with a variable index
static Constraint Choco.nth(String options, IntegerVariable index, int[] values, IntegerVariable val, int offset)
          subscript constraint: accessing an array with a variable index The offset can be used when the index variable needs to be shifted of a given value (the offset)
static Constraint Choco.nth(String option, IntegerVariable index, IntegerVariable[] varArray, IntegerVariable val)
          subscript constraint: accessing an array of variables with a variable index
static Constraint Choco.nth(String options, IntegerVariable index, IntegerVariable[] varArray, IntegerVariable val, int offset)
          subscript constraint: accessing an array of variables with a variable index The offset can be used when the index variable needs to be shifted of a given value (the offset)
static Constraint DeprecatedChoco.occurenceMax(int value, IntegerVariable occurence, IntegerVariable... vars)
          Deprecated. 
static Constraint DeprecatedChoco.occurenceMin(int value, IntegerVariable occurence, IntegerVariable... vars)
          Deprecated. 
static Constraint Choco.occurrence(IntegerVariable occurrence, IntegerVariable[] vars, int value)
          Ensures that the occurrence variable contains the number of occurrences of the given value in the list of variables
static Constraint Choco.occurrence(int occurrence, IntegerVariable[] variables, int value)
          Ensures that N variables of the VARIABLES collection are assigned to value VALUE.
static Constraint Choco.occurrence(int value, IntegerVariable occurrence, IntegerVariable... vars)
          Ensures that the occurrence variable contains the number of occurrences of the given value in the list of variables
static Constraint Choco.occurrenceMax(IntegerVariable occurrence, IntegerVariable[] vars, int value)
          Ensures that the upper bound of occurrence is at least equal to the number of occurrences size{forall v in vars | v = value} <= occurrence
static Constraint Choco.occurrenceMax(int value, IntegerVariable occurrence, IntegerVariable... vars)
          Ensures that the upper bound of occurrence is at least equal to the number of occurrences size{forall v in vars | v = value} <= occurrence
static Constraint Choco.occurrenceMin(IntegerVariable occurrence, IntegerVariable[] vars, int value)
          Ensures that the lower bound of occurrence is at most equal to the number of occurrences size{forall v in vars | v = value} >= occurrence
static Constraint Choco.occurrenceMin(int value, IntegerVariable occurrence, IntegerVariable... vars)
          Ensures that the lower bound of occurrence is at most equal to the number of occurrences size{forall v in vars | v = value} >= occurrence
static Constraint Choco.oppositeSign(IntegerExpressionVariable n1, IntegerExpressionVariable n2)
           
static Constraint Choco.or(Constraint... n)
           
static Constraint Choco.or(IntegerVariable... literals)
          A constraint for logical disjunction between boolean variables lit1 OR lit2 OR ...
static Constraint Choco.pack(PackModel packMod, String... options)
           
static Constraint Choco.pack(SetVariable[] itemSets, IntegerVariable[] loads, IntegerVariable[] bins, IntegerConstantVariable[] sizes, IntegerVariable nbNonEmpty, String... options)
           
static Constraint Choco.precedence(TaskVariable t1, TaskVariable t2)
          T1 ends before t2 starts or t1 precedes t2.
static Constraint Choco.precedence(TaskVariable t1, TaskVariable t2, int delta)
          T1 ends before t2 starts or t1 precedes t2.
static Constraint Choco.precedenceDisjoint(IntegerVariable v1, int dur1, IntegerVariable v2, int dur2, IntegerVariable bool)
           direction = 1 => v1 + dur1 <= v2 (T1 << T2); direction = 0 => v2 + dur2 <= v1 (T2 << T1);
static Constraint Choco.precedenceDisjoint(TaskVariable t1, TaskVariable t2, IntegerVariable direction)
          represents a disjunction without setup times
static Constraint Choco.precedenceDisjoint(TaskVariable t1, TaskVariable t2, IntegerVariable direction, int forwardSetup, int backwardSetup)
          precedence disjoint with setup times: direction = 1 => t1.end() + forwardSetup <= t2.start() (T1 << T2); direction = 0 => t2.end() + backwardSetup <= t1.start() (T2 << T1);
static Constraint Choco.precedenceImplied(IntegerVariable x1, int k1, IntegerVariable x2, IntegerVariable b)
          represents an implied precedence: b = 1 => x1 + k1 <= x2 b = 0 => TRUE
static Constraint Choco.precedenceImplied(TaskVariable t1, int delta, TaskVariable t2, IntegerVariable b)
          represents a reidied precedence with setup times between a pair of tasks: b = 1 => e1 + delta <= s2 b = 0 => TRUE;
static Constraint Choco.precedenceReified(IntegerVariable x1, int k1, IntegerVariable x2, IntegerVariable b)
          represents a reidied precedence: b = 1 => x1 + k1 <= x2 b = 0 => x1 + k1 > x2
static Constraint Choco.precedenceReified(TaskVariable t1, int delta, TaskVariable t2, IntegerVariable b)
          represents a reidied precedence with setup times between a pair of tasks: b = 1 => e1 + delta <= s2 b = 0 => e1 + delta > s2
static Constraint DeprecatedChoco.preceding(IntegerVariable v1, int dur1, IntegerVariable v2, int dur2, IntegerVariable bool)
          Deprecated. 
static Constraint DeprecatedChoco.preceding(TaskVariable t1, TaskVariable t2)
          Deprecated. 
static Constraint DeprecatedChoco.preceding(TaskVariable t1, TaskVariable t2, IntegerVariable direction)
          Deprecated. 
static Constraint Choco.regular(DFA auto, IntegerVariable[] vars)
          Deprecated. reorder parameters
static Constraint Choco.regular(IAutomaton auto, IntegerVariable[] vars)
          Deprecated. reorder parameters
static Constraint Choco.regular(IntegerVariable[] vars, DFA auto)
          Create a Regular constraint that enforce the sequence of variables to be a word recognized by the dfa auto.
static Constraint Choco.regular(IntegerVariable[] vars, IAutomaton auto)
          Create a Regular constraint that enforce the sequence of variables to be a word recognized by the dfa auto.
static Constraint Choco.regular(IntegerVariable[] vars, List<int[]> tuples)
          A Regular constraint based on a DFA which is built from a list of FEASIBLE tuples.
static Constraint Choco.regular(IntegerVariable[] vars, List<int[]> tuples, int[] min, int[] max)
          A Regular constraint based on a DFA which is built from a list of INFEASIBLE tuples As the relation is defined by infeasible tuples and we build the feasible automaton, we need to know the range of values by the max and min fields...
static Constraint Choco.regular(IntegerVariable[] vars, String regexp)
          Create a Regular constraint that enforce the sequence of variables to match the regular expression.
static Constraint Choco.regular(String regexp, IntegerVariable[] vars)
          Deprecated. reorder parameters
static Constraint Choco.reifiedAnd(IntegerVariable binVar, IntegerVariable... literals)
          A reified constraint for logical conjunction between boolean variables binVar = lit1 AND lit2 AND ...
static Constraint Choco.reifiedConstraint(IntegerVariable binVar, Constraint cst)
           
static Constraint Choco.reifiedConstraint(IntegerVariable binVar, Constraint cst, Constraint oppCst)
           
static Constraint Choco.reifiedIntConstraint(IntegerVariable binVar, Constraint cst)
          Deprecated. 
static Constraint Choco.reifiedIntConstraint(IntegerVariable binVar, Constraint cst, Constraint oppCst)
          Deprecated. 
static Constraint Choco.reifiedLeftImp(IntegerVariable binVar, IntegerVariable lit1, IntegerVariable lit2)
          A reified constraint for reverse implication binVar = lit1 implies lit2
static Constraint Choco.reifiedNand(IntegerVariable binVar, IntegerVariable... literals)
          A reified constraint for logical conjunction between boolean variables binVar = lit1 NAND lit2 NAND ...
static Constraint Choco.reifiedNor(IntegerVariable binVar, IntegerVariable... literals)
          A reified constraint for logical conjunction between boolean variables binVar = lit1 NOR lit2 NOR ...
static Constraint Choco.reifiedNot(IntegerVariable binVar, IntegerVariable lit)
          A reified constraint for logical negation binVar = NOT(lit)
static Constraint Choco.reifiedOr(IntegerVariable binVar, IntegerVariable... literals)
          A reified constraint for logical disjunction between boolean variables binVar = lit1 OR lit2 OR ...
static Constraint Choco.reifiedRightImp(IntegerVariable binVar, IntegerVariable lit1, IntegerVariable lit2)
          A reified constraint for forward implication binVar = lit2 implies lit1
static Constraint Choco.reifiedXnor(IntegerVariable binVar, IntegerVariable lit1, IntegerVariable lit2)
          A reified constraint for logical equality binVar = lit1 XNOR lit2
static Constraint Choco.reifiedXor(IntegerVariable binVar, IntegerVariable lit1, IntegerVariable lit2)
          A reified constraint for logical exclusive disjunction between boolean variables binVar = lit1 XOR lit2
static Constraint Choco.relationPairAC(IntegerVariable v1, IntegerVariable v2, BinRelation binR)
          Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables.
static Constraint Choco.relationPairAC(String options, IntegerVariable v1, IntegerVariable v2, BinRelation binR)
          Build a Table constraint defined extensionnaly by the set of infeasibles pairs of values for the corresponding variables
static Constraint Choco.relationTupleAC(IntegerVariable[] vs, LargeRelation rela)
          Create a constraint enforcing Arc Consistency on a given consistency relation defined by infeasible tuples.
static Constraint Choco.relationTupleAC(String options, IntegerVariable[] vs, LargeRelation rela)
           
static Constraint Choco.relationTupleFC(IntegerVariable[] vs, LargeRelation rela)
          Create a constraint enforcing Forward Checking on a given consistency relation
static Constraint Choco.sameSign(IntegerExpressionVariable n1, IntegerExpressionVariable n2)
           
static Constraint Choco.setDisjoint(SetVariable... sv)
          Ensure every set of sv are disjoints from each other.
static Constraint Choco.setInter(SetVariable sv1, SetVariable sv2, SetVariable inter)
          Enforce a set to be the intersection of two others.
static Constraint Choco.setLex(SetVariable x, SetVariable y)
          X <=lex Y
static Constraint Choco.setUnion(SetVariable[] sv, SetVariable union)
          Enforce a set to be the union of n others
static Constraint Choco.setUnion(SetVariable sv1, SetVariable sv2, SetVariable union)
          Enforce a set to be the union of two others
static Constraint Choco.setValuePrecede(SetVariable[] sv, int s, int t)
          If there exists a set variable v1 of VARIABLES such that S does not belong to v1 and T does, then there also exists a set variable v2 preceding v1 such that S belongs to v2 and T does not.
static Constraint Choco.softMultiCostRegular(IntegerVariable[] vars, IntegerVariable[] counters, IntegerVariable[] penaltyVars, IntegerVariable globalPenalty, IPenaltyFunction[] pfunction, IAutomaton auto, int[][][][] costs)
           
static Constraint Choco.softMultiCostRegular(IntegerVariable[] vars, IntegerVariable[] counters, IntegerVariable[] penaltyVars, IntegerVariable globalPenalty, IPenaltyFunction[] pfunction, IAutomaton auto, int[][][][] costs, int... sumDimension)
           
static Constraint Choco.sorting(IntegerVariable[] v1, IntegerVariable[] v2)
          Let x and x' be two vectors of variables of the same length, and v be an instantiation.
static Constraint Choco.startsAfter(TaskVariable t, int min)
          This task begins before max
static Constraint Choco.startsAfterBegin(TaskVariable t1, TaskVariable t2)
          Temporal constraint : start(t1) >= start(t2)
static Constraint Choco.startsAfterBegin(TaskVariable t1, TaskVariable t2, int delta)
          Temporal constraint : start(t1) >= start(t2) +delta
static Constraint Choco.startsAfterEnd(TaskVariable t1, TaskVariable t2)
          Temporal constraint: start(t1) >= end(t2)
static Constraint Choco.startsAfterEnd(TaskVariable t1, TaskVariable t2, int delta)
          Temporal constraint: start(t1) >= end(t2) + delta
static Constraint Choco.startsAt(TaskVariable t, int time)
          This task starts at time.
static Constraint Choco.startsBefore(TaskVariable t, int max)
          This task starts before max
static Constraint Choco.startsBeforeBegin(TaskVariable t1, TaskVariable t2)
          Temporal constraint : start(t1) <= start(s2)
static Constraint Choco.startsBeforeBegin(TaskVariable t1, TaskVariable t2, int delta)
          Temporal constraint : start(t1) +delta <= start(s2)
static Constraint Choco.startsBeforeEnd(TaskVariable t1, TaskVariable t2)
          Temporal constraint : start(t1) + delta <= end(t2)
static Constraint Choco.startsBeforeEnd(TaskVariable t1, TaskVariable t2, int delta)
          Temporal constraint : start(t1) + delta <= end(t2)
static Constraint Choco.startsBetween(TaskVariable t, int min, int max)
          This task ends between min and max
static Constraint Choco.stretchPath(List<int[]> stretchesParameters, IntegerVariable... vars)
          Enforce the minimal and maximal sizes of the streches of any value given in strechesParameters.
static Constraint Choco.times(IntegerVariable x, IntegerVariable y, IntegerVariable z)
          Enforce z = x * y
static Constraint Choco.times(IntegerVariable x, int y, IntegerVariable z)
          Enforce z = x * y
static Constraint Choco.times(int x, IntegerVariable y, IntegerVariable z)
          Enforce z = x * y
protected static Constraint Choco.timeWindow(IntegerVariable var, int min, int max)
           
static Constraint Choco.tree(TreeParametersObject param)
           
static Constraint ChocoContrib.useResource(TaskVariable task, Constraint... resources)
           
static Constraint ChocoContrib.useResourceGeq(TaskVariable task, Constraint... resources)
           
static Constraint ChocoContrib.useResources(TaskVariable task, int k, Constraint... resources)
           
static Constraint ChocoContrib.useResourcesGeq(TaskVariable task, int k, Constraint... resources)
           
static Constraint Choco.xnor(IntegerVariable lit1, IntegerVariable lit2)
          A reified constraint for logical equality lit1 XNOR lit2
static Constraint Choco.xor(IntegerVariable lit1, IntegerVariable lit2)
          A reified constraint for logical exclusive disjunctive lit1 XOR lit2
 

Methods in choco with parameters of type Constraint
static Constraint Choco.and(Constraint... n)
           
static Constraint Choco.ifOnlyIf(Constraint n1, Constraint n2)
           
static Constraint Choco.ifThenElse(Constraint n1, Constraint n2, Constraint n3)
           
static IntegerExpressionVariable Choco.ifThenElse(Constraint n1, IntegerExpressionVariable n2, IntegerExpressionVariable n3)
           
static Constraint Choco.implies(Constraint n1, Constraint n2)
           
static Constraint Choco.nand(Constraint... n)
           
static Constraint Choco.nor(Constraint... n)
           
static Constraint Choco.not(Constraint n)
           
static Constraint Choco.or(Constraint... n)
           
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 ChocoContrib.useResource(TaskVariable task, Constraint... resources)
           
static Constraint ChocoContrib.useResourceGeq(TaskVariable task, Constraint... resources)
           
static Constraint ChocoContrib.useResources(TaskVariable task, int k, Constraint... resources)
           
static Constraint ChocoContrib.useResourcesGeq(TaskVariable task, int k, Constraint... resources)
           
 

Uses of Constraint in choco.cp.common.util.preprocessor
 

Fields in choco.cp.common.util.preprocessor with type parameters of type Constraint
protected  gnu.trove.TLongObjectHashMap<Constraint> AbstractAdvancedDetector.constraintsToAdd
          Internal structure to store constraint addition instructions
protected  gnu.trove.TLongObjectHashMap<Constraint> AbstractAdvancedDetector.constraintsToDelete
          Internal structure to store constraint deletion instructions
 

Methods in choco.cp.common.util.preprocessor with parameters of type Constraint
protected  void AbstractAdvancedDetector.add(Constraint c)
          Add a constraint c to the model which is currently treated by the detector.
protected  void AbstractAdvancedDetector.delete(Constraint c)
          Delete a constraint c to the model which is currently treated by the detector.
protected  void AbstractAdvancedDetector.forget(Constraint c)
          Remove addition instruction on c.
protected  void AbstractAdvancedDetector.keep(Constraint c)
          Remove deletion instruction on c.
 

Uses of Constraint in choco.cp.common.util.preprocessor.detector
 

Methods in choco.cp.common.util.preprocessor.detector with parameters of type Constraint
protected abstract  void AbstractIntegerVariableEqualitiesDetector.action(Constraint c)
          Do an action on c, depending on implementation.
protected  void AbstractIntegerVariableEqualitiesDetector.IntegerVariableEqualitiesSolverDetector.action(Constraint c)
          Delete link between Model object and Solver object.
protected  void AbstractIntegerVariableEqualitiesDetector.IntegerVariableEqualitiesModelDetector.action(Constraint c)
          Store deletion instruction of c
 void AbstractGraphBasedDetector.addEdge(Variable a, Variable b, Constraint c)
           
 

Uses of Constraint in choco.cp.common.util.preprocessor.detector.scheduling
 

Methods in choco.cp.common.util.preprocessor.detector.scheduling with parameters of type Constraint
protected  void AbstractTemporalDetector.apply(Constraint c)
           
protected  void AbstractRscDetector.apply(Constraint ct)
           
protected  boolean AbstractTemporalDetector.isInPreprocess(Constraint c)
           
protected  boolean AbstractRscDetector.isInPreprocess(Constraint c)
           
 

Uses of Constraint in choco.cp.common.util.preprocessor.graph
 

Fields in choco.cp.common.util.preprocessor.graph with type parameters of type Constraint
 gnu.trove.THashMap<ArrayGraph.Edge,Constraint> ArrayGraph.storeEdges
           
 

Methods in choco.cp.common.util.preprocessor.graph that return Constraint
 Constraint ArrayGraph.getConstraintEdge(int a, int b)
           
 

Methods in choco.cp.common.util.preprocessor.graph with parameters of type Constraint
 void ArrayGraph.storeEdge(Constraint c, int a, int b)
           
 

Uses of Constraint in choco.cp.model
 

Fields in choco.cp.model with type parameters of type Constraint
protected  TIHIterator<Constraint> CPModel._iterator
           
protected  DeterministicIndicedList<Constraint> CPModel.constraints
          All the constraint of the model
 

Methods in choco.cp.model that return Constraint
 Constraint CPModel.getConstraint(int i)
          Network management: Retrieve a constraint by its index.
 

Methods in choco.cp.model that return types with arguments of type Constraint
 DisposableIterator<Constraint> CPModel.getConstraintByType(ConstraintType t)
           
 Iterator<Constraint> CPModel.getConstraintIterator()
          Return an iterator over the constraints of the model
 Iterator<Constraint> CPModel.getIntConstraintIterator()
          Deprecated.  
 

Methods in choco.cp.model with parameters of type Constraint
 void CPModel.addConstraint(Constraint... c)
          Deprecated.  
 void CPModel.addConstraint(Constraint c)
          Add one constraint to the model.
 void CPModel.addConstraint(String options, Constraint... c)
          Deprecated.  
 void CPModel.addConstraint(String options, Constraint c)
          Add one constraint to the model.
 void CPModel.addConstraints(Constraint... c)
          Add one or more constraint to the model.
 void CPModel.addConstraints(String options, Constraint... tabc)
          Add constraints to the model
 boolean CPModel.contains(Constraint c)
           
 void CPModel.removeConstraint(Constraint c)
           
 

Uses of Constraint in choco.cp.model.managers
 

Methods in choco.cp.model.managers with parameters of type Constraint
 INode UseResourcesManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
           
 INode SetConstraintManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build a expression node
 INode MixedConstraintManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build a expression node
 INode IntConstraintManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 

Uses of Constraint in choco.cp.model.managers.constraints
 

Methods in choco.cp.model.managers.constraints with parameters of type Constraint
 INode EqManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode BooleanManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 

Uses of Constraint in choco.cp.model.managers.constraints.expressions
 

Methods in choco.cp.model.managers.constraints.expressions with parameters of type Constraint
 INode XorManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode XnorManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode OrManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode NotManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode NorManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode NandManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode ImpliesManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode IfThenElseManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode IfOnlyIfManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode AndManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 

Uses of Constraint in choco.cp.model.managers.constraints.global
 

Methods in choco.cp.model.managers.constraints.global with parameters of type Constraint
 INode TreeManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 

Uses of Constraint in choco.cp.model.managers.constraints.integer
 

Methods in choco.cp.model.managers.constraints.integer with parameters of type Constraint
 INode SignOpManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode ModuloManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode AbsoluteManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Make a solver expression variable from a model expression variable
 

Uses of Constraint in choco.cp.model.managers.operators
 

Methods in choco.cp.model.managers.operators with parameters of type Constraint
 INode DoubleManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
           
 INode SumManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode SqrtManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Make a solver expression variable from a model expression variable
 INode SinManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode ScalarManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode PowerManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode PlusManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode NegManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode MultManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode MinusManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode MinManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode MaxManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode DivManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Make a solver expression variable from a model expression variable
 INode DistanceNEQManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Make a solver expression variable from a model expression variable
 INode DistanceLTManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Make a solver expression variable from a model expression variable
 INode DistanceGTManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Make a solver expression variable from a model expression variable
 INode DistanceEQManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Make a solver expression variable from a model expression variable
 INode CosManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build arithm node from a IntegerExpressionVariable
 INode AbsManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Make a solver expression variable from a model expression variable
 

Uses of Constraint in choco.cp.model.managers.variables
 

Methods in choco.cp.model.managers.variables with parameters of type Constraint
 INode TaskVariableManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build a expression node
 INode SetVariableManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build a expression node
 INode RealVariableManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build a expression node
 INode IntegerVariableManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build a expression node
 INode IntegerExpressionManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] variables)
          Build arithm node from a IntegerExpressionVariable
 

Uses of Constraint in choco.cp.solver
 

Methods in choco.cp.solver with parameters of type Constraint
 void CPSolver.addConstraint(boolean dynamic, Constraint... tabic)
           
 void CPSolver.addConstraint(Constraint... tabic)
           
protected  BoolNode CPModelToCPSolver.buildBoolNode(Constraint ic)
           
protected  SConstraint CPModelToCPSolver.createMetaConstraint(Constraint ic, Boolean decomp)
           
 SConstraint CPSolver.getCstr(Constraint ic)
           
 SConstraint CPSolver.makeSConstraint(Constraint mc)
           
 SConstraint CPModelToCPSolver.makeSConstraint(Constraint ic)
           
 SConstraint CPSolver.makeSConstraint(Constraint mc, boolean b)
           
 SConstraint CPModelToCPSolver.makeSConstraint(Constraint ic, Boolean decomp)
           
 SConstraint[] CPSolver.makeSConstraintAndOpposite(Constraint mc)
           
 SConstraint[] CPModelToCPSolver.makeSConstraintAndOpposite(Constraint ic)
           
 SConstraint[] CPSolver.makeSConstraintAndOpposite(Constraint mc, boolean b)
           
 SConstraint[] CPModelToCPSolver.makeSConstraintAndOpposite(Constraint ic, Boolean decomp)
           
 void CPModelToCPSolver.readConstraint(Constraint ic, Boolean decomp, boolean dynamic)
           
 

Uses of Constraint in choco.cp.solver.constraints.set
 

Methods in choco.cp.solver.constraints.set that return Constraint
static Constraint MemberXiY.build(IntegerVariable[] ivars, SetVariable svar)
           
 

Uses of Constraint in choco.cp.solver.constraints.strong
 

Methods in choco.cp.solver.constraints.strong with parameters of type Constraint
protected  BoolNode StrongConsistencyManager.buildBoolNode(Constraint ic, Solver cpsolver)
           
protected  ExpressionSConstraint StrongConsistencyManager.createMetaConstraint(Constraint ic, Solver cpsolver)
           
 INode StrongConsistencyManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
           
 

Uses of Constraint in choco.cp.solver.constraints.strong.xmlmodel
 

Methods in choco.cp.solver.constraints.strong.xmlmodel that return Constraint
static Constraint[] ChocoFactoryRPC.makeModelConstraint(PConstraint pc)
           
 

Uses of Constraint in choco.cp.solver.preprocessor
 

Methods in choco.cp.solver.preprocessor with type parameters of type Constraint
<MC extends Constraint,SC extends SConstraint>
void
PreProcessCPSolver.setCstr(MC c, SC sc)
           
 

Methods in choco.cp.solver.preprocessor with parameters of type Constraint
 BoolNode PPModelToCPSolver.buildNode(Constraint ic)
           
 boolean PreProcessCPSolver.contains(Constraint c)
           
protected  SConstraint PPModelToCPSolver.createMetaConstraint(Constraint ic, Boolean decomp)
          Override the creation of Expression Constraint as in the preprocessing they might have been built earlier or identified as an intensional constraint.
 void PPModelToCPSolver.storeExpressionSConstraint(Constraint c, ExpressionSConstraint ic)
           
 

Uses of Constraint in choco.kernel.common.util.tools
 

Methods in choco.kernel.common.util.tools that return types with arguments of type Constraint
static Iterator<Constraint> IteratorUtils.iterator(Model m, Collection<Constraint> constraints)
           
 

Methods in choco.kernel.common.util.tools with parameters of type Constraint
static IResource<TaskVar> TaskUtils.createFakeResource(Solver s, Constraint c)
           
static IResource<?>[] TaskUtils.createFakeResources(Solver s, Constraint... c)
           
 

Method parameters in choco.kernel.common.util.tools with type arguments of type Constraint
static Iterator<Constraint> IteratorUtils.iterator(Model m, Collection<Constraint> constraints)
           
 

Uses of Constraint in choco.kernel.model
 

Fields in choco.kernel.model declared as Constraint
protected static Constraint[] VariableArray.NO_CONSTRAINTS
           
 

Methods in choco.kernel.model that return Constraint
 Constraint VariableArray.VConstraintsDataStructure.getConstraint(int i)
           
 Constraint Model.getConstraint(int i)
          Network management: Retrieve a constraint by its index.
 Constraint IConstraintList.getConstraint(int i)
           
 Constraint[] VariableArray.VConstraintsDataStructure.getConstraints()
           
 Constraint[] IConstraintList.getConstraints()
           
 

Methods in choco.kernel.model that return types with arguments of type Constraint
 Iterator<Constraint> Model.getConstraintByType(ConstraintType t)
          Return an iterator over constraint of a certain type
 Iterator<Constraint> Model.getConstraintIterator()
          Return an iterator over the constraints of the model
 Iterator<Constraint> VariableArray.VConstraintsDataStructure.getConstraintIterator(Model m)
           
 Iterator<Constraint> IConstraintList.getConstraintIterator(Model m)
           
 Iterator<Constraint> Model.getIntConstraintIterator()
          Deprecated.  
 

Methods in choco.kernel.model with parameters of type Constraint
 void VariableArray.VConstraintsDataStructure._addConstraint(Constraint c)
           
 void IConstraintList._addConstraint(Constraint c)
           
 boolean VariableArray.VConstraintsDataStructure._contains(Constraint c)
           
 boolean IConstraintList._contains(Constraint c)
           
 void VariableArray.VConstraintsDataStructure._removeConstraint(Constraint c)
           
 void IConstraintList._removeConstraint(Constraint c)
           
 void Model.addConstraint(Constraint... c)
          Deprecated.  
 void Model.addConstraint(Constraint c)
          Add one constraint to the model.
 void Model.addConstraint(String options, Constraint... c)
          Deprecated.  
 void Model.addConstraint(String options, Constraint c)
          Add one constraint to the model.
 void Model.addConstraints(Constraint... c)
          Add one or more constraint to the model.
 void Model.addConstraints(String options, Constraint... c)
          Add one or more constraint to the model.
 boolean Model.contains(Constraint c)
           
 void Model.removeConstraint(Constraint c)
          Remove a constraint from the model.
 

Uses of Constraint in choco.kernel.model.constraints
 

Classes in choco.kernel.model.constraints with type parameters of type Constraint
 class MetaConstraint<E extends Constraint>
           
 

Classes in choco.kernel.model.constraints that implement Constraint
 class AbstractConstraint
           
 class ComponentConstraint
           
 class ComponentConstraintWithSubConstraints
           
 class MetaConstraint<E extends Constraint>
           
 class MetaTaskConstraint
          An wrapper for constraint involving some Taskvariable.
 class TemporalConstraint
           
 

Fields in choco.kernel.model.constraints declared as Constraint
protected  Constraint MetaTaskConstraint.constraint
           
protected  E[] MetaConstraint.constraints
           
 

Methods in choco.kernel.model.constraints that return Constraint
 E[] MetaConstraint.getConstraints()
           
 

Methods in choco.kernel.model.constraints with parameters of type Constraint
 void ComponentConstraintWithSubConstraints.addElements(Variable[] vars, Constraint... cstrs)
           
 INode ExpressionManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
          Build a expression node
 

Constructors in choco.kernel.model.constraints with parameters of type Constraint
ComponentConstraintWithSubConstraints(Class componentClass, Variable[] variables, Object params, Constraint... constraints)
           
ComponentConstraintWithSubConstraints(ConstraintType constraintType, Variable[] variables, Object params, Constraint... constraints)
           
ComponentConstraintWithSubConstraints(String componentClassName, Variable[] variables, Object params, Constraint... constraints)
           
MetaConstraint(Class metaManager, E... constraints)
           
MetaConstraint(ConstraintType type, E... constraints)
           
MetaConstraint(String metaManager, E... constraints)
           
MetaTaskConstraint(TaskVariable[] taskvariables, Constraint constraint)
           
 

Uses of Constraint in choco.kernel.model.constraints.pack
 

Methods in choco.kernel.model.constraints.pack that return Constraint
 Constraint PackModel.allDiffLargeItems()
          Redundant Constraint : allDifferent on the k-th largest items
 Constraint[] PackModel.decreasingCardinalities(int fromIndex)
          Deprecated. 
 Constraint[] PackModel.decreasingLoads(int fromIndex)
          Deprecated. 
 Constraint[] PackModel.orderEqualSizedItems(int fromIndex)
          Deprecated. 
 Constraint[] PackModel.packLargeItems()
          Deprecated. 
 

Uses of Constraint in choco.kernel.model.factories
 

Methods in choco.kernel.model.factories that return Constraint
static Constraint ConstraintListFactory.get(int i)
           
 

Methods in choco.kernel.model.factories that return types with arguments of type Constraint
static ArrayList<Constraint> ConstraintListFactory.getConstraintList()
           
 

Methods in choco.kernel.model.factories with parameters of type Constraint
static int ConstraintListFactory.add(Constraint c)
           
static boolean ConstraintListFactory.remove(int i, Constraint removeOne)
           
 

Uses of Constraint in choco.kernel.model.variables
 

Methods in choco.kernel.model.variables that return Constraint
 Constraint ComponentVariable.ConstraintsDataStructure.getConstraint(int i)
           
 Constraint AbstractVariable.getConstraint(int idx)
           
 Constraint[] ComponentVariable.ConstraintsDataStructure.getConstraints()
           
 Constraint[] AbstractVariable.getConstraints()
           
 

Methods in choco.kernel.model.variables that return types with arguments of type Constraint
 Iterator<Constraint> Variable.getConstraintIterator()
          Deprecated. 
 Iterator<Constraint> AbstractVariable.getConstraintIterator()
          Deprecated. 
 Iterator<Constraint> ComponentVariable.ConstraintsDataStructure.getConstraintIterator(Model m)
           
 Iterator<Constraint> AbstractVariable.getConstraintIterator(Model m)
           
 

Methods in choco.kernel.model.variables with parameters of type Constraint
 void ComponentVariable.ConstraintsDataStructure._addConstraint(Constraint c)
           
 void AbstractVariable._addConstraint(Constraint c)
           
 boolean ComponentVariable.ConstraintsDataStructure._contains(Constraint c)
           
 boolean AbstractVariable._contains(Constraint c)
           
 void ComponentVariable.ConstraintsDataStructure._removeConstraint(Constraint c)
           
 void AbstractVariable._removeConstraint(Constraint c)
           
 

Uses of Constraint in choco.kernel.model.variables.integer
 

Fields in choco.kernel.model.variables.integer declared as Constraint
protected  Constraint[] MetaIntegerExpressionVariable.constraints
           
 

Methods in choco.kernel.model.variables.integer that return Constraint
 Constraint[] MetaIntegerExpressionVariable.getConstraints()
           
 

Constructors in choco.kernel.model.variables.integer with parameters of type Constraint
MetaIntegerExpressionVariable(Operator operator, Constraint c, IntegerExpressionVariable... variables)
           
 

Uses of Constraint in choco.kernel.solver
 

Methods in choco.kernel.solver with parameters of type Constraint
 SConstraint Solver.getCstr(Constraint ic)
           
 

Uses of Constraint in choco.visu.components.chart
 

Methods in choco.visu.components.chart with parameters of type Constraint
static org.jfree.chart.JFreeChart ChocoChartFactory.createCumulativeChart(String title, CPSolver s, Constraint rsc, boolean legend)
           
static org.jfree.chart.JFreeChart ChocoChartFactory.createUnaryHChart(String title, Solver scheduler, Constraint... resources)
           
 

Method parameters in choco.visu.components.chart with type arguments of type Constraint
static org.jfree.data.gantt.TaskSeriesCollection ChocoDatasetFactory.createTaskCollection(Solver s, Iterator<Constraint> iter)
           
 

Uses of Constraint in choco.visu.components.chart.ui
 

Method parameters in choco.visu.components.chart.ui with type arguments of type Constraint
protected  void ChocoChartPanel.createNodes(DefaultMutableTreeNode father, Iterator<Constraint> iter)
           
 

Uses of Constraint in parser.absconparseur.components
 

Fields in parser.absconparseur.components declared as Constraint
protected  Constraint PConstraint.chocoCstr
           
 

Methods in parser.absconparseur.components that return Constraint
 Constraint PConstraint.getChocoCstr()
           
 

Methods in parser.absconparseur.components with parameters of type Constraint
 void PConstraint.setChocoCstr(Constraint chocoCstr)
           
 

Uses of Constraint in parser.chocogen
 

Methods in parser.chocogen that return Constraint
static Constraint GloConstraintFactory.buildAllDiff(IntegerVariable[] vars)
           
static Constraint GloConstraintFactory.buildGcc(IntegerVariable[] vars, Integer[] values, IntegerVariable[] noccurrences)
           
static Constraint[] GloConstraintFactory.makeAlldDifferent(PAllDifferent pgc)
           
static Constraint[] GloConstraintFactory.makeCumulative(PCumulative pc)
           
static Constraint[] GloConstraintFactory.makeDisjunctive(PDisjunctive pd)
           
static Constraint[] GloConstraintFactory.makeElement(PElement pe)
           
static Constraint[] ExtConstraintFactory.makeExtConstraint(PExtensionConstraint pec)
           
static Constraint[] GloConstraintFactory.makeGlobalCardinality(PGlobalCardinality pgcc)
           
static Constraint[] GloConstraintFactory.makeGlobalConstraint(PGlobalConstraint pgc)
           
static Constraint[] ModelConstraintFactory.makeIntensionConstraint(PIntensionConstraint pic)
           
static Constraint[] GloConstraintFactory.makeLexLess(PLexLess pll)
           
static Constraint[] GloConstraintFactory.makeLexLessEq(PLexLessEq plle)
           
static Constraint[] GloConstraintFactory.makeWeightedSum(PWeightedSum pws)
           
 

Uses of Constraint in samples.jobshop
 

Methods in samples.jobshop that return types with arguments of type Constraint
 Collection<Collection<Constraint>> TaillardJobShopProblem.getDisjConstraints()
           
 Collection<Collection<Constraint>> TaillardJobShopProblem.getPrecConstraints()
           
 

Methods in samples.jobshop with parameters of type Constraint
 INode SimpleDTConstraint.SimpleDTConstraintManager.makeNode(Solver solver, Constraint[] cstrs, Variable[] vars)
           
 

Uses of Constraint in samples.random
 

Methods in samples.random that return types with arguments of type Constraint
 Collection<Constraint> RandomProblem.getConstraints()
           
 

Uses of Constraint in samples.tutorials.lns.lns
 

Methods in samples.tutorials.lns.lns with parameters of type Constraint
 SConstraint AbstractLNSSolver.getCstr(Constraint ic)
          Deprecated.  
 



Copyright © 2012. All Rights Reserved.