|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
IloCplex
to select an algorithm.
expr
.
abs(e)
,
the absolute value of its argument.
expr
.
expr
.
IloAnd
.
IloModel
.
IloOr
.
cut
as a global cut to the problem being solved.
cut
as a global user cut to the problem being solved.
object
to the invoking model.
objects
to the invoking model.
objects
to the invoking model,
starting with the index start
and continuing to
the number of objects indicated by num
.
cut
as a cut to the invoking
IloCplex
object.
cut
as cuts to the invoking
IloCplex
object.
num
constraints given in cut
as cuts to the invoking IloCplex
object, starting
with element cut[start]
.
IloRange
initialized to represent the constraint expr == rhs
,
and added to the invoking IloModel
.
IloRange
initialized to represent the constraint expr == rhs
,
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint e1 == e2
,
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint e1 == e2
,
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint val == expr
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint val == expr
and added to the invoking instance of IloModeler
.
IloModeler.addEq(IloNumExpr e, double v)
IloModeler.addEq(IloNumExpr e,
double v,
String name)
IloModeler.addEq(IloNumExpr e1, IloNumExpr e2)
IloModeler.addEq(IloNumExpr e1,
IloNumExpr e2,
String name)
IloModeler.addEq(double v, IloNumExpr e)
IloModeler.addEq(double v,
IloNumExpr e,
String name)
IloRange
initialized to represent the constraint expr >= rhs
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint expr >= rhs
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint e1 >= e2
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint e1 >= e2
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint val >= expr
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint val >= expr
and added to the invoking instance of IloModeler
.
IloModeler.addGe(IloNumExpr e, double v)
IloModeler.addGe(IloNumExpr e,
double v,
String name)
IloModeler.addGe(IloNumExpr e1, IloNumExpr e2)
IloModeler.addGe(IloNumExpr e1,
IloNumExpr e2,
String name)
IloModeler.addGe(double v, IloNumExpr e)
IloModeler.addGe(double v, IloNumExpr e,
String name)
IloLPMatrix
object.
IloLPMatrix
object,
with the specified name, to the invoking model.
IloMPModeler.addLPMatrix(String name)
IloMPModeler.addLPMatrix()
IloRange
initialized to represent the constraint expr <= rhs
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint expr <= rhs
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint e1 <= e2
,
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint e1 <= e2
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint val <= expr
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint val <= expr
and added to the invoking instance of IloModeler
.
IloModeler.addLe(IloNumExpr e, double v)
IloModeler.addLe(IloNumExpr e, double v,
String name)
IloModeler.addLe(IloNumExpr e1, IloNumExpr e2)
IloModeler.addLe(IloNumExpr e1, IloNumExpr e2,
String name)
IloModeler.addLe(double v, IloNumExpr e)
IloModeler.addLe(double v, IloNumExpr e,
String name)
cut
as a local cut to the problem being solved.
name
and adds it to the invoking
model.
IloObjective
representing an objective to maximize the expression expr
and added to the invoking model.
IloObjective
,
representing an objective to maximize the expression expr
,
assigned the name name
, and added to the invoking model.
IloModeler.addMaximize(IloNumExpr)
IloModeler.addMaximize(IloNumExpr, String)
IloMPModeler.addMaximize()
IloMPModeler.addMaximize(String)
name
and adds the empty objective to the invoking model.
IloObjective
representing an objective to minimize the expression expr
and added to the invoking model.
IloObjective
representing an objective to minimize the expression expr
,
assigned the name name
, and added to the invoking model.
IloModeler.addMinimize(IloNumExpr)
IloModeler.addMinimize(IloNumExpr, String)
IloMPModeler.addMinimize()
IloMPModeler.addMinimize(String)
sense
and adds it to the invoking model.
name
and with the specified
sense
and adds it to the invoking model.
IloObjective
representing an objective to optimize the expression
expr
with respect to the optimization sense
indicated by sense
and added to the invoking model.
IloObjective
representing an objective to optimize the expression expr
with respect to the optimization sense indicated by sense
,
assigned the name name
, and
added to the invoking model.
IloModeler.addObjective(IloObjectiveSense,
IloNumExpr, String)
IloModeler.addObjective(IloObjectiveSense,
IloNumExpr)
IloMPModeler.addObjective(IloObjectiveSense)
IloMPModeler.addObjective(IloObjectiveSense,
String)
IloRange
object.
IloRange
object with the specified
name
and upper and lower bounds.
IloRange
initialized to represent the constraint
lb <= expr <= ub
and added to the invoking instance of IloModeler
.
IloRange
initialized to represent the constraint
lb <= expr <= ub
and added to the invoking instance of IloModeler
.
IloModeler.addRange(double lb,
IloNumExpr expr,
double ub,
String name)
IloModeler.addRange(double lb,
IloNumExpr expr,
double ub)
IloMPModeler.addRange(double lb,
double ub,
String name)
IloMPModeler.addRange(double lb, double ub)
num
of
the specified variables and weights,
starting from the index specified by start
,
and adds the SOS to the invoking model.
num
specified variables, weights, and names, starting from the index
specified by start
, and adds the SOS to the invoking mode.
IloMPModeler.addSOS1(IloNumVar[] var,
double[] val)
IloMPModeler.addSOS1(IloNumVar[] var,
double[] val,
int start, int num)
IloMPModeler.addSOS1(IloNumVar[] var,
double[] val, String name)
IloMPModeler.addSOS1(IloNumVar[] var,
double[] val,
int start,
int num,
String name)
num
of the
specified variables and weights, starting from the index
specified by start
, and adds the SOS to the
invoking model.
num
of the specified
variables and weights, starting from the index specified by
start
, and adds the new SOS along with its name
to the invoking model.
IloMPModeler.addSOS2(IloNumVar[] var, double[] val)
IloMPModeler.addSOS2(IloNumVar[] var,
double[] val,
int start, int num)
IloMPModeler.addSOS2(IloNumVar[] var,
double[] val,
String name)
IloMPModeler.addSOS2(IloNumVar[] var,
double[] val,
int start,
int num,
String name)
coef * var
to a scalar product.
coef * var
to a scalar product.
coef * var
to a scalar product.
coef * var
to a scalar product.
sum_i(coef[i] * var[i])
to a scalar product.
sum_i(coef[i] * var[i])
to a scalar product.
sum_i(coef[i] * var[i])
to a scalar product.
sum_i(coef[i] * var[i])
to a scalar product.
sum_i(coef[i] * var[i])
to a scalar product.
sum_i(coef[i] * var[i])
to a scalar product.
sum_i(coef[i] * var[i])
to a scalar product.
sum_i(coef[i] * var[i])
to a scalar product.
IloObjective
object.
IloRange
object.
IloMPModeler.addToExpr(IloObjective, IloNumExpr)
IloMPModeler.addToExpr(IloRange rng,
IloNumExpr expr)
IloAnd
constraint
suitable for grouping
other constraints or building logical constraints.
and
goal from two arguments.
and
goal from three arguments.
and
goal from four arguments.
and
goal from five arguments.
and
goal from six arguments.
cons
starting with the index indicated by start
and continuing
to the number of constraints indicated by num
.
cons
starting with the index indicated by start
and
continuing to the number of constraints indicated by num
.
name
to the group.
evaluator
to
the search tree defined by the goal
.
Bounded
solution status indicates that the
IloCplex
optimizer has determined that the model is not
unbounded.
IloCplex.BranchType
indicating a
complex branching.
IloCplex.BranchType
indicating a
branch on a Special Ordered Set (SOS) of type 1 (one).
IloCplex.BranchType
indicating a
branch on a Special Ordered Set (SOS) of type 2.
IloCplex.BranchType
indicating a
branch on a single variable.
IloModeler.boolVar(String)
IloModeler.boolVar()
IloMPModeler.boolVar(IloColumn column,
String name)
IloMPModeler.boolVar(IloColumn column)
n
new Boolean variables (domain 0,1).
n
new Boolean variables (domain 0,1).
IloModeler.boolVarArray(int)
IloModeler.boolVarArray(int, String[])
IloMPModeler.boolVarArray(IloColumnArray cols)
IloMPModeler.boolVarArray(IloColumnArray cols,
String[] name)
IloNumVarBound
to represent the specified bound of the variable var
.
IloCplex
would in the absence of any goal at the current node.
0
expression behind.
0
expression behind.
IloCplex
object.
IloCplex
object
with the methods addCut
and addCuts
.
0
.
0
.
IloColumn
object suitable for adding a new
variable to
constraint rng
as a linear term with coefficient
val
.
IloColumn
object suitable for adding a new
variable to the objective obj
as a linear term with
coefficient val
.
IloColumn
object suitable for adding a new
variable to an LP matrix as an empty column.
IloColumn
object suitable for adding a new
variable to an LP matrix as a new column.
IloColumn
object suitable for adding a new
variable to an LP matrix as a new column.
IloMPModeler.column(IloRange rng, double val)
IloMPModeler.column(IloObjective obj, double val)
IloMPModeler.column(IloLPMatrix lp)
IloMPModeler.column(IloLPMatrix lp,
int[] ind, double[] val)
IloMPModeler.column(IloLPMatrix lp,
int[] ind, double[] val,
int start, int num)
IloColumnArray
suitable for adding new variables
to constraint rng
as linear terms with coefficients specified
in val
.
IloColumnArray
suitable for adding
num
new variables to constraint IloRange
as
linear terms with coefficients specified in val
.
IloColumnArray
object suitable for adding new
variables to the objective obj
as linear terms with
coefficients specified in val
.
IloColumnArray
object suitable for adding
num
new variables to the objective obj
as
linear terms with coefficients specified in val
.
IloColumnArray
object suitable for adding new
variables to an IloLPMatrix
as columns.
IloColumnArray
object suitable for adding new
variables to an IloLPMatrix
as empty columns.
IloMPModeler.columnArray(IloRange rng,
double[] val)
IloMPModeler.columnArray(IloRange rng,
double[] val,
int start, int num)
IloMPModeler.columnArray(IloObjective obj,
double[] val)
IloMPModeler.columnArray(IloObjective obj,
double[] val,
int start, int num)
IloMPModeler.columnArray(IloLPMatrix lp, int num,
int[][] ind,
double[][] val)
IloMPModeler.columnArray(IloLPMatrix lp, int num)
c
.
c
.
IloModeler.constant(double)
IloModeler.constant(int)
cut
.
cut
.
IloConversion
object for converting
the type of a variable in a model.
IloConversion
object, with
the specified name, for converting the type of a variable in a model.
IloConversion
object for converting
the type of the variables in array var
in a model.
IloConversion
object with
the specified type and name, for converting
the type of the variables in array var
in a model.
IloConversion
object for converting
the type of the variables in the array var
in a model.
IloConversion
object,
with the specified name, for converting
the type of the variables in array var
in a model.
IloMPModeler.conversion(IloNumVar var,
IloNumVarType type,
String name)
IloMPModeler.conversion(IloNumVar var,
IloNumVarType type)
IloMPModeler.conversion(IloNumVar[] ilovar,
IloNumVarType type,
String name)
IloMPModeler.conversion(IloNumVar[] ilovar,
IloNumVarType type)
IloMPModeler.conversion(IloNumVar[] ilovar,
IloNumVarType[] type,
String name)
IloMPModeler.conversion(IloNumVar[] ilovar,
IloNumVarType[] type)
IloConversion
objects in the
active model.
var
.
var
.
num
consecutive variables in the array var
,
starting with the variable var[start]
.
var
.
num
consecutive variables in the array var
,
starting with the variable var[start]
.
var
.
obj
from the
invoking model.
obj[start]
through
obj[start+num-1]
from a model.
IloMPModeler.delete(IloCopyable obj)
IloMPModeler.delete(IloCopyable[] obj)
IloMPModeler.delete(IloCopyable[] obj,
int beg, int num)
e
and value v
.
e1
and e2
.
v
and the expression e1
.
e
and value v
.
expr1
and expr2
.
v
and the integer expression e1
.
IloModeler.diff(IloIntExpr, int)
IloModeler.diff(IloNumExpr, double)
IloModeler.diff(IloNumExpr, IloNumExpr)
IloModeler.diff(double, IloNumExpr)
IloModeler.diff(IloIntExpr, IloIntExpr)
IloModeler.diff(int, IloIntExpr)
Error
solution status indicates that an error has
occurred.
IloCplex
license held by the invoking object,
and all the memory allocated by it.
IloRange
initialized to represent the constraint e1 == e2
.
IloRange
initialized to represent the constraint e1 == e2
and
assigned the name name
.
IloRange
initialized to represent the constraint expr == rhs
.
IloRange
initialized to represent the constraint expr == rhs
and assigned the name name
.
IloRange
initialized to represent the constraint val == expr
.
IloRange
initialized to represent the constraint val == expr
and assigned the name name
.
IloModeler.eq(IloNumExpr e, double v)
IloModeler.eq(IloNumExpr e, double v, String name)
IloModeler.eq(IloNumExpr e1, IloNumExpr e2)
IloModeler.eq(IloNumExpr e1, IloNumExpr e2,
String name)
IloModeler.eq(double v, IloNumExpr e)
IloModeler.eq(double v, IloNumExpr e,
String name)
expr == rhs
.
expr1 == expr2
.
lhs == expr
.
IloCplex
calls this method for every node controlled by the
invoking evaluator in order to compute an evaluation value for the
node.
filename
.
Feasible
solution status indicates that the
IloCplex
optimizer has found a feasible solution
that can be queried with the method
getValue
.
IloCplex.DeleteMode.FixBasis
, the
invoking object will do basis pivots in order to maintain a valid basis
when variables or constraints are removed.
cts
.
vars
and
by relaxing the bounds of the range constraints specified in
the array rngs
.
vars
.
rngs
.
IloRange
initialized to represent the constraint expr >= rhs
.
IloRange
initialized to represent the constraint expr >= rhs
and assigned the name name
.
IloRange
initialized to represent the constraint e1 >= e2
.
IloRange
initialized to represent the constraint e1 >= e2
and assigned the name name
.
IloRange
initialized to represent the constraint val >= expr
.
IloRange
initialized to represent the constraint val >= expr
and assigned the name name
.
IloModeler.ge(IloNumExpr e, double v)
IloModeler.ge(IloNumExpr e, double v, String name)
IloModeler.ge(IloNumExpr e1, IloNumExpr e2)
IloModeler.ge(IloNumExpr e1,
IloNumExpr e2, String name)
IloModeler.ge(double v, IloNumExpr e)
IloModeler.ge(double v, IloNumExpr e,
String name)
expr >= rhs
.
expr1 >= expr2
.
lhs >= expr
.
num
consecutive rows, starting from the
index specified by start
, of an LP matrix.
var
.
con
.
var
.
num
consecutive variables,
starting from the index specified by start
,
in the array var
.
con
.
num
consecutive
constraints, starting from the index specified by
start
, in the array of constraints con
.
num
consecutive variables, starting from
the index specified by start
,
in the specified LP matrix.
vars
.
num
consecutive variables, starting from the index
specified by start
, in the array var
.
IloCplex
is going to do at
the current node unless overridden by the invoking callback.
IloCplex
is going to do at
the current node unless overridden by the invoking goal.
node
.
IloCplex
would create at the current
node if not overridden by the invoking callback.
IloCplex
would create at the current
node unless overridden by the invoking goal.
refineConflict
and returns the status of the constraints
in the array cts
.
refineConflict
and returns the conflict status for the
constraint ct
.
refineConflict
and returns the conflict status
of num
consecutive constraints in the
array cts
.
IloLinearIntExpr
.
IloLinearIntExpr
.
IloCplex.CplexStatus
for the current
node.
IloCplex.CplexStatus
of the last
solve
call.
IloCplex
algorithm.
IloCplex.CplexStatus
status of the last node problem solved.
IloCplex
object.
num
consecutive
variables, starting from the index specified by var[start]
.
var
.
var
.
num
rows of an LP matrix.
num
consecutive range constraints, starting from
the index specified by start
.
node
.
IloObjective
object.
IloRange
object.
var
are integer feasible, integer infeasible, or implied
integer feasible in the current node solution.
var
are integer feasible, integer infeasible, or implied
integer feasible in the current node solution.
var
are integer feasible, integer infeasible, or implied
integer feasible in the current node solution.
var
are integer feasible, integer infeasible, or implied
integer feasible in the current node solution.
var
is integer feasible,
integer infeasible, or implied integer feasible in the current node
solution.
var
is integer feasible,
integer infeasible, or implied integer feasible in the current node
solution.
var
for the current best
integer solution.
var
for the current best integer
solution.
num
consecutive variables,
starting from the index specified by start
.
num
rows of LP matrix, starting from the row specified by
start
.
num
consecutive constraints,
starting from the index specified by start
, from
an array con
of constraints.
node
.
IloNumVar
object.
var
.
var
.
SOS
s of type 1 in the active model.
SOS
s of type 2 in the active model.
SOS
s of both types, 1 and 2 in the
active model.
row
and
col
from the invoking LP matrix.
IloCplex
is going to create
at the current node unless overridden by the invoking callback.
IloCplex
is going to create
at the current node unless overridden by the invoking goal.
node
.
node
.
IloCplex.NodeId
of the current node.
node
.
nodeid
.
i
-th column of
the LP matrix.
SOS1
object.
SOS2
object.
var
in the model being solved.
var
in the model being solved.
num
consecutive columns of the specified LP matrix.
num
consecutive variables, starting
at the index specified by start
.
node
.
IloObjective
object of the
active model, or null
if no IloObjective
object
is currently in the active model.
num
consecutive variables,
starting from the index specified by start
.
var
.
var
.
IloCplex.Quality
that contains
the requested quality measure.
IloCplex.QualityType
of the invoking quality
measure.
num
constraints, starting from the index specified by start
.
num
constraints, corresponding to a range of rows of an LP matrix,
starting from the index specified by start
.
i
-th row
of the LP matrix.
rng
.
num
consecutive range constraints in the array
rng
, starting with the index specified by
rng[start]
.
num
rows of the LP matrix
matrix
starting with row start
.
matrix
.
num
columns of LP matrix, starting from the column specified by
start
.
num
consecutive variables,
starting from the index specified by start
.
IloSemiContVar
.
IloObjective
object.
IloColumnArray
object.
num
consecutive
constraints, starting from the index specified by start
,
in the array rng
for the proposed incumbent solution.
num
consecutive rows,
starting from the index specified by start
, of an LP matrix.
num
consecutive constraints,
starting from the index specified by start
, from
an array rng
.
solve
call.
IloConversion
object converts variable var
.
IloNumVar
object.
IloNumVar
object.
var
.
var
.
var
.
var
.
IloIntVar
accessed by the last
call to the method next()
.
IloNumVar
accessed by the last
call to the method next()
.
expr
takes for the solution of the
continuous relaxation of the current node.
expr
takes for the solution of the
current node relaxation.
var
in the potential
incumbent solution.
expr
takes for the
proposed incumbent solution.
expr
takes for the current solution.
SOS1
object.
SOS2
object.
var
in the potential incumbent solution.
num
consecutive variables,
starting from the index specified by start
, in the array
var
of variables in the potential incumbent solution.
num
columns of an LP matrix, starting at the index specified by
start
.
cut
.
cut
.
true
if an incumbent solution has been found.
true
if an incumbent solution has been found when
the callback is called.
IloColumn
are used to create a variable
using column-wise modeling.IloColumnArray
are used to create an
array of variables using column-wise modeling.IloConversion
objects allow you to locally change the type of
one or more variables.IloCplex
is the class used to create and solve
a large variety of Mathematical Programming models.IloCplex
with an empty active model.
IloCplex
uses the
barrier optimizer.IloCplex
that are
Boolean-valued.BranchCallback
.refineConflict
.IloCplex
object or any object that has been created with it
after the end
method has been called.IloCplex
algorithm
status codes.IloCplex
, as controlled by the methods
setDeleteMode
and getDeleteMode
.IloCplex
parameters.IloCplex.IntParam.DPriInd
.IloCplex
parameters.IloCplex.IntParam.MIPEmphasis
parameter.IloCplex
is attempted to be used
by anotherIloCplex
object at the same time.IloCplex
uses the
network optimizer.IloCplex.IntParam.NodeSel
parameter.IloCplex.IntParam.PPriInd
.IloCplex
solution qualities.FeasOptMode
.IloCplex
uses the
simplex optimizer.cplex.getStatus
.IloCplex
parameters.IloCplex
object.IloCplex.IntParam.VarSel
parameter.IloException
by also capturing
the CPLEX error code.IloLPMatrix
allows you to treat a set of variables and
range constraints (instances of IloRange
)
as a matrix.IloLinearIntExpr
expression object.IloLinearNumExpr
expression object.IloMPModeler
is an extension of the IloModeler
modeling interface for mathematical programming (MP).IloObjective
object.lb <= expr <= ub
.Infeasible
solution status indicates that the
IloCplex
optimizer has determined that the model is
infeasible.
InfeasibleOrUnbounded
solution status indicates that
the IloCplex
optimizer has determined that the model is
infeasible or unbounded.
con1
is true, then
con2
must also be true.
con1
is true, then
con2
must also be true, and it names the new constraint.
con1
is true, then
con2
must also be true.
con1
is true, then
con2
must also be true.
name
into the active model.
IloCplex
right before the first
time evaluate
is called for a node and allows you to
initialize the evaluator based on that node.
IloCplex.limitSearch
is
executed, IloCplex
calls this method after initializing
the invoked search limit to the current node.
IloModeler.intExpr()
min
, the maximum element is
max
, and all integers between min
and
max
are included in the possible set.
values
, an array of integers.
IloModeler.intVar(int, int, String)
IloModeler.intVar(int, int)
IloMPModeler.intVar(IloColumn column,
int lb, int ub)
IloMPModeler.intVar(IloColumn column,
int lb, int ub, String name)
n
integer variables
with the specified bounds.
n
initialized
to n
new modeling integer
variables, each with the same specified bounds
and returns them in an array.
n
initialized to n
new integer variables,
each variable with its own bounds.
n
initialized to n
new integer variables,
each variable with its own bounds.
IloModeler.intVarArray(int, int, int)
IloModeler.intVarArray(int, int[], int[])
IloModeler.intVarArray(int, int, int, String[])
IloModeler.intVarArray(int, int[], int[], String[])
IloMPModeler.intVarArray(IloColumnArray cols,
int lb, int ub,
String[] name)
IloMPModeler.intVarArray(IloColumnArray cols,
int[] lb, int[] ub,
String[] name)
IloMPModeler.intVarArray(IloColumnArray cols,
int lb, int ub)
IloMPModeler.intVarArray(IloColumnArray cols,
int[] lb, int[] ub)
true
if a dual feasible solution is available for
the current node.
true
if a dual feasible solution is available for
the current node.
true
if a dual feasible solution is available.
true
if the current node solution is considered to
be integer feasible and thus potentially eligible as a new incumbent,
but not suitable for branching.
true
if current solution is integer feasible
true
if the active model is a MIP.
true
if a primal feasible solution is available for
the current node.
true
if a primal feasible solution
is available for the current node.
true
if a primal feasible solution is available.
true
if the active model has quadratic
constraints.
true
if the active model has a quadratic objective
function.
IloLPMatrix
object.
IloLPMatrix
object with
the specified name.
IloMPModeler.LPMatrix(String name)
IloMPModeler.LPMatrix()
IloLPMatrix
objects in the
active model.
IloCplex.DeleteMode.LeaveBasis
, an existing basis
will remain unchanged if variables or constraints are removed from the
loaded LP model.
IloRange
initialized to represent the constraint expr <= rhs
.
IloRange
initialized to represent the constraint expr <= rhs
and assigned the name name
.
IloRange
initialized to represent the constraint e1 <= e2
.
IloRange
initialized to represent the constraint e1 <= e2
and assigned the name name
.
IloRange
initialized to represent the constraint val <= expr
.
IloRange
initialized to represent the constraint val <= expr
and assigned the name name
.
IloModeler.le(IloNumExpr e, double v)
IloModeler.le(IloNumExpr e, double v, String name)
IloModeler.le(IloNumExpr e1, IloNumExpr e2)
IloModeler.le(IloNumExpr e1, IloNumExpr e2,
String name)
IloModeler.le(double v, IloNumExpr e)
IloModeler.le(double v, IloNumExpr e, String name)
expr <= rhs
.
expr1 <= expr2
.
lhs >= expr
.
goal
, as specified by
limit
.
val
.
IloModeler.linearIntExpr(int)
IloModeler.linearIntExpr()
IloLinearIntExpr
expression.
IloLinearNumExpr
expression.
IloModeler.linearNumExpr()
IloModeler.linearNumExpr(double)
IloNumVarBound
to represent the lower bound of the variable var
.
max(e1, e2)
.
max(val, e2)
.
max(e1, val)
.
max(e)
,
the maximum over the array.
max(e1, e2)
.
max(val, e2)
.
max(e1, val)
.
max(e)
.
IloObjective
representing an objective to maximize the expression expr
.
IloObjective
representing an objective to maximize the expression
expr
and assigned the name name
.
IloModeler.maximize(IloNumExpr, String)
IloModeler.maximize(IloNumExpr)
IloMPModeler.maximize()
IloMPModeler.maximize(String)
min(e1, e2)
.
min(val, e2)
.
min(e1, val)
.
min(e)
,
the minimum over the array.
min(e1, e2)
.
min(val, e2)
.
min(e1, val)
.
min(e)
.
IloObjective
representing an objective to minimize the expression expr
.
IloObjective
representing an objective to minimize the expression
expr
and assigned the name name
.
IloModeler.minimize(IloNumExpr, String)
IloModeler.minimize(IloNumExpr)
IloMPModeler.minimize()
IloMPModeler.minimize(String)
-e
,
the negation of the expression e
.
-e
,
the negation of the expression e
.
IloModeler.negative(IloNumExpr)
IloModeler.negative(IloIntExpr)
IloIntVar
of the next linear term in the scalar product.
IloNumVar
of the next linear term in the
underlying IloLinearNumExpr
.
name
as the name of the
returned constraint.
IloModeler.numExpr()
name
, type, lower bound, and upper bound
for column-wise modeling in the target column
.
Float
with upper bound, lower bound, and name as specified,
for column-wise modeling.
Float
with upper bound and lower bound as specified,
for column-wise modeling.
IloNumVarType.Float
with bounds and name.
IloNumVarType.Float
with specified bounds.
IloModeler.numVar(double, double, IloNumVarType)
IloModeler.numVar(double, double, IloNumVarType,
String)
IloModeler.numVar(double, double, String)
IloModeler.numVar(double, double)
IloMPModeler.numVar(IloColumn column,
double lb, double ub,
IloNumVarType type)
IloMPModeler.numVar(IloColumn column,
double lb, double ub,
IloNumVarType type,
String name)
IloMPModeler.numVar(IloColumn column,
double lb, double ub,
String name)
IloMPModeler.numVar(IloColumn column,
double lb, double ub)
type
, all with same upper bound, all with the same
lower bound, as specified, for column-wise modeling.
type
, and individual upper and lower bounds as specified
in those arrays, for column-wise modeling.
type
, with individual upper and lower bounds as specified
in those arrays, with the name specified individually by the
corresponding entry in the array name
,
for column-wise modeling.
Float
, with the same specified bounds, but with
individually specified names, for column-wise modeling.
Float
, all with same upper bound, all with the same
lower bound, for column-wise modeling.
Float
with individually specified upper bound, and
individually specified lower bound, for column-wise modeling.
Float
with individually
specified upper bound, lower bound, and name, for column-wise
modeling.
n
new modeling objects,
numeric variables with the same
bounds and type, and returns them in an array.
n
new modeling objects, numeric variables
with the same bounds and type and distinct names,
and returns them in an array.
n
new modeling objects,
numeric variables with distinct bounds, types, and names,
and returns them in an array.
n
new modeling objects,
numeric variables with distinct
bounds and types, and returns them in an array.
n
initialized to n
new modeling objects that are
numerica variables all of the same type
IloNumVarType.Float
and same bounds.
n
initialized to n
new modeling objects that are
numeric variables
of type IloNumVarType.Float
.
n
initialized to n
new modeling objects that are
numeric variables of type IloNumVarType.Float
with distinct bounds and distinct names.
n
initialized to n
new modeling objects that are
numeric variables of type IloNumVarType.Float
with distinct bounds.
IloModeler.numVarArray(int, double, double,
IloNumVarType)
IloModeler.numVarArray(int, double, double,
IloNumVarType, String[])
IloModeler.numVarArray(int, double[], double[],
IloNumVarType[])
IloModeler.numVarArray(int, double[], double[],
IloNumVarType[], String[])
IloModeler.numVarArray(int, double, double)
IloModeler.numVarArray(int, double[], double[])
IloModeler.numVarArray(int, double, double,
String[])
IloModeler.numVarArray(int, double[], double[],
String[])
IloMPModeler.numVarArray(IloColumnArray cols,
double lb, double ub,
IloNumVarType type)
IloMPModeler.numVarArray(IloColumnArray cols,
double lb, double ub,
IloNumVarType type,
String[] name)
IloMPModeler.numVarArray(IloColumnArray cols,
double[] lb, double[] ub,
IloNumVarType[] type)
IloMPModeler.numVarArray(IloColumnArray cols,
double[] lb, double[] ub,
IloNumVarType[] type,
String[] name)
IloMPModeler.numVarArray(IloColumnArray cols,
double lb, double ub)
IloMPModeler.numVarArray(IloColumnArray cols,
double[] lb, double[] ub)
IloMPModeler.numVarArray(IloColumnArray cols,
double lb, double ub,
String[] name)
IloMPModeler.numVarArray(IloColumnArray cols,
double[] lb, double[] ub,
String[] name)
Optimal
solution status indicates that the
IloCplex
optimizer has found an optimal solution that
can be queried with the method getValue
.
sense
.
sense
and with the name specified by
name
.
IloObjective
representing an objective to optimize the expression
expr
with respect to the
optimization sense indicated by sense
.
IloObjective
representing an objective to optimize the expression
expr
with respect to the
optimization sense indicated by sense
and
assigned the name name
.
IloModeler.objective(IloObjectiveSense, IloNumExpr,
String)
IloModeler.objective(IloObjectiveSense, IloNumExpr)
IloMPModeler.objective(IloObjectiveSense)
IloMPModeler.objective(IloObjectiveSense, String)
IloOr
constraint
for expressing disjunctions.
cons
, an array
of constraints.
cons
, an array
of constraints.
start
and continuing through the number
of elements indicated by the number num
among the elements
of its argument cons
, an array of constraints.
or
goal from two arguments.
or
goal from three arguments.
or
goal from four arguments.
or
goal from five arguments.
or
goal from six arguments.
cons
, an array
of constraints.
cons
, an array
of constraints.
cons
, an array
of constraints and also assigns the string name
as the
name of that returned constraint.
start
and continuing through the number
of elements indicated by the number num
among the elements
of its argument cons
, an array of constraints.
start
and continuing through the number
of elements indicated by the number num
among the elements
of its argument cons
, an array of constraints;
also assigns the string name
as the name of
the returned constraint.
IloCplex
object.
IloMPModeler.piecewiseLinear(IloNumExpr, double[],
double[], double,
double)
IloMPModeler.piecewiseLinear(IloNumExpr, double[],
int, int, double[],
int, double, double)
e
and the value v
.
expr1
and expr2
.
e1
and the value v
.
val
, the variable var1
,
and the variable var2
.
var1
,
the value val
,
and the variable var2
.
var1
,
the variable var2
, and
the value val
.
e * v
.
e1 * e2
.
v * e
.
IloModeler.prod(double, IloNumVar, IloNumVar)
IloModeler.prod(IloNumVar, double, IloNumVar)
IloModeler.prod(IloNumVar, IloNumVar, double)
IloModeler.prod(IloNumExpr, double)
IloModeler.prod(IloNumExpr, IloNumExpr)
IloModeler.prod(double, IloNumExpr)
IloModeler.prod(IloIntExpr, int)
IloModeler.prod(IloIntExpr, IloIntExpr)
IloModeler.prod(int, IloIntExpr)
ILOG_LICENSE_FILE
environment variable
used by CPLEX.
IloRange
object with
the specified upper and lower bound.
IloRange
object with the
specified name
and upper and lower bounds.
IloRange
initialized to represent the constraint
lb <= expr <= ub
.
IloRange
initialized to represent the constraint
lb <= expr <= ub
and assigned the name name
.
IloModeler.range(double lb,
IloNumExpr expr,
double ub,
String name)
IloModeler.range(double lb,
IloNumExpr expr,
double ub)
IloMPModeler.range(double lb,
double ub,
String name)
IloMPModeler.range(double lb, double ub)
IloRange
in the
active model.
name
,
and copies that basis into the invoking object.
name
and
copies the MIP start information into the invoking object.
name
and copies the priority order information
into the invoking CPLEX problem object.
name
and applies them to the invoking object.
name
and copies this information into the invoking object.
IloAnd
.
IloLinearIntExpr
expression.
IloLinearIntExpr
expression.
IloLinearIntExpr
expression.
IloLinearNumExpr
expression.
IloLinearNumExpr
expression.
IloLinearNumExpr
expression.
IloOr
.
object
from the invoking model.
objects
from the invoking model.
objects
from the
invoking model, starting with the index start
and
continuing to the number of objects indicated by num
.
num
specified variables and weights, starting from the index specified
by start
.
num
specified variables and weights, starting from the index specified
by start
, and assigns the new SOS a name.
IloMPModeler.SOS1(IloNumVar[] var, double[] val)
IloMPModeler.SOS1(IloNumVar[] var,
double[] val,
int start, int num)
IloMPModeler.SOS1(IloNumVar[] var,
double[] val, String name)
IloMPModeler.SOS1(IloNumVar[] var,
double[] val,
int start,
int num,
String name)
IloSOS1
objects in the
active model.
num
specified variables and weights, starting from the index specified
by start
.
name
.
num
specified variables and weights, starting from the index specified by
start
, and assigns
the new SOS its name
.
IloMPModeler.SOS2(IloNumVar[] var, double[] val)
IloMPModeler.SOS2(IloNumVar[] var,
double[] val,
int start,
int num)
IloMPModeler.SOS2(IloNumVar[] var,
double[] val,
String name)
IloMPModeler.SOS2(IloNumVar[] var,
double[] val,
int start,
int num,
String name)
IloSOS2
objects in the
active model.
coefs[start]...coefs[start+num-1]
with the variables
provided in vars[start]...vars[start+num-1]
.
coefs[start]...coefs[start+num-1]
with the variables
provided in vars[start]...vars[start+num-1]
.
vars1[start]...vars1[start+num-1]
with the variables prodived in
vars2[start]...vars2[start+num-1]
.
vals[start]...vals[start+num-1]
with the integer variables provided in
vars[start]...vars[start+num-1]
.
vals[start]...vals[start+num-1]
with the integer variables provided in
vars[start]...vars[start+num-1]
.
IloModeler.scalProd(double[], IloNumVar[])
IloModeler.scalProd(IloNumVar[], double[])
IloModeler.scalProd(double[], IloNumVar[], int, int)
IloModeler.scalProd(IloNumVar[], double[], int, int)
IloModeler.scalProd(int[], IloNumVar[])
IloModeler.scalProd(IloNumVar[], int[])
IloModeler.scalProd(int[], IloIntVar[])
IloModeler.scalProd(IloIntVar[], int[])
IloModeler.scalProd(int[], IloIntVar[], int, int)
IloModeler.scalProd(IloIntVar[], int[], int, int)
num
values in vals
starting
at element start
with the corresponding variables in
vars
.
num
variables in vars
starting
at element start
with the corresponding values in
vals
.
IloMPModeler.semiContVar(double, double,
IloNumVarType, String)
IloMPModeler.semiContVar(double, double,
IloNumVarType)
IloMPModeler.semiContVar(IloColumn, double,
double, IloNumVarType,
String)
IloMPModeler.semiContVar(IloColumn, double,
double, IloNumVarType)
n
semi-continuous modeling variables,
all with the same type, semi-continuous lower bound, and upper bound,
but with individually specified names.
n
semi-continuous modeling variables,
all of the same type, with the same semi-continuous lower bound and
upper bound.
n
semi-continuous modeling variables,
all of the same type, with the same semi-continuous lower bound and
upper bound, and individually specified names.
n
semi-continuous modeling variables,
with individually specified type, semi-continuous lower bound, and
upper bound.
IloMPModeler.semiContVarArray(int, double,
double, IloNumVarType)
IloMPModeler.semiContVarArray(int, double[],
double[],
IloNumVarType[])
IloMPModeler.semiContVarArray(int, double,
double, IloNumVarType,
String[])
IloMPModeler.semiContVarArray(int, double[],
double[],
IloNumVarType[],
String[])
IloMPModeler.semiContVarArray(IloColumnArray,
double,
double, IloNumVarType)
IloMPModeler.semiContVarArray(IloColumnArray,
double[], double[],
IloNumVarType[])
IloMPModeler.semiContVarArray(IloColumnArray,
double, double,
IloNumVarType,
String[])
IloMPModeler.semiContVarArray(IloColumnArray cols,
double[] lb,
double[] ub,
IloNumVarType[] type,
String[] name)
cnum
consecutive
variables, starting from the index specified by var[start]
,
and rnum
consecutive constraints, starting from the
index specified by con[start]
.
var
.
var
.
var
.
IloLinearIntExpr
to val
.
IloLinearIntExpr
to val
.
num
consecutive
variables, starting from the index specified by start
.
IloObjective
object.
IloRange
object to
expr
.
IloIntVar
of the last linear term in the scalar product.
IloNumVar
object.
var
to val
in the expression of the specified IloObjective
object.
var
to val
in the expression of the specified IloObjective
object.
var
to val
in the expression of the specified IloRange
object.
var
to val
in the expression of the specified IloRange
object.
IloMPModeler.setLinearCoef(IloObjective,
double, IloNumVar)
IloMPModeler.setLinearCoef(IloObjective,
IloNumVar, double)
IloMPModeler.setLinearCoef(IloRange rng,
double val,
IloNumVar var)
IloMPModeler.setLinearCoef(IloRange rng,
IloNumVar var,
double val)
IloObjective
object.
IloObjective
object.
IloObjective
object.
IloObjective
object.
IloRange
object.
IloRange
object.
IloRange
object.
IloRange
object.
IloMPModeler.setLinearCoefs(IloObjective,
double[], IloNumVar[])
IloMPModeler.setLinearCoefs(IloObjective,
IloNumVar[], double[])
IloMPModeler.setLinearCoefs(IloObjective,
double[], IloNumVar[],
int, int)
IloMPModeler.setLinearCoefs(IloObjective,
IloNumVar[],
double[], int, int)
IloMPModeler.setLinearCoefs(IloRange rng,
double[] val,
IloNumVar[] var)
IloMPModeler.setLinearCoefs(IloRange rng,
IloNumVar[] var,
double[] val)
IloMPModeler.setLinearCoefs(IloRange rng,
double[] val,
IloNumVar[] var,
int start, int num)
IloMPModeler.setLinearCoefs(IloRange rng,
IloNumVar[] var,
double[] val,
int start, int num)
model
as the active model.
model
as the active model.
model
as the active model.
str
as the name of the invoking model.
IloNumVar
of the last linear term
in the scalar product.
IloCplex
object.
val
.
val
.
val
.
val
.
val
.
val
.
val
.
val
.
num
consecutive variables,
starting from the index specified by start
.
var
.
IloSemiContVar
to sclb
.
IloObjective
object.
IloNumVar
object.
IloIntVar
accessed by the last
call to the method next()
.
IloIntVar
accessed by the last call to the method next()
.
solve
.
solve
.
solve
.
solve
.
IloCplex
object.
alg
.
IloCplex.Algorithm.Auto
).
goal
.
e
(that is, e * e
).
e^2
.
IloModeler.square(IloNumExpr)
IloModeler.square(IloIntExpr)
IloCplex
maintains a candidate node to pick.
num
expressions provided as terms
in the array expr
starting with element start
.
expr
.
num
expressions provided in the array expr
starting with element start
.
expr
.
IloModeler.sum(IloNumExpr, double)
IloModeler.sum(IloNumExpr, IloNumExpr)
IloModeler.sum(double, IloNumExpr)
IloModeler.sum(IloNumExpr, IloNumExpr, IloNumExpr)
IloModeler.sum(IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr)
IloModeler.sum(IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr, IloNumExpr)
IloModeler.sum(IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr)
IloModeler.sum(IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr,
IloNumExpr)
IloModeler.sum(IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr,
IloNumExpr, IloNumExpr)
IloModeler.sum(IloIntExpr, int)
IloModeler.sum(int, IloIntExpr)
IloModeler.sum(IloIntExpr, IloIntExpr)
IloModeler.sum(IloIntExpr, IloIntExpr, IloIntExpr)
IloModeler.sum(IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr)
IloModeler.sum(IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr, IloIntExpr)
IloModeler.sum(IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr)
IloModeler.sum(IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr,
IloIntExpr)
IloModeler.sum(IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr,
IloIntExpr, IloIntExpr)
IloModeler.sum(IloNumExpr[] expr,
int start, int num)
IloModeler.sum(IloNumExpr[] expr)
IloModeler.sum(IloIntExpr[] expr,
int start, int num)
IloModeler.sum(IloIntExpr[] expr)
Unbounded
solution status indicates that the
IloCplex
optimizer has determined that the model is
unbounded.
Unknown
solution status indicates that the optimizer
has not gathered any information about the active model.
IloNumVarBound
to represent the upper bound of variable var
.
IloCplex
to use a solution.
IloCplex
object.
name
.
name
.
name
.
name
.
name
for all the
CPLEX parameters that are not currently
set at their default.
name
.
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |