Modifier and Type | Method and Description |
---|---|
boolean |
PropNogoods.declareDomainNogood(IntVar var)
Add clauses to ensure domain consistency, that is:
[ x ≤ d ] ⇒ [ x ≤ d +1 ]
[ x = d ] ⇔ ([ x ≤ d ] ∧ ¬[ x ≤ d + 1])
|
int |
PropNogoods.Literal(IntVar ivar,
int value,
boolean eq)
Creates or returns if already existing, the literal corresponding to :
ivar (eq ?" |
boolean |
PropSat.why(RuleStore ruleStore,
IntVar bvar,
IEventType evt,
int bvalue) |
boolean |
PropNogoods.why(RuleStore ruleStore,
IntVar ivar,
IEventType evt,
int ivalue) |
Modifier and Type | Method and Description |
---|---|
IntVar[] |
Model.retrieveIntVars(boolean includeBoolVar)
Iterate over the variable of
this and build an array that contains all the IntVar of the model. |
Modifier and Type | Method and Description |
---|---|
gnu.trove.map.hash.TIntObjectHashMap<IntVar> |
Model.getCachedConstants()
Get the map of constant IntVar the have default names to avoid creating multiple identical constants.
|
Modifier and Type | Method and Description |
---|---|
int |
Solution.getIntVal(IntVar v)
Get the value of variable v in this solution.
|
void |
Solution.setIntVal(IntVar var,
int val)
Set the value of variable v in this solution.
|
default boolean |
ICause.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value)
Add new rules to the rule store
|
Modifier and Type | Method and Description |
---|---|
default Constraint |
IIntConstraintFactory.absolute(IntVar var1,
IntVar var2)
Creates an absolute value constraint: var1 = |var2|
|
default Constraint |
IIntConstraintFactory.allDifferent(IntVar... vars)
Creates an allDifferent constraint.
|
default Constraint |
IIntConstraintFactory.allDifferent(IntVar[] vars,
String CONSISTENCY)
Creates an allDifferent constraint.
|
default Constraint |
IIntConstraintFactory.allDifferentExcept0(IntVar[] vars)
Creates an allDifferent constraint for variables that are not equal to 0.
|
default Constraint |
IIntConstraintFactory.allDifferentUnderCondition(IntVar[] vars,
Condition condition,
boolean singleCondition)
Creates an allDifferent constraint subject to the given condition.
|
default Constraint |
IIntConstraintFactory.allEqual(IntVar... vars)
Creates an allEqual constraint.
|
default Constraint |
IIntConstraintFactory.among(IntVar nbVar,
IntVar[] vars,
int[] values)
Creates an among constraint.
|
default Constraint |
IIntConstraintFactory.among(IntVar nbVar,
IntVar[] vars,
int[] values)
Creates an among constraint.
|
default Constraint |
IIntConstraintFactory.arithm(IntVar var,
String op,
int cste)
Creates an arithmetic constraint : var op cste,
where op in {"=", "!
|
default Constraint |
IIntConstraintFactory.arithm(IntVar var1,
String op,
IntVar var2)
Creates an arithmetic constraint: var1 op var2,
where op in {"=", "!
|
default Constraint |
IIntConstraintFactory.arithm(IntVar var1,
String op1,
IntVar var2,
String op2,
int cste)
Creates an arithmetic constraint : var1 op var2,
where op in {"=", "!
|
default Constraint |
IIntConstraintFactory.arithm(IntVar var1,
String op1,
IntVar var2,
String op2,
IntVar var3)
Creates an arithmetic constraint: var1 op1 var2 op2 var3,
where op1 and op2 in {"=", "!
|
default Constraint |
IIntConstraintFactory.atLeastNValues(IntVar[] vars,
IntVar nValues,
boolean AC)
Creates an atLeastNValue constraint.
|
default Constraint |
IIntConstraintFactory.atLeastNValues(IntVar[] vars,
IntVar nValues,
boolean AC)
Creates an atLeastNValue constraint.
|
default Constraint |
IIntConstraintFactory.atMostNValues(IntVar[] vars,
IntVar nValues,
boolean STRONG)
Creates an atMostNValue constraint.
|
default Constraint |
IIntConstraintFactory.atMostNValues(IntVar[] vars,
IntVar nValues,
boolean STRONG)
Creates an atMostNValue constraint.
|
default Constraint |
IIntConstraintFactory.binPacking(IntVar[] itemBin,
int[] itemSize,
IntVar[] binLoad,
int offset)
Creates a BinPacking constraint.
|
default Constraint |
IIntConstraintFactory.binPacking(IntVar[] itemBin,
int[] itemSize,
IntVar[] binLoad,
int offset)
Creates a BinPacking constraint.
|
default Constraint |
IIntConstraintFactory.bitsIntChanneling(BoolVar[] bits,
IntVar var)
Creates an channeling constraint between an integer variable and a set of bit variables.
|
default Constraint |
IIntConstraintFactory.boolsIntChanneling(BoolVar[] bVars,
IntVar var,
int offset)
Creates an channeling constraint between an integer variable and a set of boolean variables.
|
default Constraint |
IIntConstraintFactory.circuit(IntVar[] vars)
Creates a circuit constraint which ensures that
the elements of vars define a covering circuit
where vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.circuit(IntVar[] vars,
int offset)
Creates a circuit constraint which ensures that
the elements of vars define a covering circuit
where vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.circuit(IntVar[] vars,
int offset,
CircuitConf conf)
Creates a circuit constraint which ensures that
the elements of vars define a covering circuit
where vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.clausesIntChanneling(IntVar var,
BoolVar[] eVars,
BoolVar[] lVars)
Creates an channeling constraint between an integer variable and a set of clauses.
|
default Constraint |
IIntConstraintFactory.costRegular(IntVar[] vars,
IntVar cost,
ICostAutomaton costAutomaton)
Creates a regular constraint that supports a cost function.
|
default Constraint |
IIntConstraintFactory.costRegular(IntVar[] vars,
IntVar cost,
ICostAutomaton costAutomaton)
Creates a regular constraint that supports a cost function.
|
default Constraint |
IIntConstraintFactory.count(int value,
IntVar[] vars,
IntVar limit)
Creates a count constraint.
|
default Constraint |
IIntConstraintFactory.count(int value,
IntVar[] vars,
IntVar limit)
Creates a count constraint.
|
default Constraint |
IIntConstraintFactory.count(IntVar value,
IntVar[] vars,
IntVar limit)
Creates a count constraint.
|
default Constraint |
IIntConstraintFactory.count(IntVar value,
IntVar[] vars,
IntVar limit)
Creates a count constraint.
|
default Constraint |
IIntConstraintFactory.cumulative(Task[] tasks,
IntVar[] heights,
IntVar capacity)
Creates a cumulative constraint: Enforces that at each point in time,
the cumulated height of the set of tasks that overlap that point
does not exceed a given limit.
|
default Constraint |
IIntConstraintFactory.cumulative(Task[] tasks,
IntVar[] heights,
IntVar capacity)
Creates a cumulative constraint: Enforces that at each point in time,
the cumulated height of the set of tasks that overlap that point
does not exceed a given limit.
|
default Constraint |
IIntConstraintFactory.cumulative(Task[] tasks,
IntVar[] heights,
IntVar capacity,
boolean incremental)
Creates a cumulative constraint: Enforces that at each point in time,
the cumulated height of the set of tasks that overlap that point
does not exceed a given limit.
|
default Constraint |
IIntConstraintFactory.cumulative(Task[] tasks,
IntVar[] heights,
IntVar capacity,
boolean incremental)
Creates a cumulative constraint: Enforces that at each point in time,
the cumulated height of the set of tasks that overlap that point
does not exceed a given limit.
|
default Constraint |
IIntConstraintFactory.cumulative(Task[] tasks,
IntVar[] heights,
IntVar capacity,
boolean incremental,
Cumulative.Filter... filters)
Creates a cumulative constraint: Enforces that at each point in time,
the cumulated height of the set of tasks that overlap that point
does not exceed a given limit.
|
default Constraint |
IIntConstraintFactory.cumulative(Task[] tasks,
IntVar[] heights,
IntVar capacity,
boolean incremental,
Cumulative.Filter... filters)
Creates a cumulative constraint: Enforces that at each point in time,
the cumulated height of the set of tasks that overlap that point
does not exceed a given limit.
|
default Constraint |
IIntConstraintFactory.diffN(IntVar[] X,
IntVar[] Y,
IntVar[] width,
IntVar[] height,
boolean addCumulativeReasoning)
Creates a diffN constraint.
|
default Constraint |
IIntConstraintFactory.diffN(IntVar[] X,
IntVar[] Y,
IntVar[] width,
IntVar[] height,
boolean addCumulativeReasoning)
Creates a diffN constraint.
|
default Constraint |
IIntConstraintFactory.diffN(IntVar[] X,
IntVar[] Y,
IntVar[] width,
IntVar[] height,
boolean addCumulativeReasoning)
Creates a diffN constraint.
|
default Constraint |
IIntConstraintFactory.diffN(IntVar[] X,
IntVar[] Y,
IntVar[] width,
IntVar[] height,
boolean addCumulativeReasoning)
Creates a diffN constraint.
|
default Constraint |
IIntConstraintFactory.distance(IntVar var1,
IntVar var2,
String op,
int cste)
Creates a distance constraint : |var1-var2| op cste
where op can take its value among {"=", ">", "<", "! |
default Constraint |
IIntConstraintFactory.distance(IntVar var1,
IntVar var2,
String op,
IntVar var3)
Creates a distance constraint: |var1-var2| op var3
where op can take its value among {"=", ">", "<"} |
default Constraint |
IIntConstraintFactory.div(IntVar dividend,
IntVar divisor,
IntVar result)
Creates an euclidean division constraint.
|
default Constraint |
IIntConstraintFactory.element(IntVar value,
int[] table,
IntVar index)
Creates an element constraint: value = table[index]
|
default Constraint |
IIntConstraintFactory.element(IntVar value,
int[] table,
IntVar index,
int offset)
Creates an element constraint: value = table[index-offset]
|
default Constraint |
IIntConstraintFactory.element(IntVar value,
IntVar[] table,
IntVar index,
int offset)
Creates a element constraint: value = table[index-offset]
where table is an array of variables.
|
default Constraint |
IIntConstraintFactory.element(IntVar value,
IntVar[] table,
IntVar index,
int offset)
Creates a element constraint: value = table[index-offset]
where table is an array of variables.
|
default Constraint |
ISetConstraintFactory.element(IntVar index,
SetVar[] sets,
int offset,
SetVar set)
Creates a constraint enabling to retrieve an element set in sets:
sets[index-offset] = set
|
default Constraint |
ISetConstraintFactory.element(IntVar index,
SetVar[] sets,
SetVar set)
Creates a constraint enabling to retrieve an element set in sets:
sets[index] = set
|
default int[] |
IIntConstraintFactory.getDomainUnion(IntVar... vars)
Get the list of values in the domains of vars
|
default Constraint |
IIntConstraintFactory.globalCardinality(IntVar[] vars,
int[] values,
IntVar[] occurrences,
boolean closed)
Creates a global cardinality constraint (GCC):
Each value values[i] should be taken by exactly occurrences[i] variables of vars.
|
default Constraint |
IIntConstraintFactory.globalCardinality(IntVar[] vars,
int[] values,
IntVar[] occurrences,
boolean closed)
Creates a global cardinality constraint (GCC):
Each value values[i] should be taken by exactly occurrences[i] variables of vars.
|
default Constraint |
IIntConstraintFactory.intValuePrecedeChain(IntVar[] X,
int[] V)
Creates an intValuePrecedeChain constraint.
|
default Constraint |
IIntConstraintFactory.intValuePrecedeChain(IntVar[] X,
int S,
int T)
Creates an intValuePrecedeChain constraint.
|
default Constraint |
IIntConstraintFactory.inverseChanneling(IntVar[] vars1,
IntVar[] vars2)
Creates an inverse channeling between vars1 and vars2:
vars1[i] = j <=> vars2[j] = i
Performs AC if domains are enumerated.
|
default Constraint |
IIntConstraintFactory.inverseChanneling(IntVar[] vars1,
IntVar[] vars2)
Creates an inverse channeling between vars1 and vars2:
vars1[i] = j <=> vars2[j] = i
Performs AC if domains are enumerated.
|
default Constraint |
IIntConstraintFactory.inverseChanneling(IntVar[] vars1,
IntVar[] vars2,
int offset1,
int offset2)
Creates an inverse channeling between vars1 and vars2:
vars1[i-offset2] = j <=> vars2[j-offset1] = i
Performs AC if domains are enumerated.
|
default Constraint |
IIntConstraintFactory.inverseChanneling(IntVar[] vars1,
IntVar[] vars2,
int offset1,
int offset2)
Creates an inverse channeling between vars1 and vars2:
vars1[i-offset2] = j <=> vars2[j-offset1] = i
Performs AC if domains are enumerated.
|
default Constraint |
IIntConstraintFactory.keySort(IntVar[][] vars,
IntVar[] PERMvars,
IntVar[][] SORTEDvars,
int K)
Creates a keySort constraint which ensures that the variables of SORTEDvars correspond to the variables
of vars according to a permutation stored in PERMvars (optional, can be null).
|
default Constraint |
IIntConstraintFactory.keySort(IntVar[][] vars,
IntVar[] PERMvars,
IntVar[][] SORTEDvars,
int K)
Creates a keySort constraint which ensures that the variables of SORTEDvars correspond to the variables
of vars according to a permutation stored in PERMvars (optional, can be null).
|
default Constraint |
IIntConstraintFactory.keySort(IntVar[][] vars,
IntVar[] PERMvars,
IntVar[][] SORTEDvars,
int K)
Creates a keySort constraint which ensures that the variables of SORTEDvars correspond to the variables
of vars according to a permutation stored in PERMvars (optional, can be null).
|
default Constraint |
IIntConstraintFactory.knapsack(IntVar[] occurrences,
IntVar weightSum,
IntVar energySum,
int[] weight,
int[] energy)
Creates a knapsack constraint.
|
default Constraint |
IIntConstraintFactory.knapsack(IntVar[] occurrences,
IntVar weightSum,
IntVar energySum,
int[] weight,
int[] energy)
Creates a knapsack constraint.
|
default Constraint |
IIntConstraintFactory.lexChainLess(IntVar[]... vars)
Creates a lexChainLess constraint.
|
default Constraint |
IIntConstraintFactory.lexChainLessEq(IntVar[]... vars)
Creates a lexChainLessEq constraint.
|
default Constraint |
IIntConstraintFactory.lexLess(IntVar[] vars1,
IntVar[] vars2)
Creates a lexLess constraint.
|
default Constraint |
IIntConstraintFactory.lexLess(IntVar[] vars1,
IntVar[] vars2)
Creates a lexLess constraint.
|
default Constraint |
IIntConstraintFactory.lexLessEq(IntVar[] vars1,
IntVar[] vars2)
Creates a lexLessEq constraint.
|
default Constraint |
IIntConstraintFactory.lexLessEq(IntVar[] vars1,
IntVar[] vars2)
Creates a lexLessEq constraint.
|
default Constraint |
IIntConstraintFactory.max(IntVar max,
IntVar[] vars)
Creates a maximum constraint.
|
default Constraint |
IIntConstraintFactory.max(IntVar max,
IntVar[] vars)
Creates a maximum constraint.
|
default Constraint |
IIntConstraintFactory.max(IntVar max,
IntVar var1,
IntVar var2)
Creates a maximum constraint : max = max(var1, var2)
(Bound Consistency)
|
default Constraint |
ISetConstraintFactory.max(SetVar indices,
int[] weights,
int offset,
IntVar maxElementValue,
boolean notEmpty)
Creates a constraint over the maximum element induces by a set:
max{weights[i-offset] | i in indices} = maxElementValue
|
default Constraint |
ISetConstraintFactory.max(SetVar set,
IntVar maxElementValue,
boolean notEmpty)
Creates a constraint over the maximum element in a set:
max{i | i in set} = maxElementValue
|
default Constraint |
IIntConstraintFactory.mddc(IntVar[] vars,
MultivaluedDecisionDiagram MDD)
Create a constraint where solutions (tuples) are encoded by a multi-valued decision diagram.
|
default Constraint |
IIntConstraintFactory.member(IntVar var,
int[] table)
Creates a member constraint.
|
default Constraint |
IIntConstraintFactory.member(IntVar var,
int lb,
int ub)
Creates a member constraint.
|
default Constraint |
ISetConstraintFactory.member(IntVar intVar,
SetVar set)
Creates a member constraint stating that the value of intVar is in set
|
default Constraint |
IIntConstraintFactory.min(IntVar min,
IntVar[] vars)
Creates a minimum constraint.
|
default Constraint |
IIntConstraintFactory.min(IntVar min,
IntVar[] vars)
Creates a minimum constraint.
|
default Constraint |
IIntConstraintFactory.min(IntVar min,
IntVar var1,
IntVar var2)
Creates a minimum constraint: min = min(var1, var2)
(Bound Consistency)
|
default Constraint |
ISetConstraintFactory.min(SetVar indices,
int[] weights,
int offset,
IntVar minElementValue,
boolean notEmpty)
Creates a constraint over the minimum element induces by a set:
min{weights[i-offset] | i in indices} = minElementValue
|
default Constraint |
ISetConstraintFactory.min(SetVar set,
IntVar minElementValue,
boolean notEmpty)
Creates a constraint over the minimum element in a set:
min{i | i in set} = minElementValue
|
default Constraint |
IIntConstraintFactory.mod(IntVar X,
IntVar Y,
IntVar Z)
Creates a modulo constraint.
|
default Constraint |
IIntConstraintFactory.multiCostRegular(IntVar[] vars,
IntVar[] costVars,
ICostAutomaton costAutomaton)
Creates a regular constraint that supports a multiple cost function.
|
default Constraint |
IIntConstraintFactory.multiCostRegular(IntVar[] vars,
IntVar[] costVars,
ICostAutomaton costAutomaton)
Creates a regular constraint that supports a multiple cost function.
|
default Constraint |
ISetConstraintFactory.nbEmpty(SetVar[] sets,
IntVar nbEmpty)
Creates a constraint counting the number of empty sets sets
|{s in sets where |s|=0}| = nbEmpty
|
default Constraint |
IIntConstraintFactory.notAllEqual(IntVar... vars)
Creates an allEqual constraint.
|
default Constraint |
IIntConstraintFactory.notMember(IntVar var,
int[] table)
Creates a notMember constraint.
|
default Constraint |
IIntConstraintFactory.notMember(IntVar var,
int lb,
int ub)
Creates a notMember constraint.
|
default Constraint |
ISetConstraintFactory.notMember(IntVar intVar,
SetVar set)
Creates a member constraint stating that the value of intVar is not in set
|
default Constraint |
IIntConstraintFactory.nValues(IntVar[] vars,
IntVar nValues)
Creates an nValue constraint.
|
default Constraint |
IIntConstraintFactory.nValues(IntVar[] vars,
IntVar nValues)
Creates an nValue constraint.
|
default Constraint |
IIntConstraintFactory.path(IntVar[] vars,
IntVar start,
IntVar end)
Creates a path constraint which ensures that
the elements of vars define a covering path from start to end
where vars[i] = j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.path(IntVar[] vars,
IntVar start,
IntVar end)
Creates a path constraint which ensures that
the elements of vars define a covering path from start to end
where vars[i] = j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.path(IntVar[] vars,
IntVar start,
IntVar end,
int offset)
Creates a path constraint which ensures that
the elements of vars define a covering path from start to end
where vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.path(IntVar[] vars,
IntVar start,
IntVar end,
int offset)
Creates a path constraint which ensures that
the elements of vars define a covering path from start to end
where vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.regular(IntVar[] vars,
IAutomaton automaton)
Creates a regular constraint.
|
default void |
IReificationFactory.reifyXeqC(IntVar X,
int C,
BoolVar B)
Posts one constraint that expresses : (x = c) ⇔ b.
|
default void |
IReificationFactory.reifyXeqY(IntVar X,
IntVar Y,
BoolVar B)
Posts one constraint that expresses : (x = y) ⇔ b.
|
default void |
IReificationFactory.reifyXgtC(IntVar X,
int C,
BoolVar B)
Posts one constraint that expresses : (x > c) ⇔ b.
|
default void |
IReificationFactory.reifyXinS(IntVar X,
IntIterableRangeSet S,
BoolVar B)
Posts one constraint that expresses : (X ∈ S) ⇔ B.
|
default void |
IReificationFactory.reifyXleY(IntVar X,
IntVar Y,
BoolVar B)
Posts one constraint that expresses : (x ≤ y) ⇔ b.
|
default void |
IReificationFactory.reifyXltC(IntVar X,
int C,
BoolVar B)
Posts one constraint that expresses : (x < c) ⇔ b.
|
default void |
IReificationFactory.reifyXltY(IntVar X,
IntVar Y,
BoolVar B)
Posts one constraint that expresses : (x < y) ⇔ b.
|
default void |
IReificationFactory.reifyXltYC(IntVar X,
IntVar Y,
int C,
BoolVar B)
Posts one constraint that expresses : (x < y + c) ⇔ b.
|
default void |
IReificationFactory.reifyXneC(IntVar X,
int C,
BoolVar B)
Posts one constraint that expresses : (x ≠ c) ⇔ b.
|
default void |
IReificationFactory.reifyXneY(IntVar X,
IntVar Y,
BoolVar B)
Posts one constraint that expresses : (x ≠ y) ⇔ b.
|
default Constraint |
IIntConstraintFactory.scalar(IntVar[] vars,
int[] coeffs,
String operator,
int scalar)
Creates a scalar constraint which ensures that Sum(vars[i]*coeffs[i]) operator scalar
|
default Constraint |
IIntConstraintFactory.scalar(IntVar[] vars,
int[] coeffs,
String operator,
IntVar scalar)
Creates a scalar constraint which ensures that Sum(vars[i]*coeffs[i]) operator scalar
|
default Constraint |
IIntConstraintFactory.scalar(IntVar[] vars,
int[] coeffs,
String operator,
IntVar scalar)
Creates a scalar constraint which ensures that Sum(vars[i]*coeffs[i]) operator scalar
|
default Constraint |
ISetConstraintFactory.setsIntsChanneling(SetVar[] sets,
IntVar[] ints)
Creates a constraint channeling set variables and integer variables :
x in sets[y] <=> ints[x] = y
|
default Constraint |
ISetConstraintFactory.setsIntsChanneling(SetVar[] sets,
IntVar[] ints,
int offset1,
int offset2)
Creates a constraint channeling set variables and integer variables :
x in sets[y-offset1] <=> ints[x-offset2] = y
|
default Constraint |
IIntConstraintFactory.sort(IntVar[] vars,
IntVar[] sortedVars)
Creates a sort constraint which ensures that the variables of sortedVars correspond to the variables
of vars according to a permutation.
|
default Constraint |
IIntConstraintFactory.sort(IntVar[] vars,
IntVar[] sortedVars)
Creates a sort constraint which ensures that the variables of sortedVars correspond to the variables
of vars according to a permutation.
|
default Constraint |
IIntConstraintFactory.square(IntVar var1,
IntVar var2)
Creates a square constraint: var1 = var2^2
|
default Constraint |
IIntConstraintFactory.subCircuit(IntVar[] vars,
int offset,
IntVar subCircuitLength)
Creates a subCircuit constraint which ensures that
the elements of vars define a single circuit of subcircuitSize nodes where
vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.subCircuit(IntVar[] vars,
int offset,
IntVar subCircuitLength)
Creates a subCircuit constraint which ensures that
the elements of vars define a single circuit of subcircuitSize nodes where
vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.subPath(IntVar[] vars,
IntVar start,
IntVar end,
int offset,
IntVar SIZE)
Creates a subPath constraint which ensures that
the elements of vars define a path of SIZE vertices, leading from start to end
where vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.subPath(IntVar[] vars,
IntVar start,
IntVar end,
int offset,
IntVar SIZE)
Creates a subPath constraint which ensures that
the elements of vars define a path of SIZE vertices, leading from start to end
where vars[i] = offset+j means that j is the successor of i.
|
default Constraint |
IIntConstraintFactory.sum(BoolVar[] vars,
String operator,
IntVar sum)
Creates a sum constraint.
|
default Constraint |
IIntConstraintFactory.sum(IntVar[] vars,
String operator,
int sum)
Creates a sum constraint.
|
default Constraint |
IIntConstraintFactory.sum(IntVar[] vars,
String operator,
IntVar sum)
Creates a sum constraint.
|
default Constraint |
IIntConstraintFactory.sum(IntVar[] vars,
String operator,
IntVar sum)
Creates a sum constraint.
|
default Constraint |
ISetConstraintFactory.sum(SetVar set,
IntVar sum)
Creates a constraint summing elements of set
sum{i | i in set} = sum
|
default Constraint |
ISetConstraintFactory.sumElements(SetVar indices,
int[] weights,
int offset,
IntVar sum)
Creates a constraint summing weights given by a set of indices:
sum{weights[i-offset] | i in indices} = sum
Also ensures that elements in indices belong to [offset, offset+weights.length-1]
|
default Constraint |
ISetConstraintFactory.sumElements(SetVar indices,
int[] weights,
IntVar sum)
Creates a constraint summing weights given by a set of indices:
sum{weights[i] | i in indices} = sum
Also ensures that elements in indices belong to [0, weights.length-1]
|
default Constraint |
IIntConstraintFactory.table(IntVar[] vars,
Tuples tuples)
Creates a table constraint specifying that the sequence of variables vars must belong to the list of tuples
(or must NOT belong in case of infeasible tuples)
Default configuration with GACSTR+ algorithm for feasible tuples and GAC3rm otherwise
|
default Constraint |
IIntConstraintFactory.table(IntVar[] vars,
Tuples tuples,
String algo)
Creates a table constraint, with the specified algorithm defined algo
- CT+: Compact-Table algorithm (AC),
- GAC2001: Arc Consistency version 2001 for tuples, - GAC2001+: Arc Consistency version 2001 for allowed tuples, - GAC3rm: Arc Consistency version AC3 rm for tuples, - GAC3rm+ (default): Arc Consistency version 3rm for allowed tuples, - GACSTR+: Arc Consistency version STR for allowed tuples, - STR2+: Arc Consistency version STR2 for allowed tuples, - FC: Forward Checking. |
default Constraint |
IIntConstraintFactory.table(IntVar var1,
IntVar var2,
Tuples tuples)
Create a table constraint over a couple of variables var1 and var2
Uses AC3rm algorithm by default
|
default Constraint |
IIntConstraintFactory.table(IntVar var1,
IntVar var2,
Tuples tuples,
String algo)
Creates a table constraint over a couple of variables var1 and var2:
- AC2001: table constraint which applies the AC2001 algorithm, - AC3: table constraint which applies the AC3 algorithm, - AC3rm: table constraint which applies the AC3 rm algorithm, - AC3bit+rm (default): table constraint which applies the AC3 bit+rm algorithm, - FC: table constraint which applies forward checking algorithm. |
default Constraint |
IIntConstraintFactory.times(IntVar X,
int Y,
IntVar Z)
Creates a multiplication constraint: X * Y = Z
|
default Constraint |
IIntConstraintFactory.times(IntVar X,
IntVar Y,
int Z)
Creates a multiplication constraint: X * Y = Z
|
default Constraint |
IIntConstraintFactory.times(IntVar X,
IntVar Y,
IntVar Z)
Creates a multiplication constraint: X * Y = Z
|
default Constraint |
IIntConstraintFactory.tree(IntVar[] succs,
IntVar nbTrees)
Creates a tree constraint.
|
default Constraint |
IIntConstraintFactory.tree(IntVar[] succs,
IntVar nbTrees)
Creates a tree constraint.
|
default Constraint |
IIntConstraintFactory.tree(IntVar[] succs,
IntVar nbTrees,
int offset)
Creates a tree constraint.
|
default Constraint |
IIntConstraintFactory.tree(IntVar[] succs,
IntVar nbTrees,
int offset)
Creates a tree constraint.
|
default Constraint |
ISetConstraintFactory.union(IntVar[] ints,
SetVar union)
Creates a constraint ensuring that union is exactly the union of values taken by ints,
|
boolean |
Propagator.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
Arithmetic(IntVar var,
Operator op,
int cste) |
Arithmetic(IntVar var1,
Operator op,
IntVar var2) |
Arithmetic(IntVar var1,
Operator op1,
IntVar var2,
Operator op2,
int cste) |
Modifier and Type | Method and Description |
---|---|
void |
PropDistanceXYC.filterFromVarToVar(IntVar var1,
IntVar var2)
Initial propagation in case of EQ and enumerated domains
|
void |
PropDistanceXYC.filterGTonVar(IntVar v0,
IntVar v1)
In case of a GT, due to a modification on v0 domain
|
void |
PropDistanceXYC.filterLTonVar(IntVar v0,
IntVar v1)
In case of a LT, due to a modification on v0 domain
|
void |
PropDistanceXYC.filterOnInf(IntVar v0,
IntVar v1)
In case of a EQ, due to a modification of the lower bound of v0
|
void |
PropDistanceXYC.filterOnInst(IntVar v,
int val)
In case of a EQ, due to the instantion to one variable to val
|
void |
PropDistanceXYC.filterOnSup(IntVar v0,
IntVar v1)
In case of a EQ, due to a modification of the upper bound of v0
|
boolean |
PropSquare.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropNotEqualXY_C.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropNotEqualX_YC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropNotEqualX_Y.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropLessOrEqualXY_C.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropGreaterOrEqualXY_C.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropGreaterOrEqualX_YC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropGreaterOrEqualX_Y.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropEqualXY_C.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropEqualX_YC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropEqualX_Y.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropDistanceXYC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropAbsolute.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropAbsolute(IntVar X,
IntVar Y) |
PropDistanceXYC(IntVar[] vars,
Operator operator,
int cste) |
PropEqualX_Y(IntVar x,
IntVar y) |
PropEqualX_YC(IntVar[] vars,
int c) |
PropEqualXY_C(IntVar[] vars,
int c) |
PropGreaterOrEqualX_Y(IntVar[] vars) |
PropGreaterOrEqualX_YC(IntVar[] vars,
int c) |
PropGreaterOrEqualXY_C(IntVar[] vars,
int c) |
PropLessOrEqualXY_C(IntVar[] vars,
int c) |
PropNotEqualX_Y(IntVar x,
IntVar y) |
PropNotEqualX_YC(IntVar[] vars,
int c) |
PropNotEqualXY_C(IntVar[] vars,
int c) |
PropScale(IntVar x,
int y,
IntVar z)
Scale propagator : ensures x * y = z
|
PropSquare(IntVar X,
IntVar Y) |
Modifier and Type | Method and Description |
---|---|
static Constraint |
ElementFactory.detect(IntVar VALUE,
int[] TABLE,
IntVar INDEX,
int OFFSET)
Detect and return the most adapted Element propagator wrt to the values in TABLE
|
boolean |
PropElement.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropElement(IntVar value,
int[] values,
IntVar index,
int offset)
Create a propagator which ensures that VALUE = TABLE[INDEX-OFFSET] holds.
|
Modifier and Type | Method and Description |
---|---|
static Tuples |
TuplesFactory.absolute(IntVar VAR1,
IntVar VAR2)
Generate valid tuples for absolute constraint: VAR1 = |VAR2|
|
static Tuples |
TuplesFactory.allDifferent(IntVar... VARS)
Generate valid tuples for allDifferent constraint
|
static Tuples |
TuplesFactory.allEquals(IntVar... VARS)
Generate valid tuples for allEquals constraint
|
static Tuples |
TuplesFactory.arithm(IntVar VAR1,
String OP,
IntVar VAR2)
Generate valid tuples for VAR1 OP VAR2, where OP in {"=", "!
|
static boolean |
TuplesFactory.canBeTupled(IntVar... VARS)
Check whether the intension constraint to extension constraint substitution is enabled and can be achieved
|
ESat |
Tuples.check(IntVar... vars)
Checks entailment of a table constraint over vars with this Tuples object
|
static Tuples |
TuplesFactory.element(IntVar VALUE,
int[] TABLE,
IntVar INDEX,
int OFFSET)
Generate valid tuples for an element constraint : TABLE[INDEX-OFFSET] = VALUE
|
static Tuples |
TuplesFactory.eucl_div(IntVar DIVIDEND,
IntVar DIVISOR,
IntVar RESULT)
Generate valid tuples for euclidean division constraint: DIVIDEND / DIVISOR = RESULT, rounding towards 0
|
static Tuples |
TuplesFactory.generateTuples(TupleValidator filter,
boolean feasible,
IntVar... vars)
A method that generates all tuples from a set of variables and stores (and returns) the valid tuples wrt to the
filter . |
static Tuples |
TuplesFactory.lex_chain_less_eq(IntVar... VARS)
Generate valid tuples for lexChainLessEq constraint
|
static Tuples |
TuplesFactory.lex_chain_less(IntVar... VARS)
Generate valid tuples for lexChainLess constraint
|
static Tuples |
TuplesFactory.maximum(IntVar VAR1,
IntVar VAR2,
IntVar MAX)
Generate valid tuples for minus constraint: MAX = max(VAR1,VAR2)
|
static Tuples |
TuplesFactory.minimum(IntVar VAR1,
IntVar VAR2,
IntVar MIN)
Generate valid tuples for minimum constraint: MIN = min(VAR1,VAR2)
|
static Tuples |
TuplesFactory.minus(IntVar VAR1,
IntVar VAR2,
IntVar RESULT)
Generate valid tuples for minus constraint: VAR1 - VAR2 = RESULT
|
static Tuples |
TuplesFactory.modulo(IntVar VAR1,
IntVar VAR2,
IntVar MOD)
Generate valid tuples for minimum constraint: VAR1 % VAR2 = MOD
|
static Tuples |
TuplesFactory.plus(IntVar VAR1,
IntVar VAR2,
IntVar RESULT)
Generate valid tuples for plus constraint: VAR1 + VAR2 = RESULT
|
static Tuples |
TuplesFactory.power(IntVar VAR1,
IntVar VAR2,
int POWER)
Generate valid tuples for absolute constraint: VAR1 = VAR2^POWER
|
static Tuples |
TuplesFactory.scalar(IntVar[] VARS,
int[] COEFFS,
IntVar SCALAR,
int SCALAR_COEFF)
Generate valid tuples for ∑i in |VARS|VARSi*COEFFSi OPERATOR SCALAR
|
static Tuples |
TuplesFactory.scalar(IntVar[] VARS,
int[] COEFFS,
IntVar SCALAR,
int SCALAR_COEFF)
Generate valid tuples for ∑i in |VARS|VARSi*COEFFSi OPERATOR SCALAR
|
static Tuples |
TuplesFactory.scalar(IntVar[] VARS,
int[] COEFFS,
String OPERATOR,
IntVar SCALAR,
int SCALAR_COEFF,
int CSTE)
Generate valid tuples for ∑i in |VARS|VARSi*COEFFSi OPERATOR SCALAR + CSTE
with OPERATOR in {"=", "!
|
static Tuples |
TuplesFactory.scalar(IntVar[] VARS,
int[] COEFFS,
String OPERATOR,
IntVar SCALAR,
int SCALAR_COEFF,
int CSTE)
Generate valid tuples for ∑i in |VARS|VARSi*COEFFSi OPERATOR SCALAR + CSTE
with OPERATOR in {"=", "!
|
static Tuples |
TuplesFactory.square(IntVar VAR1,
IntVar VAR2)
Generate valid tuples for absolute constraint: VAR1 = VAR2^2
|
static Tuples |
TuplesFactory.sum(IntVar[] VARS,
String OPERATOR,
IntVar SUM,
int CSTE)
Generate valid tuples for ∑i in |VARS|VARSi OPERATOR SUM + CSTE
with OPERATOR in {"=", "!
|
static Tuples |
TuplesFactory.sum(IntVar[] VARS,
String OPERATOR,
IntVar SUM,
int CSTE)
Generate valid tuples for ∑i in |VARS|VARSi OPERATOR SUM + CSTE
with OPERATOR in {"=", "!
|
static Tuples |
TuplesFactory.times(IntVar VAR1,
IntVar VAR2,
IntVar RESULT)
Generate valid tuples for times constraint: VAR1 * VAR2 = RESULT
|
Modifier and Type | Field and Description |
---|---|
protected IntVar |
PropBinCSP.v0 |
protected IntVar |
PropBinCSP.v1 |
Modifier and Type | Method and Description |
---|---|
boolean |
PropBinAC3bitrm.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropBinAC2001(IntVar x,
IntVar y,
Tuples tuples) |
PropBinAC3(IntVar x,
IntVar y,
Tuples tuples) |
PropBinAC3bitrm(IntVar x,
IntVar y,
Tuples tuples) |
PropBinAC3rm(IntVar x,
IntVar y,
Tuples tuples) |
PropBinCSP(IntVar x,
IntVar y,
BinRelation relation) |
PropBinFC(IntVar x,
IntVar y,
Tuples tuples) |
Modifier and Type | Field and Description |
---|---|
protected IntVar[] |
ValidityChecker.vars |
Modifier and Type | Method and Description |
---|---|
protected boolean |
LargeRelation.valid(int[] tuple,
IntVar[] vars) |
Modifier and Type | Method and Description |
---|---|
boolean |
PropKnapsack.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropDiffN(IntVar[] x,
IntVar[] y,
IntVar[] dx,
IntVar[] dy,
boolean fast) |
PropDiffN(IntVar[] x,
IntVar[] y,
IntVar[] dx,
IntVar[] dy,
boolean fast) |
PropDiffN(IntVar[] x,
IntVar[] y,
IntVar[] dx,
IntVar[] dy,
boolean fast) |
PropDiffN(IntVar[] x,
IntVar[] y,
IntVar[] dx,
IntVar[] dy,
boolean fast) |
PropIntValuePrecedeChain(IntVar[] vars,
int s,
int t) |
PropKLoops(IntVar[] succs,
int offSet,
IntVar nbLoops)
Incremental propagator which restricts the number of loops:
|{succs[i]=i+offSet}| = nbLoops
|
PropKLoops(IntVar[] succs,
int offSet,
IntVar nbLoops)
Incremental propagator which restricts the number of loops:
|{succs[i]=i+offSet}| = nbLoops
|
PropKnapsack(IntVar[] itemOccurence,
IntVar capacity,
IntVar power,
int[] weight,
int[] energy) |
PropKnapsack(IntVar[] itemOccurence,
IntVar capacity,
IntVar power,
int[] weight,
int[] energy) |
Modifier and Type | Method and Description |
---|---|
boolean |
PropAllDiffInst.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropAllDiffBC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
AllDifferent(IntVar[] vars,
String type) |
PropAllDiffAC(IntVar[] variables)
AllDifferent constraint for integer variables
enables to control the cardinality of the matching
|
PropAllDiffAdaptative(IntVar[] variables)
AllDifferent constraint for integer variables
enables to control the cardinality of the matching
|
PropAllDiffBC(IntVar[] variables) |
PropAllDiffInst(IntVar[] variables)
AllDifferent constraint for integer variables
enables to control the cardinality of the matching
|
Modifier and Type | Method and Description |
---|---|
void |
AlgoAllDiffBC.reset(IntVar[] variables) |
Constructor and Description |
---|
AlgoAllDiffAC(IntVar[] variables,
ICause cause) |
Modifier and Type | Method and Description |
---|---|
boolean |
Condition.holdOnVar(IntVar x) |
Constructor and Description |
---|
PropCondAllDiff_AC(IntVar[] variables,
Condition condition)
AllDifferent constraint for integer variables
Holds only on the subset of variables satisfying the given condition
|
PropCondAllDiffInst(IntVar[] variables,
Condition c,
boolean mode)
ConditionnalAllDifferent constraint for integer variables
enables to control the cardinality of the matching
IF mode
for all X in vars, condition(X) => X !
|
Constructor and Description |
---|
PropAmongGAC(IntVar[] variables,
int[] values)
Creates a propagator for Among:
Counts the number of decision variables which take a value in the input value set
|
Modifier and Type | Field and Description |
---|---|
gnu.trove.map.hash.TObjectIntHashMap<IntVar> |
PropMultiCostRegular.map
Map to retrieve rapidly the index of a given variable.
|
Constructor and Description |
---|
CostRegular(IntVar[] ivars,
IntVar cost,
ICostAutomaton cautomaton) |
CostRegular(IntVar[] ivars,
IntVar cost,
ICostAutomaton cautomaton) |
PropCostRegular(IntVar[] variables,
ICostAutomaton cautomaton,
StoredValuedDirectedMultiGraph graph) |
PropMultiCostRegular(IntVar[] variables,
IntVar[] costvariables,
ICostAutomaton cauto)
Constructs a multi-cost-regular propagator
|
PropMultiCostRegular(IntVar[] variables,
IntVar[] costvariables,
ICostAutomaton cauto)
Constructs a multi-cost-regular propagator
|
PropRegular(IntVar[] variables,
IAutomaton automaton) |
Modifier and Type | Method and Description |
---|---|
static ICostAutomaton |
CostAutomaton.makeMultiResources(IAutomaton auto,
int[][][][] c,
IntVar[] z) |
static ICostAutomaton |
CostAutomaton.makeMultiResources(IAutomaton auto,
int[][][] c,
IntVar[] z) |
Modifier and Type | Method and Description |
---|---|
double |
NullPenaltyFunction.maxGHat(double lambda,
IntVar var)
Deprecated.
|
double |
IPenaltyFunction.maxGHat(double lambda,
IntVar var) |
double |
AbstractPenaltyFunction.maxGHat(double lambda,
IntVar var) |
double |
NullPenaltyFunction.minGHat(double lambda,
IntVar var)
Deprecated.
|
double |
IPenaltyFunction.minGHat(double lambda,
IntVar var) |
double |
AbstractPenaltyFunction.minGHat(double lambda,
IntVar var) |
Modifier and Type | Method and Description |
---|---|
void |
StoredValuedDirectedMultiGraph.removeArc(int arcId,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator,
ICause aCause) |
void |
StoredValuedDirectedMultiGraph.updateLeft(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator) |
void |
StoredValuedDirectedMultiGraph.updateLPFS(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator)
Deprecated.
|
void |
StoredValuedDirectedMultiGraph.updateLPFT(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator)
Deprecated.
|
void |
StoredValuedDirectedMultiGraph.updateRight(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator) |
void |
StoredValuedDirectedMultiGraph.updateSPFS(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator)
Deprecated.
|
void |
StoredValuedDirectedMultiGraph.updateSPFT(int nid,
gnu.trove.stack.TIntStack toRemove,
Propagator<IntVar> propagator)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
boolean[] |
FastPathFinder.computeShortestAndLongestPath(gnu.trove.stack.TIntStack removed,
IntVar[] z,
PropMultiCostRegular propagator) |
void |
StoredDirectedMultiGraph.delayedBoundUpdate(gnu.trove.stack.TIntStack toRemove,
IntVar[] z,
int... dim) |
Modifier and Type | Method and Description |
---|---|
boolean |
StoredDirectedMultiGraph.removeArc(int arcId,
gnu.trove.stack.TIntStack toRemove,
gnu.trove.stack.TIntStack[] updateLeft,
gnu.trove.stack.TIntStack[] updateRight,
Propagator<IntVar> propagator) |
void |
StoredDirectedMultiGraph.updateLeft(gnu.trove.stack.TIntStack updateLeft,
gnu.trove.stack.TIntStack toRemove,
int dim,
boolean[] modBound,
Propagator<IntVar> propagator) |
void |
StoredDirectedMultiGraph.updateRight(gnu.trove.stack.TIntStack updateRight,
gnu.trove.stack.TIntStack toRemove,
int dim,
boolean[] modBound,
Propagator<IntVar> propagator) |
Constructor and Description |
---|
StoredDirectedMultiGraph(IEnvironment environment,
org.jgrapht.graph.DirectedMultigraph<Node,Arc> graph,
int[][] layers,
int[] starts,
int[] offsets,
int supportLength,
ICostAutomaton pi,
IntVar[] z) |
Modifier and Type | Method and Description |
---|---|
void |
StoredDirectedMultiGraph.clearSupports(int idxVar,
int val,
Propagator<IntVar> p) |
Constructor and Description |
---|
PropItemToLoad(IntVar[] binOfItem,
int[] itemSize,
IntVar[] binLoad,
int offset)
Incremental propagator for a Bin Packing constraint
Propagates item/bin allocations to bin loads
Should be used together with PropLoadToItem
|
PropItemToLoad(IntVar[] binOfItem,
int[] itemSize,
IntVar[] binLoad,
int offset)
Incremental propagator for a Bin Packing constraint
Propagates item/bin allocations to bin loads
Should be used together with PropLoadToItem
|
PropLoadToItem(IntVar[] binOfItem,
int[] itemSize,
IntVar[] binLoad,
int offset)
Incremental propagator for a Bin Packing constraint
Propagates bin loads to item/bin allocations
Should be used together with PropItemToLoad
|
PropLoadToItem(IntVar[] binOfItem,
int[] itemSize,
IntVar[] binLoad,
int offset)
Incremental propagator for a Bin Packing constraint
Propagates bin loads to item/bin allocations
Should be used together with PropItemToLoad
|
Modifier and Type | Method and Description |
---|---|
boolean |
PropInverseChannelAC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropClauseChanneling.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropBitChanneling(IntVar OCTET,
BoolVar[] BITS) |
PropClauseChanneling(IntVar iv,
BoolVar[] eb,
BoolVar[] lb) |
PropEnumDomainChanneling(BoolVar[] bvars,
IntVar aVar,
int offSet) |
PropInverseChannelAC(IntVar[] X,
IntVar[] Y,
int minX,
int minY) |
PropInverseChannelAC(IntVar[] X,
IntVar[] Y,
int minX,
int minY) |
PropInverseChannelBC(IntVar[] X,
IntVar[] Y,
int minX,
int minY) |
PropInverseChannelBC(IntVar[] X,
IntVar[] Y,
int minX,
int minY) |
Constructor and Description |
---|
PropCircuit_AntiArboFiltering(IntVar[] succs,
int offSet,
CircuitConf conf) |
PropCircuit_ArboFiltering(IntVar[] succs,
int offSet,
CircuitConf conf) |
PropCircuitSCC(IntVar[] succs,
int offSet,
CircuitConf conf) |
PropNoSubtour(IntVar[] variables,
int offset)
Ensures that graph has no subCircuit, with Caseaux/Laburthe/Pesant algorithm
runs incrementally in O(1) per instantiation event
|
PropSubcircuit(IntVar[] variables,
int offset,
IntVar length) |
PropSubcircuit(IntVar[] variables,
int offset,
IntVar length) |
PropSubcircuitDominatorFilter(IntVar[] succs,
int offSet,
boolean adaptable) |
Modifier and Type | Method and Description |
---|---|
boolean |
PropCountVar.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropCount_AC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropCount_AC(IntVar[] decvars,
int restrictedValue,
IntVar valueCardinality)
Propagator for Count Constraint for integer variables
Performs Arc Consistency
|
PropCount_AC(IntVar[] decvars,
int restrictedValue,
IntVar valueCardinality)
Propagator for Count Constraint for integer variables
Performs Arc Consistency
|
PropCountVar(IntVar[] decvars,
IntVar restrictedValue,
IntVar valueCardinality)
Propagator for Count Constraint for integer variables
Performs Arc Consistency
|
PropCountVar(IntVar[] decvars,
IntVar restrictedValue,
IntVar valueCardinality)
Propagator for Count Constraint for integer variables
Performs Arc Consistency
|
Modifier and Type | Field and Description |
---|---|
protected IntVar |
PropCumulative.capa |
protected IntVar[] |
PropCumulative.d |
protected IntVar[] |
PropCumulative.e |
protected IntVar[] |
PropCumulative.h |
protected IntVar[] |
PropCumulative.s |
Modifier and Type | Field and Description |
---|---|
protected Propagator<IntVar> |
CumulFilter.aCause |
Modifier and Type | Method and Description |
---|---|
static IntVar[] |
Cumulative.extract(Task[] tasks,
IntVar[] heights,
IntVar capa) |
Modifier and Type | Method and Description |
---|---|
protected boolean |
SweepHeiSortCumulFilter.checkSort(IntVar[] h,
int nbT) |
static IntVar[] |
Cumulative.extract(Task[] tasks,
IntVar[] heights,
IntVar capa) |
static IntVar[] |
Cumulative.extract(Task[] tasks,
IntVar[] heights,
IntVar capa) |
void |
TimeCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
TimeCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
TimeCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
TimeCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
TimeCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepHeiSortCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepHeiSortCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepHeiSortCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepHeiSortCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepHeiSortCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
SweepCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
NRJCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
NRJCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
NRJCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
NRJCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
NRJCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DisjunctiveTaskIntervalFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DisjunctiveTaskIntervalFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DisjunctiveTaskIntervalFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DisjunctiveTaskIntervalFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DisjunctiveTaskIntervalFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DefaultCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DefaultCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DefaultCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DefaultCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
void |
DefaultCumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks) |
abstract void |
CumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks)
Filters the cumulative constraint over the subset of tasks induced by tasks
|
abstract void |
CumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks)
Filters the cumulative constraint over the subset of tasks induced by tasks
|
abstract void |
CumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks)
Filters the cumulative constraint over the subset of tasks induced by tasks
|
abstract void |
CumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks)
Filters the cumulative constraint over the subset of tasks induced by tasks
|
abstract void |
CumulFilter.filter(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
ISet tasks)
Filters the cumulative constraint over the subset of tasks induced by tasks
|
protected void |
TimeCumulFilter.filterInf(IntVar start,
int dlb,
int hlb,
int min,
int max,
int[] time,
int capaMax) |
protected void |
TimeCumulFilter.filterSup(IntVar end,
int dlb,
int hlb,
int min,
int max,
int[] time,
int capaMax) |
protected void |
SweepCumulFilter.pruneMax(IntVar[] e) |
protected void |
HeightCumulFilter.pruneMax(IntVar[] e) |
protected void |
SweepCumulFilter.pruneMin(IntVar[] s) |
protected void |
HeightCumulFilter.pruneMin(IntVar[] s) |
protected void |
SweepCumulFilter.removeNullDurations(IntVar[] d,
ISet tasks) |
protected boolean |
SweepHeiSortCumulFilter.sweep(IntVar capamax,
IntVar[] h,
int nbT) |
protected boolean |
SweepHeiSortCumulFilter.sweep(IntVar capamax,
IntVar[] h,
int nbT) |
protected boolean |
SweepCumulFilter.sweep(IntVar capamax,
IntVar[] h,
int nbT) |
protected boolean |
SweepCumulFilter.sweep(IntVar capamax,
IntVar[] h,
int nbT) |
protected boolean |
HeightCumulFilter.sweep(IntVar capamax,
IntVar[] h,
int nbT) |
protected boolean |
HeightCumulFilter.sweep(IntVar capamax,
IntVar[] h,
int nbT) |
Modifier and Type | Method and Description |
---|---|
abstract CumulFilter |
Cumulative.Filter.make(int n,
Propagator<IntVar> cause)
Create an instance of the filtering algorithm
|
Constructor and Description |
---|
Cumulative(Task[] tasks,
IntVar[] heights,
IntVar capacity,
boolean graphBased,
Cumulative.Filter... filters)
Cumulative constraint
|
Cumulative(Task[] tasks,
IntVar[] heights,
IntVar capacity,
boolean graphBased,
Cumulative.Filter... filters)
Cumulative constraint
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean reactToFineEvt,
Cumulative.Filter... filters)
protected constructor, should not be called by a user
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean reactToFineEvt,
Cumulative.Filter... filters)
protected constructor, should not be called by a user
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean reactToFineEvt,
Cumulative.Filter... filters)
protected constructor, should not be called by a user
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean reactToFineEvt,
Cumulative.Filter... filters)
protected constructor, should not be called by a user
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean reactToFineEvt,
Cumulative.Filter... filters)
protected constructor, should not be called by a user
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
Cumulative.Filter... filters)
Classical cumulative propagator
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
Cumulative.Filter... filters)
Classical cumulative propagator
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
Cumulative.Filter... filters)
Classical cumulative propagator
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
Cumulative.Filter... filters)
Classical cumulative propagator
|
PropCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
Cumulative.Filter... filters)
Classical cumulative propagator
|
PropGraphCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean fast,
Cumulative.Filter... filters)
Graph-based cumulative propagator:
- only filters over subsets of overlapping tasks
|
PropGraphCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean fast,
Cumulative.Filter... filters)
Graph-based cumulative propagator:
- only filters over subsets of overlapping tasks
|
PropGraphCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean fast,
Cumulative.Filter... filters)
Graph-based cumulative propagator:
- only filters over subsets of overlapping tasks
|
PropGraphCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean fast,
Cumulative.Filter... filters)
Graph-based cumulative propagator:
- only filters over subsets of overlapping tasks
|
PropGraphCumulative(IntVar[] s,
IntVar[] d,
IntVar[] e,
IntVar[] h,
IntVar capa,
boolean fast,
Cumulative.Filter... filters)
Graph-based cumulative propagator:
- only filters over subsets of overlapping tasks
|
Constructor and Description |
---|
CumulFilter(int nbMaxTasks,
Propagator<IntVar> cause)
An object which can filter subset of tasks for the cumulative constraint
|
DefaultCumulFilter(int nbMaxTasks,
Propagator<IntVar> cause) |
DisjunctiveTaskIntervalFilter(int nbMaxTasks,
Propagator<IntVar> cause) |
HeightCumulFilter(int n,
Propagator<IntVar> cause) |
NRJCumulFilter(int n,
Propagator<IntVar> cause) |
SweepCumulFilter(int n,
Propagator<IntVar> cause) |
SweepHeiSortCumulFilter(int n,
Propagator<IntVar> cause) |
TimeCumulFilter(int nbMaxTasks,
Propagator<IntVar> cause) |
Modifier and Type | Method and Description |
---|---|
boolean |
PropElementV_fast.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropElementV_fast(IntVar value,
IntVar[] values,
IntVar index,
int offset,
boolean fast) |
PropElementV_fast(IntVar value,
IntVar[] values,
IntVar index,
int offset,
boolean fast) |
Modifier and Type | Method and Description |
---|---|
static Constraint |
GlobalCardinality.reformulate(IntVar[] vars,
IntVar[] card,
Model model) |
static Constraint |
GlobalCardinality.reformulate(IntVar[] vars,
IntVar[] card,
Model model) |
Constructor and Description |
---|
GlobalCardinality(IntVar[] vars,
int[] values,
IntVar[] cards) |
GlobalCardinality(IntVar[] vars,
int[] values,
IntVar[] cards) |
PropFastGCC(IntVar[] decvars,
int[] restrictedValues,
gnu.trove.map.hash.TIntIntHashMap map,
IntVar[] valueCardinalities)
Propagator for Global Cardinality Constraint (GCC) for integer variables
Basic filter: no particular consistency but fast and with a correct checker
|
PropFastGCC(IntVar[] decvars,
int[] restrictedValues,
gnu.trove.map.hash.TIntIntHashMap map,
IntVar[] valueCardinalities)
Propagator for Global Cardinality Constraint (GCC) for integer variables
Basic filter: no particular consistency but fast and with a correct checker
|
Constructor and Description |
---|
PropLex(IntVar[] X,
IntVar[] Y,
boolean strict) |
PropLex(IntVar[] X,
IntVar[] Y,
boolean strict) |
PropLexChain(IntVar[][] variables,
boolean strict) |
PropLexInt(IntVar[] X,
int[] Y,
boolean strict) |
Constructor and Description |
---|
PropMax(IntVar[] variables,
IntVar maxVar) |
PropMax(IntVar[] variables,
IntVar maxVar) |
PropMin(IntVar[] variables,
IntVar maxVar) |
PropMin(IntVar[] variables,
IntVar maxVar) |
Constructor and Description |
---|
PropAMNV(IntVar[] X,
IntVar N,
G graph,
F heur,
R[] rules)
Creates a propagator for the atMostNValues constraint
The number of distinct values in X is at most equal to N
|
PropAMNV(IntVar[] X,
IntVar N,
G graph,
F heur,
R[] rules)
Creates a propagator for the atMostNValues constraint
The number of distinct values in X is at most equal to N
|
PropAtLeastNValues_AC(IntVar[] variables,
int[] vals,
IntVar nValues)
AtLeastNValues Propagator (similar to SoftAllDiff)
The number of distinct values in vars is at least nValues
Performs Generalized Arc Consistency based on Maximum Bipartite Matching
The worst case time complexity is O(nm) but this is very pessimistic
In practice it is more like O(m) where m is the number of variable-value pairs
|
PropAtLeastNValues_AC(IntVar[] variables,
int[] vals,
IntVar nValues)
AtLeastNValues Propagator (similar to SoftAllDiff)
The number of distinct values in vars is at least nValues
Performs Generalized Arc Consistency based on Maximum Bipartite Matching
The worst case time complexity is O(nm) but this is very pessimistic
In practice it is more like O(m) where m is the number of variable-value pairs
|
PropAtLeastNValues(IntVar[] variables,
int[] concernedValues,
IntVar nValues)
Propagator for the NValues constraint
The number of distinct values among concerned values in the set of variables vars is exactly equal to nValues
No level of consistency for the filtering
|
PropAtLeastNValues(IntVar[] variables,
int[] concernedValues,
IntVar nValues)
Propagator for the NValues constraint
The number of distinct values among concerned values in the set of variables vars is exactly equal to nValues
No level of consistency for the filtering
|
PropAtMostNValues_BC(IntVar[] variables,
IntVar nValues)
The number of distinct values in vars is at most nValues
Performs Bound Consistency in O(n+d) with
n = |vars|
d = maxValue - minValue (from initial domains)
=> very appropriate when d <= n It is indeed much better than the usual time complexity of O(n.log(n))
=> not appropriate when d >> n (you should encode another data structure and a quick sort algorithm)
|
PropAtMostNValues_BC(IntVar[] variables,
IntVar nValues)
The number of distinct values in vars is at most nValues
Performs Bound Consistency in O(n+d) with
n = |vars|
d = maxValue - minValue (from initial domains)
=> very appropriate when d <= n It is indeed much better than the usual time complexity of O(n.log(n))
=> not appropriate when d >> n (you should encode another data structure and a quick sort algorithm)
|
PropAtMostNValues(IntVar[] variables,
int[] concernedValues,
IntVar nValues)
Propagator for the NValues constraint
The number of distinct values among concerned values in the set of variables vars is exactly equal to nValues
No level of consistency for the filtering
|
PropAtMostNValues(IntVar[] variables,
int[] concernedValues,
IntVar nValues)
Propagator for the NValues constraint
The number of distinct values among concerned values in the set of variables vars is exactly equal to nValues
No level of consistency for the filtering
|
Modifier and Type | Field and Description |
---|---|
protected IntVar[] |
Gi.X |
Constructor and Description |
---|
Gci(IntVar[] X)
Creates the constrained intersection graph of X and D
by automatically detecting disequalities and allDifferent constraints.
|
Gci(IntVar[] X,
D D)
Creates the constrained intersection graph of X and D
|
Gi(IntVar[] X)
Creates the intersection graph of X
|
Modifier and Type | Method and Description |
---|---|
protected void |
R3.enforceEq(int i,
int j,
IntVar[] vars,
Propagator aCause) |
void |
R4.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
void |
R3.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
void |
R2.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
void |
R1.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
void |
R.filter(IntVar[] vars,
UndirectedGraph graph,
F heur,
Propagator aCause) |
Constructor and Description |
---|
PropKeysorting(IntVar[][] x,
IntVar[][] y,
IntVar[] p,
int key)
Creates a new
PropSort instance. |
PropKeysorting(IntVar[][] x,
IntVar[][] y,
IntVar[] p,
int key)
Creates a new
PropSort instance. |
PropKeysorting(IntVar[][] x,
IntVar[][] y,
IntVar[] p,
int key)
Creates a new
PropSort instance. |
PropSort(IntVar[] x,
IntVar[] y)
Creates a new
PropSort instance. |
PropSort(IntVar[] x,
IntVar[] y)
Creates a new
PropSort instance. |
Modifier and Type | Field and Description |
---|---|
protected IntVar |
PropSumBool.sum
The resulting variable
|
Modifier and Type | Method and Description |
---|---|
static Constraint |
IntLinCombFactory.reduce(IntVar[] VARS,
int[] COEFFS,
Operator OPERATOR,
IntVar SCALAR)
Reduce coefficients, and variables if required, when dealing with a scalar product
|
static Constraint |
IntLinCombFactory.reduce(IntVar[] VARS,
int[] COEFFS,
Operator OPERATOR,
IntVar SCALAR)
Reduce coefficients, and variables if required, when dealing with a scalar product
|
static Constraint |
IntLinCombFactory.reduce(IntVar[] VARS,
Operator OPERATOR,
IntVar SUM)
Reduce coefficients, and variables if required, when dealing with a sum (all coefficients are implicitly equal to 1)
|
static Constraint |
IntLinCombFactory.reduce(IntVar[] VARS,
Operator OPERATOR,
IntVar SUM)
Reduce coefficients, and variables if required, when dealing with a sum (all coefficients are implicitly equal to 1)
|
static Constraint |
IntLinCombFactory.selectScalar(IntVar[] VARS,
int[] COEFFS,
Operator OPERATOR,
int RESULT)
Select the most relevant ScalarProduct constraint to return
|
static Constraint |
IntLinCombFactory.selectSum(IntVar[] VARS,
int[] COEFFS,
Operator OPERATOR,
int RESULT,
int nbools)
Select the most relevant Sum constraint to return
|
boolean |
PropSum.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropScalar(IntVar[] variables,
int[] coeffs,
int pos,
Operator o,
int b)
Create a scalar product: SUM(x_i*c_i) o b
Variables and coefficients are excepted to be ordered wrt to coefficients: first positive ones then negative ones.
|
PropSum(IntVar[] variables,
int pos,
Operator o,
int b)
Creates a sum propagator: SUM(x_i) o b
Coefficients are induced by
pos :
those before pos (included) are equal to 1,
the other ones are equal to -1. |
PropSumBool(BoolVar[] variables,
int pos,
Operator o,
IntVar sum,
int b)
Creates a sum propagator: SUM(x_i) Op sum + b, where x_i are boolean variables.
|
PropSumBool(BoolVar[] variables,
int pos,
Operator o,
IntVar sum,
int b,
boolean reactOnFineEvent)
Creates a sum propagator: SUM(x_i) Op sum + b, where x_i are boolean variables.
|
PropSumBoolIncr(BoolVar[] variables,
int pos,
Operator o,
IntVar sum,
int b)
Creates a sum propagator: SUM(x_i) Op sum + b, where x_i are boolean variables, maintained incrementally.
|
Constructor and Description |
---|
PropAntiArborescences(IntVar[] succs,
int offSet,
boolean linear)
AntiArborescences propagation (simplification from tree constraint) based on dominators
|
Constructor and Description |
---|
IntEqRealConstraint(IntVar[] intVars,
RealVar[] realVars,
double epsilon)
Channeling between integer variables intVars and real variables realVars.
|
IntEqRealConstraint(IntVar intVar,
RealVar realVar,
double epsilon)
Channeling between an integer variable intVar and a real variable realVar.
|
Modifier and Type | Method and Description |
---|---|
boolean |
PropXneYReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropXneCReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropXltYReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropXltYCReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropXltCReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropXgtCReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropXeqYReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropXeqCReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropReif.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropLocalConDis(IntVar[] vars,
Propagator<IntVar>[][] propagators)
A propagator to deal with constructive disjunction
|
PropXeqCReif(IntVar x,
int c,
BoolVar r) |
PropXeqYReif(IntVar x,
IntVar y,
BoolVar r) |
PropXgtCReif(IntVar x,
int c,
BoolVar r) |
PropXinSReif(IntVar x,
IntIterableRangeSet set,
BoolVar r) |
PropXltCReif(IntVar x,
int c,
BoolVar r) |
PropXltYCReif(IntVar x,
IntVar y,
int c,
BoolVar r) |
PropXltYReif(IntVar x,
IntVar y,
BoolVar r) |
PropXneCReif(IntVar x,
int c,
BoolVar r) |
PropXneYReif(IntVar x,
IntVar y,
BoolVar r) |
Constructor and Description |
---|
PropCardinality(SetVar setVar,
IntVar cardinality)
Propagator ensuring that |setVar| = cardinality
|
PropElement(IntVar index,
SetVar[] array,
int offSet,
SetVar set)
Propagator for element constraint over sets
states that array[index-offSet] = set
|
PropIntBoundedMemberSet(SetVar setVar,
IntVar intVar)
Propagator for Member constraint
val(intVar) is in setVar
|
PropIntChannel(SetVar[] setsV,
IntVar[] intsV,
int offSet1,
int offSet2)
Channeling between set variables and integer variables
x in sets[y-offSet1] <=> ints[x-offSet2] = y
|
PropIntEnumMemberSet(SetVar setVar,
IntVar intVar)
Propagator for Member constraint
val(intVar) is in setVar
|
PropMaxElement(SetVar setVar,
int[] weights,
int offset,
IntVar max,
boolean notEmpty)
Retrieves the maximum element induced by set
MAX{weight[i-offset] | i in setVar} = max
|
PropMaxElement(SetVar setVar,
IntVar max,
boolean notEmpty)
Retrieves the maximum element of the set
MAX{i | i in setVar} = max
|
PropMinElement(SetVar setVar,
int[] weights,
int offSet,
IntVar min,
boolean notEmpty)
Retrieves the minimum element induced by setVar
MIN{weights[i-offSet] | i in setVar} = min
|
PropMinElement(SetVar setVar,
IntVar min,
boolean notEmpty)
Retrieves the minimum element of the set
MIN(i | i in setVar) = min
|
PropNbEmpty(SetVar[] sets,
IntVar nbEmpty)
Restricts the number of empty sets
|{s in sets such that |s|=0}| = nbEmpty
|
PropNotMemberIntSet(IntVar iv,
SetVar sv) |
PropNotMemberSetInt(IntVar intVar,
SetVar setVar) |
PropSetIntValuesUnion(IntVar[] X,
SetVar values) |
PropSumOfElements(SetVar setVar,
int[] weights,
int offset,
IntVar sum)
Sums elements given by a set variable:
if(weights !
|
Modifier and Type | Method and Description |
---|---|
protected boolean |
PropDivXYZ.oppSign(IntVar a,
IntVar b)
A take the opposite signs of B
|
protected boolean |
PropDivXYZ.sameSign(IntVar a,
IntVar b)
A take the signs of B
|
boolean |
PropTimesNaive.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropMinBC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropMaxBC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
PropDistanceXYZ(IntVar[] vars,
Operator op)
Enforces |x0 - x1| op x2
where op can be =, <, >
|
PropDivXYZ(IntVar x,
IntVar y,
IntVar z) |
PropMaxBC(IntVar X,
IntVar Y,
IntVar Z) |
PropMinBC(IntVar X,
IntVar Y,
IntVar Z) |
PropTimesNaive(IntVar v1,
IntVar v2,
IntVar result) |
PropXplusYeqZ(IntVar X,
IntVar Y,
IntVar Z)
Create propagator for ternary sum: X + Y =Z
|
Modifier and Type | Method and Description |
---|---|
boolean |
PropNotMemberEnum.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropNotMemberBound.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropNotEqualXC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropMemberEnum.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropMemberBound.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropLessOrEqualXC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropGreaterOrEqualXC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
boolean |
PropEqualXC.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Constructor and Description |
---|
Member(IntVar var,
int[] values) |
Member(IntVar var,
int lowerbound,
int upperbound) |
NotMember(IntVar var,
int[] values) |
NotMember(IntVar var,
int lowerbound,
int upperbound) |
PropEqualXC(IntVar var,
int cste) |
PropGreaterOrEqualXC(IntVar var,
int cste) |
PropLessOrEqualXC(IntVar var,
int cste) |
PropMemberBound(IntVar var,
int lb,
int ub) |
PropMemberEnum(IntVar var,
int[] values) |
PropNotEqualXC(IntVar var,
int cste) |
PropNotMemberBound(IntVar var,
int lb,
int ub) |
PropNotMemberEnum(IntVar var,
int[] values)
A propagator which forbids values from var domain
|
Modifier and Type | Method and Description |
---|---|
IntVar |
ArrayEventStore.getVariable(int evt) |
Modifier and Type | Method and Description |
---|---|
boolean |
RuleStore.addBoundsRule(IntVar var)
Add an upper bound rule and a lower bound rule, that is, any event on the upper bound or the lower bound of the variable needs to be retained
|
boolean |
RuleStore.addFullDomainRule(IntVar var)
Add a full domain rule, that is, any events involving the variable needs to be retained.
|
boolean |
RuleStore.addLowerBoundRule(IntVar var)
Add a lower bound rule, that is, any event on the lower bound of the variable needs to be retained
|
boolean |
RuleStore.addRemovalRule(IntVar var,
int value)
Add a value removal rule, that is, the event which remove the value needs to be retained.
|
boolean |
RuleStore.addUpperBoundRule(IntVar var)
Add a upper bound rule, that is, any event on the upper bound of the variable needs to be retained
|
default void |
IExplanationEngine.instantiateTo(IntVar var,
int val,
ICause cause,
int oldLB,
int oldUB)
Explain the assignment to
val of var due to cause . |
void |
ExplanationEngine.instantiateTo(IntVar var,
int val,
ICause cause,
int oldLB,
int oldUB)
Explain the assignment to
val of var due to cause . |
boolean |
RuleStore.matchDomain(int ruleMask,
IntVar ivar,
IntEventType evt,
int i1,
int i2,
int i3)
Check whether a variable domain matches a rule
|
void |
ArrayEventStore.pushEvent(IntVar var,
ICause cause,
IEventType mask,
int one,
int two,
int three)
Push an event on the top of this store
|
default void |
IExplanationEngine.removeValue(IntVar var,
int val,
ICause cause)
Explain the removal of the
val from var , due to cause . |
void |
ExplanationEngine.removeValue(IntVar var,
int val,
ICause cause)
Explain the removal of the
val from var , due to cause . |
default void |
IExplanationEngine.updateLowerBound(IntVar var,
int value,
int old,
ICause cause)
Explain the removal of [
old ,value [ from var , due to cause . |
void |
ExplanationEngine.updateLowerBound(IntVar var,
int value,
int old,
ICause cause)
Explain the removal of [
old ,value [ from var , due to cause . |
default void |
IExplanationEngine.updateUpperBound(IntVar var,
int value,
int old,
ICause cause)
Explain the removal of ]
value ,old ] from var , due to cause . |
void |
ExplanationEngine.updateUpperBound(IntVar var,
int value,
int old,
ICause cause)
Explain the removal of ]
value ,old ] from var , due to cause . |
Modifier and Type | Method and Description |
---|---|
IntVar |
IEventStore.getVariable(int evt) |
Modifier and Type | Method and Description |
---|---|
void |
IEventStore.pushEvent(IntVar var,
ICause cause,
IEventType mask,
int one,
int two,
int three) |
Modifier and Type | Method and Description |
---|---|
IntVar |
UnArExpression.intVar() |
IntVar |
NaArExpression.intVar() |
IntVar |
BiArExpression.intVar() |
IntVar |
ArExpression.intVar() |
Modifier and Type | Method and Description |
---|---|
default void |
ArExpression.extractVar(HashSet<IntVar> variables)
Extract the variables from this expression
|
int |
UnArExpression.ieval(int[] values,
Map<IntVar,Integer> map) |
int |
NaArExpression.ieval(int[] values,
Map<IntVar,Integer> map) |
int |
BiArExpression.ieval(int[] values,
Map<IntVar,Integer> map) |
default int |
ArExpression.ieval(int[] values,
Map<IntVar,Integer> map) |
Modifier and Type | Method and Description |
---|---|
boolean |
UnLoExpression.beval(int[] values,
Map<IntVar,Integer> map) |
boolean |
NaLoExpression.beval(int[] values,
Map<IntVar,Integer> map) |
boolean |
BiLoExpression.beval(int[] values,
Map<IntVar,Integer> map) |
void |
UnLoExpression.extractVar(HashSet<IntVar> variables) |
void |
NaLoExpression.extractVar(HashSet<IntVar> variables) |
void |
BiLoExpression.extractVar(HashSet<IntVar> variables) |
Modifier and Type | Method and Description |
---|---|
IntVar |
ReExpression.intVar() |
Modifier and Type | Method and Description |
---|---|
abstract boolean |
ReExpression.beval(int[] values,
Map<IntVar,Integer> map) |
boolean |
NaReExpression.beval(int[] values,
Map<IntVar,Integer> map) |
boolean |
BiReExpression.beval(int[] values,
Map<IntVar,Integer> map) |
abstract void |
ReExpression.extractVar(HashSet<IntVar> variables)
Extract the variables from this expression
|
void |
NaReExpression.extractVar(HashSet<IntVar> variables) |
void |
BiReExpression.extractVar(HashSet<IntVar> variables) |
int |
ReExpression.ieval(int[] values,
Map<IntVar,Integer> map) |
Modifier and Type | Method and Description |
---|---|
static IObjectiveManager<IntVar> |
ObjectiveFactory.makeObjectiveManager(IntVar objective,
ResolutionPolicy policy)
Define the variable to optimize (maximize or minimize)
By default, the manager uses
IObjectiveManager.setStrictDynamicCut() to avoid exploring worse solutions. |
Modifier and Type | Method and Description |
---|---|
static IObjectiveManager<IntVar> |
ObjectiveFactory.makeObjectiveManager(IntVar objective,
ResolutionPolicy policy)
Define the variable to optimize (maximize or minimize)
By default, the manager uses
IObjectiveManager.setStrictDynamicCut() to avoid exploring worse solutions. |
Constructor and Description |
---|
ObjectiveStrategy(IntVar objective,
int[] coefs,
OptimizationPolicy policy)
Defines a parametrized dichotomic branching over the objective variable
BEWARE: only activated after a first solution
|
ObjectiveStrategy(IntVar objective,
OptimizationPolicy policy)
Defines a branching strategy over the objective variable
BEWARE: only activated after a first solution
|
ParetoOptimizer(boolean maximize,
IntVar[] objectives)
Create an object to compute the Pareto front of a multi-objective problem.
|
Modifier and Type | Method and Description |
---|---|
default List<Solution> |
IResolutionHelper.findAllOptimalSolutions(IntVar objective,
boolean maximize,
Criterion... stop)
Attempt to find the solution that optimizes the mono-objective problem defined by
a unique objective variable and an optimization criteria, then finds and stores all optimal solution.
|
default Solution |
IResolutionHelper.findLexOptimalSolution(IntVar[] objectives,
boolean maximize,
Criterion... stop)
Attempts optimize the value of the objectives variable w.r.t. to an optimization criteria.
|
default Solution |
IResolutionHelper.findOptimalSolution(IntVar objective,
boolean maximize,
Criterion... stop)
Attempt to find the solution that optimizes the mono-objective problem defined by a unique objective variable and
an optimization criteria.
|
default List<Solution> |
IResolutionHelper.findParetoFront(IntVar[] objectives,
boolean maximize,
Criterion... stop)
Attempts optimize the value of the objectives variable w.r.t. to an optimization criteria.
|
default Stream<Solution> |
IResolutionHelper.streamOptimalSolutions(IntVar objective,
boolean maximize,
Criterion... stop)
Attempt to find the solution that optimizes the mono-objective problem defined by a unique objective variable and
an optimization criteria, then finds and stores all optimal solution.
|
Modifier and Type | Method and Description |
---|---|
static INeighbor |
INeighborFactory.blackBox(IntVar... vars)
Creates a black-box LNS neighbor
|
static INeighbor |
INeighborFactory.explanationBased(IntVar... vars)
Creates an Explanation based LNS Neighbor
|
static INeighbor |
INeighborFactory.propagationGuided(IntVar... vars)
Create a propagation guided neighborhood fixing variables based on constraint propagation
Based on "Propagation-Guided LNS", Perronn Shaw and Furnon, CP2004
|
static INeighbor |
INeighborFactory.random(IntVar... vars)
Create a random neighborhood fixing variables randomly
|
static INeighbor |
INeighborFactory.reversedPropagationGuided(IntVar... vars)
Create a reverse propagation guided neighborhood fixing variables based on constraint propagation
|
Modifier and Type | Field and Description |
---|---|
protected IntVar[] |
RandomNeighborhood.vars
Variables to consider in this neighbor
|
protected IntVar[] |
PropagationGuidedNeighborhood.vars
Array of variables to consider in a fragment
|
Constructor and Description |
---|
PropagationGuidedNeighborhood(IntVar[] vars,
int fgmtSize,
int listSize,
long seed)
Create a propagation-guided neighbor for LNS
|
RandomNeighborhood(IntVar[] vars,
int level,
long seed)
Create a neighbor for LNS which randomly selects variable to be part of a fragment
|
ReversePropagationGuidedNeighborhood(IntVar[] vars,
int fgmtSize,
int listSize,
long seed)
Create a neighbor for LNS based on PGLNS, which selects variables to not be part of a fragment
|
Modifier and Type | Method and Description |
---|---|
default void |
ISearchMonitorFactory.setNoGoodRecordingFromSolutions(IntVar... vars)
Record nogoods from solution, that is, anytime a solution is found, a nogood is produced to prevent from
finding the same solution later during the search.
|
Constructor and Description |
---|
NogoodFromSolutions(IntVar[] vars)
Avoid exploring same solutions (useful with restart on solution)
Beware :
- Must be posted as a constraint AND plugged as a monitor as well
- Cannot be reified
- Only works for integer variables
This can be used to remove similar/symmetric solutions
|
Modifier and Type | Method and Description |
---|---|
static AbstractStrategy<IntVar> |
Search.activityBasedSearch(IntVar... vars)
Create an Activity based search strategy.
|
static AbstractStrategy<IntVar> |
Search.bestBound(AbstractStrategy formerSearch)
Search heuristic combined with a constraint performing strong consistency on the next decision variable
and branching on the value with the best objective bound (for optimization) and branches on the lower bound for SAT problems.
|
static AbstractStrategy<IntVar> |
Search.domOverWDegSearch(IntVar... vars)
Assignment strategy which selects a variable according to
DomOverWDeg and assign it to its lower bound |
static AbstractStrategy<IntVar> |
Search.intVarSearch(IntVar... vars)
Builds a default search heuristics of integer variables
Relies on
Search.domOverWDegSearch(IntVar...) |
Modifier and Type | Method and Description |
---|---|
static AbstractStrategy<IntVar> |
Search.activityBasedSearch(IntVar... vars)
Create an Activity based search strategy.
|
static AbstractStrategy<IntVar> |
Search.domOverWDegSearch(IntVar... vars)
Assignment strategy which selects a variable according to
DomOverWDeg and assign it to its lower bound |
static IntStrategy |
Search.inputOrderLBSearch(IntVar... vars)
Assigns the first non-instantiated variable to its lower bound.
|
static IntStrategy |
Search.inputOrderUBSearch(IntVar... vars)
Assigns the first non-instantiated variable to its upper bound.
|
static AbstractStrategy<IntVar> |
Search.intVarSearch(IntVar... vars)
Builds a default search heuristics of integer variables
Relies on
Search.domOverWDegSearch(IntVar...) |
static IntStrategy |
Search.intVarSearch(VariableSelector<IntVar> varSelector,
IntValueSelector valSelector,
DecisionOperator<IntVar> decisionOperator,
IntVar... vars)
Builds your own search strategy based on binary decisions.
|
static IntStrategy |
Search.intVarSearch(VariableSelector<IntVar> varSelector,
IntValueSelector valSelector,
IntVar... vars)
Builds your own assignment strategy based on binary decisions.
|
static IntStrategy |
Search.minDomLBSearch(IntVar... vars)
Assigns the non-instantiated variable of smallest domain size to its lower bound.
|
static IntStrategy |
Search.minDomUBSearch(IntVar... vars)
Assigns the non-instantiated variable of smallest domain size to its upper bound.
|
static IntStrategy |
Search.randomSearch(IntVar[] vars,
long seed)
Randomly selects a variable and assigns it to a value randomly taken in
- the domain in case the variable has an enumerated domain
- {LB,UB} (one of the two bounds) in case the domain is bounded
|
Modifier and Type | Method and Description |
---|---|
static IntStrategy |
Search.intVarSearch(VariableSelector<IntVar> varSelector,
IntValueSelector valSelector,
DecisionOperator<IntVar> decisionOperator,
IntVar... vars)
Builds your own search strategy based on binary decisions.
|
static IntStrategy |
Search.intVarSearch(VariableSelector<IntVar> varSelector,
IntValueSelector valSelector,
DecisionOperator<IntVar> decisionOperator,
IntVar... vars)
Builds your own search strategy based on binary decisions.
|
static IntStrategy |
Search.intVarSearch(VariableSelector<IntVar> varSelector,
IntValueSelector valSelector,
IntVar... vars)
Builds your own assignment strategy based on binary decisions.
|
Modifier and Type | Method and Description |
---|---|
static DecisionOperator<IntVar> |
DecisionOperatorFactory.makeIntEq() |
static DecisionOperator<IntVar> |
DecisionOperatorFactory.makeIntNeq() |
static DecisionOperator<IntVar> |
DecisionOperatorFactory.makeIntReverseSplit() |
static DecisionOperator<IntVar> |
DecisionOperatorFactory.makeIntSplit() |
Modifier and Type | Method and Description |
---|---|
DecisionOperator<IntVar> |
IntDecision.getDecOp() |
Modifier and Type | Method and Description |
---|---|
IntDecision |
DecisionMaker.makeIntDecision(IntVar var,
DecisionOperator<IntVar> dop,
int value)
|
void |
IntDecision.set(IntVar v,
int value,
DecisionOperator<IntVar> assignment)
Instantiate this decision with the parameters
|
boolean |
IntDecision.why(RuleStore ruleStore,
IntVar var,
IEventType evt,
int value) |
Modifier and Type | Method and Description |
---|---|
IntDecision |
DecisionMaker.makeIntDecision(IntVar var,
DecisionOperator<IntVar> dop,
int value)
|
void |
IntDecision.set(IntVar v,
int value,
DecisionOperator<IntVar> assignment)
Instantiate this decision with the parameters
|
Modifier and Type | Method and Description |
---|---|
int |
IntValueSelector.selectValue(IntVar var)
Selects and returns the value to constrained chosen variable with.
|
int |
IntDomainRandomBound.selectValue(IntVar var)
Selects and returns the value to constrained chosen variable with.
|
int |
IntDomainRandom.selectValue(IntVar var)
Selects and returns the value to constrained chosen variable with.
|
int |
IntDomainMin.selectValue(IntVar var) |
int |
IntDomainMiddle.selectValue(IntVar var)
Selects and returns the value to constrained chosen variable with.
|
int |
IntDomainMedian.selectValue(IntVar var)
Selects and returns the value to constrained chosen variable with.
|
int |
IntDomainMax.selectValue(IntVar var)
Selects and returns the value to constrained chosen variable with.
|
Modifier and Type | Method and Description |
---|---|
IntVar |
Smallest.getVariable(IntVar[] variables) |
IntVar |
MaxRegret.getVariable(IntVar[] variables) |
IntVar |
Largest.getVariable(IntVar[] variables) |
IntVar |
FirstFail.getVariable(IntVar[] variables) |
IntVar |
AntiFirstFail.getVariable(IntVar[] variables) |
Modifier and Type | Method and Description |
---|---|
Decision<IntVar> |
ImpactBased.computeDecision(IntVar variable) |
Decision<IntVar> |
DomOverWDeg.computeDecision(IntVar variable) |
Decision<IntVar> |
ActivityBased.computeDecision(IntVar variable) |
Decision<IntVar> |
ImpactBased.getDecision() |
Decision<IntVar> |
DomOverWDeg.getDecision() |
Decision<IntVar> |
ActivityBased.getDecision() |
Modifier and Type | Method and Description |
---|---|
int |
ActivityBased.compare(IntVar o1,
IntVar o2) |
Decision<IntVar> |
ImpactBased.computeDecision(IntVar variable) |
Decision<IntVar> |
DomOverWDeg.computeDecision(IntVar variable) |
Decision<IntVar> |
ActivityBased.computeDecision(IntVar variable) |
double |
Smallest.evaluate(IntVar variable) |
double |
MaxRegret.evaluate(IntVar variable) |
double |
Largest.evaluate(IntVar variable) |
double |
FirstFail.evaluate(IntVar variable) |
double |
AntiFirstFail.evaluate(IntVar variable) |
double |
ActivityBased.getActivity(IntVar var) |
IntVar |
Smallest.getVariable(IntVar[] variables) |
IntVar |
MaxRegret.getVariable(IntVar[] variables) |
IntVar |
Largest.getVariable(IntVar[] variables) |
IntVar |
FirstFail.getVariable(IntVar[] variables) |
IntVar |
AntiFirstFail.getVariable(IntVar[] variables) |
void |
ActivityBased.onUpdate(IntVar var,
IEventType evt) |
Constructor and Description |
---|
ActivityBased(IntVar[] vars) |
ActivityBased(Model model,
IntVar[] vars,
double g,
double d,
int a,
int samplingIterationForced,
long seed) |
DomOverWDeg(IntVar[] variables,
long seed,
IntValueSelector valueSelector)
Creates a DomOverWDeg variable selector
|
ImpactBased(IntVar[] vars,
boolean initOnly) |
ImpactBased(IntVar[] ivariables,
int alpha,
int split,
int nodeImpact,
long seed,
boolean initOnly)
Create an Impact-based search strategy with Node Impact strategy.
|
Modifier and Type | Method and Description |
---|---|
Decision<IntVar> |
IntStrategy.computeDecision(IntVar variable) |
Decision<IntVar> |
FullyRandom.computeDecision(IntVar variable) |
DecisionOperator<IntVar> |
IntStrategy.getDecisionOperator() |
VariableSelector<IntVar> |
IntStrategy.getVarSelector() |
Modifier and Type | Method and Description |
---|---|
Decision<IntVar> |
IntStrategy.computeDecision(IntVar variable) |
Decision<IntVar> |
FullyRandom.computeDecision(IntVar variable) |
protected IntDecision |
AbstractStrategy.makeIntDecision(IntVar var,
int val)
Creates an assignment decision object for integer variables
Just a simple shortcut for :
solver.getDecisionPath().makeIntDecision(var,DecisionOperatorFactory.makeIntEq(),val);
|
Constructor and Description |
---|
FullyRandom(IntVar[] scope,
long seed) |
IntStrategy(IntVar[] scope,
VariableSelector<IntVar> varSelector,
IntValueSelector valSelector)
Creates a search strategy which selects a variable X and a value V to perform
the decision X = V
BEWARE: if the variable domain is not enumerated, the value V should be a domain bound.
|
IntStrategy(IntVar[] scope,
VariableSelector<IntVar> varSelector,
IntValueSelector valSelector,
DecisionOperator<IntVar> decOperator)
Creates a search strategy which selects a variable X and a value V to perform
the decision X decOperator V
This can be X <= V for instance.
|
Constructor and Description |
---|
IntStrategy(IntVar[] scope,
VariableSelector<IntVar> varSelector,
IntValueSelector valSelector)
Creates a search strategy which selects a variable X and a value V to perform
the decision X = V
BEWARE: if the variable domain is not enumerated, the value V should be a domain bound.
|
IntStrategy(IntVar[] scope,
VariableSelector<IntVar> varSelector,
IntValueSelector valSelector,
DecisionOperator<IntVar> decOperator)
Creates a search strategy which selects a variable X and a value V to perform
the decision X decOperator V
This can be X <= V for instance.
|
IntStrategy(IntVar[] scope,
VariableSelector<IntVar> varSelector,
IntValueSelector valSelector,
DecisionOperator<IntVar> decOperator)
Creates a search strategy which selects a variable X and a value V to perform
the decision X decOperator V
This can be X <= V for instance.
|
Modifier and Type | Interface and Description |
---|---|
interface |
BoolVar
CPRU r544: remove default implementation |
Modifier and Type | Method and Description |
---|---|
IntVar |
SetVar.getCard()
get the constrained cardinality variable of this set.
|
IntVar |
Task.getDuration() |
IntVar |
Task.getEnd() |
IntVar |
Task.getStart() |
default IntVar |
IViewFactory.intAbsView(IntVar var)
Creates a view over var such that: |var|.
|
default IntVar |
IViewFactory.intMinusView(IntVar var)
Creates a view over var equal to -var.
|
default IntVar |
IViewFactory.intOffsetView(IntVar var,
int cste)
Creates a view based on var, equal to var+cste.
|
default IntVar |
IViewFactory.intScaleView(IntVar var,
int cste)
Creates a view over var equal to var*cste.
|
default IntVar |
IntVar.intVar() |
default IntVar |
IVariableFactory.intVar(int value)
Create a constant integer variable equal to value
|
default IntVar |
IVariableFactory.intVar(int[] values)
Create an integer variable of initial domain values.
|
default IntVar |
IVariableFactory.intVar(int lb,
int ub)
Create an integer variable of initial domain [lb, ub]
Uses an enumerated domain if ub-lb is small, and a bounded domain otherwise
|
default IntVar |
IVariableFactory.intVar(int lb,
int ub,
boolean boundedDomain)
Create an integer variable of initial domain [lb, ub]
|
default IntVar |
IVariableFactory.intVar(String name,
int value)
Create a constant integer variable equal to value
|
default IntVar |
IVariableFactory.intVar(String name,
int[] values)
Create an integer variable of initial domain values
Uses an enumerated domain that supports holes
|
default IntVar |
IVariableFactory.intVar(String name,
int lb,
int ub)
Create an integer variable of initial domain [lb, ub]
Uses an enumerated domain if ub-lb is small, and a bounded domain otherwise
|
default IntVar |
IVariableFactory.intVar(String name,
int lb,
int ub,
boolean boundedDomain)
Create an integer variable of initial domain [lb, ub]
|
default IntVar[] |
IVariableFactory.intVarArray(int size,
int[] values)
Creates an array of size integer variables, taking their domain in values
|
default IntVar[] |
IVariableFactory.intVarArray(int size,
int lb,
int ub)
Creates an array of size integer variables, taking their domain in [lb, ub]
|
default IntVar[] |
IVariableFactory.intVarArray(int size,
int lb,
int ub,
boolean boundedDomain)
Creates an array of size integer variables, taking their domain in [lb, ub]
|
default IntVar[] |
IVariableFactory.intVarArray(String name,
int size,
int[] values)
Creates an array of size integer variables, taking their domain in values
|
default IntVar[] |
IVariableFactory.intVarArray(String name,
int size,
int lb,
int ub)
Creates an array of size integer variables, taking their domain in [lb, ub]
|
default IntVar[] |
IVariableFactory.intVarArray(String name,
int size,
int lb,
int ub,
boolean boundedDomain)
Creates an array of size integer variables, taking their domain in [lb, ub]
|
default IntVar[][] |
IVariableFactory.intVarMatrix(int dim1,
int dim2,
int[] values)
Creates a matrix of dim1*dim2 integer variables taking their domain in values
|
default IntVar[][] |
IVariableFactory.intVarMatrix(int dim1,
int dim2,
int lb,
int ub)
Creates a matrix of dim1*dim2 integer variables taking their domain in [lb, ub]
|
default IntVar[][] |
IVariableFactory.intVarMatrix(int dim1,
int dim2,
int lb,
int ub,
boolean boundedDomain)
Creates a matrix of dim1*dim2 integer variables taking their domain in [lb, ub]
|
default IntVar[][] |
IVariableFactory.intVarMatrix(String name,
int dim1,
int dim2,
int[] values)
Creates a matrix of dim1*dim2 integer variables taking their domain in values
|
default IntVar[][] |
IVariableFactory.intVarMatrix(String name,
int dim1,
int dim2,
int lb,
int ub)
Creates a matrix of dim1*dim2 integer variables taking their domain in [lb, ub]
|
default IntVar[][] |
IVariableFactory.intVarMatrix(String name,
int dim1,
int dim2,
int lb,
int ub,
boolean boundedDomain)
Creates a matrix of dim1*dim2 integer variables taking their domain in [lb, ub]
|
Modifier and Type | Method and Description |
---|---|
default IntVar |
IViewFactory.intAbsView(IntVar var)
Creates a view over var such that: |var|.
|
default IntVar |
IViewFactory.intMinusView(IntVar var)
Creates a view over var equal to -var.
|
default IntVar |
IViewFactory.intOffsetView(IntVar var,
int cste)
Creates a view based on var, equal to var+cste.
|
default IntVar |
IViewFactory.intScaleView(IntVar var,
int cste)
Creates a view over var equal to var*cste.
|
default RealVar |
IViewFactory.realIntView(IntVar var,
double precision)
Creates a real view of var, i.e. a RealVar of domain equal to the domain of var.
|
default RealVar[] |
IViewFactory.realIntViewArray(IntVar[] ints,
double precision)
Creates an array of real views for a set of integer variables
This should be used to include an integer variable in an expression/constraint requiring RealVar
|
default RealVar[][] |
IViewFactory.realIntViewMatrix(IntVar[][] ints,
double precision)
Creates a matrix of real views for a matrix of integer variables
This should be used to include an integer variable in an expression/constraint requiring RealVar
|
void |
SetVar.setCard(IntVar card)
ensure a variable is equal to the cardinality of this set.
|
default Task |
IVariableFactory.taskVar(IntVar s,
int p)
Creates a task variable, based on a starting time s and a processing time p
such that: s + p = e, where e is the ending time.
|
default Task |
IVariableFactory.taskVar(IntVar s,
IntVar p)
Creates a task variable, based on a starting time s and a processing time p
such that: s + p = e, where e is the ending time.
|
default Task |
IVariableFactory.taskVar(IntVar s,
IntVar p,
IntVar e)
Creates a task variable, made of a starting time s,
a processing time p and an ending time e such that: s + p = e.
|
default Task[] |
IVariableFactory.taskVarArray(IntVar[] s,
IntVar[] p,
IntVar[] e)
Creates an array of s.length task variables,
where task i is made of a starting time s_i,
a processing time p_i and an ending time e_i such that: s_i + p_i = e_i.
|
default Task[] |
IVariableFactory.taskVarArray(IntVar[] s,
IntVar[] p,
IntVar[] e)
Creates an array of s.length task variables,
where task i is made of a starting time s_i,
a processing time p_i and an ending time e_i such that: s_i + p_i = e_i.
|
default Task[] |
IVariableFactory.taskVarArray(IntVar[] s,
IntVar[] p,
IntVar[] e)
Creates an array of s.length task variables,
where task i is made of a starting time s_i,
a processing time p_i and an ending time e_i such that: s_i + p_i = e_i.
|
default Task[][] |
IVariableFactory.taskVarMatrix(IntVar[][] s,
IntVar[][] p,
IntVar[][] e)
Creates a matrix of s.length * s_0.length task variables,
where task i,j is made of a starting time s_(i,j),
a processing time p_(i,j) and an ending time e_(i,j) such that:
s_(i,j) + p_(i,j) = e_(i,j).
|
default Task[][] |
IVariableFactory.taskVarMatrix(IntVar[][] s,
IntVar[][] p,
IntVar[][] e)
Creates a matrix of s.length * s_0.length task variables,
where task i,j is made of a starting time s_(i,j),
a processing time p_(i,j) and an ending time e_(i,j) such that:
s_(i,j) + p_(i,j) = e_(i,j).
|
default Task[][] |
IVariableFactory.taskVarMatrix(IntVar[][] s,
IntVar[][] p,
IntVar[][] e)
Creates a matrix of s.length * s_0.length task variables,
where task i,j is made of a starting time s_(i,j),
a processing time p_(i,j) and an ending time e_(i,j) such that:
s_(i,j) + p_(i,j) = e_(i,j).
|
default BoolVar[] |
IVariableFactory.toBoolVar(IntVar... ivars)
Converts ivars into an array of boolean variables
|
default boolean |
IntVar.why(RuleStore ruleStore,
IntVar modifiedVar,
IEventType evt,
int value) |
Constructor and Description |
---|
Task(IntVar s,
IntVar d,
IntVar e)
Container representing a task:
It ensures that: start + duration = end
|
Modifier and Type | Class and Description |
---|---|
class |
BitsetArrayIntVarImpl
IntVar implementation for quite small domains bit with very distant values e.g. {-51900,42,235923} |
class |
BitsetIntVarImpl
|
class |
BoolVarImpl
|
class |
FixedBoolVarImpl
A constant view specific to boolean variable
Based on "Views and Iterators for Generic Constraint Implementations",
C.
|
class |
FixedIntVarImpl
A IntVar with one domain value.
|
class |
IntervalIntVarImpl
|
Modifier and Type | Field and Description |
---|---|
protected IntVar |
SetVarImpl.cardinality |
Modifier and Type | Method and Description |
---|---|
IntVar |
SetVarImpl.getCard() |
Modifier and Type | Method and Description |
---|---|
void |
SetVarImpl.setCard(IntVar card) |
Modifier and Type | Class and Description |
---|---|
class |
BoolNotView
A view for boolean variable, that enforce not(b).
|
class |
IntView
"A view implements the same operations as a variable.
|
class |
MinusView
View for -V, where V is a IntVar or view
Based on "Views and Iterators for Generic Constraint Implementations"
C. |
class |
OffsetView
declare an IntVar based on X and C, such as X + C
Based on "Views and Iterators for Generic Constraint Implementations" C. |
class |
ScaleView
declare an IntVar based on X and C, such as X * C
Based on "Views and Iterators for Generic Constraint Implementations"
C. |
Modifier and Type | Field and Description |
---|---|
protected IntVar |
RealView.var |
protected IntVar |
IntView.var
Observed variable
|
Modifier and Type | Method and Description |
---|---|
IntVar |
RealView.getVariable() |
IntVar |
IntView.getVariable() |
Modifier and Type | Method and Description |
---|---|
void |
ScaleView.justifyEvent(IntVar var,
ICause cause,
IntEventType mask,
int one,
int two,
int three) |
void |
RealView.justifyEvent(IntVar var,
ICause cause,
IntEventType mask,
int one,
int two,
int three) |
void |
OffsetView.justifyEvent(IntVar var,
ICause cause,
IntEventType mask,
int one,
int two,
int three) |
void |
MinusView.justifyEvent(IntVar var,
ICause cause,
IntEventType mask,
int one,
int two,
int three) |
void |
IView.justifyEvent(IntVar var,
ICause cause,
IntEventType mask,
int one,
int two,
int three)
This methods is related to explanations, it binds an event occurring on the observed
variable to the view.
|
void |
BoolNotView.justifyEvent(IntVar var,
ICause cause,
IntEventType mask,
int one,
int two,
int three) |
boolean |
IntView.why(RuleStore ruleStore,
IntVar modifiedVar,
IEventType evt,
int value) |
boolean |
BoolNotView.why(RuleStore ruleStore,
IntVar modifiedVar,
IEventType evt,
int value) |
Constructor and Description |
---|
IntView(String name,
IntVar var)
Create a view based on
var |
MinusView(IntVar var)
Create a -var view
|
OffsetView(IntVar var,
int cste)
A view based on var such that var + cste
|
RealView(IntVar var,
double precision) |
ScaleView(IntVar var,
int cste)
Create a cste × var view
|
Constructor and Description |
---|
DisposableRangeBoundIterator(IntVar var) |
DisposableValueBoundIterator(IntVar var) |
IntVarValueIterator(IntVar v)
Creates an object to iterate over an IntVar values using
for(int value:var){
...
}
that is equivalent to
int ub = var.getUB();
for(int value = var.getLB(); values <= ub; value = var.nextValue(value)){
...
}
|
Constructor and Description |
---|
MultivaluedDecisionDiagram(IntVar[] VARIABLES,
int[][] TRANSITIONS)
Create an MDD based on an array of flatten domains and a set of transitions.
|
MultivaluedDecisionDiagram(IntVar[] VARIABLES,
Tuples TUPLES)
Create an MDD based on an array of flatten domains and a set of tuples
|
MultivaluedDecisionDiagram(IntVar[] VARIABLES,
Tuples TUPLES,
boolean compactOnce,
boolean sortTuple)
Create an MDD based on an array of flatten domains and a set of tuples
|
Modifier and Type | Method and Description |
---|---|
static void |
IntIterableSetUtils.copyIn(IntVar var,
IntIterableRangeSet set)
Copy the domain of var in set.
|
static IntIterableRangeSet |
IntIterableSetUtils.extract(IntVar var)
Copy the domain of var into an
IntIterableRangeSet . |
static boolean |
IntIterableSetUtils.includedIn(IntVar var,
IntIterableRangeSet set) |
static boolean |
IntIterableSetUtils.intersect(IntVar var,
IntIterableRangeSet set) |
static boolean |
IntIterableSetUtils.notIncludedIn(IntVar var,
IntIterableRangeSet set) |
static void |
IntIterableSetUtils.union(IntIterableRangeSet set,
IntVar var)
Put all value of var into set.
|
Modifier and Type | Method and Description |
---|---|
static IntVar[] |
ArrayUtils.append(IntVar[]... toAppend)
Append two Arrays
|
static IntVar[] |
ArrayUtils.concat(IntVar[] array,
IntVar... elements)
Append elements at the end of another array
|
static IntVar[] |
VariableUtils.toIntVar(Model model,
int... values)
Transform an array of int to an array of fixed IntVar
|
Modifier and Type | Method and Description |
---|---|
static IntVar[] |
ArrayUtils.append(IntVar[]... toAppend)
Append two Arrays
|
static int[] |
VariableUtils.boundsForAddition(IntVar... vars) |
static int[] |
VariableUtils.boundsForDivision(IntVar x,
IntVar y) |
static int[] |
VariableUtils.boundsForMaximum(IntVar... vars) |
static int[] |
VariableUtils.boundsForMinimum(IntVar... vars) |
static int[] |
VariableUtils.boundsForModulo(IntVar x,
IntVar y) |
static int[] |
VariableUtils.boundsForMultiplication(IntVar x,
IntVar y) |
static int[] |
VariableUtils.boundsForPow(IntVar x,
IntVar y) |
static int[] |
VariableUtils.boundsForScalar(IntVar[] vars,
int[] coeffs) |
static int[] |
VariableUtils.boundsForSubstraction(IntVar x,
IntVar y) |
static IntVar[] |
ArrayUtils.concat(IntVar[] array,
IntVar... elements)
Append elements at the end of another array
|
static IntVar[] |
ArrayUtils.concat(IntVar[] array,
IntVar... elements)
Append elements at the end of another array
|
static long |
VariableUtils.domainCardinality(IntVar... vars) |
static boolean |
VariableUtils.intersect(IntVar x,
IntVar y) |
Copyright © 2017. All rights reserved.