IloCP

java.lang.Object
- ilog.concert.IloModelImpl
- - ilog.concert.IloModelerImpl
  - - ilog.cp.IloCP

All Implemented Interfaces:

IloAddable, ilog.concert.IloCopyable, IloModel, IloModeler
```
public class IloCP
extends ilog.concert.IloModelerImpl
implements IloModeler
```
An instance of this class represents an algorithm for CP Optimizer.

Search

CP Optimizer is designed to be used in a "model and run" fashion and as such provides a search strategy. One way of using CP is the following:
```
   IloCP cp();
   .. create Concert model ...
  if (cp.solve())
    System.out.println("Solution found of cost = " + cp.getObjValue());
  else
    System.out.println("No solution found"); 
```
You can set limits on the amount of effort CP puts into finding a solution to a model by setting a parameter. For example,

cp.setParameter(IloCP.DoubleParam.TimeLimit, 60);

will limit the solve time to one minute. At the end of one minute, CP will deliver the best solution found in that time if one was found. Access to the solution is available, through the getValue method, for example:
```
   IloCP cp = new IloCP();
   IloIntVar x = cp.intVar(0, 10);
   // ... build model if (cp.solve()) {
     System.out.println("Solution found of cost = " + cp.getObjValue());
     System.out.println("Value of x = " + cp.getValue(x)); }
 
```
Other more sophisticated search techniques are available, notably search phases (IloSearchPhase), which allow variables to be grouped according to the order in which they should be assigned in a search, and how they will be assigned.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`IloCP.Callback` This interface allows you to monitor different aspects of CP Optimizer's search process by being called upon different events.
`static class`	`IloCP.ConflictStatus` This enumeration lists the values that report the status of a constraint or a variable with respect to a conflict.
`static class`	`IloCP.DoubleInfo` Symbolic parameter names for floating-point information.
`static class`	`IloCP.DoubleParam` Symbolic parameter names for double-valued `IloCP` parameters.
`static class`	`IloCP.IntInfo` Symbolic parameter names for integer information.
`static class`	`IloCP.IntParam` Symbolic parameter names for integer-valued `IloCP` parameters.
`static class`	`IloCP.ParameterValues` Symbolic parameter names for integer-valued `IloCP` parameters.

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`Infinity` This constant represents positive infinity of type double.
`static int`	`IntervalMax` This constant represents the largest value that can be taken by the start or end of an interval variable.
`static int`	`IntervalMin` This constant represents the smallest value that can be taken by the start or end of an interval variable.
`static int`	`IntMax` This constant represents the largest possible positive integer allowed in CP Optimizer.
`static int`	`IntMin` This constant represents the smallest possible negative integer allowed in CP Optimizer.
`static int`	`NoState` This static integer of value `-1` is the conventional value of an instance of `IloStateFunction` at any point out of its definition domain.

Constructor Summary

Constructors
Constructor and Description

IloCP()
This method creates an algorithm for CP Optimizer.

Constructors
Constructor and Description
`IloCP()` This method creates an algorithm for CP Optimizer.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abortSearch()` This methods stops the current search and can be useful for interrupting CP Optimizer in an interactive application.
`IloAddable`	`add(IloAddable object)` This method adds the extractable object to the invoking model.
`void`	`addCallback(IloCP.Callback cb)` This method adds user callback `cb` to the invoking CP Optimizer instance.
`void`	`addKPI(IloNumExpr kpi, java.lang.String name)` A key performance indicator (KPI) is a value which can be associated with a solution which represents an interesting measure of some aspect of the solution.
`void`	`addTuple(IloIntTupleSet ts, int[] array)` This method adds a tuple represented by the array `array` to the tuple set `ts`.
`IloConstraint`	`allDiff(IloIntExpr[] exps)` Creates and returns a new constraint stating that the expression elements of `exps` must take different values from each other.
`IloConstraint`	`allMinDistance(IloIntVar[] vars, int k)` This method returns a constraint that ensures that the absolute distance between any pair of variables in the array `vars` will be greater than or equal to `k`.
`IloConstraint`	`allowedAssignments(IloIntExpr exp, int[] values)` Creates and returns a new constraint based on explicitly stating the allowed assignments (values) for a single expression.
`IloConstraint`	`allowedAssignments(IloIntVar[] exps, IloIntTupleSet table)` Creates and returns a new constraint based on explicitly stating the allowed assignments for a small group of variables.
`IloAlternative`	`alternative(IloIntervalVar a, IloIntervalVar[] bs)` This method creates an alternative constraint between interval variable `a` and the set of interval variables in the array `bs`.
`IloAlternative`	`alternative(IloIntervalVar a, IloIntervalVar[] bs, IloIntExpr c)` This method creates an alternative constraint between interval variable `a` and the set of interval variables in the array `bs` with cardinality `c`.
`IloAlternative`	`alternative(IloIntervalVar a, IloIntervalVar[] bs, IloIntExpr c, java.lang.String name)` This method creates an alternative constraint between interval variable `a` and the set of interval variables in the array `bs` with cardinality `c`.
`IloAlternative`	`alternative(IloIntervalVar a, IloIntervalVar[] bs, int c)` This method creates an alternative constraint between interval variable `a` and the set of interval variables in the array `bs` with cardinality `c`.
`IloAlternative`	`alternative(IloIntervalVar a, IloIntervalVar[] bs, int c, java.lang.String name)` This method creates an alternative constraint between interval variable `a` and the set of interval variables in the array `bs` with cardinality `c`.
`IloAlternative`	`alternative(IloIntervalVar a, IloIntervalVar[] bs, java.lang.String name)` This method creates an alternative constraint between interval variable `a` and the set of interval variables in the array `bs`.
`IloConstraint`	`alwaysConstant(IloStateFunction f, IloIntervalVar a)` This method returns a constraint that ensures that whenever interval variable `a` is present state function `f` is defined everywhere between the start and the end of interval variable `a` and remains constant over this interval.
`IloConstraint`	`alwaysConstant(IloStateFunction f, IloIntervalVar a, boolean startAlign, boolean endAlign)` This method returns a constraint that ensures that whenever interval variable `a` is present state function `f` is defined everywhere between the start and the end of interval variable `a` and remains constant over this interval.
`IloConstraint`	`alwaysConstant(IloStateFunction f, int start, int end)` This method returns a constraint that ensures that state function `f` is defined everywhere on the interval `[start,end)` and remains constant over this interval.
`IloConstraint`	`alwaysConstant(IloStateFunction f, int start, int end, boolean startAlign, boolean endAlign)` This method returns a constraint that ensures that state function `f` is defined everywhere on the interval `[start,end)` and remains constant over this interval.
`IloConstraint`	`alwaysEqual(IloCumulFunctionExpr f, IloIntervalVar a, int v)` This method returns a constraint that states that whenever interval variable `a` is present, the value of cumul function expression `f` should be always equal to `v` between the start and the end of `a`.
`IloConstraint`	`alwaysEqual(IloCumulFunctionExpr f, int start, int end, int v)` This method returns a constraint that states that the value of cumul function expression `f` should be always equal to `v` between `start` and `end`.
`IloConstraint`	`alwaysEqual(IloStateFunction f, IloIntervalVar a, int v)` This method returns a constraint that ensures that whenever interval variable `a` is present state function `f` is defined everywhere between the start and the end of interval variable `a` and remains equal to value `v` over this interval.
`IloConstraint`	`alwaysEqual(IloStateFunction f, IloIntervalVar a, int v, boolean startAlign, boolean endAlign)` This method returns a constraint that ensures that whenever interval variable `a` is present state function `f` is defined everywhere between the start and the end of interval variable `a` and remains equal to value `v` over this interval.
`IloConstraint`	`alwaysEqual(IloStateFunction f, int start, int end, int v)` This method returns a constraint that ensures that state function `f` is defined everywhere on the interval `[start,end)` and remains equal to value `v` over this interval.
`IloConstraint`	`alwaysEqual(IloStateFunction f, int start, int end, int v, boolean startAlign, boolean endAlign)` This method returns a constraint that ensures that state function `f` is defined everywhere on the interval `[start,end)` and remains equal to value `v` over this interval.
`IloConstraint`	`alwaysIn(IloCumulFunctionExpr f, IloIntervalVar a, int vmin, int vmax)` This method returns a constraint that states that whenever interval variable `a` is present, the value of cumul function expression `f` should be always within the range `[vmin,vmax]` between the start and the end of `a`.
`IloConstraint`	`alwaysIn(IloCumulFunctionExpr f, int start, int end, int vmin, int vmax)` This method returns a constraint that states that the value of cumul function expression `f` should be always within the range `[vmin,vmax]` between `start` and `end`.
`IloConstraint`	`alwaysIn(IloStateFunction f, IloIntervalVar a, int vmin, int vmax)` This method returns a constraint that ensures that whenever interval variable `a` is present, the value of state function `f`, if defined, remains in the range `[vmin,vmax]` for any point `t` between the start and the end of interval variable `a`.
`IloConstraint`	`alwaysIn(IloStateFunction f, int start, int end, int vmin, int vmax)` This method returns a constraint that ensures that, if it is defined, the value of state function `f` remains in the range `[vmin,vmax]` for any point `t` in the interval of integers `[start,end)`.
`IloConstraint`	`alwaysNoState(IloStateFunction f, IloIntervalVar a)` This method returns a constraint that ensures that whenever interval variable `a` is present state function `f` is undefined everywhere between the start and the end of interval variable `a`.
`IloConstraint`	`alwaysNoState(IloStateFunction f, int start, int end)` This method returns a constraint that ensures that state function `f` is undefined everywhere on the interval of integers `[start,end)`.
`java.lang.String`	`arrayEltName(java.lang.String name, int index)` This method is a shortcut to `name.concat("[").concat(String.valueOf(index)).concat("]")`.
`IloConstraint`	`before(IloIntervalSequenceVar seq, IloIntervalVar pred, IloIntervalVar succ)` This method returns a constraint that states that whenever both interval variables `pred` and `succ` are present, interval variable `pred` must be ordered before interval variable `succ` (but not necessarily immediately before) in the sequence variable `seq`.
`void`	`clearAbort()` This method should be called after `abortSearch()` before any subsequent call to `solve()` or `startNewSearch()`.
`void`	`clearExplanations()` This method is used to clear the set of failure tags (indices) to be explained.
`void`	`clearStartingPoint()` This method removes any starting point specified on the invoking CP Optimizer engine: subsequent searches will not use any starting point information, unless a new starting point is set.
`IloNumExpr`	`constant(double value, java.lang.String name)` Creates and returns a new constant expression equal to `value`.
`IloIntExpr`	`constant(int value, java.lang.String name)` Creates and returns a new constant expression equal to `value`.
`IloIntExpr`	`count(IloIntExpr[] exprs, int v)` This method creates a new constrained integer expression equal to the number of variables in `exprs` that are fixed to the value `v`.
`IloIntExpr`	`countDifferent(IloIntExpr[] exprs)` This method creates a new constrained integer expression equal to the number of different values assigned to the variables in `exprs`.
`IloCumulFunctionExpr`	`cumulFunctionExpr()` This method creates a constant cumul function expression everywhere equal to `0` that the user can modify subsequently with the operators `add`, `sub`.
`IloCumulFunctionExpr`	`cumulFunctionExpr(java.lang.String name)` This method creates a constant cumul function expression everywhere equal to `0` that the user can modify subsequently with the functions `add`, `sub`.
`IloCumulFunctionExpr`	`diff(IloCumulFunctionExpr f1, IloCumulFunctionExpr f2)` This operator returns a cumul function expression equal to the difference of its arguments.
`IloConstraint`	`distribute(IloIntExpr[] cards, IloIntExpr[] vars)` Creates and returns a counting constraint in a model.
`IloConstraint`	`distribute(IloIntExpr[] cards, int[] values, IloIntExpr[] vars)` Creates and returns a counting constraint in a model.
`IloIntExpr`	`div(IloIntExpr e1, IloIntExpr e2)` Creates and returns the integer division `e1 / e2`.
`IloIntExpr`	`div(IloIntExpr e1, int e2)` Creates and returns the integer division `e1 / e2`.
`IloIntExpr`	`div(int e1, IloIntExpr e2)` Creates and returns the integer division `e1 / e2`.
`IloIntVarEval`	`domainMax()` This method returns a variable evaluator.
`IloIntVarEval`	`domainMin()` This method returns a variable evaluator.
`IloIntVarEval`	`domainSize()` This method returns a variable evaluator.
`void`	`dumpModel(java.io.OutputStream s)` This function dumps the currently loaded model into a stream.
`void`	`dumpModel(java.lang.String filename)` This function dumps the currently loaded model into the file named `filename`.
`IloNumExpr`	`element(double[] values, IloIntExpr index)` Creates and returns a new expression equal to `values[index]`.
`IloIntExpr`	`element(IloIntExpr[] exprs, IloIntExpr index)` Creates and returns a new integer expression equal to `exprs[index]`.
`IloConstraint`	`element(IloIntExpr var, IloIntExpr index, int[] values)` Creates and returns the new constraint `var == values[index]`.
`IloConstraint`	`element(IloNumExpr var, IloIntExpr index, double[] values)` Creates and returns the new constraint `var == values[index]`.
`IloIntExpr`	`element(int[] values, IloIntExpr index)` Creates and returns a new integer expression equal to `values[index]`.
`void`	`end()` Frees all memory resources allocated by the invoking CP Optimizer.
`IloConstraint`	`endAtEnd(IloIntervalVar a, IloIntervalVar b)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-end(a)`between the end of interval `a` and the end of interval `b` must be equal to 0.
`IloConstraint`	`endAtEnd(IloIntervalVar a, IloIntervalVar b, IloIntExpr z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-end(a)`between the end of interval `a` and the end of interval `b` must be equal to `z`.
`IloConstraint`	`endAtEnd(IloIntervalVar a, IloIntervalVar b, int z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-end(a)`between the end of interval `a` and the end of interval `b` must be equal to `z`.
`IloConstraint`	`endAtStart(IloIntervalVar a, IloIntervalVar b)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-end(a)`between the end of interval `a` and the start of interval `b` must be equal to 0.
`IloConstraint`	`endAtStart(IloIntervalVar a, IloIntervalVar b, IloIntExpr z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-end(a)`between the end of interval `a` and the start of interval `b` must be equal to `z`.
`IloConstraint`	`endAtStart(IloIntervalVar a, IloIntervalVar b, int z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-end(a)`between the end of interval `a` and the start of interval `b` must be equal to `z`.
`IloConstraint`	`endBeforeEnd(IloIntervalVar a, IloIntervalVar b)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-end(a)`between the end of interval `a` and the end of interval `b` must be greater than or equal to 0.
`IloConstraint`	`endBeforeEnd(IloIntervalVar a, IloIntervalVar b, IloIntExpr z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-end(a)`between the end of interval `a` and the end of interval `b` must be greater than or equal to `z`.
`IloConstraint`	`endBeforeEnd(IloIntervalVar a, IloIntervalVar b, int z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-end(a)`between the end of interval `a` and the end of interval `b` must be greater than or equal to `z`.
`IloConstraint`	`endBeforeStart(IloIntervalVar a, IloIntervalVar b)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-end(a)`between the end of interval `a` and the start of interval `b` must be greater than or equal to 0.
`IloConstraint`	`endBeforeStart(IloIntervalVar a, IloIntervalVar b, IloIntExpr z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-end(a)`between the end of interval `a` and the start of interval `b` must be greater than or equal to `z`.
`IloConstraint`	`endBeforeStart(IloIntervalVar a, IloIntervalVar b, int z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-end(a)`between the end of interval `a` and the start of interval `b` must be greater than or equal to `z`.
`IloNumExpr`	`endEval(IloIntervalVar a, IloNumToNumSegmentFunction f)` This method returns a numerical expression that represents the value of function `f` evaluated on the end of interval variable `a` whenever the interval variable is present.
`IloNumExpr`	`endEval(IloIntervalVar a, IloNumToNumSegmentFunction f, double absVal)` This method returns a numerical expression that represents the value of function `f` evaluated on the end of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`endOf(IloIntervalVar a)` This method returns an integer expression that represents the end of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`endOf(IloIntervalVar a, int absVal)` This method returns an integer expression that represents the end of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`endOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal)` This method returns an integer expression that represents the end of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`endOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal, int absVal)` This method returns an integer expression that represents the end of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`endOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal)` This method returns an integer expression that represents the end of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloIntExpr`	`endOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal, int absVal)` This method returns an integer expression that represents the end of the interval variable that is previous to interval `a` in sequence variable `seq`.
`void`	`endSearch()` This method terminates a search and deletes the internal objects created by CP Optimizer to carry out the search.
`IloConstraint`	`eq(IloIntExpr e1, IloIntExpr e2)` Creates and returns the new constraint `e1 == e2`.
`IloConstraint`	`eq(IloIntExpr e, int v)` Creates and returns the new constraint `e == v`.
`IloConstraint`	`eq(int v, IloIntExpr e)` Creates and returns the new constraint `v == e`.
`IloConstraint`	`equiv(IloConstraint c1, IloConstraint c2)` Creates and returns the new constraint `c1 <=> c2`, in which the two constraints c1 and c2 are equivalent.
`java.io.PrintStream`	`error()` Returns the error output stream of the invoking `IloCP` object.
`void`	`explainFailure(int failTag)` This method specifies a tag(index) of the failure to explain.
`void`	`explainFailure(int[] failTagArray)` This method specifies an array of tags (indices) of failures to explain.
`IloIntValueEval`	`explicitValueEval(int[] vals, double[] evaluation)` This method is a shortcut to `explicitValueEval(vals, evaluation, 0)`.
`IloIntValueEval`	`explicitValueEval(int[] vals, double[] evaluation, double defautEval)` This method returns a value evaluator.
`IloIntValueEval`	`explicitValueEval(int[] vals, int[] evaluation)` This method is a shortcut to `explicitValueEval(vals, evaluation, 0)`.
`IloIntValueEval`	`explicitValueEval(int[] vals, int[] evaluation, double defautEval)` This method returns a value evaluator.
`IloIntVarEval`	`explicitVarEval(IloIntVar[] vars, double[] vals)` This method is a shortcut to `explicitVarEval(vars, vals, 0)`.
`IloIntVarEval`	`explicitVarEval(IloIntVar[] vars, double[] vals, double defautEval)` This method returns a variable evaluator.
`IloIntVarEval`	`explicitVarEval(IloIntVar[] vars, int[] vals)` This method is a shortcut to `explicitVarEval(vars, vals, 0)`.
`IloIntVarEval`	`explicitVarEval(IloIntVar[] vars, int[] vals, double defautEval)` This method returns a variable evaluator.
`IloNumExpr`	`exponent(IloNumExpr e)` Creates and returns the new expression `exp(e)`.
`void`	`exportModel(java.io.OutputStream s)` This function exports the currently loaded model into a stream.
`void`	`exportModel(java.lang.String filename)` This function exports the currently loaded model into the file named `filename`.
`IloConstraint`	`falseConstraint()` Creates and returns a new constraint that is always false.
`IloConstraint`	`first(IloIntervalSequenceVar seq, IloIntervalVar a)` This method returns a constraint that states that whenever interval variable `a` is present, it must be ordered first in the sequence variable `seq`.
`IloConstraint`	`forbiddenAssignments(IloIntExpr exp, int[] values)` Creates and returns a new constraint based on explicitly stating the forbidden assignments (values) for a single variable.
`IloConstraint`	`forbiddenAssignments(IloIntVar[] exps, IloIntTupleSet table)` Creates and returns a new constraint based on explicitly stating the forbidden assignments for a small group of variables.
`IloConstraint`	`forbidEnd(IloIntervalVar a, IloNumToNumStepFunction f)` This method returns a constraint that states that whenever interval variable `a` is present, it cannot end at a value `t` such that `f(t-1)=0`.
`IloConstraint`	`forbidExtent(IloIntervalVar a, IloNumToNumStepFunction f)` This method returns a constraint that states that whenever interval variable `a` is present, it cannot contain a value `t` such that `f(t)=0`.
`IloConstraint`	`forbidStart(IloIntervalVar a, IloNumToNumStepFunction f)` This method returns a constraint that states that whenever interval variable `a` is present, it cannot start at a value `t` such that `f(t)=0`.
`IloConstraint`	`ge(IloCumulFunctionExpr f, IloIntExpr vmin)` This method returns a constraint that states that the value of cumul function expression `f` should never be less than `vmin`.
`IloConstraint`	`ge(IloCumulFunctionExpr f, int vmin)` This method returns a constraint that states that the value of cumul function expression `f` should never be less than `vmin`.
`IloConstraint`	`ge(IloIntExpr vmax, IloCumulFunctionExpr f)` This method returns a constraint that states that the value of cumul function expression `f` should never be greater than `vmax`.
`IloConstraint`	`ge(IloIntExpr e1, IloIntExpr e2)` Creates and returns the new constraint `e1 >= e2`.
`IloConstraint`	`ge(IloIntExpr e, int v)` Creates and returns the new constraint `e >= v`.
`IloConstraint`	`ge(int vmax, IloCumulFunctionExpr f)` This method returns a constraint that states that the value of cumul function expression `f` should never be greater than `vmax`.
`IloConstraint`	`ge(int v, IloIntExpr e)` Creates and returns the new constraint `v >= e`.
`IloCumulFunctionExpr[]`	`getAllConstrainedIloCumulFunctionExprs()` This method returns an array of all the cumulative function expressions extracted by the invoking CP Optimizer engine whose heights are constrained: on whole definition interval using operator `<=` or `>=`, during certain intervals using constraint `IloAlwaysIn` and `IloAlwaysEqual` (`alwaysIn` in CPO language).
`IloIntervalSequenceVar[]`	`getAllIloIntervalSequenceVars()` This method returns an array of all the interval sequence variables extracted by the invoking CP Optimizer engine.
`IloIntervalVar[]`	`getAllIloIntervalVars()` This method returns an array of all the interval variables extracted by the invoking CP Optimizer engine.
`IloIntVar[]`	`getAllIloIntVars()` This method returns an array of all the integer variables extracted by the invoking CP Optimizer engine.
`IloStateFunction[]`	`getAllIloStateFunctions()` This method returns an array of all the state functions extracted by the invoking CP Optimizer engine.
`java.lang.String[]`	`getAllKPINames()` This method returns names of all KPIs.
`java.lang.String`	`getBuildID()`
`IloCP.ConflictStatus`	`getConflict(IloConstraint cst)` This method returns the conflict status for a given constraint `cst`.
`IloCP.ConflictStatus`	`getConflict(IloIntervalVar var)` This method returns the conflict status for a given interval variable `var`.
`IloCP.ConflictStatus`	`getConflict(IloNumVar var)` This method returns the conflict status for a given numerical variable `var`.
`java.lang.String`	`getDomain(IloIntervalVar var)` This method returns the current domain of interval variable `var` as maintained by the invoking instance of `IloCP`.
`int`	`getDomainSize(IloNumVar var)` This member function returns the size of the domain of variable `var` as maintained in the invoking instance of `IloCP`.
`int`	`getEnd(IloIntervalVar a)` This method returns the current value of the end of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getEnd(java.lang.String intervalVarName)` This method returns the current end time of the interval variable with the specified name.
`int`	`getEndMax(IloIntervalVar a)` This method returns the maximum value for the end of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getEndMin(IloIntervalVar a)` This method returns the minimum value for the end of interval variable `a` in the invoking instance of `IloCP`.
`IloIntervalVar`	`getFirst(IloIntervalSequenceVar seq)` This method assumes that interval sequence variable `seq` is fixed.
`IloCumulFunctionExpr`	`getIloCumulFunctionExpr(java.lang.String name)` This function finds the cumulative function expression with the given name in the current model.
`IloIntervalSequenceVar`	`getIloIntervalSequenceVar(java.lang.String name)` This function finds the interval sequence variable with the given name in the current model.
`IloIntervalVar`	`getIloIntervalVar(java.lang.String name)` This function finds the interval variable with the given name in the current model.
`IloIntVar`	`getIloIntVar(java.lang.String name)` This function finds the integer variable with the given name in the current model.
`IloStateFunction`	`getIloStateFunction(java.lang.String name)` This function finds the state function with the given name in the current model.
`double`	`getIncumbentValue(IloNumExpr expr)` This method returns the value of the given expression in the incumbent solution.
`double`	`getIncumbentValue(java.lang.String exprName)` This method returns the value of a named expression in the incumbent solution.
`double`	`getInfo(IloCP.DoubleInfo which)` This method returns the value of the floating-point information `which` in the invoked `IloCP` instance.
`int`	`getInfo(IloCP.IntInfo which)` This method returns the value of the integer information `which` in the invoked `IloCP` instance.
`int`	`getIntValue(IloIntVar var)` This method returns the current value of the variable `var` in the invoking instance of `IloCP`.
`double`	`getKPIValue(java.lang.String name)` This method returns the value of the KPI named `name`.
`IloIntervalVar`	`getLast(IloIntervalSequenceVar seq)` This method assumes that interval sequence variable `seq` is fixed.
`int`	`getLength(IloIntervalVar a)` This method returns the current value of the length of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getLength(java.lang.String intervalVarName)` This method returns the current length of the interval variable with the specified name.
`int`	`getLengthMax(IloIntervalVar a)` This method returns the maximum value for the length of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getLengthMin(IloIntervalVar a)` This method returns the minimum value for the length of interval variable `a` in the invoking instance of `IloCP`.
`double`	`getMax(IloNumVar var)` This member function returns the maximum value of the variable `var` in the invoking instance of `IloCP`.
`double`	`getMin(IloNumVar var)` This member function returns the minimum value of the variable `var` in the invoking instance of `IloCP`.
`ilog.concert.cppimpl.IloModel`	`getModelImplSafe()`
`IloIntervalVar`	`getNext(IloIntervalSequenceVar seq, IloIntervalVar a)` This method assumes that interval sequence variable `seq` is fixed.
`int`	`getNumberOfSegments(IloCumulFunctionExpr f)` This method assumes that the cumul function expression `f` is fixed.
`int`	`getNumberOfSegments(IloStateFunction f)` This method assumes that state function `f` is fixed.
`double`	`getObjBound()` This method returns the best bound on the objective found during the solve of an optimization problem.
`double[]`	`getObjBounds()` This method delivers the current bound on the objective criteria in the invoking instance of `IloCP`.
`double`	`getObjGap()` This method returns the relative gap between the objective value of the best solution found and the current objective bound.
`double[]`	`getObjGaps()` This method delivers the current gap values on the objective criteria in the invoking instance of `IloCP`.
`double`	`getObjValue()` This method returns the numeric value of the objective function associated with the CP engine.
`double[]`	`getObjValues()` This method returns the numeric values of all objective values in a multi-objective function associated with the CP engine.
`double`	`getParameter(IloCP.DoubleParam param)` This method returns the value of the floating-point parameter `param` in the invoked `IloCP` instance.
`int`	`getParameter(IloCP.IntParam param)` This method returns the value of the integer parameter `param` in the invoked `IloCP` instance.
`double`	`getParameterDefault(IloCP.DoubleParam param)` This method returns the default value of the floating-point parameter `param` in the invoked `IloCP` instance.
`int`	`getParameterDefault(IloCP.IntParam param)` This method returns the default value of the integer parameter `param` in the invoked `IloCP` instance.
`IloIntervalVar`	`getPrev(IloIntervalSequenceVar seq, IloIntervalVar a)` This method assumes that interval sequence variable `seq` is fixed.
`int`	`getRandomInt(int n)` This method returns a pseudo-randomly generated integer value in the range [0..n).
`double`	`getRandomNum()` This method returns a pseudo-randomly generated floating-point value in the range [0..1).
`int`	`getSegmentEnd(IloCumulFunctionExpr f, int i)` This method assumes that the cumul function expression `f` is fixed.
`int`	`getSegmentEnd(IloStateFunction f, int i)` This method assumes that state function `f` is fixed.
`int`	`getSegmentStart(IloCumulFunctionExpr f, int i)` This method assumes that the cumul function expression `f` is fixed.
`int`	`getSegmentStart(IloStateFunction f, int i)` This method assumes that state function `f` is fixed.
`int`	`getSegmentValue(IloCumulFunctionExpr f, int i)` This method assumes that the cumul function expression `f` is fixed.
`int`	`getSegmentValue(IloStateFunction f, int i)` This method assumes that state function `f` is fixed.
`int`	`getSize(IloIntervalVar a)` This method returns the current value of the size of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getSize(java.lang.String intervalVarName)` This method returns current size of the interval variable with the specified name.
`int`	`getSizeMax(IloIntervalVar a)` This method returns the maximum value for the size of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getSizeMin(IloIntervalVar a)` This method returns the minimum value for the size of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getStart(IloIntervalVar a)` This method returns the current value of the start of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getStart(java.lang.String intervalVarName)` This method returns the current start time of the interval variable with the specified name.
`int`	`getStartMax(IloIntervalVar a)` This method returns the maximum value for the start of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getStartMin(IloIntervalVar a)` This method returns the minimum value for the start of interval variable `a` in the invoking instance of `IloCP`.
`int`	`getValue(IloCumulFunctionExpr f, int t)` This method assumes that cumul function expression `f` is fixed.
`double`	`getValue(IloIntExpr i)` This method returns the current value of the expression `i` in the invoking instance of `IloCP`.
`double`	`getValue(IloIntVar i)` This method returns the current value of the variable `i` in the invoking instance of `IloCP`.
`double`	`getValue(IloNumExpr num)` This method returns the current value of the expression `num` in the invoking instance of `IloCP`.
`int`	`getValue(IloStateFunction f, int t)` This method assumes that state function `f` is fixed.
`int`	`getValue(java.lang.String intVarName)` This method returns the current value of an integer variable with the given name.
`void`	`getValues(IloIntVar[] vars, double[] vals)` This method accepts an array of variables `vars` and puts the corresponding values into the array `vals`; the corresponding values come from the current solution of the invoking algorithm.
`java.lang.String`	`getVersion()` This method returns a string indicating the version of the product.
`IloConstraint`	`gt(IloIntExpr e1, IloIntExpr e2)` Creates and returns the new constraint `e1 > e2`.
`IloConstraint`	`gt(IloIntExpr e, int v)` Creates and returns the new constraint `e > v`.
`IloConstraint`	`gt(int v, IloIntExpr e)` Creates and returns the new constraint `v > e`.
`boolean`	`hasObjective()` This method returns true if and only if the invoking CP Optimizer has extracted a model involving an objective.
`IloIntExpr`	`heightAtEnd(IloIntervalVar a, IloCumulFunctionExpr f)` Whenever interval variable `a` is present, this function returns an integer expression that represents the total contribution of the end of interval variable `a` to the cumul function expression `f`.
`IloIntExpr`	`heightAtEnd(IloIntervalVar a, IloCumulFunctionExpr f, int absVal)` Whenever interval variable `a` is present, this function returns an integer expression that represents the total contribution of the end of interval variable `a` to the cumul function expression `f`.
`IloIntExpr`	`heightAtStart(IloIntervalVar a, IloCumulFunctionExpr f)` Whenever interval variable `a` is present, this method returns an integer expression that represents the total contribution of the start of interval variable `a` to the cumul function expression `f`.
`IloIntExpr`	`heightAtStart(IloIntervalVar a, IloCumulFunctionExpr f, int absVal)` Whenever interval variable `a` is present, this method returns an integer expression that represents the total contribution of the start of interval variable `a` to the cumul function expression `f`.
`IloConstraint`	`ifThenElse(IloConstraint c1, IloConstraint c2, IloConstraint c3)` Creates and returns the new constraint `(c1 => c2) && (!`
`IloIntVarEval`	`impactOfLastBranch()` This method returns a variable evaluator.
`IloConstraint`	`imply(IloConstraint c1, IloConstraint c2)` Creates and returns the new constraint `c1 => c2`, that is, the first constraint implies the other.
`void`	`importModel(java.io.InputStream s)` This function reads a model from the specified stream.
`void`	`importModel(java.lang.String filename)` This function reads a model from a file specified by the `filename` parameter.
`IloIntervalSequenceVar`	`intervalSequenceVar(IloIntervalVar[] a)` This method creates an instance of sequence variable on the set of interval variables defined by array `a`.
`IloIntervalSequenceVar`	`intervalSequenceVar(IloIntervalVar[] a, int[] types)` This method creates an instance of sequence variable on the set of interval variables defined by array `a`.
`IloIntervalSequenceVar`	`intervalSequenceVar(IloIntervalVar[] a, int[] types, java.lang.String name)` This method creates an instance of sequence variable on the set of interval variables defined by array `a`.
`IloIntervalSequenceVar`	`intervalSequenceVar(IloIntervalVar[] a, java.lang.String name)` This method creates an instance of sequence variable on the set of interval variables defined by array `a`.
`IloIntervalVar`	`intervalVar()` This method creates an interval variable.
`IloIntervalVar`	`intervalVar(int sz)` This method creates an interval variable.
`IloIntervalVar`	`intervalVar(int szmin, int szmax)` This method creates an interval variable.
`IloIntervalVar`	`intervalVar(int szmin, int szmax, boolean opt, IloNumToNumStepFunction intensity, int granularity)` This method creates an interval variable.
`IloIntervalVar`	`intervalVar(int sz, java.lang.String name)` This method creates an interval variable.
`IloIntervalVar`	`intervalVar(java.lang.String name)` This method creates an interval variable.
`IloIntExpr`	`intExpr(IloConstraint ct)` Creates and returns a new `IloIntExpr` from the `ct`.
`IloIntExpr[]`	`intExprArray(int n)` Creates and returns an array of null expressions.
`IloIntTupleSet`	`intTable(int dimension)` Creates and returns a new table `table`.
`IloIntValueChooser`	`intValueChooser(IloValueSelector valueSel)` This method returns an `IloIntValueChooser` made with the `IloValueSelector` `valueSel`.
`IloIntValueChooser`	`intValueChooser(IloValueSelector[] valueSels)` This method returns an `IloIntValueChooser` made with the array of `IloValueSelector` `valueSels`.
`IloIntVar`	`intVar(int[] values)` Creates and returns a new integer variable with a domain of possible values.
`IloIntVar`	`intVar(int[] values, java.lang.String name)` Creates and returns a new integer variable with a domain of possible values and a name.
`IloIntVar`	`intVar(int lb, int ub, java.lang.String name)` See `IloModeler.intVar(int, int, String)`
`IloIntVar[]`	`intVarArray(int n)` This method returns a new array of `n` null variables.
`IloIntVar[]`	`intVarArray(int n, int[] values, java.lang.String name)` Returns a new array of `n` variables with domain values and a name.
`IloIntVar[]`	`intVarArray(int n, int min, int max, java.lang.String name)` Creates and returns a new array of `n` variables with domain `min..max` and a name.
`IloIntVarChooser`	`intVarChooser(IloVarSelector varSel)` This method returns an `IloIntVarChooser` made with the `IloVarSelector` `varSel`.
`IloIntVarChooser`	`intVarChooser(IloVarSelector[] varSels)` This method returns an `IloIntVarChooser` made with the array of `IloVarSelector` `varSels`.
`IloConstraint`	`inverse(IloIntExpr[] f, IloIntExpr[] invf)` Creates and returns an inverse constraint.
`boolean`	`isAbsent(IloIntervalVar a)` This method returns true if and only if interval variable `a` is absent in the invoking instance of `IloCP`.
`boolean`	`isAbsent(java.lang.String intervalVarName)` This method returns true if the interval variable with the specified name is currently set to be absent.
`boolean`	`isFixed(IloCumulFunctionExpr f)` This method indicates if the cumul function expression `f` takes on a particular value as maintained by the invoking `IloCP` instance.
`boolean`	`isFixed(IloIntervalSequenceVar seq)` This method indicates if the domain of the interval sequence variable `seq` takes on a particular value as maintained by the invoking `IloCP` instance.
`boolean`	`isFixed(IloIntervalVar a)` This method indicates if the domain of `a` takes on a particular value as maintained by the invoking `IloCP` instance.
`boolean`	`isFixed(IloNumVar var)` This member function indicates if the domain of `var` takes on a particular value as maintained by the invoking `IloCP` instance.
`boolean`	`isFixed(IloStateFunction f)` This method indicates if the state function `f` takes on a particular value as maintained by the invoking `IloCP` instance.
`boolean`	`isInDomain(IloNumVar var, int value)` This member function indicates whether `value` is contained in the current domain of `var` as maintained by the invoking `IloCP` instance.
`IloIsomorphism`	`isomorphism(IloIntervalVar[] domain, IloIntervalVar[] intervals)` This method creates an isomorphism constraint between the set of interval variables in the array `domain` and the set of interval variables in the array `intervals`.
`IloIsomorphism`	`isomorphism(IloIntervalVar[] domain, IloIntervalVar[] intervals, IloIntExpr[] map, int absVal)` This method creates an isomorphism constraint between the set of interval variables in the array `domain` and the set of interval variables in the array `intervals`.
`IloIsomorphism`	`isomorphism(IloIntervalVar[] domain, IloIntervalVar[] intervals, IloIntExpr[] map, int absVal, java.lang.String name)` This method creates an isomorphism constraint between the set of interval variables in the array `domain` and the set of interval variables in the array `intervals`.
`IloIsomorphism`	`isomorphism(IloIntervalVar[] domain, IloIntervalVar[] intervals, java.lang.String name)` This method creates an isomorphism constraint between the set of interval variables in the array `domain` and the set of interval variables in the array `intervals`.
`boolean`	`isPresent(IloIntervalVar a)` This method returns true if and only if interval variable `a` is present in the invoking instance of `IloCP`.
`boolean`	`isPresent(java.lang.String intervalVarName)` This method returns true if the interval variable with the specified name is currently set to be present.
`java.util.Iterator`	`iterator(IloIntVar var)` This member function returns an iterator to iterate over the domain of `var`, as maintained by the invoking IloCP.
`IloConstraint`	`last(IloIntervalSequenceVar seq, IloIntervalVar a)` This method returns a constraint that states that whenever interval variable `a` is present, it must be ordered last in the sequence variable `seq`.
`IloConstraint`	`le(IloCumulFunctionExpr f, IloIntExpr vmax)` This method returns a constraint that states that the value of cumul function expression `f` should never be greater than `vmax`.
`IloConstraint`	`le(IloCumulFunctionExpr f, int vmax)` This method returns a constraint that states that the value of cumul function expression `f` should never be greater than `vmax`.
`IloConstraint`	`le(IloIntExpr vmin, IloCumulFunctionExpr f)` This method returns a constraint that states that the value of cumul function expression `f` should never be less than than `vmin`.
`IloConstraint`	`le(IloIntExpr e1, IloIntExpr e2)` Creates and returns the new constraint `e1 <= e2`.
`IloConstraint`	`le(IloIntExpr e, int v)` Creates and returns the new constraint `e <= v`.
`IloConstraint`	`le(int vmin, IloCumulFunctionExpr f)` This method returns a constraint that states that the value of cumul function expression `f` should never be less than than `vmin`.
`IloConstraint`	`le(int v, IloIntExpr e)` Creates and returns the new constraint `v <= e`.
`IloNumExpr`	`lengthEval(IloIntervalVar a, IloNumToNumSegmentFunction f)` This method returns a numerical expression that represents the value of function `f` evaluated on the length of interval variable `a` whenever the interval variable is present.
`IloNumExpr`	`lengthEval(IloIntervalVar a, IloNumToNumSegmentFunction f, double absVal)` This method returns a numerical expression that represents the value of function `f` evaluated on the length of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`lengthOf(IloIntervalVar a)` This method returns an integer expression that represents the length of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`lengthOf(IloIntervalVar a, int absVal)` This method returns an integer expression that represents the length of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`lengthOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal)` This method returns an integer expression that represents the length of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`lengthOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal, int absVal)` This method returns an integer expression that represents the length of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`lengthOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal)` This method returns an integer expression that represents the length of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloIntExpr`	`lengthOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal, int absVal)` This method returns an integer expression that represents the length of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloConstraint`	`lexicographic(IloIntExpr[] arg1, IloIntExpr[] arg2)` Creates and returns a constraint which maintains two arrays to be lexicographically ordered.
`IloNumExpr`	`log(IloNumExpr e)` Creates and returns the new expression `log(e)`.
`IloConstraint`	`lt(IloIntExpr e1, IloIntExpr e2)` Creates and returns the new constraint `e1 < e2`.
`IloConstraint`	`lt(IloIntExpr e, int v)` Creates and returns the new constraint `e < v`.
`IloConstraint`	`lt(int v, IloIntExpr e)` Creates and returns the new constraint `vintExpr < e`.
`IloIntExpr`	`max(IloIntExpr[] exprs)` Creates and returns the new expression `max(expr)`.
`IloNumExpr`	`max(IloNumExpr[] exprs)` Creates and returns the new numeric expression `max(expr)`, the maximum over the array.
`IloObjective`	`maximize(IloIntExpr e)` Creates a maximization objective.
`IloObjective`	`maximize(IloMultiCriterionExpr e)` Creates a maximization multicriteria objective.
`IloIntExpr`	`min(IloIntExpr[] exprs)` Creates and returns the new expression `min(exprs)`.
`IloNumExpr`	`min(IloNumExpr[] exprs)` Creates and returns the new numeric expression `min(exprs)`, the minimum over the array.
`IloObjective`	`minimize(IloIntExpr e)` Creates a minimization objective.
`IloObjective`	`minimize(IloMultiCriterionExpr e)` Creates a minimization multicriteria objective.
`IloModel`	`model()` Creates and returns a new empty model.
`IloIntExpr`	`modulo(IloIntExpr e, int r)` Creates and returns the modulo expression `e % r`.
`IloConstraint`	`neq(IloConstraint c1, IloConstraint c2)` Creates and returns the new constraint `c1 <=> !`
`IloConstraint`	`neq(IloIntExpr e1, IloIntExpr e2)` Creates and returns the new constraint `e1 !`
`IloConstraint`	`neq(IloIntExpr e, int v)` Creates and returns the new constraint `e !`
`IloConstraint`	`neq(int v, IloIntExpr e)` Creates and returns the new constraint `v !`
`boolean`	`next()` This method searches for a new (or first) solution to the model.
`IloNoOverlap`	`noOverlap(IloIntervalSequenceVar seq)` This method creates a no-overlap constraint on the sequence variable `seq`.
`IloNoOverlap`	`noOverlap(IloIntervalSequenceVar seq, IloTransitionDistance tdist)` This method creates a no-overlap constraint on the sequence variable `seq`.
`IloNoOverlap`	`noOverlap(IloIntervalSequenceVar seq, IloTransitionDistance tdist, boolean direct)` This method creates a no-overlap constraint on the sequence variable `seq`.
`IloNoOverlap`	`noOverlap(IloIntervalSequenceVar seq, IloTransitionDistance tdist, boolean direct, java.lang.String name)` This method creates a no-overlap constraint on the sequence variable `seq`.
`IloNoOverlap`	`noOverlap(IloIntervalSequenceVar seq, IloTransitionDistance tdist, java.lang.String name)` This method creates a no-overlap constraint on the sequence variable `seq`.
`IloNoOverlap`	`noOverlap(IloIntervalVar[] a)` This method creates a no-overlap constraint on the set of interval variables defined by array `a`.
`IloNoOverlap`	`noOverlap(IloIntervalVar[] a, java.lang.String name)` This method creates a no-overlap constraint on the set of interval variables defined by array `a`.
`IloNumExpr[]`	`numExprArray(int n)` Creates and returns an array of null expressions.
`IloNumToNumSegmentFunction`	`numToNumSegmentFunction()` This method creates a piecewise linear function that is constant.
`IloNumToNumSegmentFunction`	`numToNumSegmentFunction(double[] x, double[] v)` This method creates a piecewise linear function defined everywhere whose segments are defined by the two argument arrays `x` and `v`.
`IloNumToNumSegmentFunctionCursor`	`numToNumSegmentFunctionCursor(IloNumToNumSegmentFunction f, double x)` This method creates a cursor to inspect piecewise linear function `f`.
`IloNumToNumStepFunction`	`numToNumStepFunction()` This method creates a step function defined everywhere with value 0.
`IloNumToNumStepFunctionCursor`	`numToNumStepFunctionCursor(IloNumToNumStepFunction f, double x)` This method creates a cursor to inspect step function `f`.
`IloNumVar[]`	`numVarArray(int n, double min, double max, java.lang.String name)` Returns a new array of `n` variables with domain `min..max` and a name.
`java.io.PrintStream`	`output()` Returns the output stream of the invoking `IloCP` object.
`IloIntExpr`	`overlapLength(IloIntervalVar a1, IloIntervalVar a2)` This method returns an integer expression that represents the length of the overlap of interval variable `a1` and interval variable `a2` whenever interval variables `a1` and `a2` are present.
`IloIntExpr`	`overlapLength(IloIntervalVar a1, IloIntervalVar a2, int absVal)` This method returns an integer expression that represents the length of the overlap of interval variable `a1` and interval variable `a2` whenever interval variables `a1` and `a2` are present.
`IloIntExpr`	`overlapLength(IloIntervalVar a, int start, int end)` This method returns an integer expression that represents the length of the overlap of interval variable `a` and constant interval `[start, end)` whenever interval variable `a` is present.
`IloIntExpr`	`overlapLength(IloIntervalVar a, int start, int end, int absVal)` This method returns an integer expression that represents the length of the overlap of interval variable `a` and constant interval `[start, end)` whenever interval variable `a` is present.
`IloConstraint`	`pack(IloIntExpr[] load, IloIntExpr[] where, int[] weight)` Creates and returns a pack constraint which maintains the load of a set of containers or bins, given a set of weighted items and an assignment of items to containers.
`IloConstraint`	`pack(IloIntExpr[] load, IloIntExpr[] where, int[] weight, IloIntExpr used)` Creates and returns a pack constraint which maintains the load of a set of containers or bins, given a set of weighted items and an assignment of items to containers.
`IloNumExpr`	`piecewiseLinear(IloNumExpr e, double[] point, double[] slope, double a, double fa)` This method creates an expression to represent a continuous or discontinuous piecewise linear function f of the variable e.
`IloNumExpr`	`piecewiseLinear(IloNumExpr e, double firstSlope, double[] point, double[] value, double lastSlope)` This method creates an expression to represent a continuous or discontinuous piecewise linear function f of the variable e.
`IloNumToNumSegmentFunction`	`piecewiseLinearFunction(double[] point, double[] slope, double a, double fa)` This method builds an instance of piecewise linear function defined everywhere.
`IloNumToNumSegmentFunction`	`piecewiseLinearFunction(double[] point, double[] slope, double a, double fa, java.lang.String name)` This method builds an instance of piecewise linear function defined everywhere.
`IloNumExpr`	`power(double e1, IloNumExpr e2)` Creates and returns the new expression `e1 ^ e2`.
`IloNumExpr`	`power(IloNumExpr e1, double e2)` Creates and returns the new expression `e1 ^ e2`.
`IloNumExpr`	`power(IloNumExpr e1, IloNumExpr e2)` Creates and returns the new expression `e1 ^ e2`.
`IloConstraint`	`presenceOf(IloIntervalVar a)` This method returns a constraint that states that interval variable `a` is present.
`IloConstraint`	`previous(IloIntervalSequenceVar seq, IloIntervalVar prev, IloIntervalVar next)` This method returns a constraint that states that whenever both interval variables `prev` and `next` are present, interval variable `prev` must be ordered immediately before interval variable `next` in the sequence variable `seq`.
`void`	`printInformation()` This method displays statistics about the CP Optimizer instance.
`void`	`printInformation(java.io.OutputStream s)` This method displays statistics about the current state of the CP Optimizer instance on stream `s`.
`IloNumExpr`	`prod(double[] values, IloNumExpr[] exps)` Returns an expression equal to the scalar product of `values` and `exps`, that is, `values[0]exps[0] + values[1]exps[1] + ...`
`IloIntExpr`	`prod(IloIntExpr[] exps1, IloIntExpr[] exps2)` Returns an expression equal to the scalar product of `exps1` and `exps2`, that is, `exps1[0]exps2[0] + exps1[1]exps2[1] + ...`
`IloIntExpr`	`prod(IloIntExpr[] exps, int[] values)` Returns an expression equal to the scalar product of `values` and `exps`, that is, `values[0]exps[0] + values[1]exps[1] + ...`
`IloNumExpr`	`prod(IloNumExpr[] exps, double[] values)` Returns an expression equal to the scalar product of `values` and `exps`, that is, `values[0]exps[0] + values[1]exps[1] + ...`
`IloNumExpr`	`prod(IloNumExpr[] exps1, IloNumExpr[] exps2)` Returns an expression equal to the scalar product of `exps1` and `exps2`, that is, `exps1[0]exps2[0] + exps1[1]exps2[1] + ...`
`IloIntExpr`	`prod(int[] values, IloIntExpr[] exps)` Returns an expression equal to the scalar product of `values` and `exps`; that is, `values[0]exps[0] + values[1]exps[1] + ...`
`boolean`	`propagate()` Propagates all constraints without a goal.
`boolean`	`propagate(IloConstraint ct)` Propagates a constraint
`IloCumulFunctionExpr`	`pulse(IloIntervalVar a, int v)` This method returns an elementary cumul function expression that, whenever interval variable `a` is present, is equal to `v` between the start and the end of interval variable `a` and equal to `0` everywhere else.
`IloCumulFunctionExpr`	`pulse(IloIntervalVar a, int vmin, int vmax)` This method returns an elementary cumul function expression that, whenever interval variable `a` is present, is equal to a value `v` such that `vmin <= v <= vmax` everywhere between the start and the end of interval variable `a` and equal to `0` everywhere else.
`IloCumulFunctionExpr`	`pulse(int start, int end, int v)` This method returns an elementary cumul function expression that is equal to `v` between `start` and `end` and equal to `0` everywhere else.
`IloNumExpr`	`quot(double e1, IloNumExpr e2)` Creates and returns the new expression `e1 / e2`.
`IloNumExpr`	`quot(IloNumExpr e1, double e2)` Creates and returns the new expression `e1 / e2`.
`IloNumExpr`	`quot(IloNumExpr e1, IloNumExpr e2)` Creates and returns the new expression `e1 / e2`.
`IloRange`	`range(IloNumExpr expr, double b)` Creates and returns an `IloRange` object.
`boolean`	`refineConflict()` This method identifies a minimal conflict for the infeasibility of the current model.
`boolean`	`refineConflict(IloConstraint[] csts)` This method identifies a minimal conflict for the infeasibility of a subset of the constraints of the current model.
`boolean`	`refineConflict(IloConstraint[] csts, double[] prefs)` This method identifies a minimal conflict for the infeasibility of a subset of the constraints of the current model.
`IloAddable`	`remove(IloAddable object)` This method removes the extractable object from the invoking model.
`void`	`removeAllCallbacks()` This method removes all the callbacks from the invoking CP Optimizer instance.
`void`	`removeAllKPIs()` This method removes all the KPIs from CP Optimizer.
`void`	`removeCallback(IloCP.Callback cb)` This method removes user callback `cb` from the invoking CP Optimizer instance.
`void`	`removeKPI(java.lang.String name)` This method removes a KPI.
`boolean`	`restore(IloSolution solution)` This method uses the invoking CP Optimizer object to instantiate the variables in `solution` with their saved values.
`void`	`runSeeds(int n)` This method runs `n` times the CP Optimizer search with different random seeds and computes statistics from the result of these runs.
`IloConstraint`	`sameCommonSubsequence(IloIntervalSequenceVar seq1, IloIntervalSequenceVar seq2)` This function creates a same-common-subsequence constraint between sequence variables `seq1` and `seq2`.
`IloConstraint`	`sameCommonSubsequence(IloIntervalSequenceVar seq1, IloIntervalSequenceVar seq2, IloIntervalVar[] a1, IloIntervalVar[] a2)` This function creates a same-common-subsequence constraint between sequence variables `seq1` and `seq2`.
`IloConstraint`	`sameCommonSubsequence(IloIntervalSequenceVar seq1, IloIntervalSequenceVar seq2, IloIntervalVar[] a1, IloIntervalVar[] a2, java.lang.String name)` This function creates a same-common-subsequence constraint between sequence variables `seq1` and `seq2`.
`IloConstraint`	`sameCommonSubsequence(IloIntervalSequenceVar seq1, IloIntervalSequenceVar seq2, java.lang.String name)` This function creates a same-common-subsequence constraint between sequence variables `seq1` and `seq2`.
`IloConstraint`	`sameSequence(IloIntervalSequenceVar seq1, IloIntervalSequenceVar seq2)` This function creates a same-sequence constraint between sequence variables `seq1` and `seq2`.
`IloConstraint`	`sameSequence(IloIntervalSequenceVar seq1, IloIntervalSequenceVar seq2, IloIntervalVar[] a1, IloIntervalVar[] a2)` This function creates a same-sequence constraint between sequence variables `seq1` and `seq2`.
`IloConstraint`	`sameSequence(IloIntervalSequenceVar seq1, IloIntervalSequenceVar seq2, IloIntervalVar[] a1, IloIntervalVar[] a2, java.lang.String name)` This function creates a same-sequence constraint between sequence variables `seq1` and `seq2`.
`IloConstraint`	`sameSequence(IloIntervalSequenceVar seq1, IloIntervalSequenceVar seq2, java.lang.String name)` This function creates a same-sequence constraint between sequence variables `seq1` and `seq2`.
`IloSearchPhase`	`searchPhase(IloIntervalSequenceVar[] sequenceVars)` This method creates a search phase with an array of interval sequence variables.
`IloSearchPhase`	`searchPhase(IloIntervalVar[] intervalVars)` This method creates a search phase with an array of interval variables.
`IloSearchPhase`	`searchPhase(IloIntVar[] vars)` This method creates a search phase with an array of variables only.
`IloSearchPhase`	`searchPhase(IloIntVar[] vars, IloIntVarChooser varChooser, IloIntValueChooser valueChooser)` This method creates a search phase with an array of variable and choosers.
`IloSearchPhase`	`searchPhase(IloIntVarChooser varChooser, IloIntValueChooser valueChooser)` This method creates a search phase with a variable and a value chooser.
`IloValueSelector`	`selectLargest(double minNumber, IloIntValueEval e)` This method returns a selector of value assignments to a variable that selects at least `minNumber` values having the largest evaluation according to the evaluator `e`.
`IloVarSelector`	`selectLargest(double minNumber, IloIntVarEval e)` This method returns a selector of integer variables that selects at least `minNumber` variables having the largest evaluation according to the evaluator `e`.
`IloValueSelector`	`selectLargest(IloIntValueEval e)` This method returns a selector of value assignments to a variable that selects all values having the largest evaluation according to the evaluator `e`.
`IloValueSelector`	`selectLargest(IloIntValueEval e, double tol)` This method returns a selector of integer variable assignments that selects all domain values whose evaluations are in the range `[max - tol, max]`, where `max` is is the maximum valuation by `e` over the domain values to be evaluated.
`IloVarSelector`	`selectLargest(IloIntVarEval e)` This method returns a selector of integer variables that selects all variables having the largest evaluation according to the evaluator `e`.
`IloVarSelector`	`selectLargest(IloIntVarEval e, double tol)` This method returns a selector of integer variables that selects all variables whose evaluations are in the range `[max - tol, max]`, where `max` is is the maximum valuation by `e` over the variables to be evaluated.
`IloValueSelector`	`selectRandomValue()` This method returns a selector of integer variable value assignments that selects a domain value randomly.
`IloVarSelector`	`selectRandomVar()` This method returns a selector of integer variables that selects a variable randomly from those available.
`IloValueSelector`	`selectSmallest(double minNumber, IloIntValueEval e)` This method returns a selector of integer variable assignments that selects at least `minNumber` domain values having the smallest evaluation according to the evaluator `e`.
`IloVarSelector`	`selectSmallest(double minNumber, IloIntVarEval e)` This method returns a selector of integer variables that selects at least `minNumber` variables having the smallest evaluation according to the evaluator `e`.
`IloValueSelector`	`selectSmallest(IloIntValueEval e)` This method returns a selector of value assignments to a variable that selects all values having the smallest evaluation according to the evaluator `e`.
`IloValueSelector`	`selectSmallest(IloIntValueEval e, double tol)` This method returns a selector of integer variable assignments that selects all domain values whose evaluations are in the range `[min, min + tol]`, where `min` is is the minimum valuation by `e` over the domain values to be evaluated.
`IloVarSelector`	`selectSmallest(IloIntVarEval e)` This method returns a selector of integer variables that selects all variables having the smallest evaluation according to the evaluator `e`.
`IloVarSelector`	`selectSmallest(IloIntVarEval e, double tol)` This method returns a selector of integer variables that selects all variables whose evaluations are in the range `[min, min + tol]`, where `min` is is the minimum valuation by `e` over the variables to be evaluated.
`IloConstraint`	`sequence(int nbMin, int nbMax, int seqWidth, IloIntVar[] vars, int[] values, IloIntVar[] cards)`
`void`	`serializeAConflict(java.io.OutputStream s, int indentStep)`
`void`	`serializeCP(java.io.OutputStream s, int indentStep, boolean status, boolean solution, boolean info, boolean params, int nextStatus)`
`void`	`serializeCPAfterEndSearch(java.io.OutputStream s, int indentStep)`
`void`	`serializeCPAfterNextFailure(java.io.OutputStream s, int indentStep)`
`void`	`serializeCPAfterNextSucceed(java.io.OutputStream s, int indentStep)`
`void`	`serializeCPAfterSolve(java.io.OutputStream s, int indentStep)`
`void`	`serializeCPBeforeSolve(java.io.OutputStream s, int indentStep)`
`void`	`serializeCPCurrentDomains(java.io.OutputStream s, int indentStep)`
`void`	`serializeCPSolutionOnly(java.io.OutputStream s, int indentStep)`
`void`	`setError(java.io.OutputStream s)` Sets the error stream of the invoking `IloCP` object.
`void`	`setOut(java.io.OutputStream s)` Sets the default output stream of the invoking `IloCP` object.
`void`	`setParameter(IloCP.DoubleParam param, double value)` This method sets the floating-point parameter `param` to the value `value` in the invoked IloCP instance.
`void`	`setParameter(IloCP.DoubleParam param, IloCP.ParameterValues value)` This method sets the floating-point parameter `param` to the value `value` in the invoked IloCP instance.
`void`	`setParameter(IloCP.IntParam param, IloCP.ParameterValues value)` This method sets the integer parameter `param` to the value `value` in the invoked `IloCP` instance.
`void`	`setParameter(IloCP.IntParam param, int value)` This method sets the integer parameter `param` to the value `value` in the invoked `IloCP` instance.
`void`	`setSearchPhases()` This method clears the search phases set on the `IloCP` instance.
`void`	`setSearchPhases(IloSearchPhase phase)` This method specifies a search phase that need to be used to instantiate variables in CP Optimizer embedded search.
`void`	`setSearchPhases(IloSearchPhase[] phases)` This method specifies the array of search phases that need to be used to instantiate variables in CP Optimizer embedded search.
`void`	`setStartingPoint(IloSolution sp)` This method sets solution `sp` as the new starting point for subsequent searches of the invoking CP Optimizer engine.
`void`	`setWarning(java.io.OutputStream s)` Sets the warning stream of the invoking `IloCP` object.
`IloNumExpr`	`sizeEval(IloIntervalVar a, IloNumToNumSegmentFunction f)` This method returns a numerical expression that represents the value of function `f` evaluated on the size of interval variable `a` whenever the interval variable is present.
`IloNumExpr`	`sizeEval(IloIntervalVar a, IloNumToNumSegmentFunction f, double absVal)` This method returns a numerical expression that represents the value of function `f` evaluated on the size of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`sizeOf(IloIntervalVar a)` This method returns an integer expression that represents the size of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`sizeOf(IloIntervalVar a, int absVal)` This method returns an integer expression that represents the size of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`sizeOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal)` This method returns an integer expression that represents the size of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`sizeOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal, int absVal)` This method returns an integer expression that represents the size of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`sizeOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal)` This method returns an integer expression that represents the size of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloIntExpr`	`sizeOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal, int absVal)` This method returns an integer expression that represents the size of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloSolution`	`solution()` This method creates and returns an instance of `IloSolution`.
`boolean`	`solve()` This method solves a problem using CP Optimizer's built-in strategy.
`IloSpan`	`span(IloIntervalVar a, IloIntervalVar[] bs)` This method creates a span constraint between interval variable `a` and the set of interval variables in the array `bs`.
`IloSpan`	`span(IloIntervalVar a, IloIntervalVar[] bs, java.lang.String name)` This method creates a span constraint between interval variable `a` and the set of interval variables in the array `bs`.
`IloNumExpr`	`standardDeviation(IloIntExpr[] exprs)` This method creates a new constrained numeric expression which is equal to the standard deviation of the values of the variables in the array `exprs`.
`IloNumExpr`	`standardDeviation(IloIntExpr[] exprs, double meanLB, double meanUB)` This method creates a new constrained numeric expression which is equal to the standard deviation of the values of the variables in the array `exprs`.
`IloNumExpr`	`standardDeviation(ilog.concert.IloIntExprArray exprs, double meanLB, double meanUB)`
`IloConstraint`	`startAtEnd(IloIntervalVar a, IloIntervalVar b)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-start(a)`between the start of interval `a` and the end of interval `b` must be equal to 0.
`IloConstraint`	`startAtEnd(IloIntervalVar a, IloIntervalVar b, IloIntExpr z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-start(a)`between the start of interval `a` and the end of interval `b` must be equal to `z`.
`IloConstraint`	`startAtEnd(IloIntervalVar a, IloIntervalVar b, int z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-start(a)`between the start of interval `a` and the end of interval `b` must be equal to `z`.
`IloConstraint`	`startAtStart(IloIntervalVar a, IloIntervalVar b)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-start(a)`between the start of interval `a` and the start of interval `b` must be equal to 0.
`IloConstraint`	`startAtStart(IloIntervalVar a, IloIntervalVar b, IloIntExpr z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-start(a)`between the start of interval `a` and the start of interval `b` must be equal to `z`.
`IloConstraint`	`startAtStart(IloIntervalVar a, IloIntervalVar b, int z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-start(a)`between the start of interval `a` and the start of interval `b` must be equal to `z`.
`IloConstraint`	`startBeforeEnd(IloIntervalVar a, IloIntervalVar b)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-start(a)`between the start of interval `a` and the end of interval `b` must be greater than or equal to 0.
`IloConstraint`	`startBeforeEnd(IloIntervalVar a, IloIntervalVar b, IloIntExpr z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-start(a)`between the start of interval `a` and the end of interval `b` must be greater than or equal to `z`.
`IloConstraint`	`startBeforeEnd(IloIntervalVar a, IloIntervalVar b, int z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `end(b)-start(a)`between the start of interval `a` and the end of interval `b` must be greater than or equal to `z`.
`IloConstraint`	`startBeforeStart(IloIntervalVar a, IloIntervalVar b)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-start(a)`between the start of interval `a` and the start of interval `b` must be greater than or equal to 0.
`IloConstraint`	`startBeforeStart(IloIntervalVar a, IloIntervalVar b, IloIntExpr z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-start(a)`between the start of interval `a` and the start of interval `b` must be greater than or equal to `z`.
`IloConstraint`	`startBeforeStart(IloIntervalVar a, IloIntervalVar b, int z)` This method returns a constraint that states that whenever both interval variables `a` and `b` are present, the distance `start(b)-start(a)`between the start of interval `a` and the start of interval `b` must be greater than or equal to `z`.
`IloNumExpr`	`startEval(IloIntervalVar a, IloNumToNumSegmentFunction f)` This method returns a numerical expression that represents the value of function `f` evaluated on the start of interval variable `a` whenever the interval variable is present.
`IloNumExpr`	`startEval(IloIntervalVar a, IloNumToNumSegmentFunction f, double absVal)` This method returns a numerical expression that represents the value of function `f` evaluated on the start of interval variable `a` whenever the interval variable is present.
`void`	`startNewSearch()` This method starts a new search using the built-in strategy of `IloCP`.
`IloIntExpr`	`startOf(IloIntervalVar a)` This method returns an integer expression that represents the start of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`startOf(IloIntervalVar a, int absVal)` This method returns an integer expression that represents the start of interval variable `a` whenever the interval variable is present.
`IloIntExpr`	`startOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal)` This method returns an integer expression that represents the start of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`startOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal, int absVal)` This method returns an integer expression that represents the start of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`startOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal)` This method returns an integer expression that represents the start of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloIntExpr`	`startOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal, int absVal)` This method returns an integer expression that represents the start of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloStateFunction`	`stateFunction()` This method creates an instance of state function.
`IloStateFunction`	`stateFunction(IloTransitionDistance t)` This method creates an instance of state function with transition distance `t`.
`IloStateFunction`	`stateFunction(IloTransitionDistance t, java.lang.String name)` This method creates an instance of state function with transition distance `t`.
`IloStateFunction`	`stateFunction(java.lang.String name)` This method creates an instance of state function.
`IloMultiCriterionExpr`	`staticLex(IloNumExpr[] criteria)` This function defines a multicriteria expression for lexicographic ordering.
`IloMultiCriterionExpr`	`staticLex(IloNumExpr[] criteria, java.lang.String name)` This function defines a multicriteria expression for lexicographic ordering.
`IloMultiCriterionExpr`	`staticLex(IloNumExpr c1, IloNumExpr c2)` This function defines a multicriteria expression for lexicographic ordering.
`IloMultiCriterionExpr`	`staticLex(IloNumExpr c1, IloNumExpr c2, IloNumExpr c3)` This function defines a multicriteria expression for lexicographic ordering.
`IloMultiCriterionExpr`	`staticLex(IloNumExpr c1, IloNumExpr c2, IloNumExpr c3, IloNumExpr c4)` This function defines a multicriteria expression for lexicographic ordering.
`IloCumulFunctionExpr`	`step(int t, int v)` This method returns an elementary cumul function expression that is equal to `0` before point `t` and equal to `v` after point `t`.
`IloCumulFunctionExpr`	`stepAtEnd(IloIntervalVar a, int v)` This method returns an elementary cumul function expression that, whenever interval variable `a` is present, is equal to `0` before the end of `a` and equal to `v` after the end of `a`.
`IloCumulFunctionExpr`	`stepAtEnd(IloIntervalVar a, int vmin, int vmax)` This method returns an elementary cumul function expression that, whenever interval variable `a` is present, is equal to a `0` before the end of `a` and equal to a value `v` such that `vmin <= v <= vmax` after the end of `a`.
`IloCumulFunctionExpr`	`stepAtStart(IloIntervalVar a, int v)` This method returns an elementary cumul function expression that, whenever interval variable `a` is present, is equal to `0` before the start of `a` and equal to `v` after the start of `a`.
`IloCumulFunctionExpr`	`stepAtStart(IloIntervalVar a, int vmin, int vmax)` This method returns an elementary cumul function expression that, whenever interval variable `a` is present, is equal to a `0` before the start of `a` and equal to a value `v` such that `vmin <= v <= vmax` after the start of `a`.
`void`	`store(IloSolution solution)` This method stores the values of the objects added to `solution` by examining their current values in the invoking `IloCP`.
`IloConstraint`	`strong(IloIntVar[] vars)` An instance of a `strong` constraint strengthens the model on the variables of the array given as argument.
`IloConstraint`	`subCircuit(IloIntExpr[] next)`
`IloCumulFunctionExpr`	`sum(IloCumulFunctionExpr f1, IloCumulFunctionExpr f2)` This operator returns a cumul function expression equal to the sum of its arguments.
`IloIntExpr`	`sum(IloIntExpr[] exprs)` Creates and returns an integer expression representing the sum of the expressions provided in the array `exprs`.
`IloNumExpr`	`sum(IloNumExpr[] exprs)` Creates and returns an expression representing the sum of the expressions provided as terms in the array `expr`.
`IloSynchronize`	`synchronize(IloIntervalVar a, IloIntervalVar[] bs)` This method creates a synchronization constraint between interval variable `a` and the set of interval variables in the array `bs`.
`IloSynchronize`	`synchronize(IloIntervalVar a, IloIntervalVar[] bs, java.lang.String name)` This method creates a synchronization constraint between interval variable `a` and the set of interval variables in the array `bs`.
`IloTransitionDistance`	`transitionDistance(int i)` This method returns an instance of transition distance of the specified size `i`.
`IloTransitionDistance`	`transitionDistance(int[][] dtable)` This method returns an instance of transition distance.
`IloTransitionDistance`	`transitionDistance(int[][] dtable, java.lang.String name)` This method returns an instance of transition distance.
`IloTransitionDistance`	`transitionDistance(int i, java.lang.String name)` This method returns an instance of transition distance of the specified size `i`.
`IloConstraint`	`trueConstraint()` Creates and returns a new constraint that is always true.
`IloIntExpr`	`typeOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal)` This method returns an integer expression that represents the type of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`typeOfNext(IloIntervalSequenceVar seq, IloIntervalVar a, int lastVal, int absVal)` This method returns an integer expression that represents the type of the interval variable that is next to interval `a` in sequence variable `seq`.
`IloIntExpr`	`typeOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal)` This method returns an integer expression that represents the type of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloIntExpr`	`typeOfPrevious(IloIntervalSequenceVar seq, IloIntervalVar a, int firstVal, int absVal)` This method returns an integer expression that represents the type of the interval variable that is previous to interval `a` in sequence variable `seq`.
`IloIntValueEval`	`value()` This method returns a value evaluator.
`IloIntValueEval`	`valueImpact()` This method returns a value evaluator.
`IloIntValueEval`	`valueIndex(int[] vals)` This method is a shortcut to `valueIndex(vals, -1)`;
`IloIntValueEval`	`valueIndex(int[] vals, int defautEval)` This method returns a value evaluator.
`IloIntValueEval`	`valueSuccessRate()` This method returns a value evaluator.
`IloIntVarEval`	`varImpact()` This method returns a variable evaluator.
`IloIntVarEval`	`varIndex(IloIntVar[] vars)` This method is a shortcut to `varIndex(vars, -1)`.
`IloIntVarEval`	`varIndex(IloIntVar[] vars, int defaultIndex)` This method returns a variable evaluator.
`IloIntVarEval`	`varLocalImpact()` This method is a shortcut to `varLocalImpact(-1)`.
`IloIntVarEval`	`varLocalImpact(int effort)` This method returns a variable evaluator.
`IloIntVarEval`	`varSuccessRate()` This method returns a variable evaluator.
`java.io.PrintStream`	`warning()` Returns the warning output stream of the invoking `IloCP` object.
`void`	`writeConflict()` This method can be used as a shorthand for `cp.writeConflict(cp.output())`.
`void`	`writeConflict(java.io.OutputStream s)` This method displays the current conflict.

Methods inherited from class ilog.concert.IloModelerImpl
abs, abs, addEq, addEq, addEq, addEq, addEq, addEq, addGe, addGe, addGe, addGe, addGe, addGe, addLe, addLe, addLe, addLe, addLe, addLe, addMaximize, addMaximize, addMinimize, addMinimize, addObjective, addObjective, addRange, addRange, and, and, boolVar, boolVar, boolVarArray, boolVarArray, clearModel, constant, constant, diff, diff, diff, diff, diff, diff, eq, eq, eq, eq, eq, eq, ge, ge, ge, ge, ge, ge, getEnvImpl, getEnvImplNoThrow, ifThen, ifThen, intExpr, intRange, intVar, intVarArray, intVarArray, intVarArray, intVarArray, le, le, le, le, le, le, linearIntExpr, linearIntExpr, linearNumExpr, linearNumExpr, max, max, max, max, max, max, maximize, maximize, min, min, min, min, min, min, minimize, minimize, negative, negative, not, not, numExpr, numSet, numVar, numVar, numVar, numVar, numVarArray, numVarArray, numVarArray, numVarArray, numVarArray, numVarArray, numVarArray, numVarArray, numVarArrayO, numVarArrayO, objective, objective, or, or, or, or, or, or, or, prod, prod, prod, prod, prod, prod, prod, prod, prod, range, range, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, square, square, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum

Methods inherited from class ilog.concert.IloModelImpl
add, add, getCopy, getModelImpl, getName, iterator, makeCopy, needCopy, remove, remove, setModelImpl, setName

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

Methods inherited from interface ilog.concert.IloModeler
abs, addEq, addEq, addEq, addEq, addEq, addEq, addGe, addGe, addGe, addGe, addGe, addGe, addLe, addLe, addLe, addLe, addLe, addLe, addMaximize, addMaximize, addMinimize, addMinimize, addObjective, addObjective, addRange, addRange, and, and, and, and, and, and, and, boolVar, boolVar, boolVarArray, boolVarArray, constant, constant, diff, diff, diff, diff, diff, diff, eq, eq, eq, eq, eq, eq, ge, ge, ge, ge, ge, ge, ifThen, ifThen, intExpr, intVar, intVarArray, intVarArray, intVarArray, intVarArray, le, le, le, le, le, le, linearIntExpr, linearIntExpr, linearNumExpr, linearNumExpr, max, max, max, max, max, max, maximize, maximize, min, min, min, min, min, min, minimize, minimize, negative, negative, not, not, numExpr, numVar, numVar, numVar, numVar, numVarArray, numVarArray, numVarArray, numVarArray, numVarArray, numVarArray, numVarArray, numVarArray, objective, objective, or, or, or, or, or, or, or, prod, prod, prod, prod, prod, prod, prod, prod, prod, range, range, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, scalProd, square, square, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum

Methods inherited from interface ilog.concert.IloModel
add, add, iterator, remove, remove

Methods inherited from interface ilog.concert.IloAddable
getName, setName

- Field Detail
  - IntMin
```
public static final int IntMin
```
    This constant represents the smallest possible negative integer allowed in CP Optimizer.
    
    See Also:
    Constant Field Values
  - IntMax
```
public static final int IntMax
```
    This constant represents the largest possible positive integer allowed in CP Optimizer.
    
    See Also:
    Constant Field Values
  - Infinity
```
public static final double Infinity
```
    This constant represents positive infinity of type double.
    
    See Also:
    Constant Field Values
  - IntervalMin
```
public static final int IntervalMin
```
    This constant represents the smallest value that can be taken by the start or end of an interval variable.
    
    See Also:
    Constant Field Values
  - IntervalMax
```
public static final int IntervalMax
```
    This constant represents the largest value that can be taken by the start or end of an interval variable.
    
    See Also:
    Constant Field Values
  - NoState
```
public static final int NoState
```
    This static integer of value -1 is the conventional value of an instance of IloStateFunction at any point out of its definition domain.
    
    The following sample prints IloCP.NoState.
```
    IloCP cp = new IloCP();
    IloStateFunction f = cp.stateFunction();
    cp.add(cp.alwaysNoState(f, -1, 1));

    System.out.println("[" + cp.getValue(f, 0)
                    + "," + cp.getSegmentEnd(f, i)
                    + "):" + cp.getSegmentValue(f, i) );
 
```
    See Also:
    Constant Field Values
- Constructor Detail
  - IloCP
```
public IloCP()
```
    This method creates an algorithm for CP Optimizer.
    
    The first creation of an IloCP object in a process is not multi-thread safe. All IloCP objects created after the first are multi-thread safe.
- Method Detail
  - getModelImplSafe
```
public ilog.concert.cppimpl.IloModel getModelImplSafe()
```
    Overrides:
    
    getModelImplSafe in class ilog.concert.IloModelImpl
  - model
```
public IloModel model()
```
    Creates and returns a new empty model.
    
    Returns:
    The newly created empty model.
  - setParameter
```
public void setParameter(IloCP.IntParam param,
                IloCP.ParameterValues value)
                  throws IloException
```
    This method sets the integer parameter param to the value value in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - setParameter
```
public void setParameter(IloCP.IntParam param,
                int value)
                  throws IloException
```
    This method sets the integer parameter param to the value value in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - getParameter
```
public int getParameter(IloCP.IntParam param)
                 throws IloException
```
    This method returns the value of the integer parameter param in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - getParameterDefault
```
public int getParameterDefault(IloCP.IntParam param)
                        throws IloException
```
    This method returns the default value of the integer parameter param in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - setParameter
```
public void setParameter(IloCP.DoubleParam param,
                IloCP.ParameterValues value)
                  throws IloException
```
    This method sets the floating-point parameter param to the value value in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - setParameter
```
public void setParameter(IloCP.DoubleParam param,
                double value)
                  throws IloException
```
    This method sets the floating-point parameter param to the value value in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - getParameter
```
public double getParameter(IloCP.DoubleParam param)
                    throws IloException
```
    This method returns the value of the floating-point parameter param in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - getParameterDefault
```
public double getParameterDefault(IloCP.DoubleParam param)
                           throws IloException
```
    This method returns the default value of the floating-point parameter param in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - getInfo
```
public int getInfo(IloCP.IntInfo which)
            throws IloException
```
    This method returns the value of the integer information which in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - getInfo
```
public double getInfo(IloCP.DoubleInfo which)
               throws IloException
```
    This method returns the value of the floating-point information which in the invoked IloCP instance.
    
    Throws:
    
    IloException
  - solution
```
public IloSolution solution()
                     throws IloException
```
    This method creates and returns an instance of IloSolution. You can define what variables are stored in the solution by adding variables directly to the returned instance of solution.
    
    Throws:
    
    IloException
  - store
```
public void store(IloSolution solution)
           throws IloException
```
    This method stores the values of the objects added to solution by examining their current values in the invoking IloCP.
    
    Throws:
    
    IloException
  - restore
```
public boolean restore(IloSolution solution)
                throws IloException
```
    This method uses the invoking CP Optimizer object to instantiate the variables in solution with their saved values. The value of any objective added to the solution is not restored. If the solution does not violate any constraints of the model extracted by the invoking CP Optimizer, then true is returned and the state of the constraint variables in CP Optimizer reflect those stored in solution. Otherwise the optimizer's state remains unchanged and false is returned.
    
    Throws:
    
    IloException
  - setSearchPhases
```
public void setSearchPhases()
                     throws IloException
```
    This method clears the search phases set on the IloCP instance.
    
    Throws:
    
    IloException
  - setSearchPhases
```
public void setSearchPhases(IloSearchPhase phase)
                     throws IloException
```
    This method specifies a search phase that need to be used to instantiate variables in CP Optimizer embedded search. Search will be invoked by a call to the method IloCP.solve() or IloCP.startNewSearch(). The method IloCP.setSearchPhases() can be used to clear the search phases set on the IloCP instance.
    
    Throws:
    
    IloException
  - setSearchPhases
```
public void setSearchPhases(IloSearchPhase[] phases)
                     throws IloException
```
    This method specifies the array of search phases that need to be used to instantiate variables in CP Optimizer embedded search. Search will be invoked by a call to the method IloCP.solve() or IloCP.startNewSearch(). The method IloCP.setSearchPhases() can be used to clear the search phases set on the IloCP instance.
    
    Throws:
    
    IloException
  - clearExplanations
```
public void clearExplanations()
                       throws IloException
```
    This method is used to clear the set of failure tags (indices) to be explained.
    
    Throws:
    
    IloException
  - explainFailure
```
public void explainFailure(int failTag)
                    throws IloException
```
    This method specifies a tag(index) of the failure to explain. Several failure tags can be added.
    
    Throws:
    
    IloException
  - explainFailure
```
public void explainFailure(int[] failTagArray)
                    throws IloException
```
    This method specifies an array of tags (indices) of failures to explain. Several failure tags can be added.
    
    Throws:
    
    IloException
  - setStartingPoint
```
public void setStartingPoint(IloSolution sp)
```
    This method sets solution sp as the new starting point for subsequent searches of the invoking CP Optimizer engine.
    
    For more information on starting points, see the Starting Point concept.
  - clearStartingPoint
```
public void clearStartingPoint()
```
    This method removes any starting point specified on the invoking CP Optimizer engine: subsequent searches will not use any starting point information, unless a new starting point is set.
    
    For more information on starting points, see the Starting Point concept.
  - solve
```
public boolean solve()
              throws IloException
```
    This method solves a problem using CP Optimizer's built-in strategy. The built-in strategy is determined by setting the parameter IloCP.IntParam.SearchType. If the model contains an objective (instance of IloObjective), then the optimal solution with respect to the objective will be calculated. Otherwise, a solution satisfying all problem constraints will be calculated. If no such solution exists, the method returns false, otherwise, it returns true. If the search has been limited in time or fails, via the parameters IloCP.IntParam.FailLimit or IloCP.DoubleParam.TimeLimit, then the search is not guaranteed to return the optimal solution, but the best one found within the limit specified.
    
    Throws:
    
    IloException
  - startNewSearch
```
public void startNewSearch()
                    throws IloException
```
    This method starts a new search using the built-in strategy of IloCP. It should be used in conjunction with the method next().
    
    Throws:
    
    IloException
  - endSearch
```
public void endSearch()
               throws IloException
```
    This method terminates a search and deletes the internal objects created by CP Optimizer to carry out the search.
    
    The use of this method is optional. CP Optimizer now automatically ends the search the next time startNewSearch() or solve() is called. However, if you omit endSearch you will not obtain the correct summary information on the search log, or through getInfo(ilog.cp.IloCP.IntInfo) until you do so.
    
    You may not call next() after calling endSearch() without first calling startNewSearch().
    
    Throws:
    
    IloException
  - next
```
public boolean next()
             throws IloException
```
    This method searches for a new (or first) solution to the model.
    In the case of an optimization problem (with an instance of IloObjective in the model), next finds a solution strictly better than the previous solution found. In the case of a satisfaction problem, next returns a solution usually different from those previously found but, it may occasionally find a solution that had been found already. Repeatedly calling next until it returns false is guaranteed to terminate and to not miss any solutions of the model being solved. Solutions can be accessed via getValue; for example cp.getValue(IloIntVar).
    
    This method returns true when it has found a solution and false when there are no more (improving) solutions or search has been stopped by a limit. You can use IloCP.getInfo with parameter IloCP.IntInfo.FailStatus to find out the exact reason for the search stopping.
    
    For convenience, in the case where next() returns false, the last solution found will be delivered by the invoking CP Optimizer. When the model contains an instance of IloObjective, this will be the best solution found during search.
    
    Throws:
    
    IloException
  - abortSearch
```
public void abortSearch()
```
    This methods stops the current search and can be useful for interrupting CP Optimizer in an interactive application.
    Typically, this method would be called from a thread other than the one executing the instance of IloCP. After a call to this method, CP Optimizer will exit cleanly with a failure status, IloCP.IntInfo.FailStatus, set to IloCP.ParameterValues.SearchStoppedByAbort. You may also call this function from a callback object (#Callback) from the same thread.
  - clearAbort
```
public void clearAbort()
```
    This method should be called after abortSearch() before any subsequent call to solve() or startNewSearch(). It should be called from the same thread that run the previous search and not the one that invoked the abortSearch in order to avoid any synchronization issues.
  - printInformation
```
public void printInformation(java.io.OutputStream s)
                      throws IloException
```
    This method displays statistics about the current state of the CP Optimizer instance on stream s. For more information, see printInformation().
    
    Throws:
    
    IloException
  - printInformation
```
public void printInformation()
                      throws IloException
```
    This method displays statistics about the CP Optimizer instance.
    
    Specifically, on CP Optimizer's output stream, this method displays the following information:
    - The number of internal variables actually used by CP Optimizer. Depending on presolve, and internal variables added to support CP Optimizer's internal workings, this number can be higher or lower than the number of variables in the model. However, it is typically higher.
    - The number of internal constraints actually used by CP Optimizer. Depending on presolve, and internal constraints added to support CP Optimizer's internal workings, this number can be higher or lower than the number of constraints in the model.
    - The total memory usage of CP Optimizer not including memory used by Concert Technology.
    - The time spent in the last solve (including startNewSearch/next).
    - The total time spent in this CP Optimizer instance since its creation.
    Each of these numbers can be accessed individually via #getInfo().
    
    Typical output from the method printInformation looks like this:
```
 Number of variables     : 767
 Number of constraints   : 6303
 Engine memory usage     : 11.5 MB
 Time in last solve      : 0.33s (0.32s engine + 0.01s extraction)
 Total time spent in CP  : 0.33s
 
```
    Throws:
    
    IloException
  - trueConstraint
```
public IloConstraint trueConstraint()
                             throws IloException
```
    Creates and returns a new constraint that is always true.
    
    Throws:
    
    IloException
  - falseConstraint
```
public IloConstraint falseConstraint()
                              throws IloException
```
    Creates and returns a new constraint that is always false.
    
    Throws:
    
    IloException
  - allDiff
```
public IloConstraint allDiff(IloIntExpr[] exps)
                      throws IloException
```
    Creates and returns a new constraint stating that the expression elements of exps must take different values from each other.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - allMinDistance
```
public IloConstraint allMinDistance(IloIntVar[] vars,
                           int k)
                             throws IloException
```
    This method returns a constraint that ensures that the absolute distance between any pair of variables in the array vars will be greater than or equal to k.
    
    Throws:
    
    IloException
  - distribute
```
public IloConstraint distribute(IloIntExpr[] cards,
                       int[] values,
                       IloIntExpr[] vars)
                         throws IloException
```
    Creates and returns a counting constraint in a model. The constraint has no effect until you add it to the CP optimizer. When the constraint is added, the number of constrained variables in the array cards is equal to the number of occurrences in the array vars of the values in the array values. More precisely, for each i, cards[i] is equal to the number of occurrences of values[i] in the array vars. After propagation of this constraint, the minimum of cards[i] is at least equal to the number of variables contained in vars bound to the value at values[i]; and the maximum of cards[i] is at most equal to the number of variables in vars that contain the value at values[i] in their domain. The arrays cards and values must be the same length, otherwise an exception will be thrown.
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
    Parameters:
    cards - The array containing the number of occurrences of values (must be a non empty array).
    values - The array of values.
    vars - The array of constrained variables (must be a non empty array).
    
    Returns:
    The newly created counting constraint.
  - distribute
```
public IloConstraint distribute(IloIntExpr[] cards,
                       IloIntExpr[] vars)
                         throws IloException
```
    Creates and returns a counting constraint in a model. The constraint has no effect until you add it to the CP optimizer. When the constraint is added, the number of constrained variables in the array cards is equal to the number of occurrences in the array vars of the values in an array of consecutive integers starting with 0 (zero). For each i, cards[i] is equal to the number of occurrences of i in the array vars. After propagation of this constraint, the minimum of cards[i] is at least equal to the number of variables contained in vars bound to the value i; and the maximum of cards[i] is at most equal to the number of variables contained in vars that contain i in their domain.
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
    Parameters:
    cards - The array containing the number of occurrences of values (must be a non empty array).
    vars - The array of constrained variables (must be a non empty array).
    
    Returns:
    The newly created counting constraint.
  - subCircuit
```
public IloConstraint subCircuit(IloIntExpr[] next)
                         throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - sequence
```
public IloConstraint sequence(int nbMin,
                     int nbMax,
                     int seqWidth,
                     IloIntVar[] vars,
                     int[] values,
                     IloIntVar[] cards)
                       throws IloException
```
    Throws:
    
    IloException
  - element
```
public IloConstraint element(IloIntExpr var,
                    IloIntExpr index,
                    int[] values)
                      throws IloException
```
    Creates and returns the new constraint var == values[index].
    
    Throws:
    
    IloException
  - element
```
public IloConstraint element(IloNumExpr var,
                    IloIntExpr index,
                    double[] values)
                      throws IloException
```
    Creates and returns the new constraint var == values[index].
    
    Throws:
    
    IloException
  - eq
```
public IloConstraint eq(IloIntExpr e,
               int v)
```
    Creates and returns the new constraint e == v.
  - eq
```
public IloConstraint eq(IloIntExpr e1,
               IloIntExpr e2)
```
    Creates and returns the new constraint e1 == e2.
  - eq
```
public IloConstraint eq(int v,
               IloIntExpr e)
```
    Creates and returns the new constraint v == e.
  - ge
```
public IloConstraint ge(IloIntExpr e,
               int v)
```
    Creates and returns the new constraint e >= v.
  - ge
```
public IloConstraint ge(IloIntExpr e1,
               IloIntExpr e2)
```
    Creates and returns the new constraint e1 >= e2.
  - ge
```
public IloConstraint ge(int v,
               IloIntExpr e)
```
    Creates and returns the new constraint v >= e.
  - gt
```
public IloConstraint gt(IloIntExpr e,
               int v)
```
    Creates and returns the new constraint e > v.
  - gt
```
public IloConstraint gt(IloIntExpr e1,
               IloIntExpr e2)
```
    Creates and returns the new constraint e1 > e2.
  - gt
```
public IloConstraint gt(int v,
               IloIntExpr e)
```
    Creates and returns the new constraint v > e.
  - inverse
```
public IloConstraint inverse(IloIntExpr[] f,
                    IloIntExpr[] invf)
                      throws IloException
```
    Creates and returns an inverse constraint. In formal terms, if the length of the arrays f and invf is n, then the inverse constraint guarantees that:
    - for all i in the interval [0, n-1], invf[f[i]]==i;
    - for all j in the interval [0, n-1], f[invf[j]]==j.
    Note: This constraint cannot be used in a logical constraint.
    Throws:
    
    IloException
  - le
```
public IloConstraint le(IloIntExpr e,
               int v)
```
    Creates and returns the new constraint e <= v.
  - le
```
public IloConstraint le(IloIntExpr e1,
               IloIntExpr e2)
```
    Creates and returns the new constraint e1 <= e2.
  - le
```
public IloConstraint le(int v,
               IloIntExpr e)
```
    Creates and returns the new constraint v <= e.
  - lexicographic
```
public IloConstraint lexicographic(IloIntExpr[] arg1,
                          IloIntExpr[] arg2)
                            throws IloException
```
    Creates and returns a constraint which maintains two arrays to be lexicographically ordered.
    
    More specifically, lexicographic(x, y) maintains that x is less than or equal to y in the lexicographical sense of the term. This means that either both arrays are equal or that there exists i < size(x) such that for all j < i, x[j] = y[j] and x[i] < y[i].
    
    Note that the size of the two arrays must be the same.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - lt
```
public IloConstraint lt(IloIntExpr e,
               int v)
```
    Creates and returns the new constraint e < v.
  - lt
```
public IloConstraint lt(IloIntExpr e1,
               IloIntExpr e2)
```
    Creates and returns the new constraint e1 < e2.
  - lt
```
public IloConstraint lt(int v,
               IloIntExpr e)
```
    Creates and returns the new constraint vintExpr < e.
  - neq
```
public IloConstraint neq(IloIntExpr e,
                int v)
```
    Creates and returns the new constraint e != v.
  - neq
```
public IloConstraint neq(IloIntExpr e1,
                IloIntExpr e2)
```
    Creates and returns the new constraint e1 != e2.
  - neq
```
public IloConstraint neq(int v,
                IloIntExpr e)
```
    Creates and returns the new constraint v != e.
  - pack
```
public IloConstraint pack(IloIntExpr[] load,
                 IloIntExpr[] where,
                 int[] weight)
                   throws IloException
```
    Creates and returns a pack constraint which maintains the load of a set of containers or bins, given a set of weighted items and an assignment of items to containers. Consider that we have n items and m containers. Each item i has an integer weight weight[i] and a constrained integer variable where[i] associated with it, indicating in which container (numbered contiguously from 0) item i is to be placed. No item can be split up, and so an item can go in only one container. Associated with each container j is an integer variable load[j] representing the load in that container; that is, the sum of the weights of the items which have been assigned to that container. A capacity can be set for each container placing an upper bound on this load variable. The constraint also ensures that the total sum of the loads of the containers is equal to the sum of the weights of the items being placed.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
    Parameters:
    load - For each c, load[c] contains the sum of the weights of all items which are in the container c, * i.e. weight[i] = c.
    where - Indicates in which container item i is placed
    weight - Weight of the items
    
    Returns:
    The newly created constraint.
  - pack
```
public IloConstraint pack(IloIntExpr[] load,
                 IloIntExpr[] where,
                 int[] weight,
                 IloIntExpr used)
                   throws IloException
```
    Creates and returns a pack constraint which maintains the load of a set of containers or bins, given a set of weighted items and an assignment of items to containers.
    Consider that we have n items and m containers. Each item i has an integer weight weight[i] and a constrained integer variable where[i] associated with it, indicating in which container (numbered contiguously from 0) item i is to be placed. No item can be split up, and so an item can go in only one container. Associated with each container j is an integer variable load[j] representing the load in that container; that is, the sum of the weights of the items which have been assigned to that container. A capacity can be set for each container placing an upper bound on this load variable. The constraint also ensures that the total sum of the loads of the containers is equal to the sum of the weights of the items being placed.
    
    Finally, the number, or indeed the set of containers used can be specified by the integer expression used. A container is used if at least one item is placed in the container in question.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
    Parameters:
    load - For each c, load[c] contains the sum of the weights of all items which are in the container c, * i.e. weight[i] = c.
    where - Indicates in which container item i is placed
    weight - Weight of the items
    used - Number of containers that are used in the pack (whose load is not zero)
    
    Returns:
    The newly created constraint.
  - allowedAssignments
```
public IloConstraint allowedAssignments(IloIntVar[] exps,
                               IloIntTupleSet table)
                                 throws IloException
```
    Creates and returns a new constraint based on explicitly stating the allowed assignments for a small group of variables. The allowed assignments are the values that satisfy the constraint; the argument table specifies the combinations of allowed values of the variables, exps. The order of the constrained variables in the array vars is important because the same order is respected in the set. To avoid exceptions, the size of vars must be the same as the arity of the set.
    
    Throws:
    
    IloException
  - allowedAssignments
```
public IloConstraint allowedAssignments(IloIntExpr exp,
                               int[] values)
                                 throws IloException
```
    Creates and returns a new constraint based on explicitly stating the allowed assignments (values) for a single expression. The argument values specifies the allowed values of the expression exp.
    
    Throws:
    
    IloException
  - forbiddenAssignments
```
public IloConstraint forbiddenAssignments(IloIntVar[] exps,
                                 IloIntTupleSet table)
                                   throws IloException
```
    Creates and returns a new constraint based on explicitly stating the forbidden assignments for a small group of variables. The forbidden assignments are the value combinations that violate the constraint; the argument table specifies the combinations of forbidden values of the variables, exps. The order of the constrained variables in the array vars is important because the same order is respected in the set. To avoid exceptions, the size of vars must be the same as the arity of the set.
    
    Throws:
    
    IloException
  - forbiddenAssignments
```
public IloConstraint forbiddenAssignments(IloIntExpr exp,
                                 int[] values)
                                   throws IloException
```
    Creates and returns a new constraint based on explicitly stating the forbidden assignments (values) for a single variable. The argument values specifies the forbidden values of the variable exp.
    
    Throws:
    
    IloException
  - strong
```
public IloConstraint strong(IloIntVar[] vars)
                     throws IloException
```
    An instance of a strong constraint strengthens the model on the variables of the array given as argument. This is done by creating an allowedAssignments(IloIntExpr, int[]) constraint in place of the strong constraint. The replacing constraint contains the solution tuples of the model on the variables of the array given as argument. It achieves the strongest domain reduction algorithm for these variables. Constraints that can be identified as redundant taken together with this new constraint are removed. This is the case for constraints that are only over the variables of the array given as argument.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
    See Also:
    IloConstraint
  - equiv
```
public IloConstraint equiv(IloConstraint c1,
                  IloConstraint c2)
                    throws IloException
```
    Creates and returns the new constraint c1 <=> c2, in which the two constraints c1 and c2 are equivalent.
    
    Throws:
    
    IloException
    Parameters:
    c1 - The first constraint.
    c2 - The other constraint.
  - ifThenElse
```
public IloConstraint ifThenElse(IloConstraint c1,
                       IloConstraint c2,
                       IloConstraint c3)
                         throws IloException
```
    Creates and returns the new constraint (c1 => c2) && (! c1 => c3), that is, if the first constraint is satisfied, it implies the second, and if it is violated, it implies the third.
    
    Throws:
    
    IloException
    Parameters:
    c1 - The condition constraint.
    c2 - The constraint implied if the condition is satisfied.
    c3 - The constraint implied if the condition is not satisfied.
  - imply
```
public IloConstraint imply(IloConstraint c1,
                  IloConstraint c2)
                    throws IloException
```
    Creates and returns the new constraint c1 => c2, that is, the first constraint implies the other.
    
    Throws:
    
    IloException
    Parameters:
    c1 - the first constraint
    c2 - the other constraint
  - neq
```
public IloConstraint neq(IloConstraint c1,
                IloConstraint c2)
                  throws IloException
```
    Creates and returns the new constraint c1 <=> !c2; that is, the truth values of c1 and c2 should be different.
    
    Throws:
    
    IloException
  - intExpr
```
public IloIntExpr intExpr(IloConstraint ct)
                   throws IloException
```
    Creates and returns a new IloIntExpr from the ct.
    
    Throws:
    
    IloException
  - intExprArray
```
public IloIntExpr[] intExprArray(int n)
                          throws IloException
```
    Creates and returns an array of null expressions.
    
    Throws:
    
    IloException
  - numExprArray
```
public IloNumExpr[] numExprArray(int n)
```
    Creates and returns an array of null expressions.
  - constant
```
public IloIntExpr constant(int value,
                  java.lang.String name)
                    throws IloException
```
    Creates and returns a new constant expression equal to value.
    
    Throws:
    
    IloException
    Parameters:
    value - The value of the constant expression.
    name - The name of the expression.
    
    Returns:
    The constant expression.
  - constant
```
public IloNumExpr constant(double value,
                  java.lang.String name)
                    throws IloException
```
    Creates and returns a new constant expression equal to value.
    
    Throws:
    
    IloException
    Parameters:
    value - The value of the constant expression.
    name - The name of the expression.
    
    Returns:
    The constant expression.
  - count
```
public IloIntExpr count(IloIntExpr[] exprs,
               int v)
                 throws IloException
```
    This method creates a new constrained integer expression equal to the number of variables in exprs that are fixed to the value v.
    
    Throws:
    
    IloException
  - countDifferent
```
public IloIntExpr countDifferent(IloIntExpr[] exprs)
                          throws IloException
```
    This method creates a new constrained integer expression equal to the number of different values assigned to the variables in exprs.
    
    Throws:
    
    IloException
  - div
```
public IloIntExpr div(IloIntExpr e1,
             IloIntExpr e2)
```
    Creates and returns the integer division e1 / e2.
  - div
```
public IloIntExpr div(int e1,
             IloIntExpr e2)
```
    Creates and returns the integer division e1 / e2.
  - div
```
public IloIntExpr div(IloIntExpr e1,
             int e2)
```
    Creates and returns the integer division e1 / e2.
  - element
```
public IloIntExpr element(IloIntExpr[] exprs,
                 IloIntExpr index)
                   throws IloException
```
    Creates and returns a new integer expression equal to exprs[index].
    
    Throws:
    
    IloException
    Parameters:
    exprs - The array of expressions
    index - The index expression.
  - element
```
public IloIntExpr element(int[] values,
                 IloIntExpr index)
                   throws IloException
```
    Creates and returns a new integer expression equal to values[index].
    
    Throws:
    
    IloException
    Parameters:
    values - The array of values.
    index - The index expression.
  - element
```
public IloNumExpr element(double[] values,
                 IloIntExpr index)
                   throws IloException
```
    Creates and returns a new expression equal to values[index].
    
    Throws:
    
    IloException
    Parameters:
    values - The array of values.
    index - The index expression.
  - exponent
```
public IloNumExpr exponent(IloNumExpr e)
```
    Creates and returns the new expression exp(e).
  - log
```
public IloNumExpr log(IloNumExpr e)
```
    Creates and returns the new expression log(e).
  - max
```
public IloIntExpr max(IloIntExpr[] exprs)
               throws IloException
```
    Creates and returns the new expression max(expr).
    
    Specified by:
    
    max in interface IloModeler
    
    Overrides:
    
    max in class ilog.concert.IloModelerImpl
    
    Throws:
    
    IloException
    Parameters:
    exprs - the array of expressions
  - max
```
public IloNumExpr max(IloNumExpr[] exprs)
               throws IloException
```
    Creates and returns the new numeric expression max(expr), the maximum over the array.
    
    Specified by:
    
    max in interface IloModeler
    
    Overrides:
    
    max in class ilog.concert.IloModelerImpl
    
    Throws:
    
    IloException
    Parameters:
    exprs - The array of expressions.
  - min
```
public IloIntExpr min(IloIntExpr[] exprs)
               throws IloException
```
    Creates and returns the new expression min(exprs).
    
    Specified by:
    
    min in interface IloModeler
    
    Overrides:
    
    min in class ilog.concert.IloModelerImpl
    
    Throws:
    
    IloException
  - min
```
public IloNumExpr min(IloNumExpr[] exprs)
               throws IloException
```
    Creates and returns the new numeric expression min(exprs), the minimum over the array.
    
    Specified by:
    
    min in interface IloModeler
    
    Overrides:
    
    min in class ilog.concert.IloModelerImpl
    
    Throws:
    
    IloException
  - modulo
```
public IloIntExpr modulo(IloIntExpr e,
                int r)
                  throws IloException
```
    Creates and returns the modulo expression e % r.
    
    Throws:
    
    IloException
  - power
```
public IloNumExpr power(IloNumExpr e1,
               IloNumExpr e2)
```
    Creates and returns the new expression e1 ^ e2. e1 is constrained to be greater than 0 (zero). If e2 is 0 (zero), the expression will take the value 1 (one).
  - power
```
public IloNumExpr power(IloNumExpr e1,
               double e2)
```
    Creates and returns the new expression e1 ^ e2. If e2 is not an integer, then e1 is constrained to be greater than 0 (zero). If e2 is 0 (zero), the expression will take the value 1 (one).
  - power
```
public IloNumExpr power(double e1,
               IloNumExpr e2)
```
    Creates and returns the new expression e1 ^ e2. e1 must be greater than 0 (zero). If e2 is 0 (zero), the expression will take the value 1 (one).
  - prod
```
public IloIntExpr prod(int[] values,
              IloIntExpr[] exps)
                throws IloException
```
    Returns an expression equal to the scalar product of values and exps; that is, values[0]*exps[0] + values[1]*exps[1] + ...
    
    Throws:
    
    IloException
  - prod
```
public IloIntExpr prod(IloIntExpr[] exps1,
              IloIntExpr[] exps2)
                throws IloException
```
    Returns an expression equal to the scalar product of exps1 and exps2, that is, exps1[0]*exps2[0] + exps1[1]*exps2[1] + ...
    
    Throws:
    
    IloException
  - prod
```
public IloIntExpr prod(IloIntExpr[] exps,
              int[] values)
                throws IloException
```
    Returns an expression equal to the scalar product of values and exps, that is, values[0]*exps[0] + values[1]*exps[1] + ...
    
    Throws:
    
    IloException
  - prod
```
public IloNumExpr prod(double[] values,
              IloNumExpr[] exps)
                throws IloException
```
    Returns an expression equal to the scalar product of values and exps, that is, values[0]*exps[0] + values[1]*exps[1] + ...
    
    Throws:
    
    IloException
  - prod
```
public IloNumExpr prod(IloNumExpr[] exps,
              double[] values)
                throws IloException
```
    Returns an expression equal to the scalar product of values and exps, that is, values[0]*exps[0] + values[1]*exps[1] + ...
    
    Throws:
    
    IloException
  - quot
```
public IloNumExpr quot(IloNumExpr e1,
              IloNumExpr e2)
```
    Creates and returns the new expression e1 / e2.
  - quot
```
public IloNumExpr quot(double e1,
              IloNumExpr e2)
```
    Creates and returns the new expression e1 / e2.
  - quot
```
public IloNumExpr quot(IloNumExpr e1,
              double e2)
```
    Creates and returns the new expression e1 / e2.
  - prod
```
public IloNumExpr prod(IloNumExpr[] exps1,
              IloNumExpr[] exps2)
                throws IloException
```
    Returns an expression equal to the scalar product of exps1 and exps2, that is, exps1[0]*exps2[0] + exps1[1]*exps2[1] + ...
    
    Throws:
    
    IloException
  - sum
```
public IloIntExpr sum(IloIntExpr[] exprs)
               throws IloException
```
    Creates and returns an integer expression representing the sum of the expressions provided in the array exprs.
    
    Specified by:
    
    sum in interface IloModeler
    
    Overrides:
    
    sum in class ilog.concert.IloModelerImpl
    
    Throws:
    
    IloException
    Parameters:
    exprs - An array containing the expressions to be summed.
    
    Returns:
    An integer expression representing the sum of the specified expressions.
  - sum
```
public IloNumExpr sum(IloNumExpr[] exprs)
               throws IloException
```
    Creates and returns an expression representing the sum of the expressions provided as terms in the array expr.
    
    Specified by:
    
    sum in interface IloModeler
    
    Overrides:
    
    sum in class ilog.concert.IloModelerImpl
    
    Throws:
    
    IloException
    Parameters:
    exprs - An array containing the terms to be summed.
    
    Returns:
    An expression representing the sum of the specified terms.
  - standardDeviation
```
public IloNumExpr standardDeviation(IloIntExpr[] exprs)
                             throws IloException
```
    This method creates a new constrained numeric expression which is equal to the standard deviation of the values of the variables in the array exprs.
    
    Throws:
    
    IloException
  - standardDeviation
```
public IloNumExpr standardDeviation(IloIntExpr[] exprs,
                           double meanLB,
                           double meanUB)
                             throws IloException
```
    This method creates a new constrained numeric expression which is equal to the standard deviation of the values of the variables in the array exprs.
    In addition, the mean of the values of exprs will be enforced to lie in the range [meanLB, meanUB]
    
    Throws:
    
    IloException
  - standardDeviation
```
public IloNumExpr standardDeviation(ilog.concert.IloIntExprArray exprs,
                           double meanLB,
                           double meanUB)
                             throws IloException
```
    Throws:
    
    IloException
  - piecewiseLinear
```
public IloNumExpr piecewiseLinear(IloNumExpr e,
                         double[] point,
                         double[] slope,
                         double a,
                         double fa)
                           throws IloException
```
    This method creates an expression to represent a continuous or discontinuous piecewise linear function f of the variable e.
    
    This signature specifies the breakpoints and slopes of the segments of the PWL function. The array point contains the n breakpoints of the function such that point[i-1] <= point[i] for i = 1, . . . , n-1. The array slope contains the n+1 slopes of the n+1 segments of the function. The values a and fa must be coordinates of a point such that fa = f(a). The specified piecewise linear function can be either continuous or discontinuous.
    
    When point[i] is equal to point[i+1] the function has a step at point[i] and is discontinuous, then the value slope[i] represents the height of that step. The argument a cannot be the coordinate of a step. In other words, a must not be the point[i] if point[i] == point[i-1] or if point[i] == point[i+1].
    
    Example
```
   double[] point = new double[2]; point[0] = 10.; point[1] = 20.;
   double[] slope = new double[3]; slope[0] = 0.3; slope[1] = 1.; slope[2] = 2.;
   cp.piecewiseLinear(x, point, slope, 0, 0);
 
```
    This expression defines a piecewise linear function f having two breakpoints at x = 10 and x = 20, and three segments; their slopes are 0.3, 1, and 2. The first segment has infinite length and ends at the point (x = 10, f(x) = 3) since f(0) = 0. The second segment starts at the point (x = 10, f(x) = 3) and ends at the point (x = 20, f(x) = 13), where the third segment starts.
    Throws:
    
    IloException
  - piecewiseLinear
```
public IloNumExpr piecewiseLinear(IloNumExpr e,
                         double firstSlope,
                         double[] point,
                         double[] value,
                         double lastSlope)
                           throws IloException
```
    This method creates an expression to represent a continuous or discontinuous piecewise linear function f of the variable e.
    
    This signatures of the method specifies the breakpoints and function values of the segments.
    
    In this approach, the array point also contains the n breakpoints of the PWL function. The array value contains the corresponding n values of the function. The argument firstSlope specifies the slope of the segment to the left of the first breakpoint; the argument lastSlope specifies the slope of the segment to the right of the final breakpoint.
    
    Throws:
    
    IloException
  - startBeforeStart
```
public IloConstraint startBeforeStart(IloIntervalVar a,
                             IloIntervalVar b)
                               throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-start(a)between the start of interval a and the start of interval b must be greater than or equal to 0.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startBeforeStart
```
public IloConstraint startBeforeStart(IloIntervalVar a,
                             IloIntervalVar b,
                             int z)
                               throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-start(a)between the start of interval a and the start of interval b must be greater than or equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startBeforeStart
```
public IloConstraint startBeforeStart(IloIntervalVar a,
                             IloIntervalVar b,
                             IloIntExpr z)
                               throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-start(a)between the start of interval a and the start of interval b must be greater than or equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startBeforeEnd
```
public IloConstraint startBeforeEnd(IloIntervalVar a,
                           IloIntervalVar b)
                             throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-start(a)between the start of interval a and the end of interval b must be greater than or equal to 0.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startBeforeEnd
```
public IloConstraint startBeforeEnd(IloIntervalVar a,
                           IloIntervalVar b,
                           int z)
                             throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-start(a)between the start of interval a and the end of interval b must be greater than or equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startBeforeEnd
```
public IloConstraint startBeforeEnd(IloIntervalVar a,
                           IloIntervalVar b,
                           IloIntExpr z)
                             throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-start(a)between the start of interval a and the end of interval b must be greater than or equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endBeforeStart
```
public IloConstraint endBeforeStart(IloIntervalVar a,
                           IloIntervalVar b)
                             throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-end(a)between the end of interval a and the start of interval b must be greater than or equal to 0.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endBeforeStart
```
public IloConstraint endBeforeStart(IloIntervalVar a,
                           IloIntervalVar b,
                           int z)
                             throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-end(a)between the end of interval a and the start of interval b must be greater than or equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endBeforeStart
```
public IloConstraint endBeforeStart(IloIntervalVar a,
                           IloIntervalVar b,
                           IloIntExpr z)
                             throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-end(a)between the end of interval a and the start of interval b must be greater than or equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endBeforeEnd
```
public IloConstraint endBeforeEnd(IloIntervalVar a,
                         IloIntervalVar b)
                           throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-end(a)between the end of interval a and the end of interval b must be greater than or equal to 0.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endBeforeEnd
```
public IloConstraint endBeforeEnd(IloIntervalVar a,
                         IloIntervalVar b,
                         int z)
                           throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-end(a)between the end of interval a and the end of interval b must be greater than or equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endBeforeEnd
```
public IloConstraint endBeforeEnd(IloIntervalVar a,
                         IloIntervalVar b,
                         IloIntExpr z)
                           throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-end(a)between the end of interval a and the end of interval b must be greater than or equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startAtStart
```
public IloConstraint startAtStart(IloIntervalVar a,
                         IloIntervalVar b)
                           throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-start(a)between the start of interval a and the start of interval b must be equal to 0.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startAtStart
```
public IloConstraint startAtStart(IloIntervalVar a,
                         IloIntervalVar b,
                         int z)
                           throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-start(a)between the start of interval a and the start of interval b must be equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startAtStart
```
public IloConstraint startAtStart(IloIntervalVar a,
                         IloIntervalVar b,
                         IloIntExpr z)
                           throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-start(a)between the start of interval a and the start of interval b must be equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startAtEnd
```
public IloConstraint startAtEnd(IloIntervalVar a,
                       IloIntervalVar b)
                         throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-start(a)between the start of interval a and the end of interval b must be equal to 0.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startAtEnd
```
public IloConstraint startAtEnd(IloIntervalVar a,
                       IloIntervalVar b,
                       int z)
                         throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-start(a)between the start of interval a and the end of interval b must be equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - startAtEnd
```
public IloConstraint startAtEnd(IloIntervalVar a,
                       IloIntervalVar b,
                       IloIntExpr z)
                         throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-start(a)between the start of interval a and the end of interval b must be equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endAtStart
```
public IloConstraint endAtStart(IloIntervalVar a,
                       IloIntervalVar b)
                         throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-end(a)between the end of interval a and the start of interval b must be equal to 0.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endAtStart
```
public IloConstraint endAtStart(IloIntervalVar a,
                       IloIntervalVar b,
                       int z)
                         throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-end(a)between the end of interval a and the start of interval b must be equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endAtStart
```
public IloConstraint endAtStart(IloIntervalVar a,
                       IloIntervalVar b,
                       IloIntExpr z)
                         throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance start(b)-end(a)between the end of interval a and the start of interval b must be equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endAtEnd
```
public IloConstraint endAtEnd(IloIntervalVar a,
                     IloIntervalVar b)
                       throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-end(a)between the end of interval a and the end of interval b must be equal to 0.
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endAtEnd
```
public IloConstraint endAtEnd(IloIntervalVar a,
                     IloIntervalVar b,
                     int z)
                       throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-end(a)between the end of interval a and the end of interval b must be equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - endAtEnd
```
public IloConstraint endAtEnd(IloIntervalVar a,
                     IloIntervalVar b,
                     IloIntExpr z)
                       throws IloException
```
    This method returns a constraint that states that whenever both interval variables a and b are present, the distance end(b)-end(a)between the end of interval a and the end of interval b must be equal to z.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - presenceOf
```
public IloConstraint presenceOf(IloIntervalVar a)
                         throws IloException
```
    This method returns a constraint that states that interval variable a is present.
    
    Typically, this constraint is used in combination with other constraints.
    
    Throws:
    
    IloException
  - forbidStart
```
public IloConstraint forbidStart(IloIntervalVar a,
                        IloNumToNumStepFunction f)
                          throws IloException
```
    This method returns a constraint that states that whenever interval variable a is present, it cannot start at a value t such that f(t)=0.
    
    Typically, this constraint can be used in combination with an intensity function to state that the interval variable cannot start at a point where its intensity function is null.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - forbidEnd
```
public IloConstraint forbidEnd(IloIntervalVar a,
                      IloNumToNumStepFunction f)
                        throws IloException
```
    This method returns a constraint that states that whenever interval variable a is present, it cannot end at a value t such that f(t-1)=0.
    
    Typically, this constraint can be used in combination with an intensity function to state that the interval variable cannot end at a point where its intensity function is null.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - forbidExtent
```
public IloConstraint forbidExtent(IloIntervalVar a,
                         IloNumToNumStepFunction f)
                           throws IloException
```
    This method returns a constraint that states that whenever interval variable a is present, it cannot contain a value t such that f(t)=0.
    
    Typically, this constraint can be used in combination with an intensity function to state that the interval variable cannot overlap intervals where its intensity function is null.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - previous
```
public IloConstraint previous(IloIntervalSequenceVar seq,
                     IloIntervalVar prev,
                     IloIntervalVar next)
                       throws IloException
```
    This method returns a constraint that states that whenever both interval variables prev and next are present, interval variable prev must be ordered immediately before interval variable next in the sequence variable seq.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - first
```
public IloConstraint first(IloIntervalSequenceVar seq,
                  IloIntervalVar a)
                    throws IloException
```
    This method returns a constraint that states that whenever interval variable a is present, it must be ordered first in the sequence variable seq.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - last
```
public IloConstraint last(IloIntervalSequenceVar seq,
                 IloIntervalVar a)
                   throws IloException
```
    This method returns a constraint that states that whenever interval variable a is present, it must be ordered last in the sequence variable seq.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - before
```
public IloConstraint before(IloIntervalSequenceVar seq,
                   IloIntervalVar pred,
                   IloIntervalVar succ)
                     throws IloException
```
    This method returns a constraint that states that whenever both interval variables pred and succ are present, interval variable pred must be ordered before interval variable succ (but not necessarily immediately before) in the sequence variable seq.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - sameSequence
```
public IloConstraint sameSequence(IloIntervalSequenceVar seq1,
                         IloIntervalSequenceVar seq2)
                           throws IloException
```
    This function creates a same-sequence constraint between sequence variables seq1 and seq2. Sequence variables seq1 and seq2 should be of the same size. The mapping between interval variables of the two sequences is given by the order of the interval variables in the arrays a1 and a2 used in the definition of the sequences. The constraint states that the two sequences seq1 and seq2 are identical modulo a mapping between intervals a1[i] and a2[i].
    
    Note: This constraint cannot be used in a logical constraint.
    
    For more information on this constraint, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sameSequence
```
public IloConstraint sameSequence(IloIntervalSequenceVar seq1,
                         IloIntervalSequenceVar seq2,
                         java.lang.String name)
                           throws IloException
```
    This function creates a same-sequence constraint between sequence variables seq1 and seq2. Sequence variables seq1 and seq2 should be of the same size. The mapping between interval variables of the two sequences is given by the order of the interval variables in the arrays a1 and a2 used in the definition of the sequences. The constraint states that the two sequences seq1 and seq2 are identical modulo a mapping between intervals a1[i] and a2[i]. You can specify a name of your own choice for the constraint.
    
    Note: This constraint cannot be used in a logical constraint.
    
    For more information on this constraint, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sameSequence
```
public IloConstraint sameSequence(IloIntervalSequenceVar seq1,
                         IloIntervalSequenceVar seq2,
                         IloIntervalVar[] a1,
                         IloIntervalVar[] a2)
                           throws IloException
```
    This function creates a same-sequence constraint between sequence variables seq1 and seq2. Sequence variables seq1 and seq2 should be of the same size n. The mapping between interval variables of the two sequences is specified by arrays a1 and a2. Arrays a1 and a2 should be of same size n. The constraint states that the two sequences seq1 and seq2 are identical modulo a mapping between intervals a1[i] and a2[i].
    
    Note: This constraint cannot be used in a logical constraint.
    
    For more information on this constraint, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sameSequence
```
public IloConstraint sameSequence(IloIntervalSequenceVar seq1,
                         IloIntervalSequenceVar seq2,
                         IloIntervalVar[] a1,
                         IloIntervalVar[] a2,
                         java.lang.String name)
                           throws IloException
```
    This function creates a same-sequence constraint between sequence variables seq1 and seq2. Sequence variables seq1 and seq2 should be of the same size n. The mapping between interval variables of the two sequences is specified by arrays a1 and a2. Arrays a1 and a2 should be of same size n. The constraint states that the two sequences seq1 and seq2 are identical modulo a mapping between intervals a1[i] and a2[i]. You can specify a name of your own choice for the constraint.
    
    Note: This constraint cannot be used in a logical constraint.
    
    For more information on this constraint, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sameCommonSubsequence
```
public IloConstraint sameCommonSubsequence(IloIntervalSequenceVar seq1,
                                  IloIntervalSequenceVar seq2)
                                    throws IloException
```
    This function creates a same-common-subsequence constraint between sequence variables seq1 and seq2. Sequence variables seq1 and seq2 should be of the same size. The mapping between interval variables of the two sequences is given by the order of the interval variables in the arrays a1 and a2 used in the definition of the sequences. The constraint states that the sub-sequences defined by seq1 and seq2 by only considering the pairs of present intervals (a1[i],a2[i]) are identical modulo the mapping between intervals a1[i] and a2[i].
    
    Note: This constraint cannot be used in a logical constraint.
    
    For more information on this constraint, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sameCommonSubsequence
```
public IloConstraint sameCommonSubsequence(IloIntervalSequenceVar seq1,
                                  IloIntervalSequenceVar seq2,
                                  java.lang.String name)
                                    throws IloException
```
    This function creates a same-common-subsequence constraint between sequence variables seq1 and seq2. Sequence variables seq1 and seq2 should be of the same size. The mapping between interval variables of the two sequences is given by the order of the interval variables in the arrays a1 and a2 used in the definition of the sequences. The constraint states that the sub-sequences defined by seq1 and seq2 by only considering the pairs of present intervals (a1[i],a2[i]) are identical modulo the mapping between intervals a1[i] and a2[i]. You can specify a name of your own choice for the constraint.
    
    Note: This constraint cannot be used in a logical constraint.
    
    For more information on this constraint, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sameCommonSubsequence
```
public IloConstraint sameCommonSubsequence(IloIntervalSequenceVar seq1,
                                  IloIntervalSequenceVar seq2,
                                  IloIntervalVar[] a1,
                                  IloIntervalVar[] a2)
                                    throws IloException
```
    This function creates a same-common-subsequence constraint between sequence variables seq1 and seq2. The mapping between interval variables of the two sequences is specified by arrays a1 and a2, those two arrays should be of the same size. Array a1 must only contain interval variables of sequence seq1 without any duplicate and array a2 must only contain interval variables of sequence seq2 without any duplicate. The constraint states that the sub-sequences defined by seq1 and seq2 by only considering the pairs of present intervals (a1[i],a2[i]) are identical modulo the mapping between intervals a1[i] and a2[i].
    
    Note: This constraint cannot be used in a logical constraint.
    
    For more information on this constraint, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sameCommonSubsequence
```
public IloConstraint sameCommonSubsequence(IloIntervalSequenceVar seq1,
                                  IloIntervalSequenceVar seq2,
                                  IloIntervalVar[] a1,
                                  IloIntervalVar[] a2,
                                  java.lang.String name)
                                    throws IloException
```
    This function creates a same-common-subsequence constraint between sequence variables seq1 and seq2. The mapping between interval variables of the two sequences is specified by arrays a1 and a2, those two arrays should be of the same size. Array a1 must only contain interval variables of sequence seq1 without any duplicate and array a2 must only contain interval variables of sequence seq2 without any duplicate. The constraint states that the sub-sequences defined by seq1 and seq2 by only considering the pairs of present intervals (a1[i],a2[i]) are identical modulo the mapping between intervals a1[i] and a2[i]. You can specify a name of your own choice for the constraint.
    
    Note: This constraint cannot be used in a logical constraint.
    
    For more information on this constraint, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - alwaysIn
```
public IloConstraint alwaysIn(IloCumulFunctionExpr f,
                     int start,
                     int end,
                     int vmin,
                     int vmax)
                       throws IloException
```
    This method returns a constraint that states that the value of cumul function expression f should be always within the range [vmin,vmax] between start and end. Values vmin and vmax must be in range 0..IloCP.IntervalMax.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysIn
```
public IloConstraint alwaysIn(IloCumulFunctionExpr f,
                     IloIntervalVar a,
                     int vmin,
                     int vmax)
                       throws IloException
```
    This method returns a constraint that states that whenever interval variable a is present, the value of cumul function expression f should be always within the range [vmin,vmax] between the start and the end of a. Values vmin and vmax must be in range 0..IloCP.IntervalMax.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysEqual
```
public IloConstraint alwaysEqual(IloCumulFunctionExpr f,
                        int start,
                        int end,
                        int v)
                          throws IloException
```
    This method returns a constraint that states that the value of cumul function expression f should be always equal to v between start and end. Value v must be in range 0..IloCP.IntervalMax.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysEqual
```
public IloConstraint alwaysEqual(IloCumulFunctionExpr f,
                        IloIntervalVar a,
                        int v)
                          throws IloException
```
    This method returns a constraint that states that whenever interval variable a is present, the value of cumul function expression f should be always equal to v between the start and the end of a. Value v must be in range 0..IloCP.IntervalMax.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - le
```
public IloConstraint le(IloCumulFunctionExpr f,
               int vmax)
```
    This method returns a constraint that states that the value of cumul function expression f should never be greater than vmax.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Overrides:
    
    le in class ilog.concert.IloModelerImpl
  - le
```
public IloConstraint le(IloCumulFunctionExpr f,
               IloIntExpr vmax)
```
    This method returns a constraint that states that the value of cumul function expression f should never be greater than vmax.
    
    Note: This constraint cannot be used in a logical constraint.
  - le
```
public IloConstraint le(int vmin,
               IloCumulFunctionExpr f)
```
    This method returns a constraint that states that the value of cumul function expression f should never be less than than vmin.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Overrides:
    
    le in class ilog.concert.IloModelerImpl
  - le
```
public IloConstraint le(IloIntExpr vmin,
               IloCumulFunctionExpr f)
```
    This method returns a constraint that states that the value of cumul function expression f should never be less than than vmin.
    
    Note: This constraint cannot be used in a logical constraint.
  - ge
```
public IloConstraint ge(int vmax,
               IloCumulFunctionExpr f)
```
    This method returns a constraint that states that the value of cumul function expression f should never be greater than vmax.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Overrides:
    
    ge in class ilog.concert.IloModelerImpl
  - ge
```
public IloConstraint ge(IloIntExpr vmax,
               IloCumulFunctionExpr f)
```
    This method returns a constraint that states that the value of cumul function expression f should never be greater than vmax.
    
    Note: This constraint cannot be used in a logical constraint.
  - ge
```
public IloConstraint ge(IloCumulFunctionExpr f,
               int vmin)
```
    This method returns a constraint that states that the value of cumul function expression f should never be less than vmin.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Overrides:
    
    ge in class ilog.concert.IloModelerImpl
  - ge
```
public IloConstraint ge(IloCumulFunctionExpr f,
               IloIntExpr vmin)
```
    This method returns a constraint that states that the value of cumul function expression f should never be less than vmin.
    
    Note: This constraint cannot be used in a logical constraint.
  - alwaysNoState
```
public IloConstraint alwaysNoState(IloStateFunction f,
                          int start,
                          int end)
                            throws IloException
```
    This method returns a constraint that ensures that state function f is undefined everywhere on the interval of integers [start,end). This constraint will ensure, in particular, that no interval variable that requires the function to be defined (see alwaysEqual, alwaysConstant) can overlap the interval [start,end).
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysNoState
```
public IloConstraint alwaysNoState(IloStateFunction f,
                          IloIntervalVar a)
                            throws IloException
```
    This method returns a constraint that ensures that whenever interval variable a is present state function f is undefined everywhere between the start and the end of interval variable a. This constraint will ensure, in particular, that no interval variable that requires the function to be defined (see alwaysEqual, alwaysConstant) can overlap interval variable a.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysIn
```
public IloConstraint alwaysIn(IloStateFunction f,
                     int start,
                     int end,
                     int vmin,
                     int vmax)
                       throws IloException
```
    This method returns a constraint that ensures that, if it is defined, the value of state function f remains in the range [vmin,vmax] for any point t in the interval of integers [start,end).
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysIn
```
public IloConstraint alwaysIn(IloStateFunction f,
                     IloIntervalVar a,
                     int vmin,
                     int vmax)
                       throws IloException
```
    This method returns a constraint that ensures that whenever interval variable a is present, the value of state function f, if defined, remains in the range [vmin,vmax] for any point t between the start and the end of interval variable a.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysConstant
```
public IloConstraint alwaysConstant(IloStateFunction f,
                           int start,
                           int end,
                           boolean startAlign,
                           boolean endAlign)
                             throws IloException
```
    This method returns a constraint that ensures that state function f is defined everywhere on the interval [start,end) and remains constant over this interval.
    
    Generally speaking, the optional boolean values startAlign and endAlign allow synchronizing start and end with the intervals of the state function:
    - When startAlign is true, it means that start must be the start of an interval of the state function.
    - When endAlign is true, it means that end must be the end of an interval of the state function.
    Note: This constraint cannot be used in a logical constraint.
    Throws:
    
    IloException
  - alwaysConstant
```
public IloConstraint alwaysConstant(IloStateFunction f,
                           int start,
                           int end)
                             throws IloException
```
    This method returns a constraint that ensures that state function f is defined everywhere on the interval [start,end) and remains constant over this interval.
    
    As the optional boolean values startAlign and endAlign are not specified, start and end are not required to be synchronized with the intervals of the state function.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysConstant
```
public IloConstraint alwaysConstant(IloStateFunction f,
                           IloIntervalVar a,
                           boolean startAlign,
                           boolean endAlign)
                             throws IloException
```
    This method returns a constraint that ensures that whenever interval variable a is present state function f is defined everywhere between the start and the end of interval variable a and remains constant over this interval.
    
    Generally speaking, the optional boolean values startAlign and endAlign allow synchronizing the start and end of interval variable a with the intervals of the state function:
    - When startAlign is true, it means that whenever interval variable a is present, the start of a must be the start of an interval of the state function.
    - When endAlign is true, it means that whenever interval variable a is present, the end of a must be the end of an interval of the state function.
    Note: This constraint cannot be used in a logical constraint.
    Throws:
    
    IloException
  - alwaysConstant
```
public IloConstraint alwaysConstant(IloStateFunction f,
                           IloIntervalVar a)
                             throws IloException
```
    This method returns a constraint that ensures that whenever interval variable a is present state function f is defined everywhere between the start and the end of interval variable a and remains constant over this interval.
    
    As the optional boolean values startAlign and endAlign are not specified, the start and end of a are not required to be synchronized with the intervals of the state function.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysEqual
```
public IloConstraint alwaysEqual(IloStateFunction f,
                        int start,
                        int end,
                        int v,
                        boolean startAlign,
                        boolean endAlign)
                          throws IloException
```
    This method returns a constraint that ensures that state function f is defined everywhere on the interval [start,end) and remains equal to value v over this interval.
    
    Generally speaking, the optional boolean values startAlign and endAlign allow synchronizing start and end with the intervals of the state function:
    - When startAlign is true, it means that start must be the start of an interval of the state function.
    - When endAlign is true, it means that end must be the end of an interval of the state function.
    Note: This constraint cannot be used in a logical constraint.
    Throws:
    
    IloException
  - alwaysEqual
```
public IloConstraint alwaysEqual(IloStateFunction f,
                        int start,
                        int end,
                        int v)
                          throws IloException
```
    This method returns a constraint that ensures that state function f is defined everywhere on the interval [start,end) and remains equal to value v over this interval.
    
    As the optional boolean values startAlign and endAlign are not specified, start and end are not required to be synchronized with the intervals of the state function.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alwaysEqual
```
public IloConstraint alwaysEqual(IloStateFunction f,
                        IloIntervalVar a,
                        int v,
                        boolean startAlign,
                        boolean endAlign)
                          throws IloException
```
    This method returns a constraint that ensures that whenever interval variable a is present state function f is defined everywhere between the start and the end of interval variable a and remains equal to value v over this interval.
    
    Generally speaking, the optional boolean values startAlign and endAlign allow synchronizing the start and end of interval variable a with the intervals of the state function:
    - When startAlign is true, it means that whenever interval variable a is present, the start of a must be the start of an interval of the state function.
    - When endAlign is true, it means that whenever interval variable a is present, the end of a must be the end of an interval of the state function.
    Note: This constraint cannot be used in a logical constraint.
    Throws:
    
    IloException
  - alwaysEqual
```
public IloConstraint alwaysEqual(IloStateFunction f,
                        IloIntervalVar a,
                        int v)
                          throws IloException
```
    This method returns a constraint that ensures that whenever interval variable a is present state function f is defined everywhere between the start and the end of interval variable a and remains equal to value v over this interval.
    
    As the optional boolean values startAlign and endAlign are not specified, the start and end of a are not required to be synchronized with the intervals of the state function.
    
    For more information on state functions, see the concept State Functions in the C++ Reference Manual.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - intVar
```
public IloIntVar intVar(int lb,
               int ub,
               java.lang.String name)
                 throws IloException
```
    Description copied from class: ilog.concert.IloModelerImpl
    
    See IloModeler.intVar(int, int, String)
    
    Specified by:
    
    intVar in interface IloModeler
    
    Overrides:
    
    intVar in class ilog.concert.IloModelerImpl
    
    Throws:
    
    IloException
    Parameters:
    lb - The minimum value of the variable.
    ub - The maximum value of the variable.
    name - The name of the variable.
  - intVar
```
public IloIntVar intVar(int[] values,
               java.lang.String name)
                 throws IloException
```
    Creates and returns a new integer variable with a domain of possible values and a name.
    
    Throws:
    
    IloException
  - intVar
```
public IloIntVar intVar(int[] values)
                 throws IloException
```
    Creates and returns a new integer variable with a domain of possible values.
    
    Throws:
    
    IloException
  - intVarArray
```
public IloIntVar[] intVarArray(int n)
                        throws IloException
```
    This method returns a new array of n null variables.
    
    Throws:
    
    IloException
  - intVarArray
```
public IloIntVar[] intVarArray(int n,
                      int[] values,
                      java.lang.String name)
                        throws IloException
```
    Returns a new array of n variables with domain values and a name.
    
    Throws:
    
    IloException
  - intVarArray
```
public IloIntVar[] intVarArray(int n,
                      int min,
                      int max,
                      java.lang.String name)
                        throws IloException
```
    Creates and returns a new array of n variables with domain min..max and a name.
    
    Throws:
    
    IloException
  - arrayEltName
```
public java.lang.String arrayEltName(java.lang.String name,
                            int index)
```
    This method is a shortcut to name.concat("[").concat(String.valueOf(index)).concat("]").
  - numVarArray
```
public IloNumVar[] numVarArray(int n,
                      double min,
                      double max,
                      java.lang.String name)
                        throws IloException
```
    Returns a new array of n variables with domain min..max and a name.
    
    Throws:
    
    IloException
  - intTable
```
public IloIntTupleSet intTable(int dimension)
                        throws IloException
```
    Creates and returns a new table table.
    
    Throws:
    
    IloException
  - addTuple
```
public void addTuple(IloIntTupleSet ts,
            int[] array)
              throws IloException
```
    This method adds a tuple represented by the array array to the tuple set ts.
    If you attempt to add an element that is already in the set, that element will not be added again. Added elements are copied. Concert Technology will throw an exception if the size of the array is not equal to the arity of the invoking set. You may use this method to add tuples to the set in a model; you may not add tuples in this way during a search.
    
    Throws:
    
    IloException
  - intervalVar
```
public IloIntervalVar intervalVar()
                           throws IloException
```
    This method creates an interval variable. The start, end and size of the new interval variable range from 0 to the constant IloCP.IntervalMax. If you need an optional interval variable, you need to use the method setOptional. As no intensity function is specified, the size of the interval variable will be equal to its length.
    
    Throws:
    
    IloException
  - intervalVar
```
public IloIntervalVar intervalVar(java.lang.String name)
                           throws IloException
```
    This method creates an interval variable. The start, end and size of the new interval variable range from 0 to the constant IloCP.IntervalMax. If you need an optional interval variable, you need to use the method setOptional. As no intensity function is specified, the size of the interval variable will be equal to its length.
    
    Throws:
    
    IloException
  - intervalVar
```
public IloIntervalVar intervalVar(int sz)
                           throws IloException
```
    This method creates an interval variable. The start and end of the new interval variable range from 0 to the constant IloCP.IntervalMax. The size of the new interval variable is fixed and equal to sz. The created interval variable is present; if you need an optional interval variable, you need to use the method setOptional. As no intensity function is specified, the size of the interval variable will be equal to its length.
    
    Throws:
    
    IloException
  - intervalVar
```
public IloIntervalVar intervalVar(int sz,
                         java.lang.String name)
                           throws IloException
```
    This method creates an interval variable. The start and end of the new interval variable range from 0 to the constant IloCP.IntervalMax. The size of the new interval variable is fixed and equal to sz. The created interval variable is present; if you need an optional interval variable, you need to use the method setOptional. As no intensity function is specified, the size of the interval variable will be equal to its length.
    
    Throws:
    
    IloException
  - intervalVar
```
public IloIntervalVar intervalVar(int szmin,
                         int szmax)
                           throws IloException
```
    This method creates an interval variable. The start and end of the new interval variable range from 0 to the constant IloCP.IntervalMax. The size of the new interval variable ranges from szmin to szmax. By default, the created interval variable is present but it can be made optional by passing a true value (true) for opt. As no intensity function is specified, the size of the interval variable will be equal to its length.
    
    Throws:
    
    IloException
  - intervalVar
```
public IloIntervalVar intervalVar(int szmin,
                         int szmax,
                         boolean opt,
                         IloNumToNumStepFunction intensity,
                         int granularity)
                           throws IloException
```
    This method creates an interval variable. The start and end of the new interval variable range from 0 to the constant IloCP.IntervalMax. The size of the new interval variable ranges from szmin to szmax. By default, the created interval variable is present but it can be made optional by passing a true value (true) for opt. The intensity function is intensity. This intensity function is an integer step function expressed as a percentage (and so must bounded in the range [0,100]).
    
    Throws:
    
    IloException
  - intervalSequenceVar
```
public IloIntervalSequenceVar intervalSequenceVar(IloIntervalVar[] a,
                                         java.lang.String name)
                                           throws IloException
```
    This method creates an instance of sequence variable on the set of interval variables defined by array a. You can specify a name of your own choice.
    
    Throws:
    
    IloException
  - intervalSequenceVar
```
public IloIntervalSequenceVar intervalSequenceVar(IloIntervalVar[] a)
                                           throws IloException
```
    This method creates an instance of sequence variable on the set of interval variables defined by array a.
    
    Throws:
    
    IloException
  - intervalSequenceVar
```
public IloIntervalSequenceVar intervalSequenceVar(IloIntervalVar[] a,
                                         int[] types,
                                         java.lang.String name)
                                           throws IloException
```
    This method creates an instance of sequence variable on the set of interval variables defined by array a. An array of non-negative integer types is specified. Arrays a and types must be of the same size and interval variable a[i] will have type types[i] in the sequence variable. You can specify a name of your own choice.
    
    Throws:
    
    IloException
  - intervalSequenceVar
```
public IloIntervalSequenceVar intervalSequenceVar(IloIntervalVar[] a,
                                         int[] types)
                                           throws IloException
```
    This method creates an instance of sequence variable on the set of interval variables defined by array a. An array of non-negative integer types is specified. Arrays a and types must be of the same size and interval variable a[i] will have type types[i] in the sequence variable.
    
    Throws:
    
    IloException
  - staticLex
```
public IloMultiCriterionExpr staticLex(IloNumExpr[] criteria,
                              java.lang.String name)
                                throws IloException
```
    This function defines a multicriteria expression for lexicographic ordering. A lexicographic ordering means that any improvement of the i-th criterion is more important than any improvement of the subsequent criteria.
    
    Throws:
    
    IloException
  - staticLex
```
public IloMultiCriterionExpr staticLex(IloNumExpr[] criteria)
                                throws IloException
```
    This function defines a multicriteria expression for lexicographic ordering. A lexicographic ordering means that any improvement of the i-th criterion is more important than any improvement of the subsequent criteria.
    
    Throws:
    
    IloException
  - staticLex
```
public IloMultiCriterionExpr staticLex(IloNumExpr c1,
                              IloNumExpr c2)
                                throws IloException
```
    This function defines a multicriteria expression for lexicographic ordering. A lexicographic ordering means that any improvement of the i-th criterion is more important than any improvement of the subsequent criteria.
    
    Throws:
    
    IloException
  - staticLex
```
public IloMultiCriterionExpr staticLex(IloNumExpr c1,
                              IloNumExpr c2,
                              IloNumExpr c3)
                                throws IloException
```
    This function defines a multicriteria expression for lexicographic ordering. A lexicographic ordering means that any improvement of the i-th criterion is more important than any improvement of the subsequent criteria.
    
    Throws:
    
    IloException
  - staticLex
```
public IloMultiCriterionExpr staticLex(IloNumExpr c1,
                              IloNumExpr c2,
                              IloNumExpr c3,
                              IloNumExpr c4)
                                throws IloException
```
    This function defines a multicriteria expression for lexicographic ordering. A lexicographic ordering means that any improvement of the i-th criterion is more important than any improvement of the subsequent criteria.
    
    Throws:
    
    IloException
  - maximize
```
public IloObjective maximize(IloIntExpr e)
                      throws IloException
```
    Creates a maximization objective.
    
    Throws:
    
    IloException
  - maximize
```
public IloObjective maximize(IloMultiCriterionExpr e)
                      throws IloException
```
    Creates a maximization multicriteria objective.
    
    Throws:
    
    IloException
  - minimize
```
public IloObjective minimize(IloIntExpr e)
                      throws IloException
```
    Creates a minimization objective.
    
    Throws:
    
    IloException
  - minimize
```
public IloObjective minimize(IloMultiCriterionExpr e)
                      throws IloException
```
    Creates a minimization multicriteria objective.
    
    Throws:
    
    IloException
  - getObjValue
```
public double getObjValue()
                   throws IloException
```
    This method returns the numeric value of the objective function associated with the CP engine.
    
    Throws:
    
    IloException
  - getObjBound
```
public double getObjBound()
                   throws IloException
```
    This method returns the best bound on the objective found during the solve of an optimization problem. For a minimization model, there does not exist a solution whose objective value is less than this bound. For a maximization model, there does not exist a solution whose objective value is greater than this bound. When solving a problem with more than one criterion, then only the bound on the first criterion is returned. In this case, please use getObjBounds() to obtain full information.
    
    Throws:
    
    IloException
    See Also:
    getObjGap(), getObjBounds(), ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
  - getObjGap
```
public double getObjGap()
                 throws IloException
```
    This method returns the relative gap between the objective value of the best solution found and the current objective bound. The gap is computed with respect to the best objective value and gives an idea of the quality of the solutions found with respect to the objective bound. The exact formula for the gap computation is gap = | objValue - objBound | / max(1e-10, |objValue|) where objValue is the best objective value and objBound is the current objective bound.
    
    Throws:
    
    IloException
    See Also:
    getObjBound(), getObjGaps(), ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
  - getObjValues
```
public double[] getObjValues()
                      throws IloException
```
    This method returns the numeric values of all objective values in a multi-objective function associated with the CP engine.
    
    Throws:
    
    IloException
  - getObjBounds
```
public double[] getObjBounds()
                      throws IloException
```
    This method delivers the current bound on the objective criteria in the invoking instance of IloCP.
    
    Note that when ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String) is used, then the bound values must be taken as a whole, as are the values delivered by getObjValues(). One cannot interpret bound values on each criterion independently. For example, suppose, we have a problem with two criteria specified to ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String), a number of workers, and a number of days to complete a job. That is, we always prefer to use less workers, but for equal numbers of workers, we prefer to take less days. Then a solution with 3 workers and 10 days is perfectly compatible with a lower bound of 2 workers and 13 days, even though the lower bound on the number of days is higher than the value in the solution.
    
    Throws:
    
    IloException
    See Also:
    getObjBound(), getObjGaps(), ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
  - getObjGaps
```
public double[] getObjGaps()
                    throws IloException
```
    This method delivers the current gap values on the objective criteria in the invoking instance of IloCP.
    
    When this method is used to obtain values specified via ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String), then the gap values follow a pattern. First, there will be the gaps of 0 or more criteria whose values are within the optimality tolerance specified (see IloCP#NumParam#OptimalityTolerance and IloCP#NumParam#RelativeOptimalityTolerance). If not all the criteria were within the optimality tolerance, then will come the gap of the first criterion which is not within this tolerance. (When examining the log, this is the value of the gap which you will see displayed, along with the rank of the criterion to which it corresponds.) Finally, should there be more criteria after this, then their gap values will be positive infinity.
    
    For the calculation of the gap, see getObjGap().
    
    Throws:
    
    IloException
    See Also:
    getObjGap(), getObjBounds(), ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
  - hasObjective
```
public boolean hasObjective()
                     throws IloException
```
    This method returns true if and only if the invoking CP Optimizer has extracted a model involving an objective.
    
    Throws:
    
    IloException
  - range
```
public IloRange range(IloNumExpr expr,
             double b)
               throws IloException
```
    Creates and returns an IloRange object. The new IloRange object is initialized to represent the constraint -b <= expr <= +b.
    
    Throws:
    
    IloException
    Parameters:
    b - Bound of the new IloRange constraint.
    expr - Expression of the new IloRange constraint.
    
    Returns:
    A new IloRange object initialized to represent the constraint -b <= expr <= +b.
  - propagate
```
public boolean propagate()
                  throws IloException
```
    Propagates all constraints without a goal.
    
    Throws:
    
    IloException
  - propagate
```
public boolean propagate(IloConstraint ct)
                  throws IloException
```
    Propagates a constraint
    
    Throws:
    
    IloException
  - dumpModel
```
public void dumpModel(java.lang.String filename)
               throws IloException
```
    This function dumps the currently loaded model into the file named filename. This file name must have extension .cpo. The file is an ordinary text file which can be used to help IBM support resolve a user problem. The names of variables and constraints will be contained inside the file as well as parameter settings. The names of variables and constraints can be anonymized using the parameter IloCP.IntParam.ModelAnonymizer.
    
    If dumpModel is called during the search then the dump contains the current domains of all variables (instead of the initial domains) and the current objective cuts. Constraints that were added during the search (such as no-goods or constraints added during LNS moves) are not included in the dump.
    
    Note that the dump file is human readable, but it contains not only the model but also internal data that makes the dump hard to read. The function exportModel(java.lang.String) produces a model file that is easier to read.
    
    The dumped model can be imported back into CP Optimizer using the function importModel(java.lang.String). Due to the internal data in the dump file, the behavior of CP Optimizer on the model after import is the same as on the original model.
    
    Note that model dump should not be edited, otherwise CP Optimizer may refuse to load the model. In this case, remove section internals from the dump.
    
    Throws:
    
    IloException
  - dumpModel
```
public void dumpModel(java.io.OutputStream s)
               throws IloException
```
    This function dumps the currently loaded model into a stream. Otherwise it behaves the same as the second variant of this function that dumps the model into a file.
    
    Throws:
    
    IloException
  - exportModel
```
public void exportModel(java.lang.String filename)
                 throws IloException
```
    This function exports the currently loaded model into the file named filename. This file name must have extension .cpo. The purpose of this function is to create a human readable file, not to capture the internal state of CP Optimizer. Please use the function dumpModel(java.lang.String) if you want to send the model to IBM support.
    
    If exportModel is called during the search then the export contains the current domains of all variables (instead of initial domains) and the current objective cuts. Constraints that were added during the search (such as no-goods or constraints added during LNS moves) are not included in the export.
    
    This function differs from the function dumpModel(java.lang.String) in several aspects:
    - The produced file contains only the model not additional internal data.
    - The names of variables and constraints will be contained inside the file, regardless of the value of the parameter IloCP.IntParam.ModelAnonymizer.
    - An exported model is easier to read by a human in comparison to a dumped model.
    - Both models can be imported back into CP Optimizer using the function importModel(java.lang.String). However only the model dump guarantees that the behavior of CP Optimizer will be the same as on the original model.
    Throws:
    
    IloException
  - exportModel
```
public void exportModel(java.io.OutputStream s)
                 throws IloException
```
    This function exports the currently loaded model into a stream. Otherwise it behaves the same as the second variant of this function that exports the model into a file.
    
    Throws:
    
    IloException
  - importModel
```
public void importModel(java.lang.String filename)
                 throws IloException
```
    This function reads a model from a file specified by the filename parameter. The file must have extension .cpo and follow the syntax described in the CP Optimizer File Format Reference Manual.
    
    Before reading the file, the function first discards any model that was used before.
    
    The file may also specify values of CP Optimizer parameters (in section parameters). Parameters that are not specified in the file are reset to their default values. Note that parameters that affect the import process itself (such as IloCP#IntParam#UseFileLocations) could be set before importModel and the setting is respected during the import however those parameters are also reset to default values (unless specified otherwise in the file).
    
    If an error happens while reading the file then the error messages are written into the stream defined by setError(java.io.OutputStream) and the function throws an instance of IloException.
    
    This function cannot be called during the search.
    
    After reading the model, it is possible to access some model objects (especially variables) using the functions getAllIloIntVars(), getAllIloIntervalVars(), getAllIloIntervalSequenceVars(), getAllIloStateFunctions() and getAllConstrainedIloCumulFunctionExprs(). It is also possible to access modeling objects by name using functions getIloIntVar(java.lang.String), getIloIntervalVar(java.lang.String), getIloIntervalSequenceVar(java.lang.String), getIloStateFunction(java.lang.String) and getIloCumulFunctionExpr(java.lang.String).
    
    Once the model is loaded it is possible to modify domains of the model variables but otherwise the model cannot be changed.
    
    For example, lets assume that there is a file colors.cpo with the following content (model of a map coloring problem):
```
    // Decision variables:
    Belgium = intVar(1..4);
    Denmark = intVar(1..4);
    France = intVar(1..4);
    Germany = intVar(1..4);
    Luxembourg = intVar(1..4);
    Netherlands = intVar(1..4);

    // Constraints:
    Belgium != France;
    Belgium != Germany;
    Belgium != Netherlands;
    Belgium != Luxembourg;
    Denmark != Germany;
    France != Germany;
    France != Luxembourg;
    Germany != Luxembourg;
    Germany != Netherlands;

    parameters {
      SearchType = DepthFirst;
    }
 
```
    The following code reads the model from the file, modifies domain of variable France, solves it and prints the solution.
```
   IloCP cp();
   cp.importModel("color.cpo");
   IloIntVar varFrance = cp.getIloIntVar("France");
   varFrance.setMin(4);
   cp.solve();
   System.out.println("Belgium: "     + cp.getValue("Belgium"));
   System.out.println("Denmark: "     + cp.getValue("Denmark"));
   System.out.println("France: "      + cp.getValue("France"));
   System.out.println("Germany: "     + cp.getValue("Germany"));
   System.out.println("Luxembourg: "  + cp.getValue("Luxembourg"));
   System.out.println("Netherlands: " + cp.getValue("Netherlands"));
 
```
    Throws:
    
    IloException
  - importModel
```
public void importModel(java.io.InputStream s)
                 throws IloException
```
    This function reads a model from the specified stream. It works in the same way as the function importModel(java.lang.String) that reads the model from a file.
    
    Throws:
    
    IloException
  - getAllIloIntVars
```
public IloIntVar[] getAllIloIntVars()
                             throws IloException
```
    This method returns an array of all the integer variables extracted by the invoking CP Optimizer engine. If the current model was not extracted or if it was changed since last extraction, this method will (re)extract it.
    
    The main use case for this function is for accessing integer variables in the case when the model was read from a file using importModel(java.lang.String).
    
    Variables returned by this function can be used, for example, to query solution values using the function getValue(IloIntVar).
    
    Throws:
    
    IloException
  - getAllIloIntervalVars
```
public IloIntervalVar[] getAllIloIntervalVars()
                                       throws IloException
```
    This method returns an array of all the interval variables extracted by the invoking CP Optimizer engine. If the current model was not extracted or if it was changed since last extraction, this method will (re)extract it.
    
    The main use case for this function is for accessing interval variables in the case when the model was read from a file using importModel(java.lang.String).
    
    The variables returned by this function can be used, for example, to query solution values using functions such as getStart(IloIntervalVar), getEnd(IloIntervalVar), getLength(IloIntervalVar), getSize(IloIntervalVar), isPresent(IloIntervalVar), isAbsent(IloIntervalVar).
    
    Throws:
    
    IloException
  - getAllIloIntervalSequenceVars
```
public IloIntervalSequenceVar[] getAllIloIntervalSequenceVars()
                                                       throws IloException
```
    This method returns an array of all the interval sequence variables extracted by the invoking CP Optimizer engine. If the current model was not extracted or if it was changed since last extraction, this method will (re)extract it.
    
    The main use case for this function is for accessing interval sequence variables in the case when the model was read from a file using importModel(java.lang.String).
    
    The variables returned by this function can be used, for example, to query solution values using functions such as getFirst(IloIntervalSequenceVar), getLast(IloIntervalSequenceVar), getNext(IloIntervalSequenceVar, IloIntervalVar), getPrev(IloIntervalSequenceVar, IloIntervalVar).
    
    Throws:
    
    IloException
  - getAllIloStateFunctions
```
public IloStateFunction[] getAllIloStateFunctions()
                                           throws IloException
```
    This method returns an array of all the state functions extracted by the invoking CP Optimizer engine. If the current model was not extracted or if it was changed since last extraction, this method will (re)extract it.
    
    The main use case for this function is for accessing state functions in the case when the model was read from a file using importModel(java.lang.String).
    
    State functions returned by this function can be used, for example, to query solution values using functions such as getValue(IloStateFunction, int), getNumberOfSegments(IloStateFunction), getSegmentStart(IloStateFunction, int), getSegmentEnd(IloStateFunction, int).
    
    Throws:
    
    IloException
  - getAllConstrainedIloCumulFunctionExprs
```
public IloCumulFunctionExpr[] getAllConstrainedIloCumulFunctionExprs()
                                                              throws IloException
```
    This method returns an array of all the cumulative function expressions extracted by the invoking CP Optimizer engine whose heights are constrained:
    - on whole definition interval using operator <= or >=,
    - during certain intervals using constraint IloAlwaysIn and IloAlwaysEqual (alwaysIn in CPO language).
    If the current model was not extracted or if it was changed since last extraction, this method will (re)extract it.
    
    The main use case for this function is for accessing cumulative function expressions in the case when the model was read from a file using importModel(java.lang.String).
    
    Note that if a cumulative function is used only in expressions such as heightAtStart then it is not included.
    
    The cumulative function expressions returned by this function can be used, for example, to query solution values using functions such as getValue(IloCumulFunctionExpr, int), getNumberOfSegments(IloCumulFunctionExpr), getSegmentStart(IloCumulFunctionExpr,int), getSegmentEnd(IloCumulFunctionExpr,int), getSegmentValue(IloCumulFunctionExpr,int).
    Throws:
    
    IloException
  - getIloIntVar
```
public IloIntVar getIloIntVar(java.lang.String name)
                       throws IloException
```
    This function finds the integer variable with the given name in the current model. It is useful especially when the model was loaded from a file using importModel(java.lang.String).
    
    All non-empty names in the model must be unique, otherwise an instance of IloException is thrown. Similarly instance of IloException is thrown when an integer variable with the given name does not exist.
    
    The first call of getIloIntVar may be slower because a necessary searchable data structure must be built first. Once it is built, the function is faster (time complexity O(n) where n is the length of the name).
    
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    
    Throws:
    
    IloException
  - getIloIntervalVar
```
public IloIntervalVar getIloIntervalVar(java.lang.String name)
                                 throws IloException
```
    This function finds the interval variable with the given name in the current model. It is useful especially when the model was loaded from a file using importModel(java.lang.String).
    
    All non-empty names in the model must be unique, otherwise an instance of IloException is thrown. Similarly an instance of IloException is thrown when the interval variable with the given name does not exist.
    
    The first call of getIloIntervalVar may be slower because a searchable data structure must be built first. Once it is built, the function is faster (time complexity O(n) where n is length of the name).
    
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    
    Throws:
    
    IloException
  - getIloIntervalSequenceVar
```
public IloIntervalSequenceVar getIloIntervalSequenceVar(java.lang.String name)
                                                 throws IloException
```
    This function finds the interval sequence variable with the given name in the current model. It is useful especially when the model was loaded from a file using importModel(java.lang.String).
    
    All non-empty names in the model must be unique, otherwise an instance of IloException is thrown. Similarly an instance of IloException is thrown when interval sequence variable with the given name does not exist.
    
    The first call of getIloIntervalSequenceVar may be slower because a searchable data structure must be built first. Once it is built, the function is faster (time complexity O(n) where n is the length of the name).
    
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    
    Throws:
    
    IloException
  - getIloStateFunction
```
public IloStateFunction getIloStateFunction(java.lang.String name)
                                     throws IloException
```
    This function finds the state function with the given name in the current model. It is useful especially when the model was loaded from a file using importModel(java.lang.String).
    
    All non-empty names in the model must be unique, otherwise an instance of IloException is thrown. Similarly an instance of IloException is thrown when a state function with the given name does not exist.
    
    The first call of getIloStateFunction may be slower because a searchable data structure must be built first. Once it is built, the function is faster (time complexity O(n) where n is the length of the name).
    
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    
    Throws:
    
    IloException
  - getIloCumulFunctionExpr
```
public IloCumulFunctionExpr getIloCumulFunctionExpr(java.lang.String name)
                                             throws IloException
```
    This function finds the cumulative function expression with the given name in the current model. It is useful especially when the model was loaded from a file using importModel(java.lang.String).
    
    If the model was read using importModel(java.lang.String) then only the following certain types of cumulative expressions can be found using this function:
    - Atomic cumulative function expressions on interval variables created using pulse, stepAtStart and stepAtEnd.
    - Cumulative function expressions that were constrained using function alwaysIn or using operator <= or <=.
    All non-empty names in the model must be unique, otherwise an instance of IloException is thrown. Similarly an instance of IloException is thrown when a cumulative function expression with the given name does not exist or does not fulfill the conditions above.
    
    The first call of getIloCumulFunctionExpr may be slower because a searchable data structure must be built first. Once it is built, the function is faster (time complexity O(n) where n is the length of the name).
    
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    Throws:
    
    IloException
  - getValue
```
public int getValue(java.lang.String intVarName)
             throws IloException
```
    This method returns the current value of an integer variable with the given name. It is a shortcut for cp.getValue(cp.getIloIntVar(intVarName)).
    
    An instance of IloException is thrown if:
    - an integer variable with the specified name does not exist,
    - or the variable is not fixed yet,
    - or there are duplicate names in the current model.
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    Throws:
    
    IloException
  - isPresent
```
public boolean isPresent(java.lang.String intervalVarName)
                  throws IloException
```
    This method returns true if the interval variable with the specified name is currently set to be present. It is a shortcut for cp.isPresent(cp.getIloIntervalVar(intervalVarName)).
    
    An instance of IloException is thrown if:
    - an interval variable with the specified name does not exist,
    - or the presence status of the interval variable is not fixed yet,
    - or there are duplicate names in the current model.
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    Throws:
    
    IloException
  - isAbsent
```
public boolean isAbsent(java.lang.String intervalVarName)
                 throws IloException
```
    This method returns true if the interval variable with the specified name is currently set to be absent. It is a shortcut for cp.isAbsent(cp.getIloIntervalVar(intervalVarName)).
    
    An instance of IloException is thrown if:
    - an interval variable with the specified name does not exist,
    - or the presence status of the interval variable is not fixed yet,
    - or there are duplicate names in the current model.
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    Throws:
    
    IloException
  - getStart
```
public int getStart(java.lang.String intervalVarName)
             throws IloException
```
    This method returns the current start time of the interval variable with the specified name. It is a shortcut for cp.getStart(cp.getIloIntervalVar(intervalVarName)).
    
    An instance of IloException is thrown if:
    - an interval variable with the specified name does not exist,
    - or the interval variable is absent,
    - or its start time is not fixed yet,
    - or there are duplicate names in the current model.
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    Throws:
    
    IloException
  - getEnd
```
public int getEnd(java.lang.String intervalVarName)
           throws IloException
```
    This method returns the current end time of the interval variable with the specified name. It is a shortcut for cp.getEnd(cp.getIloIntervalVar(intervalVarName)).
    
    An instance of IloException is thrown if:
    - an interval variable with the specified name does not exist,
    - or the interval variable is absent,
    - or its end time is not fixed yet,
    - or there are duplicate names in the current model.
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    Throws:
    
    IloException
  - getSize
```
public int getSize(java.lang.String intervalVarName)
```
    This method returns current size of the interval variable with the specified name. It is a shortcut for cp.getSize(cp.getIloIntervalVar(intervalVarName)).
    
    An instance of IloException is thrown if:
    - an interval variable with the specified name does not exist,
    - or the interval variable is absent,
    - or its size is not fixed yet,
    - or there are duplicate names in the current model.
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
  - getLength
```
public int getLength(java.lang.String intervalVarName)
              throws IloException
```
    This method returns the current length of the interval variable with the specified name. It is a shortcut for cp.getLength(cp.getIloIntervalVar(intervalVarName)).
    
    An instance of IloException is thrown if:
    - an interval variable with the specified name does not exist,
    - or the interval variable is absent,
    - or its length is not fixed yet,
    - or there are duplicate names in the current model.
    Note that name aliases cannot be used in this function as described in the section "Statements > Aliasing" of the CP Optimizer File Format Reference Manual.
    Throws:
    
    IloException
  - getValue
```
public double getValue(IloIntVar i)
```
    This method returns the current value of the variable i in the invoking instance of IloCP. An assertion is violated if v is not fixed to a value.
  - getValue
```
public double getValue(IloIntExpr i)
```
    This method returns the current value of the expression i in the invoking instance of IloCP.
  - getValue
```
public double getValue(IloNumExpr num)
```
    This method returns the current value of the expression num in the invoking instance of IloCP.
  - getValues
```
public void getValues(IloIntVar[] vars,
             double[] vals)
               throws IloException
```
    This method accepts an array of variables vars and puts the corresponding values into the array vals; the corresponding values come from the current solution of the invoking algorithm. The array vals must be a clean, empty array when you pass it to this method.
    
    If there are no values to return for vars, this method throws an exception.
    
    Throws:
    
    IloException
  - getIntValue
```
public int getIntValue(IloIntVar var)
```
    This method returns the current value of the variable var in the invoking instance of IloCP. An assertion is violated if var is not fixed to a value.
  - getMin
```
public double getMin(IloNumVar var)
```
    This member function returns the minimum value of the variable var in the invoking instance of IloCP.
  - getMax
```
public double getMax(IloNumVar var)
```
    This member function returns the maximum value of the variable var in the invoking instance of IloCP.
  - isInDomain
```
public boolean isInDomain(IloNumVar var,
                 int value)
```
    This member function indicates whether value is contained in the current domain of var as maintained by the invoking IloCP instance. An assertion is violated if var is not of integral type.
  - getDomainSize
```
public int getDomainSize(IloNumVar var)
```
    This member function returns the size of the domain of variable var as maintained in the invoking instance of IloCP. An assertion is violated if var is not of integral type.
  - isFixed
```
public boolean isFixed(IloNumVar var)
```
    This member function indicates if the domain of var takes on a particular value as maintained by the invoking IloCP instance.
  - iterator
```
public java.util.Iterator iterator(IloIntVar var)
```
    This member function returns an iterator to iterate over the domain of var, as maintained by the invoking IloCP.
  - isFixed
```
public boolean isFixed(IloIntervalVar a)
```
    This method indicates if the domain of a takes on a particular value as maintained by the invoking IloCP instance. An interval variable is said to be fixed if and only if it is either absent or present with fixed start, end and size value.
  - isAbsent
```
public boolean isAbsent(IloIntervalVar a)
```
    This method returns true if and only if interval variable a is absent in the invoking instance of IloCP.
  - isPresent
```
public boolean isPresent(IloIntervalVar a)
```
    This method returns true if and only if interval variable a is present in the invoking instance of IloCP.
  - getStartMin
```
public int getStartMin(IloIntervalVar a)
```
    This method returns the minimum value for the start of interval variable a in the invoking instance of IloCP.
  - getStartMax
```
public int getStartMax(IloIntervalVar a)
```
    This method returns the maximum value for the start of interval variable a in the invoking instance of IloCP.
  - getStart
```
public int getStart(IloIntervalVar a)
```
    This method returns the current value of the start of interval variable a in the invoking instance of IloCP. An assertion is violated if a is not fixed.
  - getEndMin
```
public int getEndMin(IloIntervalVar a)
```
    This method returns the minimum value for the end of interval variable a in the invoking instance of IloCP.
  - getEndMax
```
public int getEndMax(IloIntervalVar a)
```
    This method returns the maximum value for the end of interval variable a in the invoking instance of IloCP.
  - getEnd
```
public int getEnd(IloIntervalVar a)
```
    This method returns the current value of the end of interval variable a in the invoking instance of IloCP. An assertion is violated if a is not fixed.
  - getSizeMin
```
public int getSizeMin(IloIntervalVar a)
```
    This method returns the minimum value for the size of interval variable a in the invoking instance of IloCP.
  - getSizeMax
```
public int getSizeMax(IloIntervalVar a)
```
    This method returns the maximum value for the size of interval variable a in the invoking instance of IloCP.
  - getSize
```
public int getSize(IloIntervalVar a)
```
    This method returns the current value of the size of interval variable a in the invoking instance of IloCP. An assertion is violated if a is not fixed.
  - getLengthMin
```
public int getLengthMin(IloIntervalVar a)
```
    This method returns the minimum value for the length of interval variable a in the invoking instance of IloCP.
  - getLengthMax
```
public int getLengthMax(IloIntervalVar a)
```
    This method returns the maximum value for the length of interval variable a in the invoking instance of IloCP.
  - getLength
```
public int getLength(IloIntervalVar a)
```
    This method returns the current value of the length of interval variable a in the invoking instance of IloCP. An assertion is violated if a is not fixed.
  - getDomain
```
public java.lang.String getDomain(IloIntervalVar var)
                           throws IloException
```
    This method returns the current domain of interval variable var as maintained by the invoking instance of IloCP.
    
    Throws:
    
    IloException
  - isFixed
```
public boolean isFixed(IloIntervalSequenceVar seq)
                throws IloException
```
    This method indicates if the domain of the interval sequence variable seq takes on a particular value as maintained by the invoking IloCP instance. An interval sequence variable is said to be fixed if and only if all the interval variables of the sequence are either absent or ordered.
    
    Throws:
    
    IloException
  - getFirst
```
public IloIntervalVar getFirst(IloIntervalSequenceVar seq)
                        throws IloException
```
    This method assumes that interval sequence variable seq is fixed. It returns the interval variable at the first position in the sequence. The returned interval variable is necessarily present. If all interval variables of the sequence are absent, it returns null. An assertion is violated if the sequence seq is not fixed.
    
    Throws:
    
    IloException
  - getLast
```
public IloIntervalVar getLast(IloIntervalSequenceVar seq)
                       throws IloException
```
    This method assumes that interval sequence variable seq is fixed. It returns the interval variable at the last position in the sequence. The returned interval variable is necessarily present. If all interval variables of the sequence are absent, it returns null. An assertion is violated if the sequence seq is not fixed. This function can be used to print the reverse total order corresponding to the sequence value.
    
    Throws:
    
    IloException
  - getNext
```
public IloIntervalVar getNext(IloIntervalSequenceVar seq,
                     IloIntervalVar a)
                       throws IloException
```
    This method assumes that interval sequence variable seq is fixed. It returns the interval variable that immediately follows interval a in the sequence. The returned interval variable is necessarily present. An assertion is violated if a is absent or is not an interval variable of sequence seq and if the sequence is not fixed. If a is at the last position of the sequence, the function returns null. This function can be used to print the total order corresponding to the sequence value.
    
    Throws:
    
    IloException
  - getPrev
```
public IloIntervalVar getPrev(IloIntervalSequenceVar seq,
                     IloIntervalVar a)
                       throws IloException
```
    This method assumes that interval sequence variable seq is fixed. It returns the interval variable that immediately precedes interval a in the sequence. The returned interval variable is necessarily present. An assertion is violated if a is absent or is not an interval variable of sequence seq and if the sequence is not fixed. If a is at the first position of the sequence, the function returns null. This function can be used to print the reverse total order corresponding to the sequence value.
    
    Throws:
    
    IloException
  - getNumberOfSegments
```
public int getNumberOfSegments(IloCumulFunctionExpr f)
                        throws IloException
```
    This method assumes that the cumul function expression f is fixed. It returns the number of segments of the corresponding stepwise non-negative function. A segment is an interval [start, end) on which the value of f is constant. An exception is thrown if the cumul function expression f is not fixed.
    
    This function can be used to print the content of a cumul function expression as illustrated by the following code sample.
```
  for (int i = 0; i < cp.getNumberOfSegments(f); ++i)
    System.out.println("["  + cp.getSegmentStart(f,i) +
                       ","  + cp.getSegmentEnd(f, i) +
                       "):" + cp.getSegmentValue(f, i));
 
```
    For more information on cumul function expressions see the concept IloCumulFunctionExpr.
    Throws:
    
    IloException
  - getSegmentStart
```
public int getSegmentStart(IloCumulFunctionExpr f,
                  int i)
                    throws IloException
```
    This method assumes that the cumul function expression f is fixed. It returns the start of the ith segment of the corresponding stepwise non-negative function. A segment is an interval [start, end) on which the value of f is constant. If n is the number of segments of the function segments are indexed starting from 0 so index i should belong to the range [0,n). An exception is thrown if i is not a valid segment index or f is not fixed.
    
    Throws:
    
    IloException
  - getSegmentEnd
```
public int getSegmentEnd(IloCumulFunctionExpr f,
                int i)
                  throws IloException
```
    This method assumes that the cumul function expression f is fixed. It returns the end of the ith segment of the corresponding stepwise non-negative function. A segment is an interval [start, end) on which the value of f is constant. If n is the number of segments of the function segments are indexed starting from 0 so index i should belong to the range [0,n). An exception is thrown if i is not a valid segment index or f is not fixed.
    
    Throws:
    
    IloException
  - getSegmentValue
```
public int getSegmentValue(IloCumulFunctionExpr f,
                  int i)
                    throws IloException
```
    This method assumes that the cumul function expression f is fixed. It returns the value of the ith segment of the corresponding stepwise non-negative function. A segment is an interval [start, end) on which the value of f is constant. If n is the number of segments of the function segments are indexed starting from 0 so index i should belong to the range [0,n). An exception is thrown if i is not a valid segment index or f is not fixed.
    
    Throws:
    
    IloException
  - getValue
```
public int getValue(IloCumulFunctionExpr f,
           int t)
             throws IloException
```
    This method assumes that cumul function expression f is fixed. It returns the value of the corresponding stepwise non-negative function at point t. An exception is thrown if cumul function expression f is not fixed, or t is not in [IloCP.IntervalMin,IloCP.IntervalMax).
    
    For more information on cumul function expressions see the concept IloCumulFunctionExpr
    
    Throws:
    
    IloException
  - isFixed
```
public boolean isFixed(IloCumulFunctionExpr f)
                throws IloException
```
    This method indicates if the cumul function expression f takes on a particular value as maintained by the invoking IloCP instance. A cumul function expression f is said to be fixed if it defines a fixed value f(t) for all t in [IloCP.IntervalMin,IloCP.IntervalMax). When fixed, a cumul function expression is a stepwise non-negative function.
    
    Throws:
    
    IloException
  - getNumberOfSegments
```
public int getNumberOfSegments(IloStateFunction f)
                        throws IloException
```
    This method assumes that state function f is fixed. It returns the number of segments of the corresponding stepwise function. A segment is an interval [start, end) on which the value of f is constant. If the state function is not defined, the value is IloCP.NoState, elsewhere the value is a non-negative integer. An assertion is violated if state function f is not fixed.
    
    This code can be used to print the content of a state function as illustrated by the following code sample.
```
  for (int i=0; i < cp.getNumberOfSegments(f); ++i)
    System.out.println("[" + cp.getSegmentStart(f, i)
                    + ","  + cp.getSegmentEnd(f, i)
                    + "):" + cp.getSegmentValue(f, i) );
 
```
    Throws:
    
    IloException
  - getSegmentStart
```
public int getSegmentStart(IloStateFunction f,
                  int i)
                    throws IloException
```
    This method assumes that state function f is fixed. It returns the start of the ith segment of the corresponding stepwise function. A segment is an interval [start, end) on which the value of f is constant. If the state function is not defined, the value is IloCP.NoState, elsewhere the value is a non-negative integer. An assertion is violated if state function f is not fixed.
    
    This code can be used to print the content of a state function as illustrated by the following code sample.
```
  for (int i=0; i < cp.getNumberOfSegments(f); ++i)
    System.out.println("[" + cp.getSegmentStart(f, i)
                    + "," + cp.getSegmentEnd(f, i)
                    + "):" + cp.getSegmentValue(f, i) );
 
```
    Throws:
    
    IloException
  - getSegmentEnd
```
public int getSegmentEnd(IloStateFunction f,
                int i)
                  throws IloException
```
    This method assumes that state function f is fixed. It returns the end of the ith segment of the corresponding stepwise function. A segment is an interval [start, end) on which the value of f is constant. If the state function is not defined, the value is IloCP.NoState, elsewhere the value is a non-negative integer. An assertion is violated if state function f is not fixed.
    
    This function can be used to print the content of a state function as illustrated by the following code sample.
```
  for (int i=0; i < cp.getNumberOfSegments(f); ++i)
    System.out.println("[" + cp.getSegmentStart(f, i)
                    + ","  + cp.getSegmentEnd(f, i)
                    + "):" + cp.getSegmentValue(f, i) );
 
```
    Throws:
    
    IloException
  - getSegmentValue
```
public int getSegmentValue(IloStateFunction f,
                  int i)
                    throws IloException
```
    This method assumes that state function f is fixed. It returns the value of the ith segment of the corresponding stepwise function. A segment is an interval [start, end) on which the value of f is constant. If the state function is not defined, the returned value is IloCP.NoState, elsewhere the returned value is a non-negative integer. An assertion is violated if state function f is not fixed.
    
    This code can be used to print the content of a state function as illustrated by the following code sample.
```
  for (int i=0; i < cp.getNumberOfSegments(f); ++i)
    System.out.println("[" + cp.getSegmentStart(f, i)
                    + ","  + cp.getSegmentEnd(f, i)
                    + "):" + cp.getSegmentValue(f, i) );
 
```
    Throws:
    
    IloException
  - getValue
```
public int getValue(IloStateFunction f,
           int t)
             throws IloException
```
    This method assumes that state function f is fixed. It returns the value of the corresponding stepwise non-negative function at point t. If the state function is not defined, the returned value is IloCP.NoState, elsewhere the returned value is a non-negative integer. An assertion is violated if state function f is not fixed or if t does not belong to the interval [IloCP.IntervalMin, IloCP.IntervalMax).
    
    Throws:
    
    IloException
  - isFixed
```
public boolean isFixed(IloStateFunction f)
                throws IloException
```
    This method indicates if the state function f takes on a particular value as maintained by the invoking IloCP instance. A state function f is said to be fixed if it defines a fixed value f(t) for all t in [IloCP.IntervalMin,IloCP.IntervalMax). When fixed, a state function is a stepwise function. If the state function is not defined, the value is IloCP.NoState, elsewhere the value is a non-negative integer.
    
    Throws:
    
    IloException
  - searchPhase
```
public IloSearchPhase searchPhase(IloIntVar[] vars)
                           throws IloException
```
    This method creates a search phase with an array of variables only. The variable and value choosers for these variables will be chosen by CP Optimizer search automatically.
    
    Throws:
    
    IloException
  - searchPhase
```
public IloSearchPhase searchPhase(IloIntVar[] vars,
                         IloIntVarChooser varChooser,
                         IloIntValueChooser valueChooser)
                           throws IloException
```
    This method creates a search phase with an array of variable and choosers. The phase will use varChooser and valueChooser to determine how to instantiate variables in vars.
    
    Throws:
    
    IloException
  - searchPhase
```
public IloSearchPhase searchPhase(IloIntVarChooser varChooser,
                         IloIntValueChooser valueChooser)
                           throws IloException
```
    This method creates a search phase with a variable and a value chooser. The variables instantiated by this phase are those extracted to the IloCP instance.
    
    Throws:
    
    IloException
  - searchPhase
```
public IloSearchPhase searchPhase(IloIntervalVar[] intervalVars)
                           throws IloException
```
    This method creates a search phase with an array of interval variables. During this phase CP Optimizer fixes the value of interval variables specified in the array intervalVars: each interval variable in the array will be assigned a presence status and for each present interval, a start and an end value. This search phase fixes the start and end values of interval variables in an unidirectional manner, starting to fix first the intervals that will be assigned a small start or end value.
    
    Throws:
    
    IloException
  - searchPhase
```
public IloSearchPhase searchPhase(IloIntervalSequenceVar[] sequenceVars)
                           throws IloException
```
    This method creates a search phase with an array of interval sequence variables. During this phase CP Optimizer fixes the value of interval sequence variables specified in the array sequenceVars: each sequence variable in the array will be assigned a totally ordered sequence of present interval variables. Note that this search phase also fixes the presence statuses of the intervals involved in the sequence variables. This phase does not fix the start and end values of interval variables. It is recommended to use this search phase only if the possible range for start and end values of all interval variables is limited (for example by some known horizon that limits their maximal values).
    
    Throws:
    
    IloException
  - intVarChooser
```
public IloIntVarChooser intVarChooser(IloVarSelector varSel)
                               throws IloException
```
    This method returns an IloIntVarChooser made with the IloVarSelector varSel.
    
    Throws:
    
    IloException
  - intVarChooser
```
public IloIntVarChooser intVarChooser(IloVarSelector[] varSels)
                               throws IloException
```
    This method returns an IloIntVarChooser made with the array of IloVarSelector varSels.
    
    Throws:
    
    IloException
  - intValueChooser
```
public IloIntValueChooser intValueChooser(IloValueSelector valueSel)
                                   throws IloException
```
    This method returns an IloIntValueChooser made with the IloValueSelector valueSel.
    
    Throws:
    
    IloException
  - intValueChooser
```
public IloIntValueChooser intValueChooser(IloValueSelector[] valueSels)
                                   throws IloException
```
    This method returns an IloIntValueChooser made with the array of IloValueSelector valueSels.
    
    Throws:
    
    IloException
  - selectSmallest
```
public IloVarSelector selectSmallest(double minNumber,
                            IloIntVarEval e)
                              throws IloException
```
    This method returns a selector of integer variables that selects at least minNumber variables having the smallest evaluation according to the evaluator e. The parameter minNumber must be at least 1. For example, suppose that eight variables (A-H) have evaluations (A) 9, (B) 5, (C) 6, (D) 3, (E) 8, (F) 1, (G) 3, (H) 2. When ordered by increasing evaluation, this gives: (F) 1, (H) 2, (D) 3, (G) 3, (B) 5, (C) 6, (E) 8, (A) 9. If minNumber is 1, then variable F would be selected, if it is 2, then variables F and H would be selected, and if it is 3 or 4 then F, H, D and G would be selected. Note that when minNumber is 3, both D and G are selected as both are considered equivalent. In addition, it is possible to specify a non-integer value of minNumber. In this case, at least floor(minNumber) selections are made, with probability minNumber - floor(minNumber) of selecting an additional variable. It is still possible that this selector can select less variables than minNumber if there are less than minNumber variables supplied to it for selection, in which case all supplied variables are selected.
    
    Throws:
    
    IloException
  - selectSmallest
```
public IloVarSelector selectSmallest(IloIntVarEval e)
                              throws IloException
```
    This method returns a selector of integer variables that selects all variables having the smallest evaluation according to the evaluator e.
    
    Throws:
    
    IloException
  - selectSmallest
```
public IloVarSelector selectSmallest(IloIntVarEval e,
                            double tol)
                              throws IloException
```
    This method returns a selector of integer variables that selects all variables whose evaluations are in the range [min, min + tol], where min is is the minimum valuation by e over the variables to be evaluated. The parameter tol must be non-negative.
    
    Throws:
    
    IloException
  - selectLargest
```
public IloVarSelector selectLargest(double minNumber,
                           IloIntVarEval e)
                             throws IloException
```
    This method returns a selector of integer variables that selects at least minNumber variables having the largest evaluation according to the evaluator e. The parameter minNumber must be at least 1. For example, suppose that eight variables (A-H) have evaluations (A) 5, (B) 8, (C) 3, (D) 9, (E) 2, (F) 8, (G) 1, (H) 7. When ordered by decreasing evaluation, this gives: (D) 9, (B) 8, (F) 8, (H) 7, (A) 5, (C) 3, (E) 2, (G) 1. If minNumber is 1, then variable D would be selected, if it is 2 or 3, then variables B and F would be selected, and if it is 4 then D, B, F, and H would be selected. Note that when minNumber is 2, both B and F are selected as both are considered equivalent. In addition, it is possible to specify a non-integer value of minNumber. In this case, at least floor(minNumber) selections are made, with probability minNumber - floor(minNumber) of selecting an additional variable. It is still possible that this selector can select less variables than minNumber if there are less than minNumber variables supplied to it for selection, in which case all supplied variables are selected.
    
    Throws:
    
    IloException
  - selectLargest
```
public IloVarSelector selectLargest(IloIntVarEval e)
                             throws IloException
```
    This method returns a selector of integer variables that selects all variables having the largest evaluation according to the evaluator e.
    
    Throws:
    
    IloException
  - selectLargest
```
public IloVarSelector selectLargest(IloIntVarEval e,
                           double tol)
                             throws IloException
```
    This method returns a selector of integer variables that selects all variables whose evaluations are in the range [max - tol, max], where max is is the maximum valuation by e over the variables to be evaluated. The parameter tol must be non-negative.
    
    Throws:
    
    IloException
  - selectRandomVar
```
public IloVarSelector selectRandomVar()
                               throws IloException
```
    This method returns a selector of integer variables that selects a variable randomly from those available. It selects only one variable.
    
    Throws:
    
    IloException
  - selectSmallest
```
public IloValueSelector selectSmallest(double minNumber,
                              IloIntValueEval e)
                                throws IloException
```
    This method returns a selector of integer variable assignments that selects at least minNumber domain values having the smallest evaluation according to the evaluator e. The parameter minNumber must be at least 1. For example, suppose that eight domain values (1-8) have evaluations (1) 9, (2) 5, (3) 6, (4) 3, (5) 8, (6) 1, (7) 3, (8) 2. When ordered by increasing evaluation, this gives: (6) 1, (8) 2, (4) 3, (7) 3, (2) 5, (3) 6, (5) 8, (1) 9. If minNumber is 1, then value 6 would be selected, if it is 2, then values 6 and 8 would be selected, and if it is 3 then values 6, 8, 4 and 7 would be selected. Note that when minNumber is 3, both values 4 and 7 are selected as both are considered equivalent. In addition, it is possible to specify a non-integer value of minNumber. In this case, at least floor(minNumber) selections are made, with probability minNumber - floor(minNumber) of selecting an additional value. It is still possible that this selector can select less values than minNumber if there are less than minNumber values supplied to it for selection, in which case all supplied values are selected.
    
    Throws:
    
    IloException
  - selectSmallest
```
public IloValueSelector selectSmallest(IloIntValueEval e)
                                throws IloException
```
    This method returns a selector of value assignments to a variable that selects all values having the smallest evaluation according to the evaluator e.
    
    Throws:
    
    IloException
  - selectSmallest
```
public IloValueSelector selectSmallest(IloIntValueEval e,
                              double tol)
                                throws IloException
```
    This method returns a selector of integer variable assignments that selects all domain values whose evaluations are in the range [min, min + tol], where min is is the minimum valuation by e over the domain values to be evaluated. The parameter tol must be non-negative.
    
    Throws:
    
    IloException
  - selectLargest
```
public IloValueSelector selectLargest(double minNumber,
                             IloIntValueEval e)
                               throws IloException
```
    This method returns a selector of value assignments to a variable that selects at least minNumber values having the largest evaluation according to the evaluator e. The parameter minNumber must be at least 1. For example, suppose that eight domain values (1-8) have evaluations (1) 5, (2) 8, (3) 3, (4) 9, (5) 2, (6) 8, (7) 1, (8) 7. When ordered by decreasing evaluation, this gives: (4) 9, (2) 8, (6) 8, (8) 7, (1) 5, (3) 3, (5) 2, (7) 1. If minNumber is 1, then value 4 would be selected, if it is 2 or 3, then values 2 and 6 would be selected, and if it is 4 then values 4, 2, 6, and 8 would be selected. Note that when minNumber is 2, both 2 and 6 are selected as both are considered equivalent. In addition, it is possible to specify a non-integer value of minNumber. In this case, at least floor(minNumber) selections are made, with probability minNumber - floor(minNumber) of selecting an additional value. It is still possible that this selector can select less domain values than minNumber if there are less than minNumber values supplied to it for selection, in which case all supplied values are selected.
    
    Throws:
    
    IloException
  - selectLargest
```
public IloValueSelector selectLargest(IloIntValueEval e)
                               throws IloException
```
    This method returns a selector of value assignments to a variable that selects all values having the largest evaluation according to the evaluator e.
    
    Throws:
    
    IloException
  - selectLargest
```
public IloValueSelector selectLargest(IloIntValueEval e,
                             double tol)
                               throws IloException
```
    This method returns a selector of integer variable assignments that selects all domain values whose evaluations are in the range [max - tol, max], where max is is the maximum valuation by e over the domain values to be evaluated. The parameter tol must be non-negative.
    
    Throws:
    
    IloException
  - selectRandomValue
```
public IloValueSelector selectRandomValue()
                                   throws IloException
```
    This method returns a selector of integer variable value assignments that selects a domain value randomly. It selects only one value.
    
    Throws:
    
    IloException
  - explicitValueEval
```
public IloIntValueEval explicitValueEval(int[] vals,
                                int[] evaluation,
                                double defautEval)
                                  throws IloException
```
    This method returns a value evaluator. The evaluations of elements of vals are explicitly defined in the array of integer values evaluation; that is, the evaluation of vals[i] is evaluation[i]. The arrays vals and evaluation must have the same size. The evaluation of a value that does not appear in vals is given by defautEval.
    
    Throws:
    
    IloException
  - explicitValueEval
```
public IloIntValueEval explicitValueEval(int[] vals,
                                int[] evaluation)
                                  throws IloException
```
    This method is a shortcut to explicitValueEval(vals, evaluation, 0).
    
    Throws:
    
    IloException
  - explicitValueEval
```
public IloIntValueEval explicitValueEval(int[] vals,
                                double[] evaluation,
                                double defautEval)
                                  throws IloException
```
    This method returns a value evaluator. The evaluations of elements of vals are explicitly defined in the array of floating-point values evaluation; that is, the evaluation of vals[i] is evaluation[i]. The arrays vals and evaluation must have the same size. The evaluation of a value that does not appear in vals is given by defautEval.
    
    Throws:
    
    IloException
  - explicitValueEval
```
public IloIntValueEval explicitValueEval(int[] vals,
                                double[] evaluation)
                                  throws IloException
```
    This method is a shortcut to explicitValueEval(vals, evaluation, 0).
    
    Throws:
    
    IloException
  - valueIndex
```
public IloIntValueEval valueIndex(int[] vals,
                         int defautEval)
                           throws IloException
```
    This method returns a value evaluator. The evaluation of each value is the index of the value in the array vals. That is, the evaluation of vals[i] is i. If the value does not appear in the array, defautEval is the evaluation returned.
    
    Throws:
    
    IloException
  - valueIndex
```
public IloIntValueEval valueIndex(int[] vals)
                           throws IloException
```
    This method is a shortcut to valueIndex(vals, -1);
    
    Throws:
    
    IloException
  - value
```
public IloIntValueEval value()
                      throws IloException
```
    This method returns a value evaluator. It returns as evaluation the value itself. This is useful to define instantiation strategies that choose the smallest or the largest value in a domain.
    
    Throws:
    
    IloException
  - valueImpact
```
public IloIntValueEval valueImpact()
                            throws IloException
```
    This method returns a value evaluator. The evaluation is the average reduction of the search space observed so far when instantiating the selected variable to the evaluated value. The greater the evaluation, the more space reduction this instantiation achieves. In general it is a good strategy to prefer a value having the smallest impact.
    
    Throws:
    
    IloException
  - valueSuccessRate
```
public IloIntValueEval valueSuccessRate()
                                 throws IloException
```
    This method returns a value evaluator. The evaluation is the success rate of instantiating the selected variable to the evaluated value. Assuming the selected variable has been instantiated to the evaluated value n times so far and this has resulted in f failures, the success rate is (n-f)/n.
    
    Throws:
    
    IloException
  - varIndex
```
public IloIntVarEval varIndex(IloIntVar[] vars)
                       throws IloException
```
    This method is a shortcut to varIndex(vars, -1).
    
    Throws:
    
    IloException
  - varIndex
```
public IloIntVarEval varIndex(IloIntVar[] vars,
                     int defaultIndex)
                       throws IloException
```
    This method returns a variable evaluator. The evaluation of a variable is the index of the variable in the array vars. That is, the evaluation of vars[i] is i. If the variable does not appear in the array, defaultIndex is the evaluation returned.
    
    Throws:
    
    IloException
  - explicitVarEval
```
public IloIntVarEval explicitVarEval(IloIntVar[] vars,
                            int[] vals,
                            double defautEval)
                              throws IloException
```
    This method returns a variable evaluator. The evaluations of variables in the array vars are explicitly defined in the array of integer values vals; that is, the evaluation of vars[i] is vals[i]. The arrays vars and val must have the same size. The evaluation of a variable that does not appear in the array is given by defautEval.
    
    Throws:
    
    IloException
  - explicitVarEval
```
public IloIntVarEval explicitVarEval(IloIntVar[] vars,
                            int[] vals)
                              throws IloException
```
    This method is a shortcut to explicitVarEval(vars, vals, 0).
    
    Throws:
    
    IloException
  - explicitVarEval
```
public IloIntVarEval explicitVarEval(IloIntVar[] vars,
                            double[] vals,
                            double defautEval)
                              throws IloException
```
    This method returns a variable evaluator. The evaluation of variables from the array vars are explicitly defined in the array of floating-point values vals; that is, the evaluation of vars[i] is vals[i]. The arrays vars and vals must have the same size. The evaluation of a variable that does not appear in the array is given by defautEval.
    
    Throws:
    
    IloException
  - explicitVarEval
```
public IloIntVarEval explicitVarEval(IloIntVar[] vars,
                            double[] vals)
                              throws IloException
```
    This method is a shortcut to explicitVarEval(vars, vals, 0).
    
    Throws:
    
    IloException
  - domainMin
```
public IloIntVarEval domainMin()
                        throws IloException
```
    This method returns a variable evaluator. This evaluator returns the minimum value in the current domain of the variable.
    
    Throws:
    
    IloException
  - domainMax
```
public IloIntVarEval domainMax()
                        throws IloException
```
    This method returns a variable evaluator. This evaluator returns the maximum value in the current domain of the variable.
    
    Throws:
    
    IloException
  - domainSize
```
public IloIntVarEval domainSize()
                         throws IloException
```
    This method returns a variable evaluator. This evaluator returns the number of elements in the current domain of the evaluated variable.
    
    Throws:
    
    IloException
  - varSuccessRate
```
public IloIntVarEval varSuccessRate()
                             throws IloException
```
    This method returns a variable evaluator. The evaluation is the the success rate of the variable. Assuming the evaluated variable has been instantiated n times so far and this has resulted in f failures, the success rate is (n-f)/n.
    
    Throws:
    
    IloException
    See Also:
    IloIntVarEval
  - varImpact
```
public IloIntVarEval varImpact()
                        throws IloException
```
    This method returns a variable evaluator. The evaluation is the the average reduction of the search space observed so far for this variable. The greater the evaluation, the more space reduction this variable achieves. In general, it is a good strategy to start with variable having the greatest impact in order to reduce the search space size.
    
    Throws:
    
    IloException
    See Also:
    IloIntVarEval
  - varLocalImpact
```
public IloIntVarEval varLocalImpact(int effort)
                             throws IloException
```
    This method returns a variable evaluator. The evaluation is the impact of the variable computed at the current node of the search tree. This computation is made by probing on values from the domain of the variables. The parameter effort indicates how much effort should be spent to compute this impact. When effort is equal to -1, every value of the domain is probed otherwise the nunber of probes effort will increase as the effort value increases.
    
    Throws:
    
    IloException
    See Also:
    IloIntVarEval
  - varLocalImpact
```
public IloIntVarEval varLocalImpact()
                             throws IloException
```
    This method is a shortcut to varLocalImpact(-1).
    
    Throws:
    
    IloException
  - impactOfLastBranch
```
public IloIntVarEval impactOfLastBranch()
                                 throws IloException
```
    This method returns a variable evaluator. The evaluation is the domain reduction that the last instantiation made by search has achieved on the evaluated variable. Values returned range from 0 to 1.0. If the value is close to zero then there wasn't much domain reduction on the evaluated variable during the last instantiation. If the value is close to one, the domain was reduced considerably.
    
    Throws:
    
    IloException
    See Also:
    IloIntVarEval
  - add
```
public IloAddable add(IloAddable object)
               throws IloException
```
    Description copied from interface: IloModel
    
    This method adds the extractable object to the invoking model.
    
    Specified by:
    
    add in interface IloModel
    
    Overrides:
    
    add in class ilog.concert.IloModelImpl
    
    Throws:
    
    IloException
    Parameters:
    object - The modeling object to be added to the invoking IloModel.
    
    Returns:
    The modeling object that has been added.
  - remove
```
public IloAddable remove(IloAddable object)
                  throws IloException
```
    Description copied from interface: IloModel
    
    This method removes the extractable object from the invoking model.
    If the modeling object has been added multiple times, only one instance is removed from the model.
    
    Specified by:
    
    remove in interface IloModel
    
    Overrides:
    
    remove in class ilog.concert.IloModelImpl
    
    Throws:
    
    IloException
    Parameters:
    object - The modeling object to be removed from the invoking IloModel.
    
    Returns:
    The modeling object that has been reduced by removal of an object.
  - startOf
```
public IloIntExpr startOf(IloIntervalVar a)
                   throws IloException
```
    This method returns an integer expression that represents the start of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the value 0.
    
    Throws:
    
    IloException
  - startOf
```
public IloIntExpr startOf(IloIntervalVar a,
                 int absVal)
                   throws IloException
```
    This method returns an integer expression that represents the start of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the constant integer value absVal.
    
    Throws:
    
    IloException
  - endOf
```
public IloIntExpr endOf(IloIntervalVar a)
                 throws IloException
```
    This method returns an integer expression that represents the end of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the value 0.
    
    Throws:
    
    IloException
  - endOf
```
public IloIntExpr endOf(IloIntervalVar a,
               int absVal)
                 throws IloException
```
    This method returns an integer expression that represents the end of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the constant integer value absVal.
    
    Throws:
    
    IloException
  - lengthOf
```
public IloIntExpr lengthOf(IloIntervalVar a)
                    throws IloException
```
    This method returns an integer expression that represents the length of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the value 0.
    
    Throws:
    
    IloException
  - lengthOf
```
public IloIntExpr lengthOf(IloIntervalVar a,
                  int absVal)
                    throws IloException
```
    This method returns an integer expression that represents the length of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the constant integer value absVal.
    
    Throws:
    
    IloException
  - sizeOf
```
public IloIntExpr sizeOf(IloIntervalVar a)
                  throws IloException
```
    This method returns an integer expression that represents the size of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the value 0.
    
    Throws:
    
    IloException
  - sizeOf
```
public IloIntExpr sizeOf(IloIntervalVar a,
                int absVal)
                  throws IloException
```
    This method returns an integer expression that represents the size of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the constant integer value absVal.
    
    Throws:
    
    IloException
  - typeOfNext
```
public IloIntExpr typeOfNext(IloIntervalSequenceVar seq,
                    IloIntervalVar a,
                    int lastVal)
                      throws IloException
```
    This method returns an integer expression that represents the type of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - typeOfNext
```
public IloIntExpr typeOfNext(IloIntervalSequenceVar seq,
                    IloIntervalVar a,
                    int lastVal,
                    int absVal)
                      throws IloException
```
    This method returns an integer expression that represents the type of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - typeOfPrevious
```
public IloIntExpr typeOfPrevious(IloIntervalSequenceVar seq,
                        IloIntervalVar a,
                        int firstVal)
                          throws IloException
```
    This method returns an integer expression that represents the type of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - typeOfPrevious
```
public IloIntExpr typeOfPrevious(IloIntervalSequenceVar seq,
                        IloIntervalVar a,
                        int firstVal,
                        int absVal)
                          throws IloException
```
    This method returns an integer expression that represents the type of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - startOfNext
```
public IloIntExpr startOfNext(IloIntervalSequenceVar seq,
                     IloIntervalVar a,
                     int lastVal)
                       throws IloException
```
    This method returns an integer expression that represents the start of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - startOfNext
```
public IloIntExpr startOfNext(IloIntervalSequenceVar seq,
                     IloIntervalVar a,
                     int lastVal,
                     int absVal)
                       throws IloException
```
    This method returns an integer expression that represents the start of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - startOfPrevious
```
public IloIntExpr startOfPrevious(IloIntervalSequenceVar seq,
                         IloIntervalVar a,
                         int firstVal)
                           throws IloException
```
    This method returns an integer expression that represents the start of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - startOfPrevious
```
public IloIntExpr startOfPrevious(IloIntervalSequenceVar seq,
                         IloIntervalVar a,
                         int firstVal,
                         int absVal)
                           throws IloException
```
    This method returns an integer expression that represents the start of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - endOfNext
```
public IloIntExpr endOfNext(IloIntervalSequenceVar seq,
                   IloIntervalVar a,
                   int lastVal)
                     throws IloException
```
    This method returns an integer expression that represents the end of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - endOfNext
```
public IloIntExpr endOfNext(IloIntervalSequenceVar seq,
                   IloIntervalVar a,
                   int lastVal,
                   int absVal)
                     throws IloException
```
    This method returns an integer expression that represents the end of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - endOfPrevious
```
public IloIntExpr endOfPrevious(IloIntervalSequenceVar seq,
                       IloIntervalVar a,
                       int firstVal)
                         throws IloException
```
    This method returns an integer expression that represents the end of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - endOfPrevious
```
public IloIntExpr endOfPrevious(IloIntervalSequenceVar seq,
                       IloIntervalVar a,
                       int firstVal,
                       int absVal)
                         throws IloException
```
    This method returns an integer expression that represents the end of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sizeOfNext
```
public IloIntExpr sizeOfNext(IloIntervalSequenceVar seq,
                    IloIntervalVar a,
                    int lastVal)
                      throws IloException
```
    This method returns an integer expression that represents the size of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sizeOfNext
```
public IloIntExpr sizeOfNext(IloIntervalSequenceVar seq,
                    IloIntervalVar a,
                    int lastVal,
                    int absVal)
                      throws IloException
```
    This method returns an integer expression that represents the size of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sizeOfPrevious
```
public IloIntExpr sizeOfPrevious(IloIntervalSequenceVar seq,
                        IloIntervalVar a,
                        int firstVal)
                          throws IloException
```
    This method returns an integer expression that represents the size of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - sizeOfPrevious
```
public IloIntExpr sizeOfPrevious(IloIntervalSequenceVar seq,
                        IloIntervalVar a,
                        int firstVal,
                        int absVal)
                          throws IloException
```
    This method returns an integer expression that represents the size of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - lengthOfNext
```
public IloIntExpr lengthOfNext(IloIntervalSequenceVar seq,
                      IloIntervalVar a,
                      int lastVal)
                        throws IloException
```
    This method returns an integer expression that represents the length of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - lengthOfNext
```
public IloIntExpr lengthOfNext(IloIntervalSequenceVar seq,
                      IloIntervalVar a,
                      int lastVal,
                      int absVal)
                        throws IloException
```
    This method returns an integer expression that represents the length of the interval variable that is next to interval a in sequence variable seq. When interval a is present and is the last interval of sequence seq, it returns the constant integer value lastVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - lengthOfPrevious
```
public IloIntExpr lengthOfPrevious(IloIntervalSequenceVar seq,
                          IloIntervalVar a,
                          int firstVal)
                            throws IloException
```
    This method returns an integer expression that represents the length of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns 0.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - lengthOfPrevious
```
public IloIntExpr lengthOfPrevious(IloIntervalSequenceVar seq,
                          IloIntervalVar a,
                          int firstVal,
                          int absVal)
                            throws IloException
```
    This method returns an integer expression that represents the length of the interval variable that is previous to interval a in sequence variable seq. When interval a is present and is the first interval of sequence seq, it returns the constant integer value firstVal. When interval a is absent, it returns the constant integer value absVal.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - overlapLength
```
public IloIntExpr overlapLength(IloIntervalVar a1,
                       IloIntervalVar a2,
                       int absVal)
                         throws IloException
```
    This method returns an integer expression that represents the length of the overlap of interval variable a1 and interval variable a2 whenever interval variables a1 and a2 are present. When interval variable a1 or a2 is absent, the method returns the constant integer value absVal.
    
    Throws:
    
    IloException
  - overlapLength
```
public IloIntExpr overlapLength(IloIntervalVar a1,
                       IloIntervalVar a2)
                         throws IloException
```
    This method returns an integer expression that represents the length of the overlap of interval variable a1 and interval variable a2 whenever interval variables a1 and a2 are present. When interval variable a1 or a2 is absent, the method returns zero.
    
    Throws:
    
    IloException
  - overlapLength
```
public IloIntExpr overlapLength(IloIntervalVar a,
                       int start,
                       int end,
                       int absVal)
                         throws IloException
```
    This method returns an integer expression that represents the length of the overlap of interval variable a and constant interval [start, end) whenever interval variable a is present. When interval variable a is absent, the method returns the constant integer value absVal.
    
    Throws:
    
    IloException
  - overlapLength
```
public IloIntExpr overlapLength(IloIntervalVar a,
                       int start,
                       int end)
                         throws IloException
```
    This method returns an integer expression that represents the length of the overlap of interval variable a and constant interval [start, end) whenever interval variable a is present. When interval variable a is absent, the method returns zero.
    
    Throws:
    
    IloException
  - startEval
```
public IloNumExpr startEval(IloIntervalVar a,
                   IloNumToNumSegmentFunction f)
                     throws IloException
```
    This method returns a numerical expression that represents the value of function f evaluated on the start of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the value 0.
    
    Throws:
    
    IloException
  - startEval
```
public IloNumExpr startEval(IloIntervalVar a,
                   IloNumToNumSegmentFunction f,
                   double absVal)
                     throws IloException
```
    This method returns a numerical expression that represents the value of function f evaluated on the start of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the constant numerical value absVal.
    
    Throws:
    
    IloException
  - endEval
```
public IloNumExpr endEval(IloIntervalVar a,
                 IloNumToNumSegmentFunction f)
                   throws IloException
```
    This method returns a numerical expression that represents the value of function f evaluated on the end of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the value 0.
    
    Throws:
    
    IloException
  - endEval
```
public IloNumExpr endEval(IloIntervalVar a,
                 IloNumToNumSegmentFunction f,
                 double absVal)
                   throws IloException
```
    This method returns a numerical expression that represents the value of function f evaluated on the end of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the constant numerical value absVal.
    
    Throws:
    
    IloException
  - lengthEval
```
public IloNumExpr lengthEval(IloIntervalVar a,
                    IloNumToNumSegmentFunction f)
                      throws IloException
```
    This method returns a numerical expression that represents the value of function f evaluated on the length of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the value 0.
    
    Throws:
    
    IloException
  - lengthEval
```
public IloNumExpr lengthEval(IloIntervalVar a,
                    IloNumToNumSegmentFunction f,
                    double absVal)
                      throws IloException
```
    This method returns a numerical expression that represents the value of function f evaluated on the length of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the constant numerical value absVal.
    
    Throws:
    
    IloException
  - sizeEval
```
public IloNumExpr sizeEval(IloIntervalVar a,
                  IloNumToNumSegmentFunction f)
                    throws IloException
```
    This method returns a numerical expression that represents the value of function f evaluated on the size of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the value 0.
    
    Throws:
    
    IloException
  - sizeEval
```
public IloNumExpr sizeEval(IloIntervalVar a,
                  IloNumToNumSegmentFunction f,
                  double absVal)
                    throws IloException
```
    This method returns a numerical expression that represents the value of function f evaluated on the size of interval variable a whenever the interval variable is present. When the interval variable is absent, it returns the constant numerical value absVal 0.
    
    Throws:
    
    IloException
  - noOverlap
```
public IloNoOverlap noOverlap(IloIntervalVar[] a,
                     java.lang.String name)
                       throws IloException
```
    This method creates a no-overlap constraint on the set of interval variables defined by array a. You can specify a name of your own choice.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - noOverlap
```
public IloNoOverlap noOverlap(IloIntervalVar[] a)
                       throws IloException
```
    This method creates a no-overlap constraint on the set of interval variables defined by array a.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - noOverlap
```
public IloNoOverlap noOverlap(IloIntervalSequenceVar seq,
                     IloTransitionDistance tdist,
                     java.lang.String name)
                       throws IloException
```
    This method creates a no-overlap constraint on the sequence variable seq. This constraint states that the interval variables of the sequence do not overlap and that the order of intervals in the sequence is the order implied by the relative position of the start and end points of the non-overlapping intervals. A transition distance tdist is used to specify a minimal distance between two interval variables in the sequence. The transition distance holds between an interval and all its successors in the sequence. You can specify a name of your own choice.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - noOverlap
```
public IloNoOverlap noOverlap(IloIntervalSequenceVar seq,
                     IloTransitionDistance tdist)
                       throws IloException
```
    This method creates a no-overlap constraint on the sequence variable seq. This constraint states that the interval variables of the sequence do not overlap and that the order of intervals in the sequence is the order implied by the relative position of the start and end points of the non-overlapping intervals. A transition distance tdist is used to specify a minimal distance between two interval variables in the sequence. The transition distance holds between an interval and all its successors in the sequence.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - noOverlap
```
public IloNoOverlap noOverlap(IloIntervalSequenceVar seq)
                       throws IloException
```
    This method creates a no-overlap constraint on the sequence variable seq. This constraint states that the interval variables of the sequence do not overlap and that the order of intervals in the sequence is the order implied by the relative position of the start and end points of the non-overlapping intervals.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - noOverlap
```
public IloNoOverlap noOverlap(IloIntervalSequenceVar seq,
                     IloTransitionDistance tdist,
                     boolean direct,
                     java.lang.String name)
                       throws IloException
```
    This method creates a no-overlap constraint on the sequence variable seq. This constraint states that the interval variables of the sequence do not overlap and that the order of intervals in the sequence is the order implied by the relative position of the start and end points of the non-overlapping intervals. The transition distance tdist specifies a minimal distance between two interval variables in the sequence. If direct is true, the transition distance holds between an interval and its immediate successor in the sequence otherwise, if direct is false, the transition distance holds between an interval and all its successors in the sequence. You can specify a name of your own choice.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - noOverlap
```
public IloNoOverlap noOverlap(IloIntervalSequenceVar seq,
                     IloTransitionDistance tdist,
                     boolean direct)
                       throws IloException
```
    This method creates a no-overlap constraint on the sequence variable seq. This constraint states that the interval variables of the sequence do not overlap and that the order of intervals in the sequence is the order implied by the relative position of the start and end points of the non-overlapping intervals. The transition distance tdist specifies a minimal distance between two interval variables in the sequence. If direct is true, the transition distance holds between an interval and its immediate successor in the sequence otherwise, if direct is false, the transition distance holds between an interval and all its successors in the sequence.
    
    For more information on interval variable sequencing, see the concept Interval variable sequencing in the C++ Reference Manual.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - span
```
public IloSpan span(IloIntervalVar a,
           IloIntervalVar[] bs,
           java.lang.String name)
             throws IloException
```
    This method creates a span constraint between interval variable a and the set of interval variables in the array bs.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - span
```
public IloSpan span(IloIntervalVar a,
           IloIntervalVar[] bs)
             throws IloException
```
    This method creates a span constraint between interval variable a and the set of interval variables in the array bs.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alternative
```
public IloAlternative alternative(IloIntervalVar a,
                         IloIntervalVar[] bs)
                           throws IloException
```
    This method creates an alternative constraint between interval variable a and the set of interval variables in the array bs.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alternative
```
public IloAlternative alternative(IloIntervalVar a,
                         IloIntervalVar[] bs,
                         java.lang.String name)
                           throws IloException
```
    This method creates an alternative constraint between interval variable a and the set of interval variables in the array bs.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alternative
```
public IloAlternative alternative(IloIntervalVar a,
                         IloIntervalVar[] bs,
                         int c)
                           throws IloException
```
    This method creates an alternative constraint between interval variable a and the set of interval variables in the array bs with cardinality c. If a is present, c intervals in bs will be selected by the alternative constraint.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alternative
```
public IloAlternative alternative(IloIntervalVar a,
                         IloIntervalVar[] bs,
                         int c,
                         java.lang.String name)
                           throws IloException
```
    This method creates an alternative constraint between interval variable a and the set of interval variables in the array bs with cardinality c. If a is present, c intervals in bs will be selected by the alternative constraint.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alternative
```
public IloAlternative alternative(IloIntervalVar a,
                         IloIntervalVar[] bs,
                         IloIntExpr c)
                           throws IloException
```
    This method creates an alternative constraint between interval variable a and the set of interval variables in the array bs with cardinality c. If a is present, c intervals in bs will be selected by the alternative constraint.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - alternative
```
public IloAlternative alternative(IloIntervalVar a,
                         IloIntervalVar[] bs,
                         IloIntExpr c,
                         java.lang.String name)
                           throws IloException
```
    This method creates an alternative constraint between interval variable a and the set of interval variables in the array bs with cardinality c. If a is present, c intervals in bs will be selected by the alternative constraint.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - synchronize
```
public IloSynchronize synchronize(IloIntervalVar a,
                         IloIntervalVar[] bs,
                         java.lang.String name)
                           throws IloException
```
    This method creates a synchronization constraint between interval variable a and the set of interval variables in the array bs.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - synchronize
```
public IloSynchronize synchronize(IloIntervalVar a,
                         IloIntervalVar[] bs)
                           throws IloException
```
    This method creates a synchronization constraint between interval variable a and the set of interval variables in the array bs.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - isomorphism
```
public IloIsomorphism isomorphism(IloIntervalVar[] domain,
                         IloIntervalVar[] intervals)
                           throws IloException
```
    This method creates an isomorphism constraint between the set of interval variables in the array domain and the set of interval variables in the array intervals.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - isomorphism
```
public IloIsomorphism isomorphism(IloIntervalVar[] domain,
                         IloIntervalVar[] intervals,
                         java.lang.String name)
                           throws IloException
```
    This method creates an isomorphism constraint between the set of interval variables in the array domain and the set of interval variables in the array intervals.
    Note: This constraint cannot be used in a logical constraint.
    
    .
    
    Throws:
    
    IloException
  - isomorphism
```
public IloIsomorphism isomorphism(IloIntervalVar[] domain,
                         IloIntervalVar[] intervals,
                         IloIntExpr[] map,
                         int absVal)
                           throws IloException
```
    This method creates an isomorphism constraint between the set of interval variables in the array domain and the set of interval variables in the array intervals. The set of integer expressions in the array map is the indexer from intervals to domain with a default index value for absent intervals absVal.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - isomorphism
```
public IloIsomorphism isomorphism(IloIntervalVar[] domain,
                         IloIntervalVar[] intervals,
                         IloIntExpr[] map,
                         int absVal,
                         java.lang.String name)
                           throws IloException
```
    This method creates an isomorphism constraint between the set of interval variables in the array domain and the set of interval variables in the array intervals. The set of integer expressions in the array map is the indexer from intervals to domain with a default index value for absent intervals absVal.
    
    Note: This constraint cannot be used in a logical constraint.
    
    Throws:
    
    IloException
  - cumulFunctionExpr
```
public IloCumulFunctionExpr cumulFunctionExpr()
                                       throws IloException
```
    This method creates a constant cumul function expression everywhere equal to 0 that the user can modify subsequently with the operators add, sub.
    
    Throws:
    
    IloException
  - cumulFunctionExpr
```
public IloCumulFunctionExpr cumulFunctionExpr(java.lang.String name)
                                       throws IloException
```
    This method creates a constant cumul function expression everywhere equal to 0 that the user can modify subsequently with the functions add, sub. You can specify a name of your own choice.
    
    Throws:
    
    IloException
  - heightAtStart
```
public IloIntExpr heightAtStart(IloIntervalVar a,
                       IloCumulFunctionExpr f)
                         throws IloException
```
    Whenever interval variable a is present, this method returns an integer expression that represents the total contribution of the start of interval variable a to the cumul function expression f.
    
    Throws:
    
    IloException
  - heightAtStart
```
public IloIntExpr heightAtStart(IloIntervalVar a,
                       IloCumulFunctionExpr f,
                       int absVal)
                         throws IloException
```
    Whenever interval variable a is present, this method returns an integer expression that represents the total contribution of the start of interval variable a to the cumul function expression f.
    
    When interval variable a is absent, this function returns a constant integer expression equal to absVal.
    
    Throws:
    
    IloException
  - heightAtEnd
```
public IloIntExpr heightAtEnd(IloIntervalVar a,
                     IloCumulFunctionExpr f)
                       throws IloException
```
    Whenever interval variable a is present, this function returns an integer expression that represents the total contribution of the end of interval variable a to the cumul function expression f.
    
    Throws:
    
    IloException
  - heightAtEnd
```
public IloIntExpr heightAtEnd(IloIntervalVar a,
                     IloCumulFunctionExpr f,
                     int absVal)
                       throws IloException
```
    Whenever interval variable a is present, this function returns an integer expression that represents the total contribution of the end of interval variable a to the cumul function expression f.
    
    When interval variable a is absent, this function returns a constant integer expression equal to absVal.
    
    Throws:
    
    IloException
  - step
```
public IloCumulFunctionExpr step(int t,
                        int v)
                          throws IloException
```
    This method returns an elementary cumul function expression that is equal to 0 before point t and equal to v after point t.
    
    Throws:
    
    IloException
  - pulse
```
public IloCumulFunctionExpr pulse(int start,
                         int end,
                         int v)
                           throws IloException
```
    This method returns an elementary cumul function expression that is equal to v between start and end and equal to 0 everywhere else.
    
    Throws:
    
    IloException
  - pulse
```
public IloCumulFunctionExpr pulse(IloIntervalVar a,
                         int v)
                           throws IloException
```
    This method returns an elementary cumul function expression that, whenever interval variable a is present, is equal to v between the start and the end of interval variable a and equal to 0 everywhere else. When interval variable a is absent, the function is the constant null function.
    
    Throws:
    
    IloException
  - pulse
```
public IloCumulFunctionExpr pulse(IloIntervalVar a,
                         int vmin,
                         int vmax)
                           throws IloException
```
    This method returns an elementary cumul function expression that, whenever interval variable a is present, is equal to a value v such that vmin <= v <= vmax everywhere between the start and the end of interval variable a and equal to 0 everywhere else. The choice of the value v in the range [vmin,vmax] is a decision of the problem. When interval variable a is absent, the function is the constant null function.
    
    Throws:
    
    IloException
  - stepAtStart
```
public IloCumulFunctionExpr stepAtStart(IloIntervalVar a,
                               int v)
                                 throws IloException
```
    This method returns an elementary cumul function expression that, whenever interval variable a is present, is equal to 0 before the start of a and equal to v after the start of a. When interval variable a is absent, the function is the constant null function.
    
    Throws:
    
    IloException
  - stepAtStart
```
public IloCumulFunctionExpr stepAtStart(IloIntervalVar a,
                               int vmin,
                               int vmax)
                                 throws IloException
```
    This method returns an elementary cumul function expression that, whenever interval variable a is present, is equal to a 0 before the start of a and equal to a value v such that vmin <= v <= vmax after the start of a. The choice of the value v in the range [vmin,vmax] is a decision of the problem. When interval variable a is absent, the function is the constant null function.
    
    Throws:
    
    IloException
  - stepAtEnd
```
public IloCumulFunctionExpr stepAtEnd(IloIntervalVar a,
                             int v)
                               throws IloException
```
    This method returns an elementary cumul function expression that, whenever interval variable a is present, is equal to 0 before the end of a and equal to v after the end of a. When interval variable a is absent, the function is the constant null function.
    
    Throws:
    
    IloException
  - stepAtEnd
```
public IloCumulFunctionExpr stepAtEnd(IloIntervalVar a,
                             int vmin,
                             int vmax)
                               throws IloException
```
    This method returns an elementary cumul function expression that, whenever interval variable a is present, is equal to a 0 before the end of a and equal to a value v such that vmin <= v <= vmax after the end of a. The choice of the value v in the range [vmin,vmax] is a decision of the problem. When interval variable a is absent, the function is the constant null function.
    
    Throws:
    
    IloException
  - sum
```
public IloCumulFunctionExpr sum(IloCumulFunctionExpr f1,
                       IloCumulFunctionExpr f2)
                         throws IloException
```
    This operator returns a cumul function expression equal to the sum of its arguments.
    
    Throws:
    
    IloException
  - diff
```
public IloCumulFunctionExpr diff(IloCumulFunctionExpr f1,
                        IloCumulFunctionExpr f2)
                          throws IloException
```
    This operator returns a cumul function expression equal to the difference of its arguments.
    
    Throws:
    
    IloException
  - transitionDistance
```
public IloTransitionDistance transitionDistance(int i,
                                       java.lang.String name)
                                         throws IloException
```
    This method returns an instance of transition distance of the specified size i. Initially, the transition distance between any two indices is 0. You need to fill the transition distance using the method setValue. You can specify a name of your own choice.
    
    Throws:
    
    IloException
  - transitionDistance
```
public IloTransitionDistance transitionDistance(int i)
                                         throws IloException
```
    This method returns an instance of transition distance of the specified size i. Initially, the transition distance between any two indices is 0. You need to fill the transition distance using the method setValue.
    
    Throws:
    
    IloException
  - transitionDistance
```
public IloTransitionDistance transitionDistance(int[][] dtable,
                                       java.lang.String name)
                                         throws IloException
```
    This method returns an instance of transition distance. The 2-dimensional integer array argument dtable gives the values of the transition distance. You can specify a name of your own choice.
    
    Throws:
    
    IloException
  - transitionDistance
```
public IloTransitionDistance transitionDistance(int[][] dtable)
                                         throws IloException
```
    This method returns an instance of transition distance. The 2-dimensional integer array argument dtable gives the values of the transition distance.
    
    Throws:
    
    IloException
  - stateFunction
```
public IloStateFunction stateFunction()
                               throws IloException
```
    This method creates an instance of state function.
    
    Throws:
    
    IloException
  - stateFunction
```
public IloStateFunction stateFunction(java.lang.String name)
                               throws IloException
```
    This method creates an instance of state function. You can specify a name of your own choice.
    
    Throws:
    
    IloException
  - stateFunction
```
public IloStateFunction stateFunction(IloTransitionDistance t)
                               throws IloException
```
    This method creates an instance of state function with transition distance t.
    
    Throws:
    
    IloException
  - stateFunction
```
public IloStateFunction stateFunction(IloTransitionDistance t,
                             java.lang.String name)
                               throws IloException
```
    This method creates an instance of state function with transition distance t. You can specify a name of your own choice.
    
    Throws:
    
    IloException
  - numToNumSegmentFunction
```
public IloNumToNumSegmentFunction numToNumSegmentFunction()
                                                   throws IloException
```
    This method creates a piecewise linear function that is constant. It is defined everywhere with value 0.
    
    Throws:
    
    IloException
  - numToNumSegmentFunction
```
public IloNumToNumSegmentFunction numToNumSegmentFunction(double[] x,
                                                 double[] v)
                                                   throws IloException
```
    This method creates a piecewise linear function defined everywhere whose segments are defined by the two argument arrays x and v. More precisely, the size n of array x must be equal to the size of array v and the function values will be:
    - v[0] for t < x[0],
    - v[i] + (t-x[i])*(v[i+1]-v[i])/(x[i+1]-x[i]) for t in [x[i], x[i+1]) for all i in [0, n-2] such that x[i-1] <> x[i], and
    - v[n-1] for x[n-1] <= t.
    Throws:
    
    IloException
  - piecewiseLinearFunction
```
public IloNumToNumSegmentFunction piecewiseLinearFunction(double[] point,
                                                 double[] slope,
                                                 double a,
                                                 double fa,
                                                 java.lang.String name)
                                                   throws IloException
```
    This method builds an instance of piecewise linear function defined everywhere. The array point contains the n breakpoints of the function such that point [i-1] <= point [i] for i = 1, . . ., n-1. The array slope contains the n+1 slopes of the n+1 segments of the function. The values a and fa must be coordinates of a point such that fa = f(a).
    
    When point[i-1] = point[i], there is a step at the x-coordinate point[i-1] and its height is slope[i] to reach the y-coordinate of point[i].
    
    Throws:
    
    IloException
  - piecewiseLinearFunction
```
public IloNumToNumSegmentFunction piecewiseLinearFunction(double[] point,
                                                 double[] slope,
                                                 double a,
                                                 double fa)
                                                   throws IloException
```
    This method builds an instance of piecewise linear function defined everywhere. The array point contains the n breakpoints of the function such that point [i-1] <= point [i] for i = 1, . . ., n-1. The array slope contains the n+1 slopes of the n+1 segments of the function. The values a and fa must be coordinates of a point such that fa = f(a).
    
    When point[i-1] = point[i], there is a step at the x-coordinate point[i-1] and its height is slope[i] to reach the y-coordinate of point[i].
    
    Throws:
    
    IloException
  - numToNumSegmentFunctionCursor
```
public IloNumToNumSegmentFunctionCursor numToNumSegmentFunctionCursor(IloNumToNumSegmentFunction f,
                                                             double x)
                                                               throws IloException
```
    This method creates a cursor to inspect piecewise linear function f. This cursor lets you iterate forward or backward over the steps of the function. The cursor initially specifies the step of the function that contains x.
    
    Throws:
    
    IloException
  - numToNumStepFunction
```
public IloNumToNumStepFunction numToNumStepFunction()
                                             throws IloException
```
    This method creates a step function defined everywhere with value 0.
    
    Throws:
    
    IloException
  - numToNumStepFunctionCursor
```
public IloNumToNumStepFunctionCursor numToNumStepFunctionCursor(IloNumToNumStepFunction f,
                                                       double x)
                                                         throws IloException
```
    This method creates a cursor to inspect step function f. This cursor lets you iterate forward or backward over the steps of the function. The cursor initially specifies the step of the function that contains x.
    
    Throws:
    
    IloException
  - refineConflict
```
public boolean refineConflict()
                       throws IloException
```
    This method identifies a minimal conflict for the infeasibility of the current model. Since the conflict is minimal, removal of any one of these constraints will remove that particular cause for infeasibility. There may be other conflicts in the model; consequently, repair of a given conflict does not guarantee feasibility of the remaining model.
    
    If the conflict refiner also works on variable domains (parameter IloCP.IntParam.ConflictRefinerOnVariables set to IloCP.ParameterValues.On), it will first identify a minimal conflicting set of constraints. Then, it will refine this conflict further by identifying a minimal subset of variables whose initial domain is responsible for the infeasibility from amongst the decision variables involved in the constraints of the conflict.
    
    This method returns a boolean value reporting whether or not a conflict has been found.
    
    When this method returns true, the conflict can be queried with the getConflict methods. The method writeConflict can write the elements of the current conflict.
    
    For more information on the conflict refiner, see the concept Conflict Refiner in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - refineConflict
```
public boolean refineConflict(IloConstraint[] csts)
                       throws IloException
```
    This method identifies a minimal conflict for the infeasibility of a subset of the constraints of the current model. Since the conflict is minimal, removal of any one of these constraints will remove that particular cause for infeasibility. There may be other conflicts in the model; consequently, repair of a given conflict does not guarantee feasibility of the remaining model.
    
    The constraints among which to look for a conflict are passed to this method through the argument csts.
    
    Constraints may be grouped by IloAnd. If any constraint in a group participates in the conflict, the entire group is determined to do so. No further detail about the constraints within that group is returned.
    
    Only constraints directly added to the model or a group of such constraints organized by IloAnd can be specified in array csts. If a constraint does not appear in this array, the constraint is assumed to be part of the conflict without any analysis and the conflict refiner will never try to remove this constraint in order to produce a smaller conflict.
    
    If the conflict refiner also works on variable domains (parameter IloCP.IntParam.ConflictRefinerOnVariables set to IloCP.ParameterValues.On), it will first identify a minimal conflicting set of constraints. Then, it will refine this conflict further by identifying a minimal subset of variables whose initial domain is responsible for the infeasibility from amongst the decision variables involved in the constraints of the conflict.
    
    This method returns a boolean value reporting whether or not a conflict has been found.
    
    When this method returns true, the conflict can be queried with the getConflict methods. The method writeConflict can write the elements of the current conflict.
    
    For more information on the conflict refiner, see the concept Conflict Refiner in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - refineConflict
```
public boolean refineConflict(IloConstraint[] csts,
                     double[] prefs)
                       throws IloException
```
    This method identifies a minimal conflict for the infeasibility of a subset of the constraints of the current model. Since the conflict is minimal, removal of any one of these constraints will remove that particular cause for infeasibility. There may be other conflicts in the model; consequently, repair of a given conflict does not guarantee feasibility of the remaining model.
    
    The constraints among which to look for a conflict are passed to this method through the argument csts.
    
    Constraints may be grouped by IloAnd. If any constraint in a group participates in the conflict, the entire group is determined to do so. No further detail about the constraints within that group is returned.
    
    Groups or constraints may be assigned preference. A group or constraint with a higher preference is more likely to be included in the conflict. More formally, if C={c1,...,cn} denotes the set of constraints in csts and each constraint ci is associated a preference p(ci), the preference of a subset of constraints S of C is defined as p(S)=min{c in S} p(c). Function refineConflict will return a minimal conflict S of maximal preference p(S).
    
    A negative preference value specifies that the corresponding group or constraint should not be considered in the computation of a conflict. In other words, such groups are not considered part of the model.
    
    Groups or constraints with a preference of 0 (zero) are always considered to be part of the conflict. No further checking is performed on such groups or constraints: the conflict refiner will never try to remove any of these constraints in order to produce a smaller conflict.
    
    Only constraints directly added to the model or a group of such constraints organized by IloAnd can be specified in array csts. If a constraint does not appear in this array, the constraint is assumed to be part of the conflict without any analysis and the conflict refiner will never try to remove this constraint in order to produce a smaller conflict. It will behave as if the constraint was associated a preference of 0 (zero).
    
    If the conflict refiner also works on variable domains (parameter IloCP.IntParam.ConflictRefinerOnVariables set to IloCP.ParameterValues.On), it will first identify a minimal conflicting set of constraints. Then, it will refine this conflict further by identifying a minimal subset of variables whose initial domain is responsible for the infeasibility from amongst the decision variables involved in the constraints of the conflict.
    
    This method returns a boolean value reporting whether or not a conflict has been found.
    
    When this method returns true, the conflict can be queried with the getConflict methods. The method writeConflict can write the elements of the current conflict.
    
    For more information on the conflict refiner, see the concept Conflict Refiner in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - getConflict
```
public IloCP.ConflictStatus getConflict(IloConstraint cst)
                                 throws IloException
```
    This method returns the conflict status for a given constraint cst.
    
    The status of each of the constraints that were initially specified as being part of the conflict and that were consequently not refined by the conflict refiner is IloCP.ConflictStatus.ConflictPossibleMember (constraints not in the array of constraints passed to refineConflict or constraints or groups with preference 0).
    
    For more information on the conflict refiner, see the concept Conflict Refiner in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - getConflict
```
public IloCP.ConflictStatus getConflict(IloNumVar var)
                                 throws IloException
```
    This method returns the conflict status for a given numerical variable var.
    
    In case the conflict refiner did not operate on variables (parameter IloCP.IntParam.ConflictRefinerOnVariables not set to IloCP.ParameterValues.On), this method returns status IloCP.ConflictStatus.ConflictPossibleMember.
    
    For more information on the conflict refiner, see the concept Conflict Refiner in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - getConflict
```
public IloCP.ConflictStatus getConflict(IloIntervalVar var)
                                 throws IloException
```
    This method returns the conflict status for a given interval variable var.
    
    In case the conflict refiner did not operate on variables (parameter IloCP.IntParam.ConflictRefinerOnVariables not set to IloCP.ParameterValues.On), this method returns status IloCP.ConflictStatus.ConflictPossibleMember.
    
    For more information on the conflict refiner, see the concept Conflict Refiner in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - writeConflict
```
public void writeConflict(java.io.OutputStream s)
                   throws IloException
```
    This method displays the current conflict. It will not display the constraints that were initially specified as being part of the conflict and that were consequently not refined by the conflict refiner (constraints not in the array of constraints passed to refineConflict or constraints or groups with preference 0).
    
    For more information on the conflict refiner, see the concept Conflict Refiner in the C++ Reference Manual.
    
    Throws:
    
    IloException
  - writeConflict
```
public void writeConflict()
                   throws IloException
```
    This method can be used as a shorthand for cp.writeConflict(cp.output()).
    
    Throws:
    
    IloException
  - runSeeds
```
public void runSeeds(int n)
              throws IloException
```
    This method runs n times the CP Optimizer search with different random seeds and computes statistics from the result of these runs.
    
    Throws:
    
    IloException
  - getRandomInt
```
public int getRandomInt(int n)
                 throws IloException
```
    This method returns a pseudo-randomly generated integer value in the range [0..n).
    
    Throws:
    
    IloException
  - getRandomNum
```
public double getRandomNum()
                    throws IloException
```
    This method returns a pseudo-randomly generated floating-point value in the range [0..1).
    
    Throws:
    
    IloException
  - getVersion
```
public java.lang.String getVersion()
                            throws IloException
```
    This method returns a string indicating the version of the product.
    
    Throws:
    
    IloException
  - getBuildID
```
public java.lang.String getBuildID()
                            throws IloException
```
    Throws:
    
    IloException
  - serializeCPCurrentDomains
```
public void serializeCPCurrentDomains(java.io.OutputStream s,
                             int indentStep)
                               throws IloException
```
    Throws:
    
    IloException
  - serializeAConflict
```
public void serializeAConflict(java.io.OutputStream s,
                      int indentStep)
                        throws IloException
```
    Throws:
    
    IloException
  - serializeCP
```
public void serializeCP(java.io.OutputStream s,
               int indentStep,
               boolean status,
               boolean solution,
               boolean info,
               boolean params,
               int nextStatus)
                 throws IloException
```
    Throws:
    
    IloException
  - serializeCPSolutionOnly
```
public void serializeCPSolutionOnly(java.io.OutputStream s,
                           int indentStep)
                             throws IloException
```
    Throws:
    
    IloException
  - serializeCPAfterSolve
```
public void serializeCPAfterSolve(java.io.OutputStream s,
                         int indentStep)
                           throws IloException
```
    Throws:
    
    IloException
  - serializeCPAfterNextSucceed
```
public void serializeCPAfterNextSucceed(java.io.OutputStream s,
                               int indentStep)
                                 throws IloException
```
    Throws:
    
    IloException
  - serializeCPAfterNextFailure
```
public void serializeCPAfterNextFailure(java.io.OutputStream s,
                               int indentStep)
                                 throws IloException
```
    Throws:
    
    IloException
  - serializeCPAfterEndSearch
```
public void serializeCPAfterEndSearch(java.io.OutputStream s,
                             int indentStep)
                               throws IloException
```
    Throws:
    
    IloException
  - serializeCPBeforeSolve
```
public void serializeCPBeforeSolve(java.io.OutputStream s,
                          int indentStep)
                            throws IloException
```
    Throws:
    
    IloException
  - getAllKPINames
```
public java.lang.String[] getAllKPINames()
```
    This method returns names of all KPIs. These will be KPIs added via addKPI(ilog.concert.IloNumExpr, java.lang.String) or loaded through importModel(java.lang.String).
  - getKPIValue
```
public double getKPIValue(java.lang.String name)
                   throws IloException
```
    This method returns the value of the KPI named name. If there is no KPI with this name, an exception of type IloException is thrown. This method can only be called when a solution has been found. If it called when no solution has been found, an exception of type IloException is thrown.
    
    Throws:
    
    IloException
  - getIncumbentValue
```
public double getIncumbentValue(java.lang.String exprName)
                         throws IloException
```
    This method returns the value of a named expression in the incumbent solution. If there is no expression with this name, an exception of type IloException is thrown. This method can only be called when a solution has been found. If it called when no solution has been found, an exception of type IloException is thrown.
    
    Throws:
    
    IloException
  - getIncumbentValue
```
public double getIncumbentValue(IloNumExpr expr)
                         throws IloException
```
    This method returns the value of the given expression in the incumbent solution. This method can only be called when a solution has been found. If it called when no solution has been found, or the expression expr has not been extracted, then an exception of type IloException is thrown.
    
    Throws:
    
    IloException
  - addKPI
```
public void addKPI(IloNumExpr kpi,
          java.lang.String name)
            throws IloException
```
    A key performance indicator (KPI) is a value which can be associated with a solution which represents an interesting measure of some aspect of the solution.
    For example, in a scheduling problem one may wish to minimize the makespan (date at which all tasks are completed), but other values may be of interest, like the average job completion time, or the maximum number of tasks executing in parallel over the horizon. One can identify such expressions in the model by marking them as KPIs. KPI values are automatically displayed in the log, can be queried after the solve or for each solution, and are exported to a CPO file when the model is exported.
    
    This method adds the given KPI (expression) under the given name to the CP Optimizer engine.
    
    Throws:
    
    IloException
  - removeKPI
```
public void removeKPI(java.lang.String name)
               throws IloException
```
    This method removes a KPI. The name passed should be the one used in addKPI. If no such KPI exists, an exception of type IloException is thrown. After execution of this method the KPI named name will be removed.
    
    Throws:
    
    IloException
  - removeAllKPIs
```
public void removeAllKPIs()
                   throws IloException
```
    This method removes all the KPIs from CP Optimizer.
    
    Throws:
    
    IloException
  - output
```
public java.io.PrintStream output()
```
    Returns the output stream of the invoking IloCP object. This stream is used by IloCP for printing logging information. It can be set with the method setOut.
    
    Returns:
    The output stream of the invoking IloCP object.
    See Also:
    setOut(java.io.OutputStream)
  - warning
```
public java.io.PrintStream warning()
```
    Returns the warning output stream of the invoking IloCP object. This stream is used by IloCP for printing warnings. It can be set with the method setWarning.
    
    Returns:
    The warning stream of the invoking IloCP object.
    See Also:
    setWarning(java.io.OutputStream)
  - error
```
public java.io.PrintStream error()
```
    Returns the error output stream of the invoking IloCP object. This stream is used by IloCP for printing errors. It can be set with the method setError.
    
    Returns:
    The error stream of the invoking IloCP object.
    See Also:
    setError(java.io.OutputStream)
  - setOut
```
public void setOut(java.io.OutputStream s)
```
    Sets the default output stream of the invoking IloCP object. After this call, all logging output will be output via the new stream. Passing null as the new output stream will turn off all logging output.
    
    Parameters:
    s - The new default output stream.
  - setWarning
```
public void setWarning(java.io.OutputStream s)
```
    Sets the warning stream of the invoking IloCP object. After this call, all warnings will be output via the new stream. Passing null as the new output stream will turn off all warnings.
    
    Parameters:
    s - The new warnings output stream.
  - setError
```
public void setError(java.io.OutputStream s)
```
    Sets the error stream of the invoking IloCP object. After this call, all errors will be output via the new stream. Passing null as the new output stream will turn off all errors.
    
    Parameters:
    s - The new errors output stream.
  - end
```
public void end()
```
    Frees all memory resources allocated by the invoking CP Optimizer.
    
    Overrides:
    
    end in class ilog.concert.IloModelerImpl
  - addCallback
```
public void addCallback(IloCP.Callback cb)
                 throws IloException
```
    This method adds user callback cb to the invoking CP Optimizer instance. Solves invoked after the addition will make calls to the callback.
    
    Throws:
    
    IloException
  - removeCallback
```
public void removeCallback(IloCP.Callback cb)
                    throws IloException
```
    This method removes user callback cb from the invoking CP Optimizer instance. Solves invoked after the addition will not make calls to the callback. If the callback is not known by CP Optimizer, an exception of type IloException is thrown.
    
    Throws:
    
    IloException
  - removeAllCallbacks
```
public void removeAllCallbacks()
                        throws IloException
```
    This method removes all the callbacks from the invoking CP Optimizer instance.
    
    Throws:
    
    IloException

Class IloCP

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class ilog.concert.IloModelerImpl

Methods inherited from class ilog.concert.IloModelImpl

Methods inherited from class java.lang.Object

Methods inherited from interface ilog.concert.IloModeler

Methods inherited from interface ilog.concert.IloModel

Methods inherited from interface ilog.concert.IloAddable

Field Detail

IntMin

IntMax

Infinity

IntervalMin

IntervalMax

NoState

Constructor Detail

IloCP

Method Detail

getModelImplSafe

model

setParameter

setParameter

getParameter

getParameterDefault

setParameter

setParameter

getParameter

getParameterDefault

getInfo

getInfo

solution

store

restore

setSearchPhases

setSearchPhases

setSearchPhases

clearExplanations

explainFailure

explainFailure

setStartingPoint

clearStartingPoint

solve

startNewSearch

endSearch

next

abortSearch

clearAbort

printInformation

printInformation

trueConstraint

falseConstraint

allDiff

allMinDistance

distribute

distribute

subCircuit

sequence

element

element

eq

eq

eq

ge

ge

ge

gt

gt

gt

inverse

le

le

le

lexicographic

lt

lt

lt

neq