IntConstraintFactory (org.choco-solver-choco-solver 3.3.1-j7 API)

java.lang.Object
- org.chocosolver.solver.constraints.IntConstraintFactory

Direct Known Subclasses:

ICF
```
public class IntConstraintFactory
extends Object
```
A Factory to declare constraint based on integer variables (only). One can call directly the constructor of constraints, but it is recommended to use the Factory, because signatures and javadoc are ensured to be up-to-date.
As much as possible, the API names of global constraints must match those define in the Global Constraint Catalog.
Note that, for the sack of readability, the Java naming convention is not respected for methods arguments.
Constraints are ordered as the following: 1) Unary constraints 2) Binary constraints 3) Terary constraints 4) Global constraints

Since:

21/01/13

Author:

Charles Prud'homme

Method Summary

Methods
Modifier and Type	Method and Description
`static Constraint`	`absolute(IntVar VAR1, IntVar VAR2)` Enforces VAR1 = \|VAR2\|
`static Constraint`	`alldifferent_conditionnal(IntVar[] VARS, Condition CONDITION)` Alldifferent holds on the subset of VARS which satisfies the given CONDITION
`static Constraint`	`alldifferent_conditionnal(IntVar[] VARS, Condition CONDITION, boolean AC)` Alldifferent holds on the subset of VARS which satisfies the given CONDITION
`static Constraint`	`alldifferent_except_0(IntVar[] VARS)` Variables in VARS must either be different or equal to 0
`static Constraint`	`alldifferent(IntVar[] VARS)` Ensures that all variables from VARS take a different value.
`static Constraint`	`alldifferent(IntVar[] VARS, String CONSISTENCY)` Ensures that all variables from VARS take a different value.
`static Constraint`	`among(IntVar NVAR, IntVar[] VARS, int[] VALUES)` NVAR is the number of variables of the collection VARIABLES that take their value in VALUES.
`static Constraint`	`arithm(IntVar VAR, String OP, int CSTE)` Ensures: VAR OP CSTE, where OP in {"=", "!
`static Constraint`	`arithm(IntVar VAR1, String OP, IntVar VAR2)` Ensures: VAR1 OP VAR2, where OP in {"=", "!
`static Constraint`	`arithm(IntVar VAR1, String OP1, IntVar VAR2, String OP2, int CSTE)` Ensures: VAR1 OP VAR2, where OP in {"=", "!
`static Constraint`	`atleast_nvalues(IntVar[] VARS, IntVar NVALUES, boolean AC)` Let N be the number of distinct values assigned to the variables of the VARS collection.
`static Constraint`	`atmost_nvalues(IntVar[] VARS, IntVar NVALUES, boolean STRONG)` Let N be the number of distinct values assigned to the variables of the VARS collection.
`static Constraint[]`	`bin_packing(IntVar[] ITEM_BIN, int[] ITEM_SIZE, IntVar[] BIN_LOAD, int OFFSET)` Bin Packing formulation: forall b in [0,BIN_LOAD.length-1], BIN_LOAD[b]=sum(ITEM_SIZE[i] \| i in [0,ITEM_SIZE.length-1], ITEM_BIN[i] = b+OFFSET forall i in [0,ITEM_SIZE.length-1], ITEM_BIN is in [OFFSET,BIN_LOAD.length-1+OFFSET],
`static Constraint`	`bit_channeling(BoolVar[] BITS, IntVar VAR)` Ensures that VAR = 2⁰BIT_1 + 2¹BIT_2 + ... 2^n-1*BIT_n.
`static Constraint`	`boolean_channeling(BoolVar[] BVARS, IntVar VAR, int OFFSET)` Maps the boolean assignments variables BVARS with the standard assignment variable VAR.
`static Constraint`	`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.
`static Constraint`	`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.
`static Constraint`	`clause_channeling(IntVar VAR, BoolVar[] EVARS, BoolVar[] LVARS)` Link each value from the domain of VAR to two boolean variable: one reifies the equality to the i^th value of the variable domain, the other reifies the less-or-equality to the i^th value of the variable domain.
`static Constraint`	`cost_regular(IntVar[] VARS, IntVar COST, ICostAutomaton CAUTOMATON)` Ensures that the assignment of a sequence of variables is recognized by CAUTOMATON, a deterministic finite automaton, and that the sum of the costs associated to each assignment is bounded by the cost variable.
`static Constraint`	`count(int VALUE, IntVar[] VARS, IntVar LIMIT)` Let N be the number of variables of the VARIABLES collection assigned to value VALUE; Enforce condition N = LIMIT to hold.
`static Constraint`	`count(IntVar VALUE, IntVar[] VARS, IntVar LIMIT)` Let N be the number of variables of the VARIABLES collection assigned to value VALUE; Enforce condition N = LIMIT to hold.
`static Constraint`	`cumulative(Task[] TASKS, IntVar[] HEIGHTS, IntVar CAPACITY)` 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.
`static Constraint`	`cumulative(Task[] TASKS, IntVar[] HEIGHTS, IntVar CAPACITY, boolean INCREMENTAL)` 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.
`static Constraint[]`	`diffn(IntVar[] X, IntVar[] Y, IntVar[] WIDTH, IntVar[] HEIGHT, boolean USE_CUMUL)` Constrains each rectangle_i, given by their origins X_i,Y_i and sizes WIDTH_i,HEIGHT_i, to be non-overlapping.
`static Constraint`	`distance(IntVar VAR1, IntVar VAR2, String OP, int CSTE)` Ensures: \|VAR1-VAR2\| OP CSTE where OP can take its value among {"=", ">", "<", "!
`static Constraint`	`distance(IntVar VAR1, IntVar VAR2, String OP, IntVar VAR3)` Ensures: \|VAR1-VAR2\| OP VAR3 where OP can take its value among {"=", ">", "<"}
`static Constraint`	`element(IntVar VALUE, int[] TABLE, IntVar INDEX)` Build ELEMENT constraint: VALUE = TABLE[INDEX]
`static Constraint`	`element(IntVar VALUE, int[] TABLE, IntVar INDEX, int OFFSET, String SORT)` Build ELEMENT constraint: VALUE = TABLE[INDEX-OFFSET]
`static Constraint`	`element(IntVar VALUE, IntVar[] TABLE, IntVar INDEX, int OFFSET)` Build an ELEMENT constraint: VALUE = TABLE[INDEX-OFFSET] where TABLE is an array of variables.
`static Constraint`	`eucl_div(IntVar DIVIDEND, IntVar DIVISOR, IntVar RESULT)` Ensures DIVIDEND / DIVISOR = RESULT, rounding towards 0 -- Euclidean division Also ensures DIVISOR !
`static Constraint`	`FALSE(Solver solver)` Ensures the FALSE constraint
`static gnu.trove.list.array.TIntArrayList`	`getDomainUnion(IntVar[] vars)`
`static Constraint`	`global_cardinality(IntVar[] VARS, int[] VALUES, IntVar[] OCCURRENCES, boolean CLOSED)` Global Cardinality constraint (GCC): Each value VALUES[i] should be taken by exactly OCCURRENCES[i] variables of VARS.
`static Constraint`	`inverse_channeling(IntVar[] VARS1, IntVar[] VARS2, int OFFSET1, int OFFSET2)` Make an inverse channeling between VARS1 and VARS2: VARS1[i-OFFSET2] = j <=> VARS2[j-OFFSET1] = i Performs AC if domains are enumerated.
`static Constraint`	`knapsack(IntVar[] OCCURRENCES, IntVar TOTAL_WEIGHT, IntVar TOTAL_ENERGY, int[] WEIGHT, int[] ENERGY)` Ensures that : - OCCURRENCES[i] * WEIGHT[i] ≤ TOTAL_WEIGHT - OCCURRENCES[i] * ENERGY[i] = TOTAL_ENERGY and maximizing the value of TOTAL_ENERGY.
`static Constraint`	`lex_chain_less_eq(IntVar[]... VARS)` For each pair of consecutive vectors VARS_i and VARS_i+1 of the VARS collection VARS_i is lexicographically less or equal than than VARS_i+1
`static Constraint`	`lex_chain_less(IntVar[]... VARS)` For each pair of consecutive vectors VARS_i and VARS_i+1 of the VARS collection VARS_i is lexicographically strictly less than than VARS_i+1
`static Constraint`	`lex_less_eq(IntVar[] VARS1, IntVar[] VARS2)` Ensures that VARS1 is lexicographically less or equal than VARS2.
`static Constraint`	`lex_less(IntVar[] VARS1, IntVar[] VARS2)` Ensures that VARS1 is lexicographically strictly less than VARS2.
`static Constraint`	`maximum(BoolVar MAX, BoolVar[] VARS)` MAX is the maximum value of the collection of boolean variables VARS
`static Constraint`	`maximum(IntVar MAX, IntVar[] VARS)` MAX is the maximum value of the collection of domain variables VARS
`static Constraint`	`maximum(IntVar MAX, IntVar VAR1, IntVar VAR2)` Ensures: MAX = MAX(VAR1, VAR2) (Bound Consistency)
`static Constraint`	`mddc(IntVar[] VARS, MultivaluedDecisionDiagram MDD)` Create a constraint where solutions (tuples) are encoded by a multi-valued decision diagram.
`static Constraint`	`member(IntVar VAR, int[] TABLE)` Ensures VAR takes its values in TABLE
`static Constraint`	`member(IntVar VAR, int LB, int UB)` Ensures VAR takes its values in [LB, UB]
`static Constraint`	`minimum(BoolVar MIN, BoolVar[] VARS)` MIN is the minimum value of the collection of boolean variables VARS
`static Constraint`	`minimum(IntVar MIN, IntVar[] VARS)` MIN is the minimum value of the collection of domain variables VARS
`static Constraint`	`minimum(IntVar MIN, IntVar VAR1, IntVar VAR2)` Ensures: VAR1 = MIN(VAR2, VAR3) (Bound Consistency)
`static Constraint`	`mod(IntVar X, IntVar Y, IntVar Z)` Ensures X % Y = Z, i.e.
`static Constraint`	`multicost_regular(IntVar[] VARS, IntVar[] CVARS, ICostAutomaton CAUTOMATON)` Ensures that the assignment of a sequence of VARS is recognized by CAUTOMATON, a deterministic finite automaton, and that the sum of the cost vector COSTS associated to each assignment is bounded by the variable vector CVARS.
`static Constraint`	`not_member(IntVar VAR, int[] TABLE)` Ensures VAR does not take its values in TABLE
`static Constraint`	`not_member(IntVar VAR, int LB, int UB)` Ensures VAR does not take its values in [LB, UB]
`static Constraint[]`	`nvalues(IntVar[] VARS, IntVar NVALUES)` Let N be the number of distinct values assigned to the variables of the VARS collection.
`static Constraint[]`	`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.
`static Constraint`	`regular(IntVar[] VARS, IAutomaton AUTOMATON)` Enforces the sequence of VARS to be a word recognized by the deterministic finite automaton AUTOMATON.
`static Constraint`	`scalar(IntVar[] VARS, int[] COEFFS, IntVar SCALAR)` Enforces that ∑_{i in \|VARS\|}COEFFS_i * VARS_i = SCALAR.
`static Constraint`	`scalar(IntVar[] VARS, int[] COEFFS, String OPERATOR, IntVar SCALAR)` A scalar constraint which ensures that Sum(VARS[i]*COEFFS[i]) OPERATOR SCALAR
`static Constraint`	`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.
`static Constraint`	`square(IntVar VAR1, IntVar VAR2)` Enforces VAR1 = VAR2^2
`static Constraint`	`subcircuit(IntVar[] VARS, int OFFSET, IntVar SUBCIRCUIT_SIZE)` 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.
`static Constraint[]`	`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.
`static Constraint`	`sum(BoolVar[] VARS, IntVar SUM)` Enforces that ∑_{i in \|VARS\|}VARS_i = SUM.
`static Constraint`	`sum(BoolVar[] VARS, String OPERATOR, IntVar SUM)` Enforces that ∑_{i in \|VARS\|}VARS_i OPERATOR SUM.
`static Constraint`	`sum(IntVar[] VARS, IntVar SUM)` Enforces that ∑_{i in \|VARS\|}VARS_i = SUM.
`static Constraint`	`sum(IntVar[] VARS, String OPERATOR, IntVar SUM)` Enforces that ∑_{i in \|VARS\|}VARS_i OPERATOR SUM.
`static Constraint`	`table(IntVar[] VARS, Tuples TUPLES, String ALGORITHM)` Create a table constraint, with the specified algorithm defined ALGORITHM - 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.
`static Constraint`	`table(IntVar VAR1, IntVar VAR2, Tuples TUPLES, String ALGORITHM)` Create 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.
`static Constraint`	`times(IntVar X, int Y, IntVar Z)` Ensures: X * Y = Z
`static Constraint`	`times(IntVar X, IntVar Y, IntVar Z)` Ensures: X * Y = Z
`static Constraint`	`tree(IntVar[] SUCCS, IntVar NBTREES, int OFFSET)` Partition SUCCS variables into NBTREES (anti) arborescences SUCCS[i] = OFFSET+j means that j is the successor of i.
`static Constraint`	`TRUE(Solver solver)` Ensures the TRUE constraint
`static Constraint[]`	`tsp(IntVar[] SUCCS, IntVar COST, int[][] COST_MATRIX)` A constraint for the Traveling Salesman Problem : Enforces SUCCS to form a hamiltonian circuit of value COST
`static boolean`	`tupleIt(IntVar... VARS)` Check whether the intension constraint to extension constraint substitution is enabled and can be achieved

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - TRUE
```
public static Constraint TRUE(Solver solver)
```
    Ensures the TRUE constraint
    
    Parameters:
    solver - a solver
    
    Returns:
    a true constraint
  - FALSE
```
public static Constraint FALSE(Solver solver)
```
    Ensures the FALSE constraint
    
    Parameters:
    solver - a solver
    
    Returns:
    a false constraint
  - arithm
```
public static Constraint arithm(IntVar VAR,
                String OP,
                int CSTE)
```
    Ensures: VAR OP CSTE, where OP in {"=", "!=", ">","<",">=","<="}
    
    Parameters:
    VAR - a variable
    OP - an operator
    CSTE - a constant
  - member
```
public static Constraint member(IntVar VAR,
                int[] TABLE)
```
    Ensures VAR takes its values in TABLE
    
    Parameters:
    VAR - an integer variable
    TABLE - an array of values
  - member
```
public static Constraint member(IntVar VAR,
                int LB,
                int UB)
```
    Ensures VAR takes its values in [LB, UB]
    
    Parameters:
    VAR - an integer variable
    LB - the lower bound of the interval
    UB - the upper bound of the interval
  - not_member
```
public static Constraint not_member(IntVar VAR,
                    int[] TABLE)
```
    Ensures VAR does not take its values in TABLE
    
    Parameters:
    VAR - an integer variable
    TABLE - an array of values
  - not_member
```
public static Constraint not_member(IntVar VAR,
                    int LB,
                    int UB)
```
    Ensures VAR does not take its values in [LB, UB]
    
    Parameters:
    VAR - an integer variable
    LB - the lower bound of the interval
    UB - the upper bound of the interval
  - absolute
```
public static Constraint absolute(IntVar VAR1,
                  IntVar VAR2)
```
    Enforces VAR1 = |VAR2|
  - arithm
```
public static Constraint arithm(IntVar VAR1,
                String OP,
                IntVar VAR2)
```
    Ensures: VAR1 OP VAR2, where OP in {"=", "!=", ">","<",">=","<="}
    
    Parameters:
    VAR1 - first variable
    OP - an operator
    VAR2 - second variable
  - arithm
```
public static Constraint arithm(IntVar VAR1,
                String OP1,
                IntVar VAR2,
                String OP2,
                int CSTE)
```
    Ensures: VAR1 OP VAR2, where OP in {"=", "!=", ">","<",">=","<="} or {"+", "-"}
    
    Parameters:
    VAR1 - first variable
    OP1 - an operator
    VAR2 - second variable
    OP2 - another operator
    CSTE - an operator
  - distance
```
public static Constraint distance(IntVar VAR1,
                  IntVar VAR2,
                  String OP,
                  int CSTE)
```
    Ensures:
    |VAR1-VAR2| OP CSTE
    where OP can take its value among {"=", ">", "<", "!="}
  - element
```
public static Constraint element(IntVar VALUE,
                 int[] TABLE,
                 IntVar INDEX,
                 int OFFSET,
                 String SORT)
```
    Build ELEMENT constraint: VALUE = TABLE[INDEX-OFFSET]
    
    Parameters:
    VALUE - an integer variable taking its value in TABLE
    TABLE - an array of integer values
    INDEX - an integer variable representing the value of VALUE in TABLE
    OFFSET - offset matching INDEX.LB and TABLE[0] (Generally 0)
    SORT - defines ordering properties of TABLE:
    "none" if TABLE is not sorted
    "asc" if TABLE is sorted in the increasing order
    "desc" if TABLE is sorted in the decreasing order
    "detect" Let the constraint detects the ordering of TABLE, if any
  - element
```
public static Constraint element(IntVar VALUE,
                 int[] TABLE,
                 IntVar INDEX)
```
    Build ELEMENT constraint: VALUE = TABLE[INDEX]
    
    Parameters:
    VALUE - an integer variable taking its value in TABLE
    TABLE - an array of integer values
    INDEX - an integer variable representing the value of VALUE in TABLE
  - square
```
public static Constraint square(IntVar VAR1,
                IntVar VAR2)
```
    Enforces VAR1 = VAR2^2
  - table
```
public static Constraint table(IntVar VAR1,
               IntVar VAR2,
               Tuples TUPLES,
               String ALGORITHM)
```
    Create 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.
    
    Parameters:
    VAR1 - first variable
    VAR2 - second variable
    TUPLES - the relation between the two variables, among {"AC3", "AC3rm", "AC3bit+rm", "AC2001", "FC"}
  - distance
```
public static Constraint distance(IntVar VAR1,
                  IntVar VAR2,
                  String OP,
                  IntVar VAR3)
```
    Ensures:
    |VAR1-VAR2| OP VAR3
    where OP can take its value among {"=", ">", "<"}
    
    Parameters:
    VAR1 - first variable
    VAR2 - second variable
    OP - an operator
    VAR3 - resulting variable
  - eucl_div
```
public static Constraint eucl_div(IntVar DIVIDEND,
                  IntVar DIVISOR,
                  IntVar RESULT)
```
    Ensures DIVIDEND / DIVISOR = RESULT, rounding towards 0 -- Euclidean division Also ensures DIVISOR != 0
    
    Parameters:
    DIVIDEND - dividend
    DIVISOR - divisor
    RESULT - result
  - maximum
```
public static Constraint maximum(IntVar MAX,
                 IntVar VAR1,
                 IntVar VAR2)
```
    Ensures: MAX = MAX(VAR1, VAR2) (Bound Consistency)
    
    Parameters:
    MAX - a variable
    VAR1 - a variable
    VAR2 - a variable
  - minimum
```
public static Constraint minimum(IntVar MIN,
                 IntVar VAR1,
                 IntVar VAR2)
```
    Ensures: VAR1 = MIN(VAR2, VAR3) (Bound Consistency)
    
    Parameters:
    MIN - result
    VAR1 - result
    VAR2 - first variable
  - mod
```
public static Constraint mod(IntVar X,
             IntVar Y,
             IntVar Z)
```
    Ensures X % Y = Z,
    i.e.:
    - X / Y = T1 and,
    - T1 * Y = T2 and,
    - Z + T2 = X
    
    where T1 = T2 = [-|X|, |X|]
    
    Parameters:
    X - first variable
    Y - second variable
    Z - result
  - times
```
public static Constraint times(IntVar X,
               IntVar Y,
               IntVar Z)
```
    Ensures: X * Y = Z
    
    Parameters:
    X - first variable
    Y - second variable
    Z - result variable
  - times
```
public static Constraint times(IntVar X,
               int Y,
               IntVar Z)
```
    Ensures: X * Y = Z
    
    Parameters:
    X - first variable
    Y - a constant
    Z - result variable
  - alldifferent
```
public static Constraint alldifferent(IntVar[] VARS)
```
    Ensures that all variables from VARS take a different value. Uses BC plus a probabilistic AC propagator to get a compromise between BC and AC
    
    Parameters:
    VARS - list of variables
  - alldifferent
```
public static Constraint alldifferent(IntVar[] VARS,
                      String CONSISTENCY)
```
    Ensures that all variables from VARS take a different value. The consistency level should be chosen among "BC", "AC" and "DEFAULT".
    
    Parameters:
    VARS - list of variables
    CONSISTENCY - consistency level, among {"BC", "AC"}
    BC: Based on: "A Fast and Simple Algorithm for Bounds Consistency of the AllDifferent Constraint"
    A. Lopez-Ortiz, CG. Quimper, J. Tromp, P.van Beek
    AC: Uses Regin algorithm Runs in O(m.n) worst case time for the initial propagation and then in O(n+m) on average.
    DEFAULT:
    Uses BC plus a probabilistic AC propagator to get a compromise between BC and AC
  - alldifferent_conditionnal
```
public static Constraint alldifferent_conditionnal(IntVar[] VARS,
                                   Condition CONDITION,
                                   boolean AC)
```
    Alldifferent holds on the subset of VARS which satisfies the given CONDITION
    
    Parameters:
    VARS - collection of variables
    CONDITION - condition defining which variables should be constrained
    AC - specifies is AC filtering should be established
  - alldifferent_conditionnal
```
public static Constraint alldifferent_conditionnal(IntVar[] VARS,
                                   Condition CONDITION)
```
    Alldifferent holds on the subset of VARS which satisfies the given CONDITION
    
    Parameters:
    VARS - collection of variables
    CONDITION - condition defining which variables should be constrained
  - alldifferent_except_0
```
public static Constraint alldifferent_except_0(IntVar[] VARS)
```
    Variables in VARS must either be different or equal to 0
    
    Parameters:
    VARS - collection of variables
  - among
```
public static Constraint among(IntVar NVAR,
               IntVar[] VARS,
               int[] VALUES)
```
    NVAR is the number of variables of the collection VARIABLES that take their value in VALUES.
    gccat among
    Propagator : C. Bessiere, E. Hebrard, B. Hnich, Z. Kiziltan, T. Walsh, Among, common and disjoint Constraints CP-2005
    
    Parameters:
    NVAR - a variable
    VARS - vector of variables
    VALUES - set of values
  - atleast_nvalues
```
public static Constraint atleast_nvalues(IntVar[] VARS,
                         IntVar NVALUES,
                         boolean AC)
```
    Let N be the number of distinct values assigned to the variables of the VARS collection. Enforce condition N >= NVALUES to hold.
    This embeds a light propagator by default. Additional filtering algorithms can be added.
    
    Parameters:
    VARS - collection of variables
    NVALUES - limit variable
    AC - additional filtering algorithm, domain filtering algorithm derivated from (Soft)AllDifferent
  - atmost_nvalues
```
public static Constraint atmost_nvalues(IntVar[] VARS,
                        IntVar NVALUES,
                        boolean STRONG)
```
    Let N be the number of distinct values assigned to the variables of the VARS collection. Enforce condition N <= NVALUES to hold.
    This embeds a light propagator by default. Additional filtering algorithms can be added.
    
    Parameters:
    VARS - collection of variables
    NVALUES - limit variable
    STRONG - "AMNV" Filters the conjunction of AtMostNValue and disequalities (see Fages and Lapègue Artificial Intelligence 2014) automatically detects disequalities and alldifferent constraints. Presumably useful when NVALUES must be minimized.
  - bin_packing
```
public static Constraint[] bin_packing(IntVar[] ITEM_BIN,
                       int[] ITEM_SIZE,
                       IntVar[] BIN_LOAD,
                       int OFFSET)
```
    Bin Packing formulation: forall b in [0,BIN_LOAD.length-1], BIN_LOAD[b]=sum(ITEM_SIZE[i] | i in [0,ITEM_SIZE.length-1], ITEM_BIN[i] = b+OFFSET forall i in [0,ITEM_SIZE.length-1], ITEM_BIN is in [OFFSET,BIN_LOAD.length-1+OFFSET],
    
    Parameters:
    ITEM_BIN - IntVar representing the bin of each item
    ITEM_SIZE - int representing the size of each item
    BIN_LOAD - IntVar representing the load of each bin (i.e. the sum of the size of the items in it)
    OFFSET - 0 by default but typically 1 if used within MiniZinc (which counts from 1 to n instead of from 0 to n-1)
  - boolean_channeling
```
public static Constraint boolean_channeling(BoolVar[] BVARS,
                            IntVar VAR,
                            int OFFSET)
```
    Maps the boolean assignments variables BVARS with the standard assignment variable VAR. VAR = i <-> BVARS[i-OFFSET] = 1
    
    Parameters:
    BVARS - array of boolean variables
    VAR - observed variable. Should presumably have an enumerated domain
    OFFSET - 0 by default but typically 1 if used within MiniZinc (which counts from 1 to n instead of from 0 to n-1)
  - bit_channeling
```
public static Constraint bit_channeling(BoolVar[] BITS,
                        IntVar VAR)
```
    Ensures that VAR = 2⁰*BIT_1 + 2¹*BIT_2 + ... 2^n-1*BIT_n.
    BIT_1 is related to the first bit of OCTET (2^0), BIT_2 is related to the first bit of OCTET (2^1), etc.
    The upper bound of VAR is given by 2ⁿ, where n is the size of the array BITS.
    
    Parameters:
    BITS - the array of bits
    VAR - the numeric value
  - clause_channeling
```
public static Constraint clause_channeling(IntVar VAR,
                           BoolVar[] EVARS,
                           BoolVar[] LVARS)
```
    Link each value from the domain of VAR to two boolean variable: one reifies the equality to the i^th value of the variable domain, the other reifies the less-or-equality to the i^th value of the variable domain. Contract: EVARS.lenght == LVARS.length == VAR.getUB() - VAR.getLB() + 1 Contract: VAR is not a boolean variable
    
    Parameters:
    VAR - an Integer variable
    EVARS - array of EQ boolean variables
    LVARS - array of LQ boolean variables
  - circuit
```
public static Constraint 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.
    Filtering algorithms:
    subtour elimination : Caseau & Laburthe (ICLP'97)
    allDifferent GAC algorithm: Régin (AAAI'94)
    dominator-based filtering: Fages & Lorca (CP'11)
    Strongly Connected Components based filtering (Cambazard & Bourreau JFPC'06 and Fages and Lorca TechReport'12)
    See Fages PhD Thesis (2014) for more information
    
    Parameters:
    VARS - vector of variables which take their value in [OFFSET,OFFSET+|VARS|-1]
    OFFSET - 0 by default but typically 1 if used within MiniZinc (which counts from 1 to n instead of from 0 to n-1)
    CONF - filtering options
    
    Returns:
    a circuit constraint
  - circuit
```
public static Constraint 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.
    Filtering algorithms:
    subtour elimination : Caseau & Laburthe (ICLP'97)
    allDifferent GAC algorithm: Régin (AAAI'94)
    dominator-based filtering: Fages & Lorca (CP'11)
    Strongly Connected Components based filtering (Cambazar & Bourreau JFPC'06 and Fages and Lorca TechReport'12)
    
    Parameters:
    VARS - vector of variables which take their value in [OFFSET,OFFSET+|VARS|-1]
    OFFSET - 0 by default but typically 1 if used within MiniZinc (which counts from 1 to n instead of from 0 to n-1)
    
    Returns:
    a circuit constraint
  - cost_regular
```
public static Constraint cost_regular(IntVar[] VARS,
                      IntVar COST,
                      ICostAutomaton CAUTOMATON)
```
    Ensures that the assignment of a sequence of variables is recognized by CAUTOMATON, a deterministic finite automaton, and that the sum of the costs associated to each assignment is bounded by the cost variable. This version allows to specify different costs according to the automaton state at which the assignment occurs (i.e. the transition starts)
    
    Parameters:
    VARS - sequence of variables
    COST - cost variable
    CAUTOMATON - a deterministic finite automaton defining the regular language and the costs Can be built with method CostAutomaton.makeSingleResource(...)
  - count
```
public static Constraint count(int VALUE,
               IntVar[] VARS,
               IntVar LIMIT)
```
    Let N be the number of variables of the VARIABLES collection assigned to value VALUE; Enforce condition N = LIMIT to hold.
    
    Parameters:
    VALUE - an int
    VARS - a vector of variables
    LIMIT - a variable
  - count
```
public static Constraint count(IntVar VALUE,
               IntVar[] VARS,
               IntVar LIMIT)
```
    Let N be the number of variables of the VARIABLES collection assigned to value VALUE; Enforce condition N = LIMIT to hold.
    
    Parameters:
    VALUE - a variable
    VARS - a vector of variables
    LIMIT - a variable
  - cumulative
```
public static Constraint cumulative(Task[] TASKS,
                    IntVar[] HEIGHTS,
                    IntVar CAPACITY)
```
    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.
    
    Parameters:
    TASKS - TASK objects containing start, duration and end variables
    HEIGHTS - integer variables representing the resource consumption of each task
    CAPACITY - integer variable representing the resource capacity
    
    Returns:
    a cumulative constraint
  - cumulative
```
public static Constraint cumulative(Task[] TASKS,
                    IntVar[] HEIGHTS,
                    IntVar CAPACITY,
                    boolean INCREMENTAL)
```
    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.
    
    Parameters:
    TASKS - TASK objects containing start, duration and end variables
    HEIGHTS - integer variables representing the resource consumption of each task
    CAPACITY - integer variable representing the resource capacity
    INCREMENTAL - specifies if an incremental propagation should be applied
    
    Returns:
    a cumulative constraint
  - diffn
```
public static Constraint[] diffn(IntVar[] X,
                 IntVar[] Y,
                 IntVar[] WIDTH,
                 IntVar[] HEIGHT,
                 boolean USE_CUMUL)
```
    Constrains each rectangle_i, given by their origins X_i,Y_i and sizes WIDTH_i,HEIGHT_i, to be non-overlapping.
    
    Parameters:
    X - collection of coordinates in first dimension
    Y - collection of coordinates in second dimension
    WIDTH - collection of width (each duration should be > 0)
    HEIGHT - collection of height (each height should be >= 0)
    USE_CUMUL - indicates whether or not redundant cumulative constraints should be put on each dimension (advised)
    
    Returns:
    a non-overlapping constraint
  - element
```
public static Constraint element(IntVar VALUE,
                 IntVar[] TABLE,
                 IntVar INDEX,
                 int OFFSET)
```
    Build an ELEMENT constraint: VALUE = TABLE[INDEX-OFFSET] where TABLE is an array of variables.
    
    Parameters:
    VALUE - value variable
    TABLE - array of variables
    INDEX - index variable in range [OFFSET,OFFSET+|TABLE|-1]
    OFFSET - int offset, generally 0
  - global_cardinality
```
public static Constraint global_cardinality(IntVar[] VARS,
                            int[] VALUES,
                            IntVar[] OCCURRENCES,
                            boolean CLOSED)
```
    Global Cardinality constraint (GCC): Each value VALUES[i] should be taken by exactly OCCURRENCES[i] variables of VARS.
    This constraint does not ensure any well-defined level of consistency, yet.
    
    Parameters:
    VARS - collection of variables
    VALUES - collection of constrained values
    OCCURRENCES - collection of cardinality variables
    CLOSED - restricts domains of VARS to VALUES if set to true
  - inverse_channeling
```
public static Constraint inverse_channeling(IntVar[] VARS1,
                            IntVar[] VARS2,
                            int OFFSET1,
                            int OFFSET2)
```
    Make an inverse channeling between VARS1 and VARS2: VARS1[i-OFFSET2] = j <=> VARS2[j-OFFSET1] = i Performs AC if domains are enumerated. If not, then it works on bounds without guaranteeing BC (enumerated domains are strongly recommended)
    Beware you should have |VARS1| = |VARS2|
    
    Parameters:
    VARS1 - vector of variables which take their value in [OFFSET1,OFFSET1+|VARS2|-1]
    VARS2 - vector of variables which take their value in [OFFSET2,OFFSET2+|VARS1|-1]
    OFFSET1 - lowest value in VARS1 (most often 0)
    OFFSET2 - lowest value in VARS2 (most often 0)
  - knapsack
```
public static Constraint knapsack(IntVar[] OCCURRENCES,
                  IntVar TOTAL_WEIGHT,
                  IntVar TOTAL_ENERGY,
                  int[] WEIGHT,
                  int[] ENERGY)
```
    Ensures that :
    - OCCURRENCES[i] * WEIGHT[i] ≤ TOTAL_WEIGHT
    - OCCURRENCES[i] * ENERGY[i] = TOTAL_ENERGY
    and maximizing the value of TOTAL_ENERGY.
    
    A knapsack constraint wikipedia:
    "Given a set of items, each with a weight and an energy value, determine the count of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. It derives its name from the problem faced by someone who is constrained by a fixed-size knapsack and must fill it with the most useful items."
    
    Parameters:
    OCCURRENCES - number of occurrences of an item
    TOTAL_WEIGHT - capacity of the knapsack
    TOTAL_ENERGY - variable to maximize
    WEIGHT - weight of each item
    ENERGY - energy of each item
  - lex_chain_less
```
public static Constraint lex_chain_less(IntVar[]... VARS)
```
    For each pair of consecutive vectors VARS_i and VARS_i+1 of the VARS collection VARS_i is lexicographically strictly less than than VARS_i+1
    
    Parameters:
    VARS - collection of vectors of variables
  - lex_chain_less_eq
```
public static Constraint lex_chain_less_eq(IntVar[]... VARS)
```
    For each pair of consecutive vectors VARS_i and VARS_i+1 of the VARS collection VARS_i is lexicographically less or equal than than VARS_i+1
    
    Parameters:
    VARS - collection of vectors of variables
  - lex_less
```
public static Constraint lex_less(IntVar[] VARS1,
                  IntVar[] VARS2)
```
    Ensures that VARS1 is lexicographically strictly less than VARS2.
    
    Parameters:
    VARS1 - vector of variables
    VARS2 - vector of variables
  - lex_less_eq
```
public static Constraint lex_less_eq(IntVar[] VARS1,
                     IntVar[] VARS2)
```
    Ensures that VARS1 is lexicographically less or equal than VARS2.
    
    Parameters:
    VARS1 - vector of variables
    VARS2 - vector of variables
  - maximum
```
public static Constraint maximum(IntVar MAX,
                 IntVar[] VARS)
```
    MAX is the maximum value of the collection of domain variables VARS
    
    Parameters:
    MAX - a variable
    VARS - a vector of variables
  - maximum
```
public static Constraint maximum(BoolVar MAX,
                 BoolVar[] VARS)
```
    MAX is the maximum value of the collection of boolean variables VARS
    
    Parameters:
    MAX - a boolean variable
    VARS - a vector of boolean variables
  - mddc
```
public static Constraint mddc(IntVar[] VARS,
              MultivaluedDecisionDiagram MDD)
```
    Create a constraint where solutions (tuples) are encoded by a multi-valued decision diagram. The order of the variables in VARS is important and must refer to the MDD.
    
    Parameters:
    VARS - the array of variables
    MDD - the multi-valued decision diagram encoding solutions
  - minimum
```
public static Constraint minimum(IntVar MIN,
                 IntVar[] VARS)
```
    MIN is the minimum value of the collection of domain variables VARS
    
    Parameters:
    MIN - a variable
    VARS - a vector of variables
  - minimum
```
public static Constraint minimum(BoolVar MIN,
                 BoolVar[] VARS)
```
    MIN is the minimum value of the collection of boolean variables VARS
    
    Parameters:
    MIN - a boolean variable
    VARS - a vector of boolean variables
  - multicost_regular
```
public static Constraint multicost_regular(IntVar[] VARS,
                           IntVar[] CVARS,
                           ICostAutomaton CAUTOMATON)
```
    Ensures that the assignment of a sequence of VARS is recognized by CAUTOMATON, a deterministic finite automaton, and that the sum of the cost vector COSTS associated to each assignment is bounded by the variable vector CVARS. This version allows to specify different costs according to the automaton state at which the assignment occurs (i.e. the transition starts)
    
    Parameters:
    VARS - sequence of variables
    CVARS - cost variables
    CAUTOMATON - a deterministic finite automaton defining the regular language and the costs Can be built from method CostAutomaton.makeMultiResources(...)
  - nvalues
```
public static Constraint[] nvalues(IntVar[] VARS,
                   IntVar NVALUES)
```
    Let N be the number of distinct values assigned to the variables of the VARS collection. Enforce condition N = NVALUES to hold.
    This embeds a light propagator by default. Additional filtering algorithms can be added.
    see atleast_nvalue and atmost_nvalue
    
    Parameters:
    VARS - collection of variables
    NVALUES - limit variable
    
    Returns:
    the conjunction of atleast_nvalue and atmost_nvalue
  - path
```
public static Constraint[] 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.
    Moreover, VARS[END-OFFSET] = |VARS|+OFFSET
    Requires : |VARS|>0
    Filtering algorithms: see circuit constraint
    
    Parameters:
    VARS - vector of variables which take their value in [OFFSET,OFFSET+|VARS|]
    START - variable indicating the index of the first variable in the path
    END - variable indicating the index of the last variable in the path
    OFFSET - 0 by default but typically 1 if used within MiniZinc (which counts from 1 to n instead of from 0 to n-1)
    
    Returns:
    a path constraint
  - regular
```
public static Constraint regular(IntVar[] VARS,
                 IAutomaton AUTOMATON)
```
    Enforces the sequence of VARS to be a word recognized by the deterministic finite automaton AUTOMATON. For example regexp = "(1|2)(3*)(4|5)"; The same dfa can be used for different propagators.
    
    Parameters:
    VARS - sequence of variables
    AUTOMATON - a deterministic finite automaton defining the regular language
  - scalar
```
public static Constraint scalar(IntVar[] VARS,
                int[] COEFFS,
                IntVar SCALAR)
```
    Enforces that ∑_{i in |VARS|}COEFFS_i * VARS_i = SCALAR.
    
    Parameters:
    VARS - a vector of variables
    COEFFS - a vector of int
    SCALAR - a variable
  - scalar
```
public static Constraint scalar(IntVar[] VARS,
                int[] COEFFS,
                String OPERATOR,
                IntVar SCALAR)
```
    A scalar constraint which ensures that Sum(VARS[i]*COEFFS[i]) OPERATOR SCALAR
    
    Parameters:
    VARS - a collection of IntVar
    COEFFS - a collection of int, for which |VARS|=|COEFFS|
    OPERATOR - an operator in {"=", "!=", ">","<",">=","<="}
    SCALAR - an IntVar
    
    Returns:
    a scalar constraint
  - sort
```
public static Constraint 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. The variables of SORTEDVARS are also sorted in increasing order.
    
    For example:
    - X= (4,2,1,3)
    - Y= (1,2,3,4)
    
    Parameters:
    VARS - an array of variables
    SORTEDVARS - an array of variables sorted in increasing order
    
    Returns:
    a sort constraint
  - subcircuit
```
public static Constraint subcircuit(IntVar[] VARS,
                    int OFFSET,
                    IntVar SUBCIRCUIT_SIZE)
```
    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.
    and VARS[i] = OFFSET+i means that i is not part of the circuit
    the constraint ensures that |{VARS[i] =/= OFFSET+i}| = SUBCIRCUIT_SIZE
    
    Filtering algorithms:
    subtour elimination : Caseau & Laburthe (ICLP'97)
    allDifferent GAC algorithm: Régin (AAAI'94)
    dominator-based filtering: Fages & Lorca (CP'11)
    SCC-based filtering
    
    Parameters:
    VARS - a vector of variables
    OFFSET - 0 by default but 1 if used within MiniZinc (which counts from 1 to n instead of from 0 to n-1)
    SUBCIRCUIT_SIZE - expected number of nodes in the circuit
    
    Returns:
    a subcircuit constraint
  - subpath
```
public static Constraint[] 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.
    where VARS[i] = OFFSET+i means that vertex i is excluded from the path.
    Moreover, VARS[END-OFFSET] = |VARS|+OFFSET
    Requires : |VARS|>0
    Filtering algorithms: see subcircuit constraint
    
    Parameters:
    VARS - vector of variables which take their value in [OFFSET,OFFSET+|VARS|]
    START - variable indicating the index of the first variable in the path
    END - variable indicating the index of the last variable in the path
    OFFSET - 0 by default but typically 1 if used within MiniZinc (which counts from 1 to n instead of from 0 to n-1)
    SIZE - variable indicating the number of variables to belong to the path
    
    Returns:
    a subpath constraint
  - sum
```
public static Constraint sum(IntVar[] VARS,
             IntVar SUM)
```
    Enforces that ∑_{i in |VARS|}VARS_i = SUM.
    
    Parameters:
    VARS - a vector of variables
    SUM - a variable
  - sum
```
public static Constraint sum(IntVar[] VARS,
             String OPERATOR,
             IntVar SUM)
```
    Enforces that ∑_{i in |VARS|}VARS_i OPERATOR SUM.
    
    Parameters:
    VARS - a collection of IntVar
    OPERATOR - operator in {"=", "!=", ">","<",">=","<="}
    SUM - an IntVar
    
    Returns:
    a sum constraint
  - sum
```
public static Constraint sum(BoolVar[] VARS,
             IntVar SUM)
```
    Enforces that ∑_{i in |VARS|}VARS_i = SUM. This constraint is much faster than the one over integer variables
    
    Parameters:
    VARS - a vector of boolean variables
    SUM - a variable
  - sum
```
public static Constraint sum(BoolVar[] VARS,
             String OPERATOR,
             IntVar SUM)
```
    Enforces that ∑_{i in |VARS|}VARS_i OPERATOR SUM. This constraint is much faster than the one over integer variables
    
    Parameters:
    VARS - a vector of boolean variables
    SUM - a variable
  - table
```
public static Constraint table(IntVar[] VARS,
               Tuples TUPLES,
               String ALGORITHM)
```
    Create a table constraint, with the specified algorithm defined ALGORITHM
    - 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.
    
    Parameters:
    VARS - first variable
    TUPLES - the relation between the variables (list of allowed/forbidden tuples)
    ALGORITHM - to choose among {"GAC3rm", "GAC2001", "GACSTR", "GAC2001+", "GAC3rm+", "FC", "STR2+"}
  - tree
```
public static Constraint tree(IntVar[] SUCCS,
              IntVar NBTREES,
              int OFFSET)
```
    Partition SUCCS variables into NBTREES (anti) arborescences
    SUCCS[i] = OFFSET+j means that j is the successor of i.
    and SUCCS[i] = OFFSET+i means that i is a root
    
    dominator-based filtering: Fages & Lorca (CP'11)
    However, the filtering over NBTREES is quite light here
    
    Parameters:
    SUCCS - successors variables
    NBTREES - number of arborescences (=number of loops)
    OFFSET - 0 by default but 1 if used within MiniZinc (which counts from 1 to n instead of from 0 to n-1)
    
    Returns:
    a tree constraint
  - tsp
```
public static Constraint[] tsp(IntVar[] SUCCS,
               IntVar COST,
               int[][] COST_MATRIX)
```
    A constraint for the Traveling Salesman Problem : Enforces SUCCS to form a hamiltonian circuit of value COST
    
    Parameters:
    SUCCS - successors variables
    COST - cost of the cycle
    COST_MATRIX - symmetric cost matrix
    
    Returns:
    a CP model for the TSP
  - getDomainUnion
```
public static gnu.trove.list.array.TIntArrayList getDomainUnion(IntVar[] vars)
```
  - tupleIt
```
public static boolean tupleIt(IntVar... VARS)
```
    Check whether the intension constraint to extension constraint substitution is enabled and can be achieved
    
    Parameters:
    VARS - list of variables involved
    
    Returns:
    a boolean

Class IntConstraintFactory

Method Summary

Methods inherited from class java.lang.Object

Method Detail

TRUE

FALSE

arithm

member

member

not_member

not_member

absolute

arithm

arithm

distance

element

element

square

table

distance

eucl_div

maximum

minimum

mod

times

times

alldifferent

alldifferent

alldifferent_conditionnal

alldifferent_conditionnal

alldifferent_except_0

among

atleast_nvalues

atmost_nvalues

bin_packing

boolean_channeling

bit_channeling

clause_channeling

circuit

circuit

cost_regular

count

count

cumulative

cumulative

diffn

element

global_cardinality

inverse_channeling

knapsack

lex_chain_less

lex_chain_less_eq

lex_less

lex_less_eq

maximum

maximum

mddc

minimum

minimum

multicost_regular

nvalues

path

regular

scalar

scalar

sort

subcircuit

subpath

sum

sum

sum

sum

table

tree

tsp

getDomainUnion

tupleIt