java.lang.Object
- org.xcsp.modeler.implementation.ProblemIMP

Direct Known Subclasses:: ProblemIMP3

public abstract class ProblemIMP
extends Object

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class ProblemIMP.Annotations

protected class ProblemIMP.Converter

Field Summary

Fields
Modifier and Type	Field	Description
`ProblemIMP.Annotations`	`annotations`	Managing Annotations
`ProblemAPI`	`api`	Fields and Methods
`String[]`	`argsForPb`	User arguments given on the command for the problem (instance)
`CtrEntities`	`ctrEntities`
`String`	`modelVariant`
`ObjEntities`	`objEntities`
`ArrayList<AbstractMap.SimpleEntry<Object,String>>`	`parameters`	The list of parameters of the problem, as given by the user (after asking them).
`Stack<Integer>`	`stackLoops`
`VarEntities`	`varEntities`

Constructor Summary

Constructors
Modifier Constructor Description

protected ProblemIMP(ProblemAPI api, String modelVariant, String[] argsForPb)

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`Object`	`addParameter(Object value)`	Adds to the list of problem parameters a problem parameter with the specified value (and no formatting pattern).
`Object`	`addParameter(Object value, String format)`	Adds to the list of problem parameters a problem parameter with the specified value and formatting pattern.
`abstract CtrEntities.CtrEntity`	`allDifferent(IVar.Var[] list)`
`abstract CtrEntities.CtrEntity`	`allDifferent(IVar.Var[] list, int[] exceptValues)`
`abstract CtrEntities.CtrEntity`	`allDifferent(IVar.VarSymbolic[] list)`
`abstract CtrEntities.CtrEntity`	`allDifferent(XNode<IVar>[] trees)`
`abstract CtrEntities.CtrEntity`	`allDifferentList(IVar.Var[]... lists)`
`abstract CtrEntities.CtrEntity`	`allDifferentList(IVar.Var[][] lists, int[][] except)`
`abstract CtrEntities.CtrEntity`	`allDifferentMatrix(IVar.Var[][] matrix)`
`abstract CtrEntities.CtrEntity`	`allEqual(IVar.Var... list)`
`abstract CtrEntities.CtrEntity`	`allEqual(IVar.VarSymbolic... list)`
`abstract CtrEntities.CtrEntity`	`allEqualList(IVar.Var[]... lists)`
`String`	`ask(String message)`	Gets a parameter of the problem.
`boolean`	`askBoolean(String message)`	Defines a parameter of the problem.
`boolean`	`askBoolean(String message, java.util.function.Function<Boolean,String> format)`
`double`	`askDouble(String message)`	Defines a parameter of the problem.
`double`	`askDouble(String message, String format)`
`double`	`askDouble(String message, java.util.function.Predicate<Double> control)`
`double`	`askDouble(String message, java.util.function.Predicate<Double> control, String format)`
`double`	`askDouble(String message, java.util.function.Predicate<Double> control, java.util.function.DoubleFunction<String> format)`
`int`	`askInt(String message)`
`int`	`askInt(String message, String format)`
`int`	`askInt(String message, java.util.function.Predicate<Integer> control)`
`int`	`askInt(String message, java.util.function.Predicate<Integer> control, String format)`
`int`	`askInt(String message, java.util.function.Predicate<Integer> control, java.util.function.IntFunction<String> format)`	Defines a parameter of the problem.
`int`	`askInt(String message, Range range)`
`int`	`askInt(String message, Range range, String format)`
`int`	`askInt(String message, Range range, java.util.function.IntFunction<String> format)`
`String`	`askString(String message)`	Defines a parameter of the problem.
`String`	`askString(String message, java.util.function.Function<String,String> format)`	Defines a parameter of the problem.
`Object`	`buildInternClassObject(String internClass, Object... fieldValues)`
`abstract IVar.Var`	`buildVarInteger(String id, Domains.Dom dom)`	Managing Variables
`abstract IVar.VarSymbolic`	`buildVarSymbolic(String id, Domains.DomSymbolic dom)`
`abstract CtrEntities.CtrEntity`	`cardinality(IVar.Var[] list, int[] values, boolean mustBeClosed, int[] occurs)`
`abstract CtrEntities.CtrEntity`	`cardinality(IVar.Var[] list, int[] values, boolean mustBeClosed, int[] occursMin, int[] occursMax)`
`abstract CtrEntities.CtrEntity`	`cardinality(IVar.Var[] list, int[] values, boolean mustBeClosed, IVar.Var[] occurs)`
`abstract CtrEntities.CtrEntity`	`cardinality(IVar.Var[] list, IVar.Var[] values, boolean mustBeClosed, int[] occurs)`
`abstract CtrEntities.CtrEntity`	`cardinality(IVar.Var[] list, IVar.Var[] values, boolean mustBeClosed, int[] occursMin, int[] occursMax)`
`abstract CtrEntities.CtrEntity`	`cardinality(IVar.Var[] list, IVar.Var[] values, boolean mustBeClosed, IVar.Var[] occurs)`
`abstract CtrEntities.CtrEntity`	`channel(IVar.Var[] list, int startIndex)`
`abstract CtrEntities.CtrEntity`	`channel(IVar.Var[] list, int startIndex, IVar.Var value)`
`abstract CtrEntities.CtrEntity`	`channel(IVar.Var[] list1, int startIndex1, IVar.Var[] list2, int startIndex2)`
`abstract CtrEntities.CtrEntity`	`circuit(IVar.Var[] list, int startIndex)`
`abstract CtrEntities.CtrEntity`	`circuit(IVar.Var[] list, int startIndex, int size)`
`abstract CtrEntities.CtrEntity`	`circuit(IVar.Var[] list, int startIndex, IVar.Var size)`
`abstract Class<? extends IVar.Var>`	`classVI()`
`abstract Class<? extends IVar.VarSymbolic>`	`classVS()`
`abstract CtrEntities.CtrEntity`	`clause(IVar.Var[] list, Boolean[] phases)`
`<T extends IVar> T[]`	`clean(T[] vars)`
`CtrEntities.CtrEntity`	`conjunction(Object... operands)`
`static void`	`control(boolean b, Object... objects)`
`abstract CtrEntities.CtrEntity`	`count(IVar.Var[] list, int[] values, Condition condition)`
`abstract CtrEntities.CtrEntity`	`count(IVar.Var[] list, IVar.Var[] values, Condition condition)`
`abstract CtrEntities.CtrEntity`	`cumulative(IVar.Var[] origins, int[] lengths, IVar.Var[] ends, int[] heights, Condition condition)`
`abstract CtrEntities.CtrEntity`	`cumulative(IVar.Var[] origins, int[] lengths, IVar.Var[] ends, IVar.Var[] heights, Condition condition)`
`abstract CtrEntities.CtrEntity`	`cumulative(IVar.Var[] origins, IVar.Var[] lengths, IVar.Var[] ends, int[] heights, Condition condition)`
`abstract CtrEntities.CtrEntity`	`cumulative(IVar.Var[] origins, IVar.Var[] lengths, IVar.Var[] ends, IVar.Var[] heights, Condition condition)`
`void`	`decisionVariables(IVar[] list)`
`CtrEntities.CtrEntity`	`different(Object... operands)`
`CtrEntities.CtrEntity`	`disjunction(Object... operands)`
`<T extends IVar> T[]`	`distinct(T[] vars)`
`<T extends IVar> T[]`	`distinctSorted(T[] vars)`
`CtrEntities.CtrEntity`	`dummyConstraint(String message)`
`abstract CtrEntities.CtrEntity`	`element(int[][] matrix, int startRowIndex, IVar.Var rowIndex, int startColIndex, IVar.Var colIndex, Condition condition)`
`abstract CtrEntities.CtrEntity`	`element(int[] list, int startIndex, IVar.Var index, Types.TypeRank rank, Condition condition)`
`abstract CtrEntities.CtrEntity`	`element(IVar.Var[] list, int startIndex, IVar.Var index, Types.TypeRank rank, Condition condition)`
`abstract CtrEntities.CtrEntity`	`element(IVar.Var[] list, Condition condition)`
`CtrEntities.CtrEntity`	`equal(Object... operands)`
`static boolean`	`executeMethod(Object o, String methodName)`
`abstract CtrEntities.CtrAlone`	`extension(IVar.Var[] scp, int[][] tuples, boolean positive)`
`abstract CtrEntities.CtrAlone`	`extension(IVar.Var[] scp, AbstractTuple[] tuples, boolean positive)`
`abstract CtrEntities.CtrAlone`	`extension(IVar.VarSymbolic[] scp, String[][] tuples, boolean positive)`
`CtrEntities.CtrAlone`	`extension(XNodeParent<IVar> tree)`
`CtrEntities.CtrAlone`	`extensionDisjunction(List<XNodeParent<IVar>> trees)`
`Scanner`	`fileScanner()`
`IVar.Var[]`	`fill(String id, Size.Size1D size, FunctionalInterfaces.IntToDom f, IVar.Var[] t)`
`IVar.VarSymbolic[]`	`fill(String id, Size.Size1D size, FunctionalInterfaces.IntToDomSymbolic f, IVar.VarSymbolic[] t)`
`IVar.Var[][]`	`fill(String id, Size.Size2D size, FunctionalInterfaces.Intx2ToDom f, IVar.Var[][] t)`
`IVar.VarSymbolic[][]`	`fill(String id, Size.Size2D size, FunctionalInterfaces.Intx2ToDomSymbolic f, IVar.VarSymbolic[][] t)`
`IVar.Var[][][]`	`fill(String id, Size.Size3D size, FunctionalInterfaces.Intx3ToDom f, IVar.Var[][][] t)`
`IVar.VarSymbolic[][][]`	`fill(String id, Size.Size3D size, FunctionalInterfaces.Intx3ToDomSymbolic f, IVar.VarSymbolic[][][] t)`
`IVar.Var[][][][]`	`fill(String id, Size.Size4D size, FunctionalInterfaces.Intx4ToDom f, IVar.Var[][][][] t)`
`IVar.Var[][][][][]`	`fill(String id, Size.Size5D size, FunctionalInterfaces.Intx5ToDom f, IVar.Var[][][][][] t)`
`CtrEntities.CtrArray`	`forall(Range.Rangesx2 rangesx2, FunctionalInterfaces.Intx2Consumer c2)`	Builds constraints by considering the specified ranges and soliciting the specified function.
`CtrEntities.CtrArray`	`forall(Range.Rangesx3 rangesx3, FunctionalInterfaces.Intx3Consumer c3)`	Builds constraints by considering the specified ranges and soliciting the specified function.
`CtrEntities.CtrArray`	`forall(Range.Rangesx4 rangesx4, FunctionalInterfaces.Intx4Consumer c4)`	Builds constraints by considering the specified ranges and soliciting the specified function.
`CtrEntities.CtrArray`	`forall(Range.Rangesx5 rangesx5, FunctionalInterfaces.Intx5Consumer c5)`	Builds constraints by considering the specified ranges and soliciting the specified function.
`CtrEntities.CtrArray`	`forall(Range.Rangesx6 rangesx6, FunctionalInterfaces.Intx6Consumer c6)`	Builds constraints by considering the specified ranges and soliciting the specified function.
`CtrEntities.CtrArray`	`forall(Range range, java.util.function.IntConsumer c)`	Builds constraints by considering the specified range and soliciting the specified function.
`String`	`formattedPbParameters()`
`protected abstract ProblemIMP.Converter`	`getConverter()`
`CtrEntities.CtrEntity`	`greaterEqual(Object operand1, Object operand2)`
`CtrEntities.CtrEntity`	`greaterThan(Object operand1, Object operand2)`
`abstract CtrEntities.CtrEntity`	`ifThen(CtrEntities.CtrEntity c1, CtrEntities.CtrEntity c2)`
`abstract CtrEntities.CtrEntity`	`ifThenElse(CtrEntities.CtrEntity c1, CtrEntities.CtrEntity c2, CtrEntities.CtrEntity c3)`
`void`	`indentAndCompressXmlUnderLinux(String fileName)`
`abstract CtrEntities.CtrEntity`	`instantiation(IVar.Var[] list, int[] values)`
`abstract CtrEntities.CtrEntity`	`intension(XNodeParent<IVar> tree)`
`String`	`intervalAsString(int[] lbs, int[] ubs)`
`CtrEntities.CtrEntity`	`lessEqual(Object operand1, Object operand2)`
`CtrEntities.CtrEntity`	`lessThan(Object operand1, Object operand2)`
`abstract CtrEntities.CtrEntity`	`lex(IVar.Var[][] lists, Types.TypeOperatorRel operator)`
`abstract CtrEntities.CtrEntity`	`lexMatrix(IVar.Var[][] matrix, Types.TypeOperatorRel operator)`
`protected void`	`loadData(String data, String dataFormat, boolean dataSaving)`
`CtrEntities.CtrArray`	`manageLoop(Runnable r)`
`abstract ObjEntities.ObjEntity`	`maximize(IVar x)`
`abstract ObjEntities.ObjEntity`	`maximize(XNode<IVar> tree)`
`abstract ObjEntities.ObjEntity`	`maximize(Types.TypeObjective type, IVar[] list)`
`abstract ObjEntities.ObjEntity`	`maximize(Types.TypeObjective type, IVar[] list, int[] coeffs)`
`abstract ObjEntities.ObjEntity`	`maximize(Types.TypeObjective type, XNode<IVar>[] trees)`
`abstract ObjEntities.ObjEntity`	`maximize(Types.TypeObjective type, XNode<IVar>[] trees, int[] coeffs)`
`abstract CtrEntities.CtrEntity`	`maximum(IVar.Var[] list, int startIndex, IVar.Var index, Types.TypeRank rank)`
`abstract CtrEntities.CtrEntity`	`maximum(IVar.Var[] list, int startIndex, IVar.Var index, Types.TypeRank rank, Condition condition)`
`abstract CtrEntities.CtrEntity`	`maximum(IVar.Var[] list, Condition condition)`
`abstract CtrEntities.CtrEntity`	`maximum(XNode<IVar>[] trees, Condition condition)`
`abstract CtrEntities.CtrEntity`	`mdd(IVar.Var[] scp, Transition[] transitions)`
`abstract ObjEntities.ObjEntity`	`minimize(IVar x)`
`abstract ObjEntities.ObjEntity`	`minimize(XNode<IVar> tree)`
`abstract ObjEntities.ObjEntity`	`minimize(Types.TypeObjective type, IVar[] list)`
`abstract ObjEntities.ObjEntity`	`minimize(Types.TypeObjective type, IVar[] list, int[] coeffs)`
`abstract ObjEntities.ObjEntity`	`minimize(Types.TypeObjective type, XNode<IVar>[] trees)`
`abstract ObjEntities.ObjEntity`	`minimize(Types.TypeObjective type, XNode<IVar>[] trees, int[] coeffs)`
`abstract CtrEntities.CtrEntity`	`minimum(IVar.Var[] list, int startIndex, IVar.Var index, Types.TypeRank rank)`
`abstract CtrEntities.CtrEntity`	`minimum(IVar.Var[] list, int startIndex, IVar.Var index, Types.TypeRank rank, Condition condition)`
`abstract CtrEntities.CtrEntity`	`minimum(IVar.Var[] list, Condition condition)`
`abstract CtrEntities.CtrEntity`	`minimum(XNode<IVar>[] trees, Condition condition)`
`static boolean`	`mustBeIgnored(Field field)`
`String`	`name()`
`abstract CtrEntities.CtrEntity`	`noOverlap(IVar.Var[][] origins, int[][] lengths, boolean zeroIgnored)`
`abstract CtrEntities.CtrEntity`	`noOverlap(IVar.Var[][] origins, IVar.Var[][] lengths, boolean zeroIgnored)`
`abstract CtrEntities.CtrEntity`	`noOverlap(IVar.Var[] origins, int[] lengths, boolean zeroIgnored)`
`abstract CtrEntities.CtrEntity`	`noOverlap(IVar.Var[] origins, IVar.Var[] lengths, boolean zeroIgnored)`
`abstract CtrEntities.CtrEntity`	`nValues(IVar.Var[] list, Condition condition)`
`abstract CtrEntities.CtrEntity`	`nValues(IVar.Var[] list, Condition condition, int[] exceptValues)`
`abstract CtrEntities.CtrEntity`	`ordered(IVar.Var[] list, int[] lengths, Types.TypeOperatorRel operator)`
`abstract CtrEntities.CtrEntity`	`ordered(IVar.Var[] list, IVar.Var[] lengths, Types.TypeOperatorRel operator)`
`abstract CtrEntities.CtrEntity`	`precedence(IVar.Var[] list, int[] values, boolean covered)`
`static List<Field>`	`problemDataFields(List<Field> list, Class<?> cl)`
`abstract CtrEntities.CtrEntity`	`regular(IVar.Var[] list, Automaton automaton)`
`void`	`save(Document document, String fileName)`
`IVar[]`	`scope(Object... objects)`
`static Method`	`searchMethod(Class<?> cl, String name)`
`void`	`setDataValues(Object value1, Object... otherValues)`
`abstract CtrEntities.CtrEntity`	`slide(IVar[] list, Range range, java.util.function.IntFunction<CtrEntities.CtrEntity> template)`
`abstract CtrEntities.CtrEntity`	`stretch(IVar.Var[] list, int[] values, int[] widthsMin, int[] widthsMax, int[][] patterns)`
`abstract CtrEntities.CtrEntity`	`sum(IVar.Var[] list, int[] coeffs, Condition condition)`
`abstract CtrEntities.CtrEntity`	`sum(IVar.Var[] list, IVar.Var[] coeffs, Condition condition)`
`abstract CtrEntities.CtrEntity`	`sum(XNode<IVar>[] trees, int[] coeffs, Condition condition)`
`String`	`trimParameter(String s)`
`Types.TypeFramework`	`typeFramework()`
`String`	`variableNameSuffixFor(int... vals)`
`<T extends IVar> T[]`	`vars(Object... objects)`	Builds and returns a 1-dimensional array of variables from the specified sequence of parameters.
`<T extends IVar> T[]`	`vars(T[][] x)`

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

Field Detail

api
```
public final ProblemAPI api
```
Fields and Methods

modelVariant
```
public final String modelVariant
```

argsForPb
```
public final String[] argsForPb
```
User arguments given on the command for the problem (instance)

varEntities
```
public final VarEntities varEntities
```

ctrEntities
```
public CtrEntities ctrEntities
```

objEntities
```
public ObjEntities objEntities
```

stackLoops
```
public Stack<Integer> stackLoops
```

parameters
```
public ArrayList<AbstractMap.SimpleEntry<Object,String>> parameters
```
The list of parameters of the problem, as given by the user (after asking them).

annotations

public ProblemIMP.Annotations annotations

Managing Annotations

Constructor Detail

ProblemIMP

protected ProblemIMP(ProblemAPI api,
                     String modelVariant,
                     String[] argsForPb)

Method Detail

control

public static void control(boolean b,
                           Object... objects)

searchMethod

public static Method searchMethod(Class<?> cl,
                                  String name)

executeMethod

public static boolean executeMethod(Object o,
                                    String methodName)

problemDataFields

public static List<Field> problemDataFields(List<Field> list,
                                            Class<?> cl)

mustBeIgnored

public static boolean mustBeIgnored(Field field)

buildInternClassObject

public Object buildInternClassObject(String internClass,
                                     Object... fieldValues)

loadData

protected void loadData(String data,
                        String dataFormat,
                        boolean dataSaving)

setDataValues

public void setDataValues(Object value1,
                          Object... otherValues)

name
```
public String name()
```

classVI

public abstract Class<? extends IVar.Var> classVI()

classVS

public abstract Class<? extends IVar.VarSymbolic> classVS()

typeFramework

public Types.TypeFramework typeFramework()

addParameter

public Object addParameter(Object value,
                           String format)

Adds to the list of problem parameters a problem parameter with the specified value and formatting pattern.

addParameter
```
public Object addParameter(Object value)
```
Adds to the list of problem parameters a problem parameter with the specified value (and no formatting pattern).

ask
```
public final String ask(String message)
```
Gets a parameter of the problem. If the value of the parameter is not directly given on the command line, then the specified message is displayed when the method is executed, and the user is asked to enter a (String) value.

trimParameter

public String trimParameter(String s)

formattedPbParameters
```
public String formattedPbParameters()
```

askBoolean

public boolean askBoolean(String message,
                          java.util.function.Function<Boolean,String> format)

askBoolean
```
public boolean askBoolean(String message)
```
Defines a parameter of the problem. If the value of the parameter is not directly given on the command line, then the specified message is displayed when the method is executed, and the user is asked to enter a Boolean value.

askInt
```
public int askInt(String message,
                  java.util.function.Predicate<Integer> control,
                  java.util.function.IntFunction<String> format)
```
Defines a parameter of the problem. If the value of the parameter is not directly given on the command line, then the specified message is displayed when the method is executed, and the user is asked to enter an integer value.

askInt

public int askInt(String message,
                  Range range,
                  java.util.function.IntFunction<String> format)

askInt

public int askInt(String message,
                  java.util.function.Predicate<Integer> control,
                  String format)

askInt

public int askInt(String message,
                  Range range,
                  String format)

askInt

public int askInt(String message,
                  java.util.function.Predicate<Integer> control)

askInt

public int askInt(String message,
                  Range range)

askInt

public int askInt(String message,
                  String format)

askInt
```
public int askInt(String message)
```

askDouble

public double askDouble(String message,
                        java.util.function.Predicate<Double> control,
                        java.util.function.DoubleFunction<String> format)

askDouble

public double askDouble(String message,
                        java.util.function.Predicate<Double> control,
                        String format)

askDouble

public double askDouble(String message,
                        java.util.function.Predicate<Double> control)

askDouble

public double askDouble(String message,
                        String format)

askDouble
```
public double askDouble(String message)
```
Defines a parameter of the problem. If the value of the parameter is not directly given on the command line, then the specified message is displayed when the method is executed, and the user is asked to enter a double value. It is also possible to indicate both minimum and maximum bounds, by using for example the method range.

askString
```
public String askString(String message,
                        java.util.function.Function<String,String> format)
```
Defines a parameter of the problem. If the value of the parameter is not directly given on the command line, then the specified message is displayed when the method is executed, and the user is asked to enter a String value. The specified functional interface is used to format the value of the parameter when a file name for the problem instance is built.

askString
```
public String askString(String message)
```
Defines a parameter of the problem. If the value of the parameter is not directly given on the command line, then the specified message is displayed when the method is executed, and the user is asked to enter a String value.

fileScanner
```
public Scanner fileScanner()
```

buildVarInteger

public abstract IVar.Var buildVarInteger(String id,
                                         Domains.Dom dom)

Managing Variables

buildVarSymbolic

public abstract IVar.VarSymbolic buildVarSymbolic(String id,
                                                  Domains.DomSymbolic dom)

fill

public IVar.Var[] fill(String id,
                       Size.Size1D size,
                       FunctionalInterfaces.IntToDom f,
                       IVar.Var[] t)

fill

public IVar.Var[][] fill(String id,
                         Size.Size2D size,
                         FunctionalInterfaces.Intx2ToDom f,
                         IVar.Var[][] t)

fill

public IVar.Var[][][] fill(String id,
                           Size.Size3D size,
                           FunctionalInterfaces.Intx3ToDom f,
                           IVar.Var[][][] t)

fill

public IVar.Var[][][][] fill(String id,
                             Size.Size4D size,
                             FunctionalInterfaces.Intx4ToDom f,
                             IVar.Var[][][][] t)

fill

public IVar.Var[][][][][] fill(String id,
                               Size.Size5D size,
                               FunctionalInterfaces.Intx5ToDom f,
                               IVar.Var[][][][][] t)

fill

public IVar.VarSymbolic[] fill(String id,
                               Size.Size1D size,
                               FunctionalInterfaces.IntToDomSymbolic f,
                               IVar.VarSymbolic[] t)

fill

public IVar.VarSymbolic[][] fill(String id,
                                 Size.Size2D size,
                                 FunctionalInterfaces.Intx2ToDomSymbolic f,
                                 IVar.VarSymbolic[][] t)

fill

public IVar.VarSymbolic[][][] fill(String id,
                                   Size.Size3D size,
                                   FunctionalInterfaces.Intx3ToDomSymbolic f,
                                   IVar.VarSymbolic[][][] t)

vars
```
public <T extends IVar> T[] vars(Object... objects)
```
Builds and returns a 1-dimensional array of variables from the specified sequence of parameters. All variables encountered in the parameters, extracting them from arrays (of any dimension), trees, collections and streams, are recursively collected in order, and concatenated to form a 1-dimensional array. Note that null values, as well as any simple object not implementing IVar, are simply discarded.

Parameters:

objects - a sequence of objects

Returns:

a 1-dimensional array of variables

vars

public <T extends IVar> T[] vars(T[][] x)

clean

public <T extends IVar> T[] clean(T[] vars)

distinct

public <T extends IVar> T[] distinct(T[] vars)

distinctSorted

public <T extends IVar> T[] distinctSorted(T[] vars)

save

public void save(Document document,
                 String fileName)

indentAndCompressXmlUnderLinux

public void indentAndCompressXmlUnderLinux(String fileName)

variableNameSuffixFor

public String variableNameSuffixFor(int... vals)

intervalAsString

public String intervalAsString(int[] lbs,
                               int[] ubs)

scope

public IVar[] scope(Object... objects)

dummyConstraint

public CtrEntities.CtrEntity dummyConstraint(String message)

intension

public abstract CtrEntities.CtrEntity intension(XNodeParent<IVar> tree)

lessThan

public CtrEntities.CtrEntity lessThan(Object operand1,
                                      Object operand2)

lessEqual

public CtrEntities.CtrEntity lessEqual(Object operand1,
                                       Object operand2)

greaterThan

public CtrEntities.CtrEntity greaterThan(Object operand1,
                                         Object operand2)

greaterEqual

public CtrEntities.CtrEntity greaterEqual(Object operand1,
                                          Object operand2)

equal

public CtrEntities.CtrEntity equal(Object... operands)

different

public final CtrEntities.CtrEntity different(Object... operands)

conjunction

public final CtrEntities.CtrEntity conjunction(Object... operands)

disjunction

public final CtrEntities.CtrEntity disjunction(Object... operands)

getConverter

protected abstract ProblemIMP.Converter getConverter()

extension

public CtrEntities.CtrAlone extension(XNodeParent<IVar> tree)

extensionDisjunction

public final CtrEntities.CtrAlone extensionDisjunction(List<XNodeParent<IVar>> trees)

extension

public abstract CtrEntities.CtrAlone extension(IVar.Var[] scp,
                                               int[][] tuples,
                                               boolean positive)

extension

public abstract CtrEntities.CtrAlone extension(IVar.VarSymbolic[] scp,
                                               String[][] tuples,
                                               boolean positive)

extension

public abstract CtrEntities.CtrAlone extension(IVar.Var[] scp,
                                               AbstractTuple[] tuples,
                                               boolean positive)

regular

public abstract CtrEntities.CtrEntity regular(IVar.Var[] list,
                                              Automaton automaton)

mdd

public abstract CtrEntities.CtrEntity mdd(IVar.Var[] scp,
                                          Transition[] transitions)

allDifferent

public abstract CtrEntities.CtrEntity allDifferent(IVar.Var[] list)

allDifferent

public abstract CtrEntities.CtrEntity allDifferent(IVar.VarSymbolic[] list)

allDifferent

public abstract CtrEntities.CtrEntity allDifferent(IVar.Var[] list,
                                                   int[] exceptValues)

allDifferentList

public abstract CtrEntities.CtrEntity allDifferentList(IVar.Var[]... lists)

allDifferentList

public abstract CtrEntities.CtrEntity allDifferentList(IVar.Var[][] lists,
                                                       int[][] except)

allDifferentMatrix

public abstract CtrEntities.CtrEntity allDifferentMatrix(IVar.Var[][] matrix)

allDifferent

public abstract CtrEntities.CtrEntity allDifferent(XNode<IVar>[] trees)

allEqual

public abstract CtrEntities.CtrEntity allEqual(IVar.Var... list)

allEqual

public abstract CtrEntities.CtrEntity allEqual(IVar.VarSymbolic... list)

allEqualList

public abstract CtrEntities.CtrEntity allEqualList(IVar.Var[]... lists)

ordered

public abstract CtrEntities.CtrEntity ordered(IVar.Var[] list,
                                              int[] lengths,
                                              Types.TypeOperatorRel operator)

ordered

public abstract CtrEntities.CtrEntity ordered(IVar.Var[] list,
                                              IVar.Var[] lengths,
                                              Types.TypeOperatorRel operator)

lex

public abstract CtrEntities.CtrEntity lex(IVar.Var[][] lists,
                                          Types.TypeOperatorRel operator)

lexMatrix

public abstract CtrEntities.CtrEntity lexMatrix(IVar.Var[][] matrix,
                                                Types.TypeOperatorRel operator)

precedence

public abstract CtrEntities.CtrEntity precedence(IVar.Var[] list,
                                                 int[] values,
                                                 boolean covered)

sum

public abstract CtrEntities.CtrEntity sum(IVar.Var[] list,
                                          int[] coeffs,
                                          Condition condition)

sum

public abstract CtrEntities.CtrEntity sum(IVar.Var[] list,
                                          IVar.Var[] coeffs,
                                          Condition condition)

sum

public abstract CtrEntities.CtrEntity sum(XNode<IVar>[] trees,
                                          int[] coeffs,
                                          Condition condition)

count

public abstract CtrEntities.CtrEntity count(IVar.Var[] list,
                                            int[] values,
                                            Condition condition)

count

public abstract CtrEntities.CtrEntity count(IVar.Var[] list,
                                            IVar.Var[] values,
                                            Condition condition)

nValues

public abstract CtrEntities.CtrEntity nValues(IVar.Var[] list,
                                              Condition condition)

nValues

public abstract CtrEntities.CtrEntity nValues(IVar.Var[] list,
                                              Condition condition,
                                              int[] exceptValues)

cardinality

public abstract CtrEntities.CtrEntity cardinality(IVar.Var[] list,
                                                  int[] values,
                                                  boolean mustBeClosed,
                                                  int[] occurs)

cardinality

public abstract CtrEntities.CtrEntity cardinality(IVar.Var[] list,
                                                  int[] values,
                                                  boolean mustBeClosed,
                                                  IVar.Var[] occurs)

cardinality

public abstract CtrEntities.CtrEntity cardinality(IVar.Var[] list,
                                                  int[] values,
                                                  boolean mustBeClosed,
                                                  int[] occursMin,
                                                  int[] occursMax)

cardinality

public abstract CtrEntities.CtrEntity cardinality(IVar.Var[] list,
                                                  IVar.Var[] values,
                                                  boolean mustBeClosed,
                                                  int[] occurs)

cardinality

public abstract CtrEntities.CtrEntity cardinality(IVar.Var[] list,
                                                  IVar.Var[] values,
                                                  boolean mustBeClosed,
                                                  IVar.Var[] occurs)

cardinality

public abstract CtrEntities.CtrEntity cardinality(IVar.Var[] list,
                                                  IVar.Var[] values,
                                                  boolean mustBeClosed,
                                                  int[] occursMin,
                                                  int[] occursMax)

maximum

public abstract CtrEntities.CtrEntity maximum(IVar.Var[] list,
                                              Condition condition)

maximum

public abstract CtrEntities.CtrEntity maximum(IVar.Var[] list,
                                              int startIndex,
                                              IVar.Var index,
                                              Types.TypeRank rank)

maximum

public abstract CtrEntities.CtrEntity maximum(IVar.Var[] list,
                                              int startIndex,
                                              IVar.Var index,
                                              Types.TypeRank rank,
                                              Condition condition)

maximum

public abstract CtrEntities.CtrEntity maximum(XNode<IVar>[] trees,
                                              Condition condition)

minimum

public abstract CtrEntities.CtrEntity minimum(IVar.Var[] list,
                                              Condition condition)

minimum

public abstract CtrEntities.CtrEntity minimum(IVar.Var[] list,
                                              int startIndex,
                                              IVar.Var index,
                                              Types.TypeRank rank)

minimum

public abstract CtrEntities.CtrEntity minimum(IVar.Var[] list,
                                              int startIndex,
                                              IVar.Var index,
                                              Types.TypeRank rank,
                                              Condition condition)

minimum

public abstract CtrEntities.CtrEntity minimum(XNode<IVar>[] trees,
                                              Condition condition)

element

public abstract CtrEntities.CtrEntity element(IVar.Var[] list,
                                              Condition condition)

element

public abstract CtrEntities.CtrEntity element(IVar.Var[] list,
                                              int startIndex,
                                              IVar.Var index,
                                              Types.TypeRank rank,
                                              Condition condition)

element

public abstract CtrEntities.CtrEntity element(int[] list,
                                              int startIndex,
                                              IVar.Var index,
                                              Types.TypeRank rank,
                                              Condition condition)

element

public abstract CtrEntities.CtrEntity element(int[][] matrix,
                                              int startRowIndex,
                                              IVar.Var rowIndex,
                                              int startColIndex,
                                              IVar.Var colIndex,
                                              Condition condition)

channel

public abstract CtrEntities.CtrEntity channel(IVar.Var[] list,
                                              int startIndex)

channel

public abstract CtrEntities.CtrEntity channel(IVar.Var[] list1,
                                              int startIndex1,
                                              IVar.Var[] list2,
                                              int startIndex2)

channel

public abstract CtrEntities.CtrEntity channel(IVar.Var[] list,
                                              int startIndex,
                                              IVar.Var value)

stretch

public abstract CtrEntities.CtrEntity stretch(IVar.Var[] list,
                                              int[] values,
                                              int[] widthsMin,
                                              int[] widthsMax,
                                              int[][] patterns)

noOverlap

public abstract CtrEntities.CtrEntity noOverlap(IVar.Var[] origins,
                                                int[] lengths,
                                                boolean zeroIgnored)

noOverlap

public abstract CtrEntities.CtrEntity noOverlap(IVar.Var[] origins,
                                                IVar.Var[] lengths,
                                                boolean zeroIgnored)

noOverlap

public abstract CtrEntities.CtrEntity noOverlap(IVar.Var[][] origins,
                                                int[][] lengths,
                                                boolean zeroIgnored)

noOverlap

public abstract CtrEntities.CtrEntity noOverlap(IVar.Var[][] origins,
                                                IVar.Var[][] lengths,
                                                boolean zeroIgnored)

cumulative

public abstract CtrEntities.CtrEntity cumulative(IVar.Var[] origins,
                                                 int[] lengths,
                                                 IVar.Var[] ends,
                                                 int[] heights,
                                                 Condition condition)

cumulative

public abstract CtrEntities.CtrEntity cumulative(IVar.Var[] origins,
                                                 IVar.Var[] lengths,
                                                 IVar.Var[] ends,
                                                 int[] heights,
                                                 Condition condition)

cumulative

public abstract CtrEntities.CtrEntity cumulative(IVar.Var[] origins,
                                                 int[] lengths,
                                                 IVar.Var[] ends,
                                                 IVar.Var[] heights,
                                                 Condition condition)

cumulative

public abstract CtrEntities.CtrEntity cumulative(IVar.Var[] origins,
                                                 IVar.Var[] lengths,
                                                 IVar.Var[] ends,
                                                 IVar.Var[] heights,
                                                 Condition condition)

circuit

public abstract CtrEntities.CtrEntity circuit(IVar.Var[] list,
                                              int startIndex)

circuit

public abstract CtrEntities.CtrEntity circuit(IVar.Var[] list,
                                              int startIndex,
                                              int size)

circuit

public abstract CtrEntities.CtrEntity circuit(IVar.Var[] list,
                                              int startIndex,
                                              IVar.Var size)

clause

public abstract CtrEntities.CtrEntity clause(IVar.Var[] list,
                                             Boolean[] phases)

instantiation

public abstract CtrEntities.CtrEntity instantiation(IVar.Var[] list,
                                                    int[] values)

slide

public abstract CtrEntities.CtrEntity slide(IVar[] list,
                                            Range range,
                                            java.util.function.IntFunction<CtrEntities.CtrEntity> template)

ifThen

public abstract CtrEntities.CtrEntity ifThen(CtrEntities.CtrEntity c1,
                                             CtrEntities.CtrEntity c2)

ifThenElse

public abstract CtrEntities.CtrEntity ifThenElse(CtrEntities.CtrEntity c1,
                                                 CtrEntities.CtrEntity c2,
                                                 CtrEntities.CtrEntity c3)

manageLoop

public CtrEntities.CtrArray manageLoop(Runnable r)

forall

public CtrEntities.CtrArray forall(Range range,
                                   java.util.function.IntConsumer c)

Builds constraints by considering the specified range and soliciting the specified function.