All Known Subinterfaces:

ProblemAPI, ProblemAPIOnVals, ProblemAPIOnVars, ProblemAPISymbolic

All Known Implementing Classes:

AllInterval, Bibd, Blackhole, BoardColoration, MagicSequence, Pic, Pic2, Queens, Rack, Rack2, Sudoku, Warehouse, Zebra
```
public interface ProblemAPIBase
```

Nested Class Summary

Nested Classes
Modifier and Type	Interface	Description
`static class`	`ProblemAPIBase.Index`	Class that is useful to represent objects wrapping indexing information.
`static interface`	`ProblemAPIBase.Occurrences`

Field Summary

Fields
Modifier and Type	Field	Description
`static Types.TypeRank`	`ANY`	A constant denoting that a search is conducted with respect to any object (typically, variable) of a structure (typically, a 1-dimensional array of variables) having a certain property.
`static Map<ProblemAPI,ProblemIMP>`	`api2imp`	Advanced Use: you shouldn't normally use this map that relates `ProblemAPI` objects with `ProblemIMP` objects.
`static Types.TypeClass`	`BLOCKS`	The constant "blocks" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
`static Types.TypeClass`	`CHANNELING`	The constant "channeling" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
`static Boolean`	`CLOSED`	A constant, equal to Boolean.TRUE, that can be used to indicate that some variables must take their values in some set of values (e.g., for the constraint `cardinality`.
`static Types.TypeClass`	`CLUES`	The constant "clues" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
`static Types.TypeClass`	`COLUMNS`	The constant "columns" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
`static Types.TypeOperatorRel`	`DECREASING`	A constant denoting the relational operator "Greater than or Equal", which is useful for expressing an ordering, as for example in `ordered(x, DECREASING)` or `lex(x, DECREASING)` .
`static Types.TypeClass`	`DIAGONALS`	The constant "diagonals" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
`static Types.TypeConditionOperatorRel`	`EQ`	A constant denoting the relational operator "Equal", which is useful for expressing conditions, as for example in `sum(x, EQ, 10)` or `count(x, takingValue(0), EQ, 5)` .
`static Types.TypeObjective`	`EXPRESSION`	A constant denoting the type "expression" for an objective function, as for example in `minimize(EXPRESSION, add(x,mul(y,3))` .
`static Types.TypeRank`	`FIRST`	A constant denoting that a search is conducted with respect to the first object (typically, variable) of a structure (typically, a 1-dimensional array of variables) having a certain property.
`static Types.TypeConditionOperatorRel`	`GE`	A constant denoting the relational operator "Greater than or Equal", which is useful for expressing conditions, as for example in `sum(x, GE, 10)` or `count(x, takingValue(0), GE, 5)` .
`static Types.TypeConditionOperatorRel`	`GT`	A constant denoting the relational operator "strictly Greater Than", which is useful for expressing conditions, as for example in `sum(x, GT, 10)` or `count(x, takingValue(0), GT, 5)` .
`static Types.TypeConditionOperatorSet`	`IN`	A constant denoting the set operator "In", which is useful for expressing conditions, as for example in `sum(x, IN, 5, 10)` or `count(x, takingValue(0), IN, 5, 10)` .
`static Types.TypeOperatorRel`	`INCREASING`	A constant denoting the relational operator "Less than or Equal", which is useful for expressing an ordering, as for example in `ordered(x, INCREASING)` or `lex(x, INCREASING)` .
`static Types.TypeRank`	`LAST`	A constant denoting that a search is conducted with respect to the last object (typically, variable) of a structure (typically, a 1-dimensional array of variables) having a certain property.
`static Types.TypeConditionOperatorRel`	`LE`	A constant denoting the relational operator "Less than or Equal", which is useful for expressing conditions, as for example in `sum(x, LE, 10)` or `count(x, takingValue(0), LE, 5)` .
`static Types.TypeObjective`	`LEX`	A constant denoting the type "lex" for an objective function, as for example in `minimize(LEX, x, y, z)` .
`static Types.TypeConditionOperatorRel`	`LT`	A constant denoting the relational operator "strictly Less Than", which is useful for expressing conditions, as for example in `sum(x, LT, 10)` or `count(x, takingValue(0), LT, 5)`.
`static Types.TypeObjective`	`MAXIMUM`	A constant denoting the type "maximum" for an objective function, as for example in `minimize(MAXIMUM, x, y, z)` .
`static Types.TypeObjective`	`MINIMUM`	A constant denoting the type "minimum" for an objective function, as for example in `maximize(MINIMUM, x, y, z)` .
`static Types.TypeConditionOperatorRel`	`NE`	A constant denoting the relational operator "Not Equal", which is useful for expressing conditions, as for example in `sum(x, NE, 10)` or `count(x, takingValue(takingValue(0), NE, 5)` .
`static Boolean`	`NEGATIVE`	A constant, equal to Boolean.FALSE, that can be used to indicate that a set of tuples corresponds to conflicts.
`static Types.TypeClass`	`NOGOODS`	The constant "nogoods" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
`static Types.TypeConditionOperatorSet`	`NOTIN`	A constant denoting the set operator "Not In", which is useful for expressing conditions, as for example in `sum(x, NOTIN, 5, 10)` or `count(x, takingValue(0), NOTIN, 5, 10)` .
`static Types.TypeObjective`	`NVALUES`	A constant denoting the type "nValues" for an objective function, as for example in `minimize(NVALUES, x)` .
`static Boolean`	`POSITIVE`	A constant, equal to Boolean.TRUE, that can be used to indicate that a set of tuples corresponds to supports.
`static Types.TypeObjective`	`PRODUCT`	A constant denoting the type "product" for an objective function, as for example in `minimize(PRODUCT, x, y, z)` .
`static Types.TypeClass`	`REDUNDANT_CONSTRAINTS`	The constant "redundantConstraints" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
`static Types.TypeClass`	`ROWS`	The constant "rows" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
`static int`	`STAR`	The constant used for denoting "*" in integer tuples.
`static int`	`STAR_INT`	The constant used for denoting "*" in integer tuples.
`static String`	`STAR_SYMBOL`	The constant used for denoting the symbol "*".
`static Types.TypeOperatorRel`	`STRICTLY_DECREASING`	A constant denoting the relational operator "strictly Greater Than", which is useful for expressing an ordering, as for example in `ordered(x, STRICTLY_DECREASING)` or `lex(x, STRICTLY_DECREASING)` .
`static Types.TypeOperatorRel`	`STRICTLY_INCREASING`	A constant denoting the relational operator "strictly Less Than", which is useful for expressing an ordering, as for example in `ordered(x, STRICTLY_INCREASING)` or `lex(x, STRICTLY_INCREASING)` .
`static Types.TypeObjective`	`SUM`	A constant denoting the type "sum" for an objective function, as for example in `minimize(SUM, x, y, z)` .
`static Types.TypeClass`	`SYMMETRY_BREAKING`	The constant "symmetryBreaking" that can be used for tagging elements such as variables, constraints, blocks, groups, ...

Method Summary

All Methods Instance Methods Default Methods Deprecated Methods
Modifier and Type	Method	Description
`default IVar.Var`	`at(IVar.Var index)`	Pure Syntactic Sugar: this method simply returns its argument.
`default Automaton`	`automaton(String startState, String transitions, String... finalStates)`	Builds an `Automaton` from the specified transitions, start and final states.
`default Automaton`	`automaton(String startState, Transition[] transitions, String... finalStates)`	Builds an `Automaton` from the specified transitions, start and final states.
`default Automaton`	`automaton(String startState, Transitions transitions, String... finalStates)`	Builds an `Automaton` from the specified transitions, start and final states.
`default CtrEntities.CtrArray`	`block(Runnable r)`	Builds a block by executing the specified runnable object.
`default Condition`	`condition(Types.TypeConditionOperatorRel op, long limit)`	Returns an object `Condition` composed of the specified relational operator and value (right operand).
`default Condition`	`condition(Types.TypeConditionOperatorRel op, IVar.Var limit)`	Returns an object `Condition` composed of the specified relational operator and variable (right operand).
`default Condition`	`condition(Types.TypeConditionOperatorSet op, int[] values)`	Returns an object `Condition` composed of the specified set operator and array of integers (right operand).
`default Condition`	`condition(Types.TypeConditionOperatorSet op, Range range)`	Returns an object `Condition` composed of the specified set operator and interval (defined from the two specified bounds).
`default void`	`control(boolean b, Object... objects)`	Controls that the specified `boolean` argument is `true`.
`default int`	`exceptValue(int value)`	Pure Syntactic Sugar: this method simply returns its argument.
`default int[]`	`exceptValues(int... values)`	Pure Syntactic Sugar: this method simply returns its argument.
`default String[]`	`finalState(String finalState)`	Pure Syntactic Sugar: this method simply returns its argument.
`default String[]`	`finalStates(String... finalStates)`	Pure Syntactic Sugar: this method simply returns its argument.
`default CtrEntities.CtrArray`	`forall(Range.Rangesx2 rangesx2, FunctionalInterfaces.Intx2Consumer c2)`	Builds a group of constraints by executing the specified consumer on each double value of the specified double range.
`default CtrEntities.CtrArray`	`forall(Range.Rangesx3 rangesx3, FunctionalInterfaces.Intx3Consumer c3)`	Builds a group of constraints by executing the specified consumer on each triple value of the specified triple range.
`default CtrEntities.CtrArray`	`forall(Range.Rangesx4 rangesx4, FunctionalInterfaces.Intx4Consumer c4)`	Builds a group of constraints by executing the specified consumer on each quadruple value of the specified quadruple range.
`default CtrEntities.CtrArray`	`forall(Range.Rangesx5 rangesx5, FunctionalInterfaces.Intx5Consumer c5)`	Builds a group of constraints by executing the specified consumer on each quintuple value of the specified quintuple range.
`default CtrEntities.CtrArray`	`forall(Range.Rangesx6 rangesx6, FunctionalInterfaces.Intx6Consumer c6)`	Builds a group of constraints by executing the specified consumer on each sixtuple value of the specified sixtuple range.
`default CtrEntities.CtrArray`	`forall(Range range, java.util.function.IntConsumer c)`	Builds a group of constraints by executing the specified consumer on each value of the specified range.
`default ProblemIMP`	`imp()`	Advanced Use: you shouldn't normally use the `ProblemIMP` object that offers implementation stuff for this object.
`default ProblemAPIBase.Index`	`index(IVar.Var variable)`	Returns an object `Index` wrapping the specified variable (and the default value ANY).
`default ProblemAPIBase.Index`	`index(IVar.Var variable, Types.TypeRank rank)`	Returns an object `Index` wrapping the specified variable and the specified rank type.
`default int[][]`	`indexing(int... t)`	Builds and returns a 2-dimensional array of integers, obtained from the specified 1-dimensional array by replacing each value `v` at index `i` with a pair `(i,v)`.
`default int[][]`	`indexing(int[]... m)`	Builds and returns a 2-dimensional array of integers, obtained from the specified 2-dimensional array by collecting triplets `(i,j,v)` where `v` is the value v at index `(i,j)` of the array.
`default int[][]`	`indexing(java.util.stream.IntStream t)`	Builds and returns a 2-dimensional array of integers, obtained by replacing each value `v` at position `i` of the specified stream with a pair `(i,v)`.
`default int[][]`	`indexingTuples(int[]... tuples)`	Builds and returns a 2-dimensional array of integers, obtained from the specified array by replacing each tuple `(v1,v2,...,vr)` at index `i` with a new tuple `(i,v1,v2,...,vr)`.
`default int[][]`	`indexingTuples(java.util.stream.Stream<int[]> tuples)`	Builds and returns a 2-dimensional array of integers, obtained by replacing each tuple `(v1,v2,...,vr)` at position `i` of the specified stream with a new tuple `(i,v1,v2,...,vr)`.
`default boolean`	`isModel(String s)`	Deprecated.
`default String`	`modelVariant()`	Returns the name of the model variant.
`default boolean`	`modelVariant(String s)`	Returns `true` iff the user has indicated (through the compiler by using the argument -variant=) that the model variant corresponds to the value of the specified string.
`default String`	`name()`	Returns the name of this object (i.e., the name of this problem instance).
`default int[][]`	`number(int... t)`	Deprecated.
`default ProblemAPIBase.Occurrences`	`occurBetween(int[] occursMin, int[] occursMax)`	Returns an object `Occurrences` that represents the respective bounds about the number of times each value of a given set in a certain context (when posting a constraint `cardinality`) must occur.
`default ProblemAPIBase.Occurrences`	`occurExactly(int... occurs)`	Returns an object `Occurrences` that represents the respective number of times each value of a given set in a certain context (when posting a constraint `cardinality`) must occur.
`default ProblemAPIBase.Occurrences`	`occurExactly(IVar.Var... occurs)`	Returns an object `Occurrences` that represents the respective numbers of times each value of a given set in a certain context (when posting a constraint `cardinality`) must occur.
`default ProblemAPIBase.Occurrences`	`occurrences(int... occurs)`	Deprecated.
`default ProblemAPIBase.Occurrences`	`occurrences(IVar.Var... occurs)`	Deprecated.
`default ProblemAPIBase.Occurrences`	`occursBetween(int[] occursMin, int[] occursMax)`	Deprecated.
`default ProblemAPIBase.Occurrences`	`occursEachBetween(int occursMin, int occursMax)`	Returns an object `Occurrences` that represents the bounds about the number of times each value of a given set in a certain context (when posting a constraint `cardinality`) must occur each.
`default ProblemAPIBase.Occurrences`	`occursEachExactly(int occurs)`	Returns an object `Occurrences` that represents the number of times each value of a given set in a certain context (when posting a constraint `cardinality`) must occur.
`default FunctionalInterfaces.Intx2Predicate`	`onlyOn(FunctionalInterfaces.Intx2Predicate p)`	Pure Syntactic Sugar: this method simply returns its argument.
`default java.util.stream.Stream<String>`	`readFileLines(String filename)`	Returns a stream composed of the non-empty trimmed lines (`String`) of the specified file
`default <T> java.util.stream.Stream<T>`	`readFileLines(String filename, java.util.function.Function<String,T> f)`	Returns a stream of objects from class T, after converting each non-empty trimmed line of the specified file
`default int`	`startIndex(int value)`	Pure Syntactic Sugar: this method simply returns its argument.
`default Table`	`table()`	Builds an empty integer table that can be fed with tuples.
`default Table`	`table(boolean positive)`	Builds an empty integer table which is either positive (i.e, contains supports) or negative (i.e., contains conflicts) depending on the specified Boolean value.
`default Table`	`table(int[]... tuples)`	Builds an integer table containing the specified tuples.
`default Table`	`table(int value, int... otherValues)`	Builds an integer table containing the specified tuple.
`default Table`	`table(String tuples)`	Builds an integer table after parsing the specified string.
`default Table`	`table(Collection<int[]> collection)`	Builds an integer table containing the specified tuples.
`default Table`	`table(java.util.stream.Stream<int[]> stream)`	Builds an integer table containing the specified tuples.
`default Table`	`table(Table table)`	Builds an integer table containing all tuples from the specified table.
`default Table`	`tableIntersection(Table table1, Table table2)`	Returns a table corresponding to the intersection of the two specified tables
`default Table`	`tableWithNewColumn(Table table, int position, int value)`	Returns a new integer table obtained after adding a new column at the specified table.
`default int`	`takingValue(int value)`	Pure Syntactic Sugar: this method simply returns its argument.
`default IVar.Var`	`takingValue(IVar.Var value)`	Pure Syntactic Sugar: this method simply returns its argument.
`default int[]`	`takingValues(int... values)`	Pure Syntactic Sugar: this method simply returns its argument.
`default int[][]`	`takingValues(int[]... values)`	Pure Syntactic Sugar: this method simply returns its argument.
`default int[]`	`takingValues(Range values)`	Syntactic Sugar: this method returns the 1-dimensional array of integers represented by the specified range.
`default Transitions`	`transitions()`	Builds and returns an empty object `Transitions`.
`default Transitions`	`transitions(String transitions)`	Builds and returns an object `Transitions` after parsing the specified string.
`default int[]`	`tuple(int value, int... otherValues)`	Returns a tuple (array) of integers from the specified parameters.
`default int[]`	`weightedBy(int... coeffs)`	Pure Syntactic Sugar: this method simply returns its argument.
`default int[][]`	`weightedBy(int[]... coeffs)`	Pure Syntactic Sugar: this method simply returns its argument.
`default IVar.Var[]`	`weightedBy(IVar.Var... coeffs)`	Pure Syntactic Sugar: this method simply returns its argument.
`default IVar.Var[][]`	`weightedBy(IVar.Var[]... coeffs)`	Pure Syntactic Sugar: this method simply returns its argument.

- Field Detail
  - LT
```
static final Types.TypeConditionOperatorRel LT
```
    A constant denoting the relational operator "strictly Less Than", which is useful for expressing conditions, as for example in sum(x, LT, 10) or count(x, takingValue(0), LT, 5).
  - LE
```
static final Types.TypeConditionOperatorRel LE
```
    A constant denoting the relational operator "Less than or Equal", which is useful for expressing conditions, as for example in sum(x, LE, 10) or count(x, takingValue(0), LE, 5) .
  - GE
```
static final Types.TypeConditionOperatorRel GE
```
    A constant denoting the relational operator "Greater than or Equal", which is useful for expressing conditions, as for example in sum(x, GE, 10) or count(x, takingValue(0), GE, 5) .
  - GT
```
static final Types.TypeConditionOperatorRel GT
```
    A constant denoting the relational operator "strictly Greater Than", which is useful for expressing conditions, as for example in sum(x, GT, 10) or count(x, takingValue(0), GT, 5) .
  - NE
```
static final Types.TypeConditionOperatorRel NE
```
    A constant denoting the relational operator "Not Equal", which is useful for expressing conditions, as for example in sum(x, NE, 10) or count(x, takingValue(takingValue(0), NE, 5) .
  - EQ
```
static final Types.TypeConditionOperatorRel EQ
```
    A constant denoting the relational operator "Equal", which is useful for expressing conditions, as for example in sum(x, EQ, 10) or count(x, takingValue(0), EQ, 5) .
  - IN
```
static final Types.TypeConditionOperatorSet IN
```
    A constant denoting the set operator "In", which is useful for expressing conditions, as for example in sum(x, IN, 5, 10) or count(x, takingValue(0), IN, 5, 10) .
  - NOTIN
```
static final Types.TypeConditionOperatorSet NOTIN
```
    A constant denoting the set operator "Not In", which is useful for expressing conditions, as for example in sum(x, NOTIN, 5, 10) or count(x, takingValue(0), NOTIN, 5, 10) .
  - STRICTLY_INCREASING
```
static final Types.TypeOperatorRel STRICTLY_INCREASING
```
    A constant denoting the relational operator "strictly Less Than", which is useful for expressing an ordering, as for example in ordered(x, STRICTLY_INCREASING) or lex(x, STRICTLY_INCREASING) .
  - INCREASING
```
static final Types.TypeOperatorRel INCREASING
```
    A constant denoting the relational operator "Less than or Equal", which is useful for expressing an ordering, as for example in ordered(x, INCREASING) or lex(x, INCREASING) .
  - DECREASING
```
static final Types.TypeOperatorRel DECREASING
```
    A constant denoting the relational operator "Greater than or Equal", which is useful for expressing an ordering, as for example in ordered(x, DECREASING) or lex(x, DECREASING) .
  - STRICTLY_DECREASING
```
static final Types.TypeOperatorRel STRICTLY_DECREASING
```
    A constant denoting the relational operator "strictly Greater Than", which is useful for expressing an ordering, as for example in ordered(x, STRICTLY_DECREASING) or lex(x, STRICTLY_DECREASING) .
  - EXPRESSION
```
static final Types.TypeObjective EXPRESSION
```
    A constant denoting the type "expression" for an objective function, as for example in minimize(EXPRESSION, add(x,mul(y,3)) .
  - SUM
```
static final Types.TypeObjective SUM
```
    A constant denoting the type "sum" for an objective function, as for example in minimize(SUM, x, y, z) .
  - PRODUCT
```
static final Types.TypeObjective PRODUCT
```
    A constant denoting the type "product" for an objective function, as for example in minimize(PRODUCT, x, y, z) .
  - MINIMUM
```
static final Types.TypeObjective MINIMUM
```
    A constant denoting the type "minimum" for an objective function, as for example in maximize(MINIMUM, x, y, z) .
  - MAXIMUM
```
static final Types.TypeObjective MAXIMUM
```
    A constant denoting the type "maximum" for an objective function, as for example in minimize(MAXIMUM, x, y, z) .
  - NVALUES
```
static final Types.TypeObjective NVALUES
```
    A constant denoting the type "nValues" for an objective function, as for example in minimize(NVALUES, x) .
  - LEX
```
static final Types.TypeObjective LEX
```
    A constant denoting the type "lex" for an objective function, as for example in minimize(LEX, x, y, z) .
  - CHANNELING
```
static final Types.TypeClass CHANNELING
```
    The constant "channeling" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - CLUES
```
static final Types.TypeClass CLUES
```
    The constant "clues" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - ROWS
```
static final Types.TypeClass ROWS
```
    The constant "rows" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - COLUMNS
```
static final Types.TypeClass COLUMNS
```
    The constant "columns" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - BLOCKS
```
static final Types.TypeClass BLOCKS
```
    The constant "blocks" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - DIAGONALS
```
static final Types.TypeClass DIAGONALS
```
    The constant "diagonals" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - SYMMETRY_BREAKING
```
static final Types.TypeClass SYMMETRY_BREAKING
```
    The constant "symmetryBreaking" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - REDUNDANT_CONSTRAINTS
```
static final Types.TypeClass REDUNDANT_CONSTRAINTS
```
    The constant "redundantConstraints" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - NOGOODS
```
static final Types.TypeClass NOGOODS
```
    The constant "nogoods" that can be used for tagging elements such as variables, constraints, blocks, groups, ...
  - FIRST
```
static final Types.TypeRank FIRST
```
    A constant denoting that a search is conducted with respect to the first object (typically, variable) of a structure (typically, a 1-dimensional array of variables) having a certain property.
  - LAST
```
static final Types.TypeRank LAST
```
    A constant denoting that a search is conducted with respect to the last object (typically, variable) of a structure (typically, a 1-dimensional array of variables) having a certain property.
  - ANY
```
static final Types.TypeRank ANY
```
    A constant denoting that a search is conducted with respect to any object (typically, variable) of a structure (typically, a 1-dimensional array of variables) having a certain property.
  - POSITIVE
```
static final Boolean POSITIVE
```
    A constant, equal to Boolean.TRUE, that can be used to indicate that a set of tuples corresponds to supports.
  - NEGATIVE
```
static final Boolean NEGATIVE
```
    A constant, equal to Boolean.FALSE, that can be used to indicate that a set of tuples corresponds to conflicts.
  - CLOSED
```
static final Boolean CLOSED
```
    A constant, equal to Boolean.TRUE, that can be used to indicate that some variables must take their values in some set of values (e.g., for the constraint cardinality.
  - STAR
```
static final int STAR
```
    The constant used for denoting "*" in integer tuples.
    
    See Also:
    
    Constant Field Values
  - STAR_INT
```
static final int STAR_INT
```
    The constant used for denoting "*" in integer tuples.
    
    See Also:
    
    Constant Field Values
  - STAR_SYMBOL
```
static final String STAR_SYMBOL
```
    The constant used for denoting the symbol "*".
    
    See Also:
    
    Constant Field Values
  - api2imp
```
static final Map<ProblemAPI,ProblemIMP> api2imp
```
    Advanced Use: you shouldn't normally use this map that relates ProblemAPI objects with ProblemIMP objects.
- Method Detail
  - imp
```
default ProblemIMP imp()
```
    Advanced Use: you shouldn't normally use the ProblemIMP object that offers implementation stuff for this object.
    
    Returns:
    
    the ProblemIMP object that offers implementation stuff for this ProblemAPI object
  - control
```
default void control(boolean b,
                     Object... objects)
```
    Controls that the specified boolean argument is true. If it is not the case, the program will stop and specified objects will be displayed.
    
    Parameters:
    
    b - a boolean value to be controlled to be true
    
    objects - a sequence of objects used for displaying information when the specified boolean argument is false
  - name
```
default String name()
```
    Returns the name of this object (i.e., the name of this problem instance). By default, this is the name of the class implementing ProblemAPI followed by the values of all parameters (separated by the symbol '-'). The parameters are the fields, used as data, which are declared in the class implementing ProblemAPI, or the name of a JSON file, if one is given. Possibly, the name of a model variant, if used, is inserted after the name of the class.
  - modelVariant
```
default String modelVariant()
```
    Returns the name of the model variant. If no model variant has been explicitly specified, it is null.
    
    Returns:
    
    the name of the model variant, or (null is no model variant has been explicitly specified)
  - modelVariant
```
default boolean modelVariant(String s)
```
    Returns true iff the user has indicated (through the compiler by using the argument -variant=) that the model variant corresponds to the value of the specified string.
    
    Parameters:
    
    s - a string representing the name of a model variant
    
    Returns:
    
    true iff the model variant corresponds to the specified string
  - isModel
```
@Deprecated
default boolean isModel(String s)
```
    Deprecated.
  - readFileLines
```
default <T> java.util.stream.Stream<T> readFileLines(String filename,
                                                     java.util.function.Function<String,T> f)
```
    Returns a stream of objects from class T, after converting each non-empty trimmed line of the specified file
    
    Parameters:
    
    filename - the name of a file
    
    f - a function mapping each line (String) into an object of class T
    
    Returns:
    
    a stream of objects from class T, after converting each non-empty trimmed line of the specified file
  - readFileLines
```
default java.util.stream.Stream<String> readFileLines(String filename)
```
    Returns a stream composed of the non-empty trimmed lines (String) of the specified file
    
    Parameters:
    
    filename - the name of a file
    
    Returns:
    
    a stream composed of the non-empty trimmed lines (String) of the specified file
  - tuple
```
default int[] tuple(int value,
                    int... otherValues)
```
    Returns a tuple (array) of integers from the specified parameters.
    
    Parameters:
    
    value - an integer
    
    otherValues - a sequence of integers
    
    Returns:
    
    a 1-dimensional array of int
  - number
```
@Deprecated
default int[][] number(int... t)
```
    Deprecated.
  - indexing
```
default int[][] indexing(int... t)
```
    Builds and returns a 2-dimensional array of integers, obtained from the specified 1-dimensional array by replacing each value v at index i with a pair (i,v). For example, indexing [2,4,1] yields [[0,2],[1,4],[2,1]].
    
    Parameters:
    
    t - a 1-dimensional array of integers
    
    Returns:
    
    a 2-dimensional array of integers
  - indexing
```
default int[][] indexing(java.util.stream.IntStream t)
```
    Builds and returns a 2-dimensional array of integers, obtained by replacing each value v at position i of the specified stream with a pair (i,v). For example, indexing [2,4,1] from a stream yields [[0,2],[1,4],[2,1]].
    
    Parameters:
    
    t - a stream of integer values
    
    Returns:
    
    A 2-dimensional array of integers
  - indexing
```
default int[][] indexing(int[]... m)
```
    Builds and returns a 2-dimensional array of integers, obtained from the specified 2-dimensional array by collecting triplets (i,j,v) where v is the value v at index (i,j) of the array. For example, indexing [[1,2,1],[2,5,1]] yields [[0,0,1],[0,1,2],[0,2,1],[1,0,2],[1,1,5],[1,2,1]].
    
    Parameters:
    
    m - a 2-dimensional array of integers
    
    Returns:
    
    a 2-dimensional array of integers
  - indexingTuples
```
default int[][] indexingTuples(int[]... tuples)
```
    Builds and returns a 2-dimensional array of integers, obtained from the specified array by replacing each tuple (v1,v2,...,vr) at index i with a new tuple (i,v1,v2,...,vr). For example, indexing [[0,3,1],[2,4,1]] yields [[0,0,3,1],[1,2,4,1]].
    
    Parameters:
    
    tuples - a 2-dimensional array of integers
    
    Returns:
    
    a 2-dimensional array of integers
  - indexingTuples
```
default int[][] indexingTuples(java.util.stream.Stream<int[]> tuples)
```
    Builds and returns a 2-dimensional array of integers, obtained by replacing each tuple (v1,v2,...,vr) at position i of the specified stream with a new tuple (i,v1,v2,...,vr). For example, indexing [[0,3,1],[2,4,1]] from a stream yields [[0,0,3,1],[1,2,4,1]].
    
    Parameters:
    
    tuples - a stream of arrays of integers
    
    Returns:
    
    a 2-dimensional array of integers
  - table
```
default Table table()
```
    Builds an empty integer table that can be fed with tuples.
    
    Returns:
    
    an object TableInteger
  - table
```
default Table table(boolean positive)
```
    Builds an empty integer table which is either positive (i.e, contains supports) or negative (i.e., contains conflicts) depending on the specified Boolean value.
    
    Parameters:
    
    positive - a Boolean value indicating if the created table is positive (true) or negative (false)
    
    Returns:
    
    an empty integer table
  - table
```
default Table table(int value,
                    int... otherValues)
```
    Builds an integer table containing the specified tuple.
    
    Parameters:
    
    value - an integer
    
    otherValues - a sequence of integers
    
    Returns:
    
    an integer table with one tuple
  - table
```
default Table table(int[]... tuples)
```
    Builds an integer table containing the specified tuples.
    
    Parameters:
    
    tuples - a sequence of tuples
    
    Returns:
    
    an integer table with the specified tuples
  - table
```
default Table table(java.util.stream.Stream<int[]> stream)
```
    Builds an integer table containing the specified tuples.
    
    Parameters:
    
    stream - a stream of tuples
    
    Returns:
    
    an integer table with the specified tuples
  - table
```
default Table table(Collection<int[]> collection)
```
    Builds an integer table containing the specified tuples.
    
    Parameters:
    
    collection - a collection of tuples
    
    Returns:
    
    an integer table with the specified tuples
  - table
```
default Table table(Table table)
```
    Builds an integer table containing all tuples from the specified table.
    
    Parameters:
    
    table - an existing table
    
    Returns:
    
    an integer table with all tuples from the specified table.
  - tableIntersection
```
default Table tableIntersection(Table table1,
                                Table table2)
```
    Returns a table corresponding to the intersection of the two specified tables
    
    Parameters:
    
    table1 - a first integer table
    
    table2 - a second integer table
    
    Returns:
    
    an integer table that represents the intersection of the two specified tables
  - tableWithNewColumn
```
default Table tableWithNewColumn(Table table,
                                 int position,
                                 int value)
```
    Returns a new integer table obtained after adding a new column at the specified table. The position of the new column is specified as well as the value that must be put in that column. For example, it can be useful for adding a column with '*' in tables.
    
    Parameters:
    
    table - an integer table
    
    position - the position of a new column where the value must be put
    
    value - the value that must be put in the column
    
    Returns:
    
    an integer table obtained after adding a new column at the specified table
  - table
```
default Table table(String tuples)
```
    Builds an integer table after parsing the specified string. The string is what can be expected in XCSP3, as for example (1,2)(1,3)(2,3) for an integer table.
    
    Parameters:
    
    tuples - a string representing a sequence of integer tuples.
    
    Returns:
    
    a table containing the parsed specified tuples
  - transitions
```
default Transitions transitions()
```
    Builds and returns an empty object Transitions. It is then possible to add transitions.
    
    Returns:
    
    an object Transitions
  - transitions
```
default Transitions transitions(String transitions)
```
    Builds and returns an object Transitions after parsing the specified string. The string is what can be expected in XCSP3, as for example "(q0,0,q1)(q0,2,q2)(q1,0,q3)".
    
    Parameters:
    
    transitions - a string representing the transitions
    
    Returns:
    
    an object Transitions
  - finalStates
```
default String[] finalStates(String... finalStates)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize the set of final states when building an automaton.
    
    Parameters:
    
    finalStates - a sequence of String
    
    Returns:
    
    an array of String
  - finalState
```
default String[] finalState(String finalState)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize the (unique) final state when building an automaton.
    
    Parameters:
    
    finalState - a String
    
    Returns:
    
    a String
  - automaton
```
default Automaton automaton(String startState,
                            Transition[] transitions,
                            String... finalStates)
```
    Builds an Automaton from the specified transitions, start and final states.
    
    Parameters:
    
    startState - the start state
    
    transitions - the transitions of the automaton
    
    finalStates - the final states
    
    Returns:
    
    an automaton
  - automaton
```
default Automaton automaton(String startState,
                            Transitions transitions,
                            String... finalStates)
```
    Builds an Automaton from the specified transitions, start and final states.
    
    Parameters:
    
    startState - the start state
    
    transitions - the object denoting the transitions
    
    finalStates - the final states
    
    Returns:
    
    an automaton
  - automaton
```
default Automaton automaton(String startState,
                            String transitions,
                            String... finalStates)
```
    Builds an Automaton from the specified transitions, start and final states.
    
    Parameters:
    
    startState - the start state
    
    transitions - the string denoting the transitions
    
    finalStates - the final states
    
    Returns:
    
    an automaton
  - occursEachExactly
```
default ProblemAPIBase.Occurrences occursEachExactly(int occurs)
```
    Returns an object Occurrences that represents the number of times each value of a given set in a certain context (when posting a constraint cardinality) must occur.
    
    Parameters:
    
    occurs - an integer
    
    Returns:
    
    an object Occurrences that can be used with constraint cardinality
  - occursEachBetween
```
default ProblemAPIBase.Occurrences occursEachBetween(int occursMin,
                                                     int occursMax)
```
    Returns an object Occurrences that represents the bounds about the number of times each value of a given set in a certain context (when posting a constraint cardinality) must occur each.
    
    Parameters:
    
    occursMin - the lower bound for the number of occurrences
    
    occursMax - the upper bound for the number of occurrences
    
    Returns:
    
    an object Occurrences that can be used with constraint cardinality
  - occurExactly
```
default ProblemAPIBase.Occurrences occurExactly(int... occurs)
```
    Returns an object Occurrences that represents the respective number of times each value of a given set in a certain context (when posting a constraint cardinality) must occur.
    
    Parameters:
    
    occurs - a 1-dimensional array of integers representing the respective numbers of occurrences
    
    Returns:
    
    an object Occurrences that can be used with constraint cardinality
  - occurrences
```
@Deprecated
default ProblemAPIBase.Occurrences occurrences(int... occurs)
```
    Deprecated.
  - occurBetween
```
default ProblemAPIBase.Occurrences occurBetween(int[] occursMin,
                                                int[] occursMax)
```
    Returns an object Occurrences that represents the respective bounds about the number of times each value of a given set in a certain context (when posting a constraint cardinality) must occur.
    
    Parameters:
    
    occursMin - the lower bounds for the number of occurrences
    
    occursMax - the upper bounds for the number of occurrences
    
    Returns:
    
    an object Occurrences that can be used with constraint cardinality
  - occursBetween
```
@Deprecated
default ProblemAPIBase.Occurrences occursBetween(int[] occursMin,
                                                 int[] occursMax)
```
    Deprecated.
  - occurExactly
```
default ProblemAPIBase.Occurrences occurExactly(IVar.Var... occurs)
```
    Returns an object Occurrences that represents the respective numbers of times each value of a given set in a certain context (when posting a constraint cardinality) must occur.
    
    Parameters:
    
    occurs - a 1-dimensional array of integer variables
    
    Returns:
    
    an object Occurrences that can be used with constraint cardinality
  - occurrences
```
@Deprecated
default ProblemAPIBase.Occurrences occurrences(IVar.Var... occurs)
```
    Deprecated.
  - condition
```
default Condition condition(Types.TypeConditionOperatorRel op,
                            long limit)
```
    Returns an object Condition composed of the specified relational operator and value (right operand). Such object can be used when posting constraints.
    
    Parameters:
    
    op - a relational operator
    
    limit - an integer
    
    Returns:
    
    an object Condition composed of the specified relational operator and value
  - condition
```
default Condition condition(Types.TypeConditionOperatorRel op,
                            IVar.Var limit)
```
    Returns an object Condition composed of the specified relational operator and variable (right operand). Such object can be used when posting constraints.
    
    Parameters:
    
    op - a relational operator
    
    limit - an integer variable
    
    Returns:
    
    an object Condition composed of the specified relational operator and variable
  - condition
```
default Condition condition(Types.TypeConditionOperatorSet op,
                            Range range)
```
    Returns an object Condition composed of the specified set operator and interval (defined from the two specified bounds). Such object can be used when posting constraints.
    
    Parameters:
    
    op - a set operator
    
    range - a range (interval) of values
    
    Returns:
    
    an object Condition composed of the specified set operator and interval
  - condition
```
default Condition condition(Types.TypeConditionOperatorSet op,
                            int[] values)
```
    Returns an object Condition composed of the specified set operator and array of integers (right operand). Such object can be used when posting constraints.
    
    Parameters:
    
    op - a set operator
    
    values - an array of integers
    
    Returns:
    
    an object Condition composed of the specified set operator and array of integers
  - index
```
default ProblemAPIBase.Index index(IVar.Var variable)
```
    Returns an object Index wrapping the specified variable (and the default value ANY). Such object can be used when posting constraints.
    
    Parameters:
    
    variable - an integer variable
    
    Returns:
    
    an object Index wrapping the specified variable
  - index
```
default ProblemAPIBase.Index index(IVar.Var variable,
                                   Types.TypeRank rank)
```
    Returns an object Index wrapping the specified variable and the specified rank type. In the context of looking for an object with a certain property P in a structure (typically, a variable with property P in a 1-dimensional array of variables), the value of rank indicates if variable must be:
    
    the smallest valid index number (FIRST), meaning that variable must refer to the first object in the structure with property P
    
    the greatest valid index number (LAST), meaning that variable must refer to the last variable in the structure with property P
    
    or any valid index number (ANY), meaning that variable can refer to any variable in the structure with property P.
    Parameters:
    
    variable - an integer variable
    
    rank - the way indexing search is considered (FIRST, LAST or ANY)
    
    Returns:
    
    an object Index wrapping the specified variable and the specified rank type
  - startIndex
```
default int startIndex(int value)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize the value used as starting index when posting some constraints (e.g., element, channel or minimum).
    
    Parameters:
    
    value - an integer
    
    Returns:
    
    the same integer
  - onlyOn
```
default FunctionalInterfaces.Intx2Predicate onlyOn(FunctionalInterfaces.Intx2Predicate p)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize a limitation for some constraints (e.g., instantiation.
    
    Parameters:
    
    p - a predicate
    
    Returns:
    
    the same predicate
  - weightedBy
```
default int[] weightedBy(int... coeffs)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize a scalar product.
    
    Parameters:
    
    coeffs - a 1-dimensional array (varargs) of integers
    
    Returns:
    
    the same 1-dimensional array of integers
  - weightedBy
```
default IVar.Var[] weightedBy(IVar.Var... coeffs)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize a scalar product.
    
    Parameters:
    
    coeffs - a 1-dimensional array (varargs) of variables
    
    Returns:
    
    the same 1-dimensional array of variables
  - weightedBy
```
default int[][] weightedBy(int[]... coeffs)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize a scalar product.
    
    Parameters:
    
    coeffs - a 2-dimensional array (varargs) of integers
    
    Returns:
    
    the same 2-dimensional array of integers
  - weightedBy
```
default IVar.Var[][] weightedBy(IVar.Var[]... coeffs)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize a scalar product.
    
    Parameters:
    
    coeffs - a 2-dimensional array (varargs) of variables
    
    Returns:
    
    the same 2-dimensional array of variables
  - takingValue
```
default int takingValue(int value)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize the target when posting some constraints (e.g., count, element or instantiation).
    
    Parameters:
    
    value - an integer
    
    Returns:
    
    the same integer
  - takingValue
```
default IVar.Var takingValue(IVar.Var value)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize the target when posting some constraints (e.g., count, element or instantiation).
    
    Parameters:
    
    value - a variable
    
    Returns:
    
    the same variable
  - exceptValue
```
default int exceptValue(int value)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful when posting constraints with an "exceptional" value to be indicated.
    
    Parameters:
    
    value - an integer
    
    Returns:
    
    the same integer
  - exceptValues
```
default int[] exceptValues(int... values)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful when posting constraints with "exceptional" values to be indicated.
    
    Parameters:
    
    values - a 1-dimensional array (varargs) of integers
    
    Returns:
    
    the same 1-dimensional array of integers
  - takingValues
```
default int[] takingValues(int... values)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize the target when posting some constraints (e.g., count, element or instantiation).
    
    Parameters:
    
    values - a 1-dimensional array (varargs) of integers
    
    Returns:
    
    the same 1-dimensional array of integers
  - takingValues
```
default int[] takingValues(Range values)
```
    Syntactic Sugar: this method returns the 1-dimensional array of integers represented by the specified range. It can be useful to emphasize the target when posting some constraints (e.g., count, element or instantiation).
    
    Parameters:
    
    values - an object Range
    
    Returns:
    
    the 1-dimensional array of integers, represented by the specified range
  - takingValues
```
default int[][] takingValues(int[]... values)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize the target when posting some constraints (e.g., instantiation).
    
    Parameters:
    
    values - a 2-dimensional array (varargs) of integers
    
    Returns:
    
    the same 2-dimensional array of integers
  - at
```
default IVar.Var at(IVar.Var index)
```
    Pure Syntactic Sugar: this method simply returns its argument. It can be useful to emphasize a specific variable when posting some constraints (e.g., element).
    
    Parameters:
    
    index - a variable
    
    Returns:
    
    the same variable
  - block
```
default CtrEntities.CtrArray block(Runnable r)
```
    Builds a block by executing the specified runnable object. For example:
    block(() -> { instantiation(x, t); lexMatrix(x, INCREASING); }).tag(SYMMETRY_BREAKING);
    Parameters:
    
    r - an object to run
    
    Returns:
    
    an object CtrArray that wraps the built block and allows us to provide note and tags by method chaining
  - forall
```
default CtrEntities.CtrArray forall(Range range,
                                    java.util.function.IntConsumer c)
```
    Builds a group of constraints by executing the specified consumer on each value of the specified range. For example:
    forall(range(n - 1), i -> equal(x[i], x[i + 1]));
    Parameters:
    
    range - a range of values
    
    c - a consumer
    
    Returns:
    
    an object CtrArray that wraps the built group and allows us to provide note and tags by method chaining
  - forall
```
default CtrEntities.CtrArray forall(Range.Rangesx2 rangesx2,
                                    FunctionalInterfaces.Intx2Consumer c2)
```
    Builds a group of constraints by executing the specified consumer on each double value of the specified double range. For example:
    forall(range(n).range(n), (i,j) -> lessThan(x[i], y[j]));
    Parameters:
    
    rangesx2 - a double range of values
    
    c2 - a consumer that accepts two integers
    
    Returns:
    
    an object CtrArray that wraps the built group and allows us to provide note and tags by method chaining
  - forall
```
default CtrEntities.CtrArray forall(Range.Rangesx3 rangesx3,
                                    FunctionalInterfaces.Intx3Consumer c3)
```
    Builds a group of constraints by executing the specified consumer on each triple value of the specified triple range. For example:
    forall(range(n).range(n).range(2), (i,j,k) -> lessThan(x[i], add(y[j],k)));
    Parameters:
    
    rangesx3 - a triple range of values
    
    c3 - a consumer that accepts three integers
    
    Returns:
    
    an object CtrArray that wraps the built group and allows us to provide note and tags by method chaining
  - forall
```
default CtrEntities.CtrArray forall(Range.Rangesx4 rangesx4,
                                    FunctionalInterfaces.Intx4Consumer c4)
```
    Builds a group of constraints by executing the specified consumer on each quadruple value of the specified quadruple range. For example:
    forall(range(n).range(n).range(2).range(2), (i,j,k,l) -> lessThan(add(x[i],l), add(y[j],k)));
    Parameters:
    
    rangesx4 - a quadruple range of values
    
    c4 - a consumer that accepts four integers
    
    Returns:
    
    an object CtrArray that wraps the built group and allows us to provide note and tags by method chaining
  - forall
```
default CtrEntities.CtrArray forall(Range.Rangesx5 rangesx5,
                                    FunctionalInterfaces.Intx5Consumer c5)
```
    Builds a group of constraints by executing the specified consumer on each quintuple value of the specified quintuple range. For example:
    forall(range(n).range(n).range(2).range(2).range(10), (i,j,k,l,m) -> lessThan(add(x[i],dist(l,m)), add(y[j],k)));
    Parameters:
    
    rangesx5 - a quintuple range of values
    
    c5 - a consumer that accepts five integers
    
    Returns:
    
    an object CtrArray that wraps the built group and allows us to provide note and tags by method chaining
  - forall
```
default CtrEntities.CtrArray forall(Range.Rangesx6 rangesx6,
                                    FunctionalInterfaces.Intx6Consumer c6)
```
    Builds a group of constraints by executing the specified consumer on each sixtuple value of the specified sixtuple range.
    
    Parameters:
    
    rangesx6 - a sixtuple range of values
    
    c6 - a consumer that accepts six integers
    
    Returns:
    
    an object CtrArray that wraps the built group and allows us to provide note and tags by method chaining

Interface ProblemAPIBase

Nested Class Summary

Field Summary

Method Summary

Field Detail

LT

LE

GE

GT

NE

EQ

IN

NOTIN

STRICTLY_INCREASING

INCREASING

DECREASING

STRICTLY_DECREASING

EXPRESSION

SUM

PRODUCT

MINIMUM

MAXIMUM

NVALUES

LEX

CHANNELING

CLUES

ROWS

COLUMNS

BLOCKS

DIAGONALS

SYMMETRY_BREAKING

REDUNDANT_CONSTRAINTS

NOGOODS

FIRST

LAST

ANY

POSITIVE

NEGATIVE

CLOSED

STAR

STAR_INT

STAR_SYMBOL

api2imp

Method Detail

imp

control

name

modelVariant

modelVariant

isModel

readFileLines

readFileLines

tuple

number

indexing

indexing

indexing

indexingTuples

indexingTuples

table

table

table

table

table

table

table

tableIntersection

tableWithNewColumn

table

transitions

transitions

finalStates

finalState

automaton

automaton

automaton

occursEachExactly

occursEachBetween

occurExactly

occurrences