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.
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. |
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 and Description |
---|
IloCP()
This method creates an algorithm for CP Optimizer.
|
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
before any subsequent
call to or . |
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 . |
int |
getEnd(IloIntervalVar a)
This method returns the current value of the end of interval variable
a in the
invoking instance of . |
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 . |
int |
getEndMin(IloIntervalVar a)
This method returns the minimum value for the end of interval variable
a in the
invoking instance of . |
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
. |
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 . |
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 . |
int |
getLengthMin(IloIntervalVar a)
This method returns the minimum value for the length of interval variable
a in
the invoking instance of . |
double |
getMax(IloNumVar var)
This member function returns the maximum value of the variable
var in the invoking instance
of . |
double |
getMin(IloNumVar var)
This member function returns the minimum value of the variable
var in the invoking instance
of . |
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 . |
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 . |
int |
getSizeMin(IloIntervalVar a)
This method returns the minimum value for the size of interval variable
a in the
invoking instance of . |
int |
getStart(IloIntervalVar a)
This method returns the current value of the start of interval variable
a in the
invoking instance of . |
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 . |
int |
getStartMin(IloIntervalVar a)
This method returns the minimum value for the start of interval variable
a in
the invoking instance of . |
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
. |
double |
getValue(IloIntVar i)
This method returns the current value of the variable
i in the invoking instance of
. |
double |
getValue(IloNumExpr num)
This method returns the current value of the expression
num in the invoking instance of
. |
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)
|
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 . |
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 instance. |
boolean |
isFixed(IloIntervalVar a)
This method indicates if the domain of
a takes on a particular value as
maintained by the invoking instance. |
boolean |
isFixed(IloNumVar var)
This member function indicates if the domain of
var takes on a particular value as maintained by the
invoking 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 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 . |
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
. |
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 . |
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.
|
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
add, add, getCopy, getModelImpl, getName, iterator, makeCopy, needCopy, remove, remove, setModelImpl, setName
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
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
getName, setName
public static final int IntMin
This constant represents the smallest possible negative integer allowed in CP Optimizer.
public static final int IntMax
This constant represents the largest possible positive integer allowed in CP Optimizer.
public static final double Infinity
This constant represents positive infinity of type double.
public static final int IntervalMin
This constant represents the smallest value that can be taken by the start or end of an interval variable.
public static final int IntervalMax
This constant represents the largest value that can be taken by the start or end of an interval variable.
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) );
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.
public ilog.concert.cppimpl.IloModel getModelImplSafe()
getModelImplSafe
in class ilog.concert.IloModelImpl
public IloModel model()
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.
IloException
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.
IloException
public int getParameter(IloCP.IntParam param) throws IloException
This method returns the value of the integer parameter param
in the invoked IloCP
instance.
IloException
public int getParameterDefault(IloCP.IntParam param) throws IloException
This method returns the default value of the integer parameter param
in the invoked
IloCP
instance.
IloException
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.
IloException
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.
IloException
public double getParameter(IloCP.DoubleParam param) throws IloException
This method returns the value of the floating-point parameter param
in the invoked
IloCP
instance.
IloException
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.
IloException
public int getInfo(IloCP.IntInfo which) throws IloException
This method returns the value of the integer information which
in the invoked IloCP
instance.
IloException
public double getInfo(IloCP.DoubleInfo which) throws IloException
This method returns the value of the floating-point information which
in the invoked
IloCP
instance.
IloException
public IloSolution solution() throws IloException
IloSolution
. You can define what variables are stored in the
solution by adding variables directly to the returned instance of solution.IloException
public void store(IloSolution solution) throws IloException
solution
by examining their current
values in the invoking IloCP
.IloException
public boolean restore(IloSolution solution) throws IloException
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.IloException
public void setSearchPhases() throws IloException
IloCP
instance.IloException
public void setSearchPhases(IloSearchPhase phase) throws IloException
IloCP.solve()
or IloCP.startNewSearch()
.
The method IloCP.setSearchPhases()
can be used to clear the search phases
set on the IloCP
instance.IloException
public void setSearchPhases(IloSearchPhase[] phases) throws IloException
IloCP.solve()
or IloCP.startNewSearch()
.
The method IloCP.setSearchPhases()
can be used to clear the search phases
set on the IloCP
instance.IloException
public void clearExplanations() throws IloException
This method is used to clear the set of failure tags (indices) to be explained.
IloException
public void explainFailure(int failTag) throws IloException
This method specifies a tag(index) of the failure to explain. Several failure tags can be added.
IloException
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.
IloException
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.
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.
public boolean solve() throws IloException
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
. 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. IloException
public void startNewSearch() throws IloException
IloCP
. It should be
used in conjunction with the method next()
.IloException
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
or startNewSearch()
is called. However, if you omit solve()
endSearch
you will not
obtain the correct summary information on the search log,
or through
until you do so.
getInfo(ilog.cp.IloCP.IntInfo)
You may not call
after calling
next()
without first
calling endSearch()
.
startNewSearch()
IloException
public boolean next() throws IloException
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.
IloException
public void abortSearch()
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 (
) from the same thread.
#Callback
public void clearAbort()
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.public void printInformation(java.io.OutputStream s) throws IloException
s
.
For more information, see printInformation()
.IloException
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:
startNewSearch
/next
).
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
IloException
public IloConstraint trueConstraint() throws IloException
IloException
public IloConstraint falseConstraint() throws IloException
IloException
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.
IloException
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
.
IloException
public IloConstraint distribute(IloIntExpr[] cards, int[] values, IloIntExpr[] vars) throws IloException
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.
IloException
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).public IloConstraint distribute(IloIntExpr[] cards, IloIntExpr[] vars) throws IloException
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.
IloException
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).public IloConstraint subCircuit(IloIntExpr[] next) throws java.lang.Exception
java.lang.Exception
public IloConstraint sequence(int nbMin, int nbMax, int seqWidth, IloIntVar[] vars, int[] values, IloIntVar[] cards) throws IloException
IloException
public IloConstraint element(IloIntExpr var, IloIntExpr index, int[] values) throws IloException
var == values[index]
.IloException
public IloConstraint element(IloNumExpr var, IloIntExpr index, double[] values) throws IloException
var == values[index]
.IloException
public IloConstraint eq(IloIntExpr e, int v)
e == v
.public IloConstraint eq(IloIntExpr e1, IloIntExpr e2)
e1 == e2
.public IloConstraint eq(int v, IloIntExpr e)
v == e
.public IloConstraint ge(IloIntExpr e, int v)
e >= v
.public IloConstraint ge(IloIntExpr e1, IloIntExpr e2)
e1 >= e2
.public IloConstraint ge(int v, IloIntExpr e)
v >= e
.public IloConstraint gt(IloIntExpr e, int v)
e > v
.public IloConstraint gt(IloIntExpr e1, IloIntExpr e2)
e1 > e2
.public IloConstraint gt(int v, IloIntExpr e)
v > e
.public IloConstraint inverse(IloIntExpr[] f, IloIntExpr[] invf) throws IloException
f
and invf
is n
, then the
inverse constraint guarantees that:
i
in the interval [0, n-1]
,
invf[f[i]]==i
;j
in the interval [0, n-1]
,
f[invf[j]]==j
.Note: This constraint cannot be used in a logical constraint.
IloException
public IloConstraint le(IloIntExpr e, int v)
e <= v
.public IloConstraint le(IloIntExpr e1, IloIntExpr e2)
e1 <= e2
.public IloConstraint le(int v, IloIntExpr e)
v <= e
.public IloConstraint lexicographic(IloIntExpr[] arg1, IloIntExpr[] arg2) throws IloException
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.
IloException
public IloConstraint lt(IloIntExpr e, int v)
e < v
.public IloConstraint lt(IloIntExpr e1, IloIntExpr e2)
e1 < e2
.public IloConstraint lt(int v, IloIntExpr e)
vintExpr < e
.public IloConstraint neq(IloIntExpr e, int v)
e != v
.public IloConstraint neq(IloIntExpr e1, IloIntExpr e2)
e1 != e2
.public IloConstraint neq(int v, IloIntExpr e)
v != e
.public IloConstraint pack(IloIntExpr[] load, IloIntExpr[] where, int[] weight) throws IloException
Note: This constraint cannot be used in a logical constraint.
IloException
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 placedweight
- Weight of the itemspublic IloConstraint pack(IloIntExpr[] load, IloIntExpr[] where, int[] weight, IloIntExpr used) throws IloException
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.
IloException
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 placedweight
- Weight of the itemsused
- Number of containers that are used in the pack (whose load is not zero)public IloConstraint allowedAssignments(IloIntVar[] exps, IloIntTupleSet table) throws IloException
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.IloException
public IloConstraint allowedAssignments(IloIntExpr exp, int[] values) throws IloException
values
specifies the allowed values of
the expression exp
.IloException
public IloConstraint forbiddenAssignments(IloIntVar[] exps, IloIntTupleSet table) throws IloException
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.IloException
public IloConstraint forbiddenAssignments(IloIntExpr exp, int[] values) throws IloException
values
specifies the forbidden values of
the variable exp
.IloException
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
constraint in place of the allowedAssignments(IloIntExpr, int[])
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.
IloException
IloConstraint
public IloConstraint equiv(IloConstraint c1, IloConstraint c2) throws IloException
c1 <=> c2
, in which the two constraints c1 and c2 are
equivalent.IloException
c1
- The first constraint.c2
- The other constraint.public IloConstraint ifThenElse(IloConstraint c1, IloConstraint c2, IloConstraint c3) throws IloException
(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.IloException
c1
- The condition constraint.c2
- The constraint implied if the condition is satisfied.c3
- The constraint implied if the condition is not satisfied.public IloConstraint imply(IloConstraint c1, IloConstraint c2) throws IloException
c1 => c2
, that is, the first constraint implies the
other.IloException
c1
- the first constraintc2
- the other constraintpublic IloConstraint neq(IloConstraint c1, IloConstraint c2) throws IloException
c1 <=> !c2
; that is, the truth values
of c1
and c2
should be different.IloException
public IloIntExpr intExpr(IloConstraint ct) throws IloException
IloIntExpr
from the ct
.IloException
public IloIntExpr[] intExprArray(int n) throws IloException
IloException
public IloNumExpr[] numExprArray(int n)
public IloIntExpr constant(int value, java.lang.String name) throws IloException
value
.IloException
value
- The value of the constant expression.name
- The name of the expression.public IloNumExpr constant(double value, java.lang.String name) throws IloException
value
.IloException
value
- The value of the constant expression.name
- The name of the expression.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
.
IloException
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
.
IloException
public IloIntExpr div(IloIntExpr e1, IloIntExpr e2)
e1 / e2
.public IloIntExpr div(int e1, IloIntExpr e2)
e1 / e2
.public IloIntExpr div(IloIntExpr e1, int e2)
e1 / e2
.public IloIntExpr element(IloIntExpr[] exprs, IloIntExpr index) throws IloException
exprs[index]
.IloException
exprs
- The array of expressionsindex
- The index expression.public IloIntExpr element(int[] values, IloIntExpr index) throws IloException
values[index]
.IloException
values
- The array of values.index
- The index expression.public IloNumExpr element(double[] values, IloIntExpr index) throws IloException
values[index]
.IloException
values
- The array of values.index
- The index expression.public IloNumExpr exponent(IloNumExpr e)
exp(e)
.public IloNumExpr log(IloNumExpr e)
log(e)
.public IloIntExpr max(IloIntExpr[] exprs) throws IloException
max(expr)
.max
in interface IloModeler
max
in class ilog.concert.IloModelerImpl
IloException
exprs
- the array of expressionspublic IloNumExpr max(IloNumExpr[] exprs) throws IloException
max(expr)
, the maximum over the array.max
in interface IloModeler
max
in class ilog.concert.IloModelerImpl
IloException
exprs
- The array of expressions.public IloIntExpr min(IloIntExpr[] exprs) throws IloException
min(exprs)
.min
in interface IloModeler
min
in class ilog.concert.IloModelerImpl
IloException
public IloNumExpr min(IloNumExpr[] exprs) throws IloException
min(exprs)
, the minimum over the array.min
in interface IloModeler
min
in class ilog.concert.IloModelerImpl
IloException
public IloIntExpr modulo(IloIntExpr e, int r) throws IloException
e % r
.IloException
public IloNumExpr power(IloNumExpr e1, IloNumExpr e2)
e1 ^ e2
.
e1
is constrained to be greater than 0 (zero).
If e2
is 0 (zero), the expression will take the value 1 (one).public IloNumExpr power(IloNumExpr e1, double e2)
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).public IloNumExpr power(double e1, IloNumExpr e2)
e1 ^ e2
.
e1
must be greater than 0 (zero).
If e2
is 0 (zero), the expression will take the value 1 (one).public IloIntExpr prod(int[] values, IloIntExpr[] exps) throws IloException
values
and exps
; that is,
values[0]*exps[0] + values[1]*exps[1] + ...
IloException
public IloIntExpr prod(IloIntExpr[] exps1, IloIntExpr[] exps2) throws IloException
exps1
and exps2
, that is,
exps1[0]*exps2[0] + exps1[1]*exps2[1] + ...
IloException
public IloIntExpr prod(IloIntExpr[] exps, int[] values) throws IloException
values
and exps
, that is,
values[0]*exps[0] + values[1]*exps[1] + ...
IloException
public IloNumExpr prod(double[] values, IloNumExpr[] exps) throws IloException
values
and exps
, that is,
values[0]*exps[0] + values[1]*exps[1] + ...
IloException
public IloNumExpr prod(IloNumExpr[] exps, double[] values) throws IloException
values
and exps
, that is,
values[0]*exps[0] + values[1]*exps[1] + ...
IloException
public IloNumExpr quot(IloNumExpr e1, IloNumExpr e2)
e1 / e2
.public IloNumExpr quot(double e1, IloNumExpr e2)
e1 / e2
.public IloNumExpr quot(IloNumExpr e1, double e2)
e1 / e2
.public IloNumExpr prod(IloNumExpr[] exps1, IloNumExpr[] exps2) throws IloException
exps1
and exps2
, that is,
exps1[0]*exps2[0] + exps1[1]*exps2[1] + ...
IloException
public IloIntExpr sum(IloIntExpr[] exprs) throws IloException
exprs
.sum
in interface IloModeler
sum
in class ilog.concert.IloModelerImpl
IloException
exprs
- An array containing the expressions to be summed.public IloNumExpr sum(IloNumExpr[] exprs) throws IloException
expr
.sum
in interface IloModeler
sum
in class ilog.concert.IloModelerImpl
IloException
exprs
- An array containing the terms to be summed.public IloNumExpr standardDeviation(IloIntExpr[] exprs) throws IloException
exprs
.IloException
public IloNumExpr standardDeviation(IloIntExpr[] exprs, double meanLB, double meanUB) throws IloException
exprs
. In addition, the mean of the values of exprs
will be enforced to lie in the range [meanLB
, meanUB
]
IloException
public IloNumExpr standardDeviation(ilog.concert.IloIntExprArray exprs, double meanLB, double meanUB) throws IloException
IloException
public IloNumExpr piecewiseLinear(IloNumExpr e, double[] point, double[] slope, double a, double fa) throws IloException
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.
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]
.
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.
IloException
public IloNumExpr piecewiseLinear(IloNumExpr e, double firstSlope, double[] point, double[] value, double lastSlope) throws IloException
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.IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
le
in class ilog.concert.IloModelerImpl
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.
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.
le
in class ilog.concert.IloModelerImpl
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.
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.
ge
in class ilog.concert.IloModelerImpl
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.
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.
ge
in class ilog.concert.IloModelerImpl
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.
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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:
startAlign
is true, it means that start
must be the start of an interval of the state
function. 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.
IloException
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.
IloException
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:
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. 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.
IloException
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.
IloException
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:
startAlign
is true, it means that start
must be the start of an interval of the state
function. 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.
IloException
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.
IloException
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:
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. 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.
IloException
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.
IloException
public IloIntVar intVar(int lb, int ub, java.lang.String name) throws IloException
ilog.concert.IloModelerImpl
intVar
in interface IloModeler
intVar
in class ilog.concert.IloModelerImpl
IloException
lb
- The minimum value of the variable.ub
- The maximum value of the variable.name
- The name of the variable.public IloIntVar intVar(int[] values, java.lang.String name) throws IloException
IloException
public IloIntVar intVar(int[] values) throws IloException
IloException
public IloIntVar[] intVarArray(int n) throws IloException
n
null variables.IloException
public IloIntVar[] intVarArray(int n, int[] values, java.lang.String name) throws IloException
n
variables with domain values and a name.IloException
public IloIntVar[] intVarArray(int n, int min, int max, java.lang.String name) throws IloException
n
variables with domain min..max
and a name.IloException
public java.lang.String arrayEltName(java.lang.String name, int index)
name.concat("[").concat(String.valueOf(index)).concat("]")
.public IloNumVar[] numVarArray(int n, double min, double max, java.lang.String name) throws IloException
n
variables with domain min..max
and a name.IloException
public IloIntTupleSet intTable(int dimension) throws IloException
table
.IloException
public void addTuple(IloIntTupleSet ts, int[] array) throws IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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]).
IloException
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.
IloException
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
.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
public IloObjective maximize(IloIntExpr e) throws IloException
IloException
public IloObjective maximize(IloMultiCriterionExpr e) throws IloException
IloException
public IloObjective minimize(IloIntExpr e) throws IloException
IloException
public IloObjective minimize(IloMultiCriterionExpr e) throws IloException
IloException
public double getObjValue() throws IloException
This method returns the numeric value of the objective function associated with the CP engine.
IloException
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
to obtain
full information.
getObjBounds()
IloException
getObjGap()
,
getObjBounds()
,
ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
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.
IloException
getObjBound()
,
getObjGaps()
,
ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
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.
IloException
public double[] getObjBounds() throws IloException
This method delivers the current bound on the objective
criteria in the invoking instance of IloCP
.
Note that when
is used,
then the bound values must be taken as a whole, as are the values delivered
by ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
. One cannot interpret
bound values on each criterion independently. For example, suppose, we
have a problem with two criteria specified to
getObjValues()
, 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.
ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
IloException
getObjBound()
,
getObjGaps()
,
ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
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
, 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 ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
and
IloCP#NumParam#OptimalityTolerance
).
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.
IloCP#NumParam#RelativeOptimalityTolerance
For the calculation of the gap, see
.
getObjGap()
IloException
getObjGap()
,
getObjBounds()
,
ilog.cp.IloCP.staticLex(ilog.concert.IloNumExprArray, java.lang.String)
public boolean hasObjective() throws IloException
IloException
public IloRange range(IloNumExpr expr, double b) throws IloException
IloRange
object. The new IloRange
object is initialized to
represent the constraint -b <= expr <= +b
.IloException
b
- Bound of the new IloRange
constraint.expr
- Expression of the new IloRange
constraint.IloRange
object initialized to represent the constraint -b <= expr <=
+b
.public boolean propagate() throws IloException
IloException
public boolean propagate(IloConstraint ct) throws IloException
IloException
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
produces a
model file that is easier to read.
exportModel(java.lang.String)
The dumped model can be imported back into CP Optimizer using the function
. 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.
importModel(java.lang.String)
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.
IloException
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.
IloException
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
if
you want to send the model to IBM support.
dumpModel(java.lang.String)
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
in several aspects:
dumpModel(java.lang.String)
IloCP.IntParam.ModelAnonymizer
.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.IloException
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.
IloException
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
)
could be set before IloCP#IntParam#UseFileLocations
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
and the
function throws an instance of
setError(java.io.OutputStream)
.
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()
and
getAllIloStateFunctions()
.
It is also possible to access modeling objects by name using functions
getAllConstrainedIloCumulFunctionExprs()
,
getIloIntVar(java.lang.String)
,
getIloIntervalVar(java.lang.String)
,
getIloIntervalSequenceVar(java.lang.String)
and
getIloStateFunction(java.lang.String)
.
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"));
IloException
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
that reads the model from a
file.
importModel(java.lang.String)
IloException
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)
IloException
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)
IloException
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)
IloException
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)
IloException
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:
<=
or
>=
,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)
IloException
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
is thrown. Similarly instance of
IloException
is thrown when an integer
variable with the given name does not exist.
IloException
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.
IloException
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
is thrown. Similarly an instance of
IloException
is thrown when the interval
variable with the given name does not exist.
IloException
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.
IloException
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
is thrown. Similarly an instance of
IloException
is thrown when interval sequence
variable with the given name does not exist.
IloException
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.
IloException
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
is thrown. Similarly an instance of
IloException
is thrown when a state function
with the given name does not exist.
IloException
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.
IloException
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
then
only the following certain types of cumulative expressions can be found using this function:
importModel(java.lang.String)
pulse
, stepAtStart
and stepAtEnd
.alwaysIn
or using operator <=
or
<=
. All non-empty names in the model must be unique, otherwise an instance of
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.
IloException
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.
IloException
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
is thrown if:
IloException
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.
IloException
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
is thrown if:
IloException
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.
IloException
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
is thrown if:
IloException
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.
IloException
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
is thrown if:
IloException
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.
IloException
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
is thrown if:
IloException
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.
IloException
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
is thrown if:
IloException
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.
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
is thrown if:
IloException
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.
IloException
public double getValue(IloIntVar i)
i
in the invoking instance of
IloCP
. An assertion is violated if v
is not fixed to a value.public double getValue(IloIntExpr i)
i
in the invoking instance of
IloCP
.public double getValue(IloNumExpr num)
num
in the invoking instance of
IloCP
.public void getValues(IloIntVar[] vars, double[] vals) throws IloException
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.
IloException
public int getIntValue(IloIntVar var)
var
in the invoking instance of
IloCP
. An assertion is violated if var
is not fixed to a value.public double getMin(IloNumVar var)
var
in the invoking instance
of IloCP
.public double getMax(IloNumVar var)
var
in the invoking instance
of IloCP
.public boolean isInDomain(IloNumVar var, int value)
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.public int getDomainSize(IloNumVar var)
var
as maintained in the invoking
instance of IloCP
. An assertion is violated if var
is not of integral type.public boolean isFixed(IloNumVar var)
var
takes on a particular value as maintained by the
invoking IloCP
instance.public java.util.Iterator iterator(IloIntVar var)
var
, as maintained by the
invoking IloCP.public boolean isFixed(IloIntervalVar a)
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.public boolean isAbsent(IloIntervalVar a)
a
is absent in the
invoking instance of IloCP
.public boolean isPresent(IloIntervalVar a)
a
is present in the
invoking instance of IloCP
.public int getStartMin(IloIntervalVar a)
a
in
the invoking instance of IloCP
.public int getStartMax(IloIntervalVar a)
a
in
the invoking instance of IloCP
.public int getStart(IloIntervalVar a)
a
in the
invoking instance of IloCP
. An assertion is violated if a
is not fixed.public int getEndMin(IloIntervalVar a)
a
in the
invoking instance of IloCP
.public int getEndMax(IloIntervalVar a)
a
in the
invoking instance of IloCP
.public int getEnd(IloIntervalVar a)
a
in the
invoking instance of IloCP
. An assertion is violated if a
is not fixed.public int getSizeMin(IloIntervalVar a)
a
in the
invoking instance of IloCP
.public int getSizeMax(IloIntervalVar a)
a
in the
invoking instance of IloCP
.public int getSize(IloIntervalVar a)
a
in the
invoking instance of IloCP
. An assertion is violated if a
is not fixed.public int getLengthMin(IloIntervalVar a)
a
in
the invoking instance of IloCP
.public int getLengthMax(IloIntervalVar a)
a
in
the invoking instance of IloCP
.public int getLength(IloIntervalVar a)
a
in
the invoking instance of IloCP
. An assertion is violated if a
is not fixed.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
.
IloException
public boolean isFixed(IloIntervalSequenceVar seq) throws IloException
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.IloException
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.
IloException
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.
IloException
public IloIntervalVar getNext(IloIntervalSequenceVar seq, IloIntervalVar a) throws IloException
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.IloException
public IloIntervalVar getPrev(IloIntervalSequenceVar seq, IloIntervalVar a) throws IloException
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.IloException
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
IloException
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
i
th 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.
IloException
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
i
th 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.
IloException
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
i
th 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.
IloException
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
IloException
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.
IloException
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) );
IloException
public int getSegmentStart(IloStateFunction f, int i) throws IloException
This method assumes that state function
f
is fixed. It returns the start of the
i
th 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) );
IloException
public int getSegmentEnd(IloStateFunction f, int i) throws IloException
This method assumes that state function
f
is fixed. It returns the end of the
i
th 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) );
IloException
public int getSegmentValue(IloStateFunction f, int i) throws IloException
This method assumes that state function
f
is fixed. It returns the value of the
i
th 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) );
IloException
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)
.
IloException
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.
IloException
public IloSearchPhase searchPhase(IloIntVar[] vars) throws IloException
IloException
public IloSearchPhase searchPhase(IloIntVar[] vars, IloIntVarChooser varChooser, IloIntValueChooser valueChooser) throws IloException
varChooser
and valueChooser
to determine how to instantiate variables in
vars
.IloException
public IloSearchPhase searchPhase(IloIntVarChooser varChooser, IloIntValueChooser valueChooser) throws IloException
IloCP
instance.IloException
public IloSearchPhase searchPhase(IloIntervalVar[] intervalVars) throws IloException
intervalVars
: each interval
variable in the array will be assigned a presence status and for each present interval, a start and an end value.
IloException
public IloSearchPhase searchPhase(IloIntervalSequenceVar[] sequenceVars) throws IloException
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.
IloException
public IloIntVarChooser intVarChooser(IloVarSelector varSel) throws IloException
IloIntVarChooser
made with the IloVarSelector
varSel
.IloException
public IloIntVarChooser intVarChooser(IloVarSelector[] varSels) throws IloException
IloIntVarChooser
made with the array of IloVarSelector
varSels
.IloException
public IloIntValueChooser intValueChooser(IloValueSelector valueSel) throws IloException
IloIntValueChooser
made with the IloValueSelector
valueSel
.IloException
public IloIntValueChooser intValueChooser(IloValueSelector[] valueSels) throws IloException
IloIntValueChooser
made with the array of IloValueSelector
valueSels
.IloException
public IloVarSelector selectSmallest(double minNumber, IloIntVarEval e) throws IloException
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.IloException
public IloVarSelector selectSmallest(IloIntVarEval e) throws IloException
e
.IloException
public IloVarSelector selectSmallest(IloIntVarEval e, double tol) throws IloException
[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.IloException
public IloVarSelector selectLargest(double minNumber, IloIntVarEval e) throws IloException
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.IloException
public IloVarSelector selectLargest(IloIntVarEval e) throws IloException
e
.IloException
public IloVarSelector selectLargest(IloIntVarEval e, double tol) throws IloException
[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.IloException
public IloVarSelector selectRandomVar() throws IloException
IloException
public IloValueSelector selectSmallest(double minNumber, IloIntValueEval e) throws IloException
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.IloException
public IloValueSelector selectSmallest(IloIntValueEval e) throws IloException
e
.IloException
public IloValueSelector selectSmallest(IloIntValueEval e, double tol) throws IloException
[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.IloException
public IloValueSelector selectLargest(double minNumber, IloIntValueEval e) throws IloException
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.IloException
public IloValueSelector selectLargest(IloIntValueEval e) throws IloException
e
.IloException
public IloValueSelector selectLargest(IloIntValueEval e, double tol) throws IloException
[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.IloException
public IloValueSelector selectRandomValue() throws IloException
IloException
public IloIntValueEval explicitValueEval(int[] vals, int[] evaluation, double defautEval) throws IloException
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
.IloException
public IloIntValueEval explicitValueEval(int[] vals, int[] evaluation) throws IloException
explicitValueEval(vals, evaluation, 0)
.IloException
public IloIntValueEval explicitValueEval(int[] vals, double[] evaluation, double defautEval) throws IloException
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
.IloException
public IloIntValueEval explicitValueEval(int[] vals, double[] evaluation) throws IloException
explicitValueEval(vals, evaluation, 0)
.IloException
public IloIntValueEval valueIndex(int[] vals, int defautEval) throws IloException
vals
. That is, the evaluation of vals[i]
is i
. If the value
does not appear in the array, defautEval
is the evaluation returned.IloException
public IloIntValueEval valueIndex(int[] vals) throws IloException
valueIndex(vals, -1)
;IloException
public IloIntValueEval value() throws IloException
IloException
public IloIntValueEval valueImpact() throws IloException
IloException
public IloIntValueEval valueSuccessRate() throws IloException
n
times so far and this has resulted in f
failures, the success rate is
(n-f)/n
.IloException
public IloIntVarEval varIndex(IloIntVar[] vars) throws IloException
varIndex(vars, -1)
.IloException
public IloIntVarEval varIndex(IloIntVar[] vars, int defaultIndex) throws IloException
vars
. That is, the evaluation of vars[i]
is i
. If the variable does not
appear in the array, defaultIndex
is the evaluation returned.IloException
public IloIntVarEval explicitVarEval(IloIntVar[] vars, int[] vals, double defautEval) throws IloException
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
.IloException
public IloIntVarEval explicitVarEval(IloIntVar[] vars, int[] vals) throws IloException
explicitVarEval(vars, vals, 0)
.IloException
public IloIntVarEval explicitVarEval(IloIntVar[] vars, double[] vals, double defautEval) throws IloException
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
.IloException
public IloIntVarEval explicitVarEval(IloIntVar[] vars, double[] vals) throws IloException
explicitVarEval(vars, vals, 0)
.IloException
public IloIntVarEval domainMin() throws IloException
IloException
public IloIntVarEval domainMax() throws IloException
IloException
public IloIntVarEval domainSize() throws IloException
IloException
public IloIntVarEval varSuccessRate() throws IloException
n
times so far and this has resulted in f
failures, the success rate is (n-f)/n
.IloException
IloIntVarEval
public IloIntVarEval varImpact() throws IloException
IloException
IloIntVarEval
public IloIntVarEval varLocalImpact(int effort) throws IloException
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.IloException
IloIntVarEval
public IloIntVarEval varLocalImpact() throws IloException
varLocalImpact(-1)
.IloException
public IloIntVarEval impactOfLastBranch() throws IloException
IloException
IloIntVarEval
public IloAddable add(IloAddable object) throws IloException
IloModel
add
in interface IloModel
add
in class ilog.concert.IloModelImpl
IloException
object
- The modeling object to be added to the
invoking IloModel
.public IloAddable remove(IloAddable object) throws IloException
IloModel
If the modeling object has been added multiple times, only one instance is removed from the model.
remove
in interface IloModel
remove
in class ilog.concert.IloModelImpl
IloException
object
- The modeling object to be removed from the invoking
IloModel
.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.
IloException
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
.
IloException
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.
IloException
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
.
IloException
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.
IloException
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
.
IloException
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.
IloException
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
.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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
.
IloException
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.
IloException
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
.
IloException
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.
IloException
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.
IloException
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
.
IloException
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.
IloException
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
.
IloException
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.
IloException
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
.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
.IloException
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.
IloException
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.
IloException
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
.
IloException
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.
IloException
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
.
IloException
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
.
IloException
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
.
IloException
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
.
IloException
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
.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
public IloCumulFunctionExpr sum(IloCumulFunctionExpr f1, IloCumulFunctionExpr f2) throws IloException
This operator returns a cumul function expression equal to the sum of its arguments.
IloException
public IloCumulFunctionExpr diff(IloCumulFunctionExpr f1, IloCumulFunctionExpr f2) throws IloException
This operator returns a cumul function expression equal to the difference of its arguments.
IloException
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.
IloException
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
.
IloException
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.
IloException
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.
IloException
public IloStateFunction stateFunction() throws IloException
This method creates an instance of state function.
IloException
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.
IloException
public IloStateFunction stateFunction(IloTransitionDistance t) throws IloException
This method creates an instance of state function with transition distance
t
.
IloException
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.
IloException
public IloNumToNumSegmentFunction numToNumSegmentFunction() throws IloException
This method creates a piecewise linear function that is constant.
It is defined everywhere with value 0
.
IloException
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]
, andv[n-1]
for x[n-1] <= t
.IloException
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].
IloException
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].
IloException
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
.
IloException
public IloNumToNumStepFunction numToNumStepFunction() throws IloException
This method creates a step function defined everywhere with value 0.
IloException
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
.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
public void writeConflict() throws IloException
This method can be used as a shorthand for
cp.writeConflict(cp.output())
.
IloException
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.
IloException
public int getRandomInt(int n) throws IloException
IloException
public double getRandomNum() throws IloException
IloException
public java.lang.String getVersion() throws IloException
IloException
public java.lang.String getBuildID() throws IloException
IloException
public void serializeCPCurrentDomains(java.io.OutputStream s, int indentStep) throws IloException
IloException
public void serializeAConflict(java.io.OutputStream s, int indentStep) throws IloException
IloException
public void serializeCP(java.io.OutputStream s, int indentStep, boolean status, boolean solution, boolean info, boolean params, int nextStatus) throws IloException
IloException
public void serializeCPSolutionOnly(java.io.OutputStream s, int indentStep) throws IloException
IloException
public void serializeCPAfterSolve(java.io.OutputStream s, int indentStep) throws IloException
IloException
public void serializeCPAfterNextSucceed(java.io.OutputStream s, int indentStep) throws IloException
IloException
public void serializeCPAfterNextFailure(java.io.OutputStream s, int indentStep) throws IloException
IloException
public void serializeCPAfterEndSearch(java.io.OutputStream s, int indentStep) throws IloException
IloException
public void serializeCPBeforeSolve(java.io.OutputStream s, int indentStep) throws IloException
IloException
public java.lang.String[] getAllKPINames()
This method returns names of all KPIs. These
will be KPIs added via
or loaded through addKPI(ilog.concert.IloNumExpr, java.lang.String)
.
importModel(java.lang.String)
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.
IloException
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.
IloException
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.
IloException
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.
IloException
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.
IloException
public void removeAllKPIs() throws IloException
This method removes all the KPIs from CP Optimizer.
IloException
public java.io.PrintStream output()
IloCP
object. This stream is used by IloCP
for printing logging information. It can be set with the method setOut
.IloCP
object.setOut(java.io.OutputStream)
public java.io.PrintStream warning()
IloCP
object. This stream is used by
IloCP
for printing warnings. It can be set with the method setWarning
.IloCP
object.setWarning(java.io.OutputStream)
public java.io.PrintStream error()
IloCP
object. This stream is used by
IloCP
for printing errors. It can be set with the method setError
.IloCP
object.setError(java.io.OutputStream)
public void setOut(java.io.OutputStream s)
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.s
- The new default output stream.public void setWarning(java.io.OutputStream s)
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.s
- The new warnings output stream.public void setError(java.io.OutputStream s)
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.s
- The new errors output stream.public void end()
end
in class ilog.concert.IloModelerImpl
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.
IloException
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
is thrown.
IloException
IloException
public void removeAllCallbacks() throws IloException
This method removes all the callbacks from the invoking CP Optimizer instance.
IloException