Overview  Group  Tree  Graph  Index  Concepts 
IloCplex
derives from the class IloAlgorithm
.
Use it to solve Mathematical Programming models, such as:
An algorithm (that is, an instance of IloAlgorithm
)
extracts a model in an environment. The model extracted by an
algorithm is known as the active model.
More precisely, models to be solved by IloCplex
should
contain only IloExtractable
objects from the following
list:
IloNumVar
and its extensions
IloIntVar
and IloSemiContVar
IloRange
IloConstraint
of the form
expr1 relation expr2, where the relation is one
of ==
, >=
, <=
, or
!=
IloObjective
IloConversion
IloSOS1
or IloSOS2
The expressions used in the constraints and objective function handled
by IloCplex
are built from variables of those listed types
and can be linear or quadratic. In addition, expressions may contain the
following constructs:
IloMin
IloMax
IloAbs
IloPiecewiseLinear
Expressions that evaluate only to 0 (zero) and 1 (one) are referred to as Boolean expressions. Such expressions also support:
operator !
operator &&
or, equivalently, IloAnd
operator 
or,
equivalently, IloOr
Moreover, Boolean expressions can be constucted not only from variables, but also from constraints.
IloCplex
will automatically transform all of these constructs
into an equivalent representation
amenable to IloCplex
. Such models can be represented
in the following way:
Minimize (or Maximize) c'x + x'Qx subject to L <= Ax <= U a_i'x + x'Q_i x <= r_i, for i = 1, ..., q l <= x <= u.
That is, in fact, the standard math programming matrix
representation that IloCplex
uses internally.
A is the matrix of linear constraint coefficients,
and L and U are the vectors of lower and upper bounds on the
vector of variables in the array x. The Q matrix must
be positive semidefinite (or negative semidefinite in the maximization
case) and represents the quadratic terms of the objective function.
The matrices Q_i must be positive semidefinite and represent the quadratic
terms of the ith quadratic constraint. The a_i are vectors containing
the correponding linear terms.
For details about the Q_i, see the chapter about quadratically
constrained programs (QCP) in
the ILOG CPLEX User's Manual.
Special ordered sets (SOS) fall outside the conventional representation in terms of A and Q matrices and are stored separately.
If the model contains integer, Boolean, or semicontinuous variables,
or if the model has special ordered sets (SOSs), the model is referred to
as a mixed integer program (MIP). You can query whether the
active model is a MIP with the method
IloCplex::isMIP
.
A model with quadratic terms in the objective is referred to as
a mixed integer quadratic program (MIQP) if it is also a MIP,
and a quadratic program (QP) otherwise.
You can query whether the active model has a quadratic objective
by calling method IloCplex::isQO
.
A model with quadratic constraints is referred to as a mixed integer
quadratically constrained program (MIQCP) if it is also a MIP, and as
a quadratically constrained program (QCP) otherwise.
You can query whether the active model is
quadratically constrained by calling the method
IloCplex::isQC
.
A QCP may or may not have a quadratic objective; that is, a given problem
may be both QP and QCP. Likewise, a MIQCP may
or may not have a quadratic objective; that is, a given problem may be
both MIQP and MIQCP.
If there are no quadratic terms in the objective, no integer constraints, and the problem is not quadratically constrained, and all variables are continuous it is called a linear program (LP).
Information related to the matrix representation of the model can be queried through these methods:
IloCplex::getNcols
for querying the number of columns of A,IloCplex::getNrows
for querying the number of rows of A; that is,
the number of linear constraints,IloCplex::getNQCs
for querying the number of quadratic constraints,IloCplex::getNNZs
for querying the number of nonzero elements in A, and IloCplex::getNSOSs
for querying the
number of special ordered sets (SOSs).Additional information about the active model can be obtained through iterators defined on the different types of modeling objects in the extracted or active model.
IloCplex
effectively treats all models as MIQCP models.
That is, it allows the most general case, although the solution algorithms
make efficient use of special cases, such as taking advantage of
the absence of quadratic terms in the formulation.
The method IloCplex::solve
begins
by solving the root relaxation of the MIQCP model,
where all integrality constraints and SOSs are ignored. If the model has
no integrality constraints or SOSs, then the optimization is complete once
the root relaxation is solved. Otherwise,
IloCplex
uses a branch and cut procedure to reintroduce
the integrality constraints or SOSs. See the ILOG CPLEX
User's Manual for more information about branch & cut.
Most users can simply call solve
to solve their models.
However, several parameters are available for users who require more
control. These parameters are documented in the ILOG CPLEX
Parameter Reference Manual.
Perhaps the most important parameter is IloCplex::RootAlg
,
which determines the algorithm used to solve the root relaxation.
Possible settings, as defined in the class
IloCplex::Algorithm
, are:
IloCplex
automatically selects an algorithm. This is the
default setting.IloCplex
defaults to
the IloCplex::Auto
setting.IloCplex
defaults to the IloCplex::Auto
setting.Numerous other parameters allow you to control algorithmic aspects of the
optimizer. See the nested enumerations IloCplex::IntParam
,
IloCplex::DoubleParam
, and
IloCplex#StringParam
for further
information. Parameters are set with the method setParam
.
Even higher levels of control can be achieved through goals (see
IloCplex::Goal
) or through callbacks (see
IloCplex::Callback
and its extensions).
Information about a Solution
The solve
method returns an IloBool
value
specifying whether (IloTrue
) or not (IloFalse
)
a solution (not necessarily the optimal one) has been
found. Further information about the solution can be queried with the method
getStatus
. The return code of type
IloAlgorithm::Status
specifies whether the
solution is feasible, bounded, or optimal, or if the model has been proven
to be infeasible or unbounded.
The method IloCplex::getCplexStatus
provides more detailed information about the status of the optimizer after
solve
returns. For example, it can provide information on why
the optimizer terminated prematurely (time limit, iteration limit,
or other similar limits).
The methods IloCplex::isPrimalFeasible
and IloCplex::isDualFeasible
can
determine whether a primal or dual feasible solution has been found
and can be queried.
The most important solution information computed by IloCplex
are usually the solution vector and the objective function value.
The method IloCplex::getValue
queries the solution vector.
The method IloCplex::getObjValue
queries the objective
function value.
Most optimizers also compute additional solution information, such as
dual values, reduced costs, simplex bases, and others.
This additional information can
also be queried through various methods of IloCplex
. If you
attempt to retrieve solution information that is not available
from a particular optimizer, IloCplex
will throw an exception.
If you are solving an LP and a basis is available, the solution can be
further analyzed by performing sensitivity analysis. This information
tells you how sensitive the solution is with respect to changes in variable
bounds, constraint bounds, or objective
coefficients. The information is computed and accessed with the methods
IloCplex::getBoundSA
,
IloCplex::getRangeSA
,
IloCplex::getRHSSA
, and
IloCplex::getObjSA
.
An important consideration when you access solution information is the
numeric quality of the solution.
Since IloCplex
performs arithmetic operations using
finite precision, solutions are always subject to numeric errors.
For most problems, numeric errors are well within reasonable tolerances.
However, for numerically difficult models, you
are advised to verify the quality of the solution using the method
IloCplex::getQuality
,
which offers a variety of quality measures.
More about Solving Problems
By default when the method
IloCplex::solve
is called,
IloCplex
first
presolves the model; that is, it transforms the model into a smaller, yet
equivalent model. This operation can be controlled with the following
parameters:
IloCplex::PreInd
,
IloCplex::PreDual
,
IloCplex::AggInd
, and
IloCplex::AggFill
.
For the rare occasion when a user wants to
monitor progress during presolve, the callback class
IloCplex::PresolveCallbackI
is provided.
After the presolve is completed, IloCplex
solves the first
node relaxation and (in cases of a true MIP) enters the branch & cut
process. IloCplex
provides callback classes that allow the
user to monitor solution progress at each level. Callbacks derived from
IloCplex::ContinuousCallbackI
or one of its
derived classes are called regularly during the solution of a node
relaxation (including the root), and callbacks derived from
IloCplex::MIPCallbackI
or one of its derived callbacks are
called regularly during branch & cut search. All callbacks provide the
option to abort the current optimization.
Branch Priorities and Directions
When a branch occurs at a node in the branch & cut tree,
usually there is a
set of fractionalvalued variables available to pick from for branching.
IloCplex
has several builtin rules for making such a choice,
and they can be controlled by the parameter IloCplex::VarSel
.
Also, the method IloCplex::setPriority
allows the user to specify a priority
order. An instance of IloCplex
branches on variables with an
assigned priority before variables without a priority. It also branches on
variables with higher priority before variables with lower priority, when
the variables have fractional values.
Frequently, when two new nodes have been created (controlled by the
parameter IloCplex::BtTol
), one of the two nodes is processed
next. This activity is known as diving.
The branch direction determines which of the
branches, the up or the down branch, is used when diving. By default,
IloCplex
automatically selects the branch direction. The user
can control the branch direction by the method
IloCplex::setDirection
.
As mentioned before, the greatest flexibility for controlling the
branching during branch & cut search is provided through goals
(see IloCplex::Goal
) or through the callbacks
(see IloCplex::BranchCallbackI
). With these
concepts, you can control the branching decision based on runtime
information during the search, instead of statically through branch
priorities and directions, but the default strategies work well on many
problems.
Cuts
An instance of IloCplex
can also generate certain cuts in
order to strengthen the relaxation, that is, in order to make the relaxation
a better approximation of the original MIP. Cuts are constraints added to a
model to restrict (cut away) noninteger solutions that would otherwise be
solutions of the relaxation. The addition of cuts usually reduces the number
of branches needed to solve a MIP.
When solving a MIP, IloCplex
tries to generate violated cuts
to add to the problem after solving a node. After IloCplex
adds
cuts, the subproblem is reoptimized.
IloCplex
then repeats the process of adding
cuts at a node and reoptimizing until it finds no further effective
cuts.
An instance of IloCplex
generates its cuts in such a way
that they are valid for all subproblems, even when they are discovered
during analysis of a particular node. After a cut has been added to the
problem, it will remain in the problem to the end of the optimization.
However, cuts are added only internally; that is, they will not be part of
the model extracted to the IloCplex
object after the
optimization. Cuts are most frequently seen at the root node, but they may
be added by an instance of IloCplex
at other nodes as
conditions warrant.
IloCplex
looks for various kinds of cuts that can be
controlled by the following parameters:
IloCplex::Cliques
,
IloCplex::Covers
,
IloCplex::FlowCovers
,
IloCplex::GUBCovers
,
IloCplex::FracCuts
,
IloCplex::MIRCuts
,
IloCplex::FlowPaths
,
IloCplex::ImplBd
, and
IloCplex::DisjCuts
.
During the search, you can query information about those cuts with
a callback (see IloCplex::MIPCallbackI
and
its subclasses). For types of cuts that may take a long time to generate,
callbacks are provided to monitor the progress and potentially abort the
cut generation progress. In particular, those callback classes are
IloCplex::FractionalCutCallbackI
and
IloCplex::DisjunctiveCutCallbackI
. The callback class
IloCplex::CutCallbackI
allows you
to add your own problemspecific cuts during search. This callback also
allows you to generate and add local cuts, that is cuts that are only valid
within the subtree where they have been added.
Instead of using callbacks, you can use goals to add your own cuts during the optimization.
Heuristics
After a node has been processed, that is, the LP has been solved and no
more cuts were generated, IloCplex
may try to construct an
integer feasible solution from the LP solution at that node.
The parameter IloCplex::HeurFreq
and other parameters
provide some control over this activity.
In addition, goals or the callback class
IloCplex::HeuristicCallbackI
make it possible to call
userwritten heuristics to find an integer feasible solution.
Again, instead of using callbacks, you can use goals to add inject your own heuristically constructed solution into the running optimization.
Node Selection
When IloCplex
is not diving but picking an unexplored node
from the tree, several options are available that can be controlled with
the parameter IloCplex::NodeSel
. Again,
IloCplex
offers a callback class,
IloCplex::NodeCallbackI
, to give the user full control over
this selection. With goals, objects of type
IloCplex::NodeEvaluatorI
can be used to define your own selection strategy.
See also IloAlgorithm
in the
ILOG Concert Reference Manual.
See also Goals among the Concepts in this manual. See also goals in the ILOG CPLEX User's Manual.
See Also:
IloCplex::Algorithm, IloCplex::BasisStatus, IloCplex::BasisStatusArray, IloCplex::BranchDirection, IloCplex::BranchDirectionArray, IloCplex::CallbackI, IloCplex::DeleteMode, IloCplex::DualPricing, IloCplex::Exception, IloCplex::IntParam, IloCplex::MIPEmphasisType, IloCplex::NodeSelect, IloCplex::NumParam, IloCplex::PrimalPricing, IloCplex::Quality, IloCplex::CplexStatus, IloCplex::StringParam, IloCplex::VariableSelect, IloCplex::GoalI
Constructor Summary  

public  IloCplex(IloEnv env) 
public  IloCplex(const IloModel model) 
Inherited Methods from IloAlgorithm 

clear, end, error, extract, getEnv, getIntValue, getIntValues, getModel, getObjValue, getStatus, getTime, getValue, getValue, getValue, getValue, getValues, getValues, isExtracted, out, printTime, resetTime, setError, setOut, setWarning, solve, warning 
Inner Typedef  

IloCplex::BasisStatusArray  
IloCplex::BranchDirectionArray  
IloCplex::ConflictStatusArray  
IloCplex::Status 
An enumeration for the class IloAlgorithm .

Constructor Detail 

This constructor creates an ILOG CPLEX algorithm.
The new IloCplex
object has no IloModel
loaded
(or extracted) to it.
This constructor creates an ILOG CPLEX algorithm and extracts
model
for that algorithm.
When you create an algorithm (an instance of IloCplex
, for
example) and extract a model for it, you can write either this line:
IloCplex cplex(model);
or these two lines:
IloCplex cplex(env); cplex.extract(model);
Method Detail 

This method is used to create and return a goal that applies the
node selection strategy defined by eval
to the search strategy
defined by goal
. The resulting goal will use the node strategy
defined by eval
for the subtree generated by
goal
.
This method creates and returns a goal that puts the search specified by
goal
under the limit defined by limit
. Only the
subtree controlled by goal
will be subjected to limit
limit
.
This method adds con
as a cut to the invoking
IloCplex
object. The cut is not extracted as the regular
constraints in a model, but is only copied when invoking the method
addCut
. Thus, con
may be deleted or modified
after addCut
has been called and the change will not be
notified to the invoking IloCplex
object.
When columns are deleted from the extracted model, all cuts are
deleted as well and need to be reextracted if they should be considered.
Cuts are not part of the root problem, but are considered on an
asneeded basis. A solution computed by IloCplex
is guaranteed
to satisfy all cuts added with this method.
This method adds the constraints in con
as
cuts to the invoking IloCplex
object. Everything said for
IloCplex::addCut
applies equally to each of the
cuts given in array con
.
Creates and installs a named diversity filter for the designated integer variables with the specified lower and upper cutoff values, reference values, and weights.
Creates and installs a named diversity filter for the designated numeric variables with the specified lower and upper cutoff values, reference values, and weights.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method adds con
as a lazy constraint to the
invoking IloCplex
object. The constraint con
is
copied into the lazy constraint pool; the con
itself is not
part of the pool, so changes to con
after it has been copied
into the lazy constraint pool will not affect the lazy constraint pool.
Lazy constraints added with addLazyConstraint
are typically
constraints of the model that are not expected to be violated when left out.
The idea behind this is that the LPs that are solved when solving the MIP
can be kept smaller when these constraints are not included.
IloCplex
will, however, include a lazy constraint in the LP as
soon as it becomes violated. In other words, the solution computed by
IloCplex
makes sure that all the lazy constraints that have
been added are satisfied.
By contrast, if the constraint does not change the feasible region of the
extracted model but only strengthens the formulation, it is referred to as a
user cut. While user cuts can be added to IloCplex
with
addLazyConstraint
, it is generally preferable to do so with
addUserCuts
. It is an error, however, to add lazy constraints
by means of the method addUserCuts
.
When columns are deleted from the extracted model, all lazy constraints
are deleted as well and need to be recopied into the lazy constraint pool.
Use of this method in place of addCuts
allows for further
presolve reductions
IloCplex::addCut
.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method adds a set of lazy constraints to the invoking
IloCplex
object. Everything said for
IloCplex::addLazyConstraint
applies to each of the lazy constraints
given in array con
.
This method is equivalent to
IloCplex::addCuts
.
Creates a named range filter, using the specified lower cutoff, upper cutoff, integer variables, and weights, adds the filter to the solution pool of the invoking model, and returns the index of the filter.
Creates a named range filter, using the specified lower cutoff, upper cutoff, numeric variables, and weights, adds the filter to the solution pool of the invoking model, and returns its index.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method adds con
as a user cut to the invoking
IloCplex
object. The constraint con
is
copied into
the user cut pool; the con
itself is not part of the pool, so
changes to con
after it has been copied into the user cut pool
will not affect the user cut pool.
Cuts added with addUserCut
must be real cuts, in that the
solution of a MIP does not depend on whether the cuts are added or not.
Instead, they are there only to strengthen the formulation.
When columns are deleted from the extracted model, all user cuts are deleted as well and need to be recopied into the user cut pool.
It is an error to use addUserCut
for lazy constraints, that is, constraints whose absence may potentially
change the solution of the problem. Use addLazyConstraints
or, equivalently, addCut
when you add such a constraint.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method adds a set of user cuts to the invoking
IloCplex
object. Everything said for
IloCplex::addUserCut
applies to each of the
user cuts given in array con
.
This method can be used to compute tighter bounds
for the variables of a model
and to detect redundant constraints in the model extracted to the invoking
IloCplex
object. For every variable specified in parameter
vars
, it will return possibly tightened bounds in the
corresponding elements of arrays redlb
and redub
.
Similarly, for every constraint specified in parameter rngs
,
this method will return a Boolean value reporting
whether or not it is redundant
in the model in the corresponding element of array
redundant
.
This method deletes all cuts that have previously been added to the
invoking IloCplex
object with the methods addCut
and addCuts
.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method deletes all lazy constraints added to the invoking
IloCplex
object with the methods
IloCplex::addLazyConstraint
and
IloCplex::addLazyConstraints
.
This method is equivalent to IloCplex::clearCuts
.
This method can be used to unextract the model that is currently
extracted to the invoking IloCplex
object.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method deletes all user cuts that have previously been added
to the invoking IloCplex
object with the methods
IloCplex::addUserCut
and
IloCplex::addUserCuts
.
This method removes any existing branching direction assignment
from variable var
.
This method removes any existing branching direction assignments
from all variables in the array var
.
Deletes the speficied filter from the solution pool.
This method removes any existing priority order assignments from
all variables in the array var
.
This method removes any existing priority order assignment from
variable var
.
Deletes the specified solution from the solution pool and renumbers the indices of the remaining solutions in the pool.
Deletes a range of solutions from the solution pool and renumbers the indices of the remaining solutions in the pool.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method
returns a Farkas proof of infeasibility for the active LP model after
it has been proven to be infeasible by one of the simplex optimizers.
For every constraint i
of the active LP this method computes
a value y[i]
such that y'A >= y'b
, where
A
denotes the constraint matrix.
For more detailed information about the Farkas proof of infeasibility,
see the C routine CPXdualfarkas
, documented
in the reference manual of the Callable Library.
rng  An array of length 
y  An array of length 
The value of y'b  y'A z
for the vector
z
defined such that z[j] = ub[j]
if
y'A[j] > 0
and z[j] = lb[j]
if
y'A[j] < 0
for all variables j
.
This method writes the active model (that is, the model
that has been extracted by the
invoking algorithm) to the file filename
.
The file format is determined by the extension of the file name.
The following extensions are recognized on most platforms:
.sav
.mps
.lp
.sav.gz
(if gzip is properly installed)
.mps.gz
(if gzip is properly installed)
.lp.gz
(if gzip is properly installed)
Microsoft Windows does not support gzipped files for this API.
If no name has been assigned to a variable or range
(that is, the method getName
returns null
for that variable or range), IloCplex
uses
a default name when writing the model to the file
(or to the optimization log). Default names are of the form
IloXj for variables and IloCi, where i and j are internal
indices of IloCplex
.
See the reference manual ILOG CPLEX File Formats for more detail and the ILOG CPLEX User's Manual for additional information about file formats.
The method feasOpt
computes
a minimal relaxation of constraints in
the active model in order to make the model feasible. On successful
completion, the method installs a solution vector that is feasible
for the minimumcost relaxation. This solution can be queried with
query methods, such as
IloCplex::getValues
or
IloCplex::getInfeasibility
.
The method feasOpt
provides several different
metrics for determining what constitutes a minimum relaxation.
The metric is specified by the parameter FeasOptMode
.
The method feasOpt
can also optionally perform a second
optimization phase where the original objective is optimized,
subject to the constraint that the associated relaxation metric must
not exceed the relaxation value computed in the first phase.
The user may specify values (known as preferences)
to express relative preferences
for relaxing constraints. A larger preference
specifies a greater willingness to relax the corresponding constraint.
Internally, feasOpt
uses the
reciprocal of the preference to weight
the relaxations of the associated bounds in the phase one cost function.
A negative or 0 (zero) value as a preference specifies
that the corresponding constraint must not be relaxed.
If a preference is specified for a ranged constraint,
that preference is used for both, its upper and lower bound.
The preference for relaxing constraint
cts[i]
should be provided in prefs[i]
.
The array cts
need not contain all constraints
in the model.
Only constraints directly added to the model can be specified.
If a constraint is not present, it will not be relaxed.
IloAnd
can be used to group constraints
to be treated as one.
Thus, according to the various Inf
relaxation penalty metrics,
all constraints in a group can be relaxed for a penalty of one unit.
Similarly, according to the various Quad
metrics,
the penalty for relaxing a
group grows as the square of the sum of the individual member relaxations,
rather than as the sum of the squares of the individual relaxations.
If enough variables or constraints were allowed to be relaxed, the
function will return IloTrue
; otherwise, it returns
IloFalse
.
The active model is not changed by this method.
See Also:
Attempts to find a minimum feasible relaxation of the active
model by relaxing the bounds of the constraints specified in
rngs
. Preferences are specified in rnglb
and
rngub
on input.
The method returns IloTrue
if it finds a feasible
relaxation.
Attempts to find a minimum feasible relaxation of the
active model by relaxing the bounds of the variables specified in
vars
as specified
in varlb
and varub
.
The method returns IloTrue
if it finds a feasible
relaxation.
The method feasOpt
computes
a minimal relaxation of the range and variable bounds of
the active model in order to make the model feasible. On successful
completion, the method installs a solution vector that is feasible
for the minimumcost relaxation. This solution can be queried with
query methods, such as
IloCplex::getValues
or
IloCplex::getInfeasibility
or
The method feasOpt
provides several different
metrics for determining what constitutes a minimum relaxation.
The metric is specified by the parameter FeasOptMode
.
The method feasOpt
can also optionally perform a second
optimization phase where the original objective is optimized,
subject to the constraint that the associated relaxation metric must
not exceed the relaxation value computed in the first phase.
The user may specify values (known as preferences)
to express relative preferences
for relaxing bounds. A larger preference
specifies a greater willingness to relax the corresponding bound.
Internally, feasOpt
uses the
reciprocal of the preference to weight
the relaxations of the associated bounds in the phase one cost function.
A negative or 0 (zero) value as a preference specifies
that the corresponding bound must not be relaxed.
The preference for relaxing the lower bound of constraint
rngs[i]
should be provided in rnglb[i]
;
and likewise the preference for relaxing the upper bound of constraint
rngs[i]
in rngub[i]
. Similarly, the
preference for relaxing the lower bound of variable
vars[i]
should be provided in varlb[i]
, and
the preference for relaxing its upper bound in varub[i]
.
Arrays rngs
and vars
need not contain all
ranges and variables in the model. If a range or variable is not
present, its bounds are not relaxed.
Only constraints directly added to the model can be specified.
If enough variables or constraints were allowed to be relaxed, the
function will return IloTrue
; otherwise, it returns
IloFalse
.
The active model is not changed by this method.
See Also:
This method frees the presolved problem. Under the default
setting of parameter Reduce
, the presolved problem is freed
when an optimal solution is found; however, it is not freed if
Reduce
has been set to 1 (primal reductions) or to 2 (dual
reductions). In these instances, the function freePresolve
can be used when necessary to free it manually.
Computes A times X, where A is the corresponding LP constraint matrix.
For the constraints in con
,
this method places the values of the expressions, or, equivalently,
the activity levels of the constraints
for the current solution of the invoking
IloCplex
object into the array val
. Array
val
is resized to the same size as
array con
, and val[i]
will contain the
slack value for constraint con[i]
. All ranges in
con
must be part of the extracted model.
Computes A times X, where A is the corresponding LP constraint matrix.
This method returns the value of the expression of the constraint
range
, or, equivalently, its activity level, for the
current solution of the invoking IloCplex
object.
The range
must be part of the extracted model.
Returns a handle to the aborter being used by the invoking
IloCplex
object.
This method returns the algorithm type that was used to solve the most recent model in cases where it was not a MIP.
This method returns the basis status of the implicit slack or
artificial variable created for the constraint con
.
This method returns the basis status for the variable
var
.
This method returns the basis status for the variable
var
.
This method puts the basis status of each variable in
var
into the corresponding element of the array
cstat
, and it puts the status of each row in
con
(an array of ranges or constraints)
into the corresponding element of the array rstat
.
Arrays rstat
and cstat
are resized
accordingly.
This method puts the basis status of each constraint in
con
into the corresponding element of the array
stat
. Array stat
is resized accordingly.
This method puts the basis status of each variable in
var
into the corresponding element of the array
stat
. Array stat
is resized accordingly.
For the given set of variables vars
, bound sensitivity
information is computed. When the method returns, the element
lblower[j]
and lbupper[j]
will contain the lowest and highest value the
lower bound of variable vars[j]
can assume without affecting
the optimality of the solution. Likewise, ublower[j]
and ubupper[j]
will contain the lowest and highest value the
upper bound of variable vars[j]
can assume without affecting
the optimality of the solution. The arrays lblower
,
lbupper
, ublower
, and ubupper
will be resized to the size of array vars
.
The value 0 (zero) can be passed for any of the return
arrays if the information is not desired.
Returns the conflict status for the constraint con
.
Possible return values are:
IloCplex::ConflictMember
the constraint has been proven
to participate in the conflict.
IloCplex::ConflictPossibleMember
the constraint has not
been proven not to participate in the conflict;
in other words, it might participate, though it might not.
The constraint con
must be one that has
previously been passed to refineConflict
including IloAnd
constraints.
Returns the conflict status for each of the constraints specified in
cons
.
The element i
is the conflict status for
the constraint cons[i]
and can take the following values:
IloCplex::ConflictMember
the constraint has been proven
to participate in the conflict.
IloCplex::ConflictPossibleMember
the constraint has not
been proven not to participate in the conflict;
in other words, it might participate, though it might not.
The constraints passed in cons
must be among the same
ones that have previously been passed to refineConflict
,
including IloAnd
constraints.
This method returns the ILOG CPLEX status of the invoking
algorithm. For possible ILOG CPLEX values, see the enumeration type
IloCplex::CplexStatus
.
See also the topic Interpreting Solution Quality in the ILOG CPLEX User's Manual for more information about a status associated with infeasibility or unboundedness.
This method accesses the solution status of the last node
problem that was solved in the event of an error termination in the previous
invocation of IloCplex::solve
. The method
IloCplex::getCplexSubStatus
returns 0
in the
event of a normal termination. If the invoking IloCplex
object
is continuous, this is equivalent to the status returned by the method
IloCplex::getCplexStatus
.
This method returns the MIP cutoff value being used during the
MIP optimization. In a minimization problem, all nodes are pruned that
have an optimal solution value of the continuous relaxation that
is larger than the current cutoff value. The cutoff is updated with the
incumbent. If the invoking IloCplex
object is an LP or QP,
+IloInfinity
or IloInfinity
is returned,
depending on the optimization sense.
These method return the default setting for the parameter
parameter
.
This method returns the current delete mode of the invoking
IloCplex
object.
This method returns the branch direction previously assigned to
variable var
with method
IloCplex::setDirection
or
IloCplex::setDirections
.
If no direction has been assigned,
IloCplex::BranchGlobal
will be returned.
This method returns the branch directions previously assigned to
variables listed in var
with the method
setDirection
or setDirections
.
When the function returns,
dir[i]
will contain the branch direction
assigned for variables
var[i]
. If no branch direction has been assigned to
var[i]
, dir[i]
will be set to
IloCplex::BranchGlobal
.
This method returns the diverging variable or constraint, in a
case where the primal Simplex algorithm has determined the problem to be
infeasible. The returned extractable is either an IloNumVar
or
an IloConstraint
object extracted to the invoking
IloCplex
optimizer; it is of type IloNumVar
if the
diverging column corresponds to a variable, or of type
IloConstraint
if the diverging column corresponds to the
slack variable of a constraint.
Given the index of a diversity filter associated with the solution pool, this method returns the lower cutoff value of that filter.
Accesses the reference values declared in a diversity filter specified by its index in the solution pool.
Given the index of a diversity filter associated with the solution pool, this method returns the lower cutoff value of that filter.
Accesses the weights declared in a diversity filter specified by its index in the solution pool.
This method returns the dual value associated with the constraint
range
in the current solution of the invoking algorithm.
This method puts the dual values associated with the ranges in
the array con
into the array val
. Array
val
is resized to the same size as
array con
, and val[i]
will contain the
dual value for constraint con[i]
.
Accesses the index of a filter specified by its name.
Given the index of a filter associated with the solution pool, this method returns the type of that filter.
Accesses the variables of a diversity filter specified by its index.
This method returns the node number where the current incumbent was
found. If the invoking IloCplex
object is an LP or a
QP, 0 (zero) is returned.
This method puts the infeasibility values of the integer
variables in array var
for the current solution into
the array infeas
. The infeasibility value is 0 (zero) if
the variable bounds are satisfied. If the infeasibility value is
negative, it specifies the amount by which the lower bound of the
variable must be changed; if the value is positive, it specifies the
amount by which the upper bound of the variable must be
changed. This method does not check for integer
infeasibility. The array infeas
is automatically
resized to the same length as array var
, and
infeas[i]
will contain the infeasibility value for
variable var[i]
. This method returns the maximum
absolute infeasibility value over all integer variables in
var
.
This method puts the infeasibility values of the numeric
variables in array var
for the current solution into
the array infeas
. The infeasibility value is 0 (zero) if
the variable bounds are satisfied. If the infeasibility value is
negative, it specifies the amount by which the lower bound of the
variable must be changed; if the value is positive, it specifies the
amount by which the upper bound of the variable must be
changed. The array infeas
is automatically resized
to the same length as array var
, and
infeas[i]
will contain the infeasibility value for
variable var[i]
. This method returns the maximum
absolute infeasibility value over all numeric variables in
var
.
This method puts the infeasibility values of the current
solution for the constraints specified by the array
con
into the array infeas
. The
infeasibility value is 0 (zero) if the constraint is satisfied. More
specifically, for a range with finite lower bound and upper
bound, if the infeasibility value is negative, it specifies the
amount by which the lower bound of the range must be changed; if
the value is positive, it specifies the amount by which the upper bound
of the range must be changed. For a more general constraint such
as IloOr
, IloAnd
, IloSOS1
,
or IloSOS2
, the infeasibility value returned is the
maximal absolute infeasibility value over all range constraints
and variables created by the extraction of the queried
constraint. Array infeas
is resized to the same size
as array range
, and infeas[i]
will
contain the infeasibility value for constraint
range[i]
. This method returns the maximum absolute
infeasibility value over all constraints in con
.
This method returns the infeasibility of the integer variable
var
in the current solution. The infeasibility value
returned is 0 (zero) if the variable bounds are satisfied. If the
infeasibility value is negative, it specifies the amount by which
the lower bound of the variable must be changed; if the value is
positive, it specifies the amount by which the upper bound of the
variable must be changed. This method does not check for integer
infeasibility.
This method returns the infeasibility of the numeric variable
var
in the current solution. The infeasibility value
returned is 0 (zero) if the variable bounds are satisfied. If the
infeasibility value is negative, it specifies the amount by which
the lower bound of the variable must be changed; if the value is
positive, it specifies the amount by which the upper bound of the
variable must be changed.
This method returns the infeasibility of the current solution
for the constraint code
. The infeasibility value is
0 (zero) if the constraint is satisfied. More specifically, for a range
with finite lower bound and upper bound, if the infeasibility
value is negative, it specifies the amount by which the lower
bound of the range must be changed; if the value is positive, it
specifies the amount by which the upper bound of the range must
be changed. For a more general constraint such as
IloOr
, IloAnd
, IloSOS1
, or
IloSOS2
, the infeasibility value returned is the
maximal absolute infeasibility value over all range constraints
and variables created by the extraction of the queried
constraint.
These method return the maximum allowed value for the parameter
parameter
.
These method return the minimum allowed value for the parameter
parameter
.
This method returns the number of nonzeros extracted to the constraint matrix A of the invoking algorithm.
This method returns the number of quadratic constraints extracted from the active model for the invoking algorithm. This number may be different from the total number of constraints in the active model because linear constraints are not accounted for in this function.
See Also:
This method returns the number of SOSs extracted for the
invoking algorithm. There may be differences in the number returned by this
function and the number of numeric variables (that is, instances of
the class IloNumVar
, and so forth)
in the model that is
extracted because piecewise linear functions are extracted as a set
of SOSs.
This method returns the number of barrier iterations from the last solve.
This method returns the number of binary variables in the matrix
representation of the active model in the invoking IloCplex
object.
This method returns the number of columns extracted for the
invoking algorithm. There may be differences in the number returned by this
function and the number of object of type IloNumVar
and its
subclasses in the model that is extracted. This is because automatic
transformation of nonlinear constraints and expressions may introduce
new variables.
This method returns the number of dual exchange operations in
the crossover of the last call to method solve
or
solveFixed
, if barrier with crossover has been
used for solving an LP or QP.
This method returns the number of dual push operations in the
crossover of the last call to
IloCplex::solve
or
IloCplex::solveFixed
,
if barrier with crossover was used for solving an LP or QP.
This method returns the number of primal exchange operations in
the crossover of the last call of method
IloCplex::solve
or
IloCplex::solveFixed
,
if barrier with crossover was
used for solving an LP of QP.
This method returns the number of primal push operations in the
crossover of the last call of method
IloCplex::solve
or
IloCplex::solveFixed
, if barrier with
crossover was used for solving an LP or QP.
This method returns the number of cuts of the specified type
in use at the end of the previous mixed integer optimization.
If the invoking IloCplex
object is not a MIP,
it returns 0.
This method returns the number of dual superbasic variables in
the current solution of the invoking IloCplex
object.
Returns the number of filters currently associated with the solution pool.
This method returns the number of integer variables in the
matrix representation of the active model in the invoking
IloCplex
object.
This method returns the number of iterations that occurred
during the last call to the method
IloCplex::solve
in
the invoking algorithm.
This method returns the number of branchandcut nodes that were
processed in the current solution. If the invoking IloCplex
object is not a MIP, it returns 0.
This method returns the number of branchandcut nodes that remain to
be processed in the current solution. If the invoking IloCplex
object is not a MIP, it returns 0.
If a simplex method was used for solving continuous model, this
method returns the number of iterations in phase 1 of the last call to
IloCplex::solve
or
IloCplex::solveFixed
.
This method returns the number of primal superbasic variables in
the current solution of the invoking IloCplex
object.
This method returns the number of rows extracted for the
invoking algorithm. There may be differences in the number returned by this
function and the number of IloRange
s and
IloConstraint
s in the model that is extracted. This is
because quadratic constraints are not accounted for by method
getNrows
and automatic transformation of nonlinear
constraints and expressions may introduce new constraints.
See Also:
This method returns the number of semicontinuous variables in
the matrix representation of the active model in the invoking
IloCplex
object.
This method returns the number of semiinteger variables in the
matrix representation of the active model in the invoking
IloCplex
object.
This method returns the number of sifting iterations performed for
solving the last LP with algorithm type IloCplex::Sifting
, or,
equivalently, the number of work LPs that have been solved for it.
This method returns the number of sifting iterations performed for
solving the last LP with algorithm type IloCplex::Sifting
in
order to achieve primal feasibility.
This method performs objecitve sensitivity analysis for the
variables specified in array vars
.
When this method returns lower[i]
and upper[i]
will contain the lowest and highest value the objective function
coefficient for variable vars[i]
can assume
without affecting the optimality of the solution. The arrays
lower
and upper
will be resized to the size of
array vars
.
If any of the information is not requested, 0 (zero) can be passed
for the corresponding array parameter.
This member function returns the numeric value of the objective
function for the solution pool member indexed by
soln
.
The soln
argument may be omitted or given a value of 1
in order to access the current solution.
This method returns the instance of IloObjective
that has been extracted to the invoking instance of IloCplex
.
If no objective has been extracted, an empty handle is returned.
If you need only the current value of the objective, for example to use in a callback, consider one of these methods instead:
This method returns the current setting of parameter
in
the invoking algorithm.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
Returns a parameter set corresponding to the present parameter state.
If the method fails, an exception of type
IloException
, or one of its derived classes, is thrown.
This method returns query branch priorities previously assigned to
variables listed in var
with the method
setPriority
or setPriorities
.
When the function returns,
pri[i]
will contain the priority value assigned for variables
var[i]
. If no priority has been assigned to
var[i]
, pri[i]
will contain 0 (zero).
This method returns the priority previously assigned to the variable
var
with the method setPriority
or
setPriorities
. It returns 0 (zero) if no priority
has been assigned.
These methods return the requested quality measure for
a member of the solution pool. The soln
argument
may be given a value of 1 to return the quality meausre for
the current solution.
Some quality measures are related to a variable or a constraint.
For example, IloCplex::MaxPrimalInfeas
is related to the
variable or constraint where the maximum infeasibility (bound
violation) occurs. If this information is also requested, pointers
to instances of IloNumVar
or IloConstraint
may
be passed as optional arguments specifying where the relevant variable or
range will be written. However, if the constraint has been implicitly
created (for example, because of automatic linearization),
a null handle will be returned for these arguments.
These methods return the requested quality measure.
Some quality measures are related to a variable or a constraint.
For example, IloCplex::MaxPrimalInfeas
is related to the
variable or constraint where the maximum infeasibility (bound
violation) occurs. If this information is also requested, pointers
to instances of IloNumVar
or IloConstraint
may
be passed as optional arguments specifying where the relevant variable or
range will be written. However, if the constraint has been implicitly
created (for example, because of automatic linearization),
a null handle will be returned for these arguments.
This method performs righthand side sensitivity analysis for the
constraints specified in array cons
. The constraints must be
of the form cons[i]
: expr[i] rel rhs[i]
.
When this method returns lower[i]
and upper[i]
will contain the lowest and highest value rhs[i]
can assume
without affecting the optimality of the solution. The arrays
lower
and upper
will be resized to the size of
array cons
.
If any of the information is not requested, 0 (zero) can be passed
for the corresponding array parameter.
Accesses the coefficients (that is, the weights) declared in the range filter specified by its index.
Given the index of a range filter associated with the solution pool, this method returns the lower bound of that filter.
Given the index of a range filter associated with the solution pool, this method returns the upper bound of that filter.
This method performs sensistivity analysis
for the upper and lower bounds of the ranged constraints
passed in the array con
. When the method
returns, lblower[i]
and lbupper[i]
will contain,
respecitively, the lowest and the highest value that the lower bound of
constraint con[i]
can assume without affecting the optimality
of the solution. Similarly, ublower[i]
and
ubupper[i]
will contain, respectively, the lowest and the
highest value that the upper bound of the constraint con[i]
can assume without affecting the optimality of the solution. The arrays
lblower
, lbupper
, ublower
, and
ubupper
will be resized to the size of array con
.
If any of the information is not requested, 0
can be passed
for the corresponding array parameter.
This method returns an unbounded direction (also known
as a ray) corresponding to the present basis for an LP that has
been determined to be an unbounded problem. CPLEX puts the
the variables of the extracted model into the array vars
and
it puts the corresponding values of the unbounded direction into the
array vals
.
CPLEX resizes these arrays for you.
This method returns the reduced cost associated with
var
in the invoking algorithm.
This method returns the reduced cost associated with
var
in the invoking algorithm.
This method puts the reduced costs associated with the numeric
variables of the array var
into the array
val
. The array val
is
automatically resized to the same length as
array var
, and val[i]
will contain the
reduced cost for variable var[i]
.
This method puts the reduced costs associated with the
variables in the array var
into the array
val
. Array val
is resized to the same size as
array var
, and val[i]
will contain the
reduced cost for variable var[i]
.
This method returns the slack value associated with the constraint
range
for a solution of the invoking algorithm.
For a range with finite lower and upper bounds, the slack value
consists of the difference between the expression of the range and
its lower bound.
The current solution is used if the soln
argument is
omitted or given the value 1; otherwise, the solution pool member
indexed by soln
is used.
This method puts the slack values associated with the constraints
specified by the array con
into the array val
.
For a ranged constraint with finite lower and upper bounds, the slack
value consists of the difference between the expression in the range
and its lower bound.
The current solution is used if the soln
argument is
omitted or given the value 1; otherwise, the solution pool member
indexed by soln
is used.
Array val
is resized to the same size as
array con
, and val[i]
will contain the
slack value for constraint con[i]
.
Computes the mean of the objective values of the solutions currently in the solution pool.
Accesses the number of solutions that have been replaced according to the solution pool replacement strategy.
Accesses the number of solutions currently in the solution pool.
This method returns the status of the invoking algorithm.
For its ILOG CPLEX status, see the method
IloCplex::getCplexStatus
.
See also the topic Interpreting Solution Quality in the ILOG CPLEX User's Manual for more information about a status associated with infeasibility or unboundedness.
This method returns the type of the algorithm type that was used to solve most recent node of a MIP in the case of termination because of an error during mixed integer optimization.
This method returns the value of the objective using
the solution pool member indexed by soln
.
The soln
argument may be omitted or given a value of 1
in order to access the current solution.
This method returns the value of the expression using
the solution pool member indexed by soln
.
The soln
argument may be omitted or given a value of 1
in order to access the current solution.
This method returns the value from the solution
pool member indexed by soln
for the integer variable
specified by var
.
The soln
argument may be omitted or given a value of 1
in order to access the current solution.
This method returns the value from the solution
pool member indexed by soln
for the numeric variable
specified by var
.
The soln
argument may be omitted or given a value of 1
in order to access the current solution.
This method puts the values from the solution pool member
indexed by soln
for the integer variables
specified by the array
var
into the array val
.
The soln
argument may be omitted or given a value of 1
in order to access the current solution.
Array val
is resized to the same size as
array var
, and val[i]
will contain the
solution value for variable var[i]
.
This method puts the values from the solution pool member
indexed by soln
for the numeric variables
specified by the array
var
into the array val
.
The soln
argument may be omitted or given a value of 1
in order to access the current solution.
Array val
is resized to the same size as
array var
, and val[i]
will contain the
solution value for variable var[i]
.
This method puts the values from the solution pool member
indexed by soln
for the numeric variables
specified by the array
var
into the array val
.
The soln
argument may be omitted or given a value of 1
in order to access the current solution.
Array val
is resized to the same size as
array var
, and val[i]
will contain the
solution value for variable var[i]
.
This method puts the solution values of the integer variables
specified by the array var
into the array
val
. Array val
is resized to the same size as
array var
, and val[i]
will contain the
solution value for variable var[i]
.
This method puts the solution values of the integer variables
specified by the array var
into the array
val
. Array val
is resized to the same size as
array var
, and val[i]
will contain the
solution value for variable var[i]
.
This member function accepts an array of variables vars
and puts the
corresponding values into the array vals
; the corresponding values come
from the current solution of the invoking algorithm. The array vals
must
be a clean, empty array when you pass it to this member function.
If there are no values to return for vars
, this member function raises
an error. On platforms that support C++ exceptions, when exceptions are enabled, this
member function throws the exception NotExtractedException
in such a case.
This method puts the solution values of the numeric variables
specified by the array var
into the array
val
. Array val
is resized to the same size as
array var
, and val[i]
will contain the
solution value for variable var[i]
.
This method returns a string specifying the version of
IloCplex
.
This method reads a model from the file specified by
filename
into model
. Typically
model
will be an empty, unextracted model on entry to this
method. The invoking IloCplex
object is not affected when
you call this method unless model
is its extracted model;
follow this method with a call to IloCplex::extract
in
order to extract the imported model to the invoking IloCplex
object.
When this methods reads a file, new modeling objects, as required
by the input file, are created and added to any existing modeling objects
in the model
passed as an argument.
Note that any previous modeling objects in model
are not
removed; precede the call to importModel
with explicit calls
to IloModel::remove
if you need to remove them.
This method is a simplification of the method importModel
that does not provide arrays to return SOSs. This method is easier to
use in the case where you are dealing with continuous models because in
such a case you already know that no SOS will be present.
This method reads a model from the file specified by
filename
into model
. Typically
model
will be an empty, unextracted model on entry to this
method. The invoking IloCplex
object is not affected when
you call this method unless model
is its extracted model;
follow this method with a call to IloCplex::extract
in
order to extract the imported model to the invoking IloCplex
object.
When this methods reads a file, new modeling objects, as required
by the input file, are created and added to any existing modeling objects
in the model
passed as an argument.
Note that any previous modeling objects in model
are not
removed; precede the call to importModel
with explicit calls
to IloModel::remove
if you need to remove them.
As this method reads a model from a file,
it places the objective it has read in
obj
, the variables it has read in the array vars
, * the ranges it has read in the array rngs
; and the Special
Ordered Sets (SOS) it has read in the arrays sos1
and
sos2
.
CPLEX resizes these arrays for you to accomodate the returned objects.
This note is for advanced users only.
The two arrays lazy
and cuts
are filled with the
lazy constraints and user cuts that may be included in the model
in the file filename
.
The format of the file is determined by the extension of the file name. The following extensions are recognized on most platforms:
.sav
.mps
.lp
.sav.gz
(if gzip is properly installed)
.mps.gz
(if gzip is properly installed)
.lp.gz
(if gzip is properly installed)
Microsoft Windows does not support gzipped files for this API.
This method returns IloTrue
if a dual feasible solution
is recorded in the invoking IloCplex
object and can be
queried.
This method returns IloTrue
if the invoking
algorithm has extracted a model that is a MIP (mixedinteger programming
problem) and IloFalse
otherwise. Member functions
for accessing
duals and reduced cost basis work only if the model is not a MIP.
This method returns IloTrue
if a primal feasible solution
is recorded in the invoking IloCplex
object and can be
queried.
This method returns IloTrue
if the invoking
algorithm has extracted a model that is quadratically constrained.
Otherwise, it returns IloFalse
.
For an explanation of quadratically constrained see
the topic QCP in the ILOG CPLEX User's Manual.
This method returns IloTrue
if the invoking
algorithm has extracted a model that has quadratic objective function terms.
Otherwise, it returns IloFalse
.
The method populate
generates multiple solutions
to a mixed integer programming (MIP) model. In other words, it
populates the solution pool of the model currently extracted by
the invoking IloCplex
object. Like the method
solve
, this method returns IloTrue
if it finds a solution (not necessarily an optimal solution).
The algorithm that populates the solution pool works in two phases:
In the first phase, it solves the model to optimality (or some stopping criterion set by the user) while it sets up a branch and cut tree for the second phase.
In the second phase, it generates multiple solutions by using the information computed and stored in the first phase and by continuing to explore the tree.
The amount of preparation in the first phase and the intensity
of exploration in the second phase are controlled by the solution
pool intensity parameter SolnPoolIntensity
.
Optimality is not a stopping criterion for the
populate
method.
Even if the optimality gap is zero, this method will still try
to find alternative solutions. The stopping criteria
for populate
are these:
PopulateLim
. This parameter
controls how many solutions are generated before the method stops.
Its default value is 20.
TiLim
, as in standard MIP optimization.
NodeLim
, as in standard MIP optimization.
populate
stops when it cannot enumerate any more solutions. In particular, if the
user specifies an objective tolerance with the relative or absolute
solution pool gap parameters, populate
stops if it
cannot enumerate any more solutions within the specified objective
tolerance. There may exist additional solutions that satisfy the
specified objective tolerance; depending on the solution pool intensity
parameter, populate
may or may not enumerate all of them;
according to certain settings of the solution pool intensity parameter,
populate
may stop when it has enumerated a subset of
additional solutions satisfying the specified objective tolerance.
Successive calls to populate
create solutions
that are stored in the solution pool. However, each call to
populate
applies only to the subset of solutions
created in the current call; the call does not affect the solutions
already in the pool. In other words, solutions in the pool are
persistent.
The user may call this routine independently of any MIP optimization of a model. In that case, it carries out the first and second phase itself.
The user may also call populate
after
standard MIP optimization.
In the general case, the user reads the model,
calls MIP optimization, then calls populate
. The
activity of MIP optimization constitutes the first phase of the
populate algorithm; populate
then reuses the
information computed and stored by MIP optimization and thus
carries out only the second phase.
The method populate
does not try to generate
multiple solutions for unbounded MIP models. As soon
as the proof of unboundedness is obtained,
populate
stops.
This method performs Presolve on the model. The enumeration
alg
tells Presolve which algorithm is intended to be used
on the reduced model; NoAlg
should be specified for MIP
models.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method specifies a set of integer variables that should not be substituted out of the problem. If presolve can fix a variable to a value, it is removed, even if it is specified in the protected list.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by ILOG CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, ILOG encourages you to consider carefully whether you can accomplish the same task by means of other methods instead.
This method specifies a set of numeric variables that should not be substituted out of the problem. If presolve can fix a variable to a value, it is removed, even if it is specified in the protected list.
The quadratic objective terms in a QP model must form a positive
semidefinite Q matrix (negative semidefinite for maximization).
If IloCplex
finds that this is not true, it will discontinue
the optimization. In such cases, the qpIndefCertificate
method can be used to compute assignments (returned in array
x
) to all variables (returned in array var
)
such that the quadratic term of the objective function evaluates to a
negative value (x'Q x < 0
in matrix terms) to prove the
indefiniteness.
Reads a simplex basis from the BAS file specified by name
,
and copies that basis into the invoking IloCplex
object. The
parameter AdvInd
must be set to a nonzero value (e.g. its
default setting) for the simplex basis to be used to start a subsequent
optimization with one of the Simplex algorithms.
By convention, the file extension is .bas
.
The BAS file format is documented in the reference manual
ILOG CPLEX File Formats.
Reads solution pool filters from a file in FLT format and
copies the filters into an instance of IloCplex
.
This format is documented in
the reference manual ILOG CPLEX File Formats.
Reads the SOL file denoted by name
and
copies the MIP start information into the invoking IloCplex
object. The parameter AdvInd
must be turned on
(its default: 1 (one))
in order for the MIP start information to be used to with
a subsequent MIP optimization.
By convention, the file extension is .sol
.
The SOL file format is documented in the
ILOG CPLEX File Formats Reference Manual and in
the stylesheet solution.xsl
and schema
solution.xsd
in the include
directory
of the product. Examples of its use appear in the examples
distributed with the product and in the
ILOG CPLEX User's Manual.
This method reads a priority order from a file in ORD format into
the invoking IloCplex
object. The names in the ORD file
must match the names in the active model. The priority order will
be associated with the model. The parameter MipOrdInd
must be nonzero for the next invocation of the method
IloCplex::solve
to take
the order into account.
By convention, the file extension is .ord
.
The ORD file format is documented in the reference manual
ILOG CPLEX File Formats.
Reads parameters and their settings from the file specified by
name
and applies them to the invoking
IloCplex
object. Parameters not listed in the parameter file
will be reset to their default setting.
By convention, the file extension is .prm
.
The PRM file format is documented in the reference manual
ILOG CPLEX File Formats.
Reads a solution from the SOL file denoted by
name
and copies this information into a CPLEX problem
object. This routine is able to initiate a crossover from
the barrier solution, to restart the simplex method with an
advanced basis or to specify variable values for a MIP start.
The parameter AdvInd
must set to a
nonzero value (such as its default setting: 1 (one))
in order for the solution file
to take effect with the method solve
.
By convention, the file extension is .sol
.
The SOL file format is documented in
the ILOG CPLEX File Format Reference Manual and in
the stylesheet solution.xsl
and schema
solution.xsd
in
the include
directory of the product.
Examples of its use appear in the examples distributed with
the product and in the ILOG CPLEX User's Manual.
The method refineConflict
identifies a
minimal conflict for the infeasibility of the current model or for 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 cons
.
Only constraints directly added to the model can be specified.
Constraints may also 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. However, no guarantee is made when a minimal conflict is returned that other conflicts containing groups or constraints with higher preference do not exist.
When this method returns, the conflict can be queried with the
methods getConflict
. The method writeConflict
can write a file in LP format containing the conflict.
cons  An array of constraints among which to look for a conflict. The constraints may be any constraint in the active model, or a group of constraints organized by 
prefs  An array of integers containing the preferences for the groups or constraints. 
This method removes the aborter object abort
from the
invoking IloCplex
object.
This method uses the array cstats
to set the basis
status of the variables in the array var
; it uses the array
rstats
to set the basis status of the ranges in the array
con
.
This method resets all CPLEX parameters to their default values.
This method sets the delete mode in the invoking
IloCplex
object to mode
.
This method sets the preferred branching direction for variable
var
to dir
. This setting will
cause CPLEX first to
explore the branch specified by dir
after branching on
variable var
.
This method sets the preferred branching direction for each
variable in the array var
to the corresponding value in the
array dir
. This will cause CPLEX first to
explore the branch specified by dir[i]
after branching on
variable var[i]
.
This method sets parameter
to value
in
the invoking algorithm. See the ILOG CPLEX User's Manual
for more detailed information about parameters and
for examples of their use.
Sets the parameter state using a parameter set.
If the method fails, an exception of type
IloException
, or one of its derived classes, is thrown.
set 
The parameter set.

This method sets the priority order for all variables in the
array var
to the corresponding value in the array
pri
. During branching, integer variables with higher
priorities are given preference over integer variables with lower
priorities. Further, variables that have priority
assigned to them are given preference over variables that do not.
Priorities must be nonnegative integers. By default, the priority
of a variable without a userassigned priority is 0 (zero).
The parameter MIPOrdInd
by default specifies that
userassigned priority orders should be taken into account.
When MIPOrdInd
is reset to its nondefault value
0 (zero), CPLEX ignores userassigned priorities.
To remove userassigned priority from a variable,
see the method IloCplex::delPriorities
.
For more detail about how
priorities are applied, see the topic Issuing Priority Orders
in the ILOG CPLEX User's Manual.
This method sets the priority order for the variable
var
to pri
. During branching, integer
variables with higher priorities are given preference over integer
variables with lower priorities. Further, variables that have priority
assigned to them are given preference over variables that do not.
Priorities must be nonnegative integers. By default, the priority
of a variable without a userassigned priority is 0 (zero).
The parameter MIPOrdInd
by default specifies that
userassigned priority orders should be taken into account.
When MIPOrdInd
is reset to its nondefault value
0 (zero), CPLEX ignores userassigned priorities.
To remove userassigned priority from a variable,
see the method IloCplex::delPriority
.
For more detail about how
priorities are applied, see the topic Issuing Priority Orders
in the ILOG CPLEX User's Manual.
This method allows a user to specify a starting point for the following
invocation of the method IloCplex::solve
.
For all variables in var
, x[i]
specifies
the starting value for the variable var[i]
. Similarly,
dj[i]
specifies the starting reduced cost for variable
var[i]
. For all ranged constraints specified in
rng
, slack[i]
specifies the starting slack
value for rng[i]
. Similarly, pi[i]
specifies
the starting dual value for rng[i]
.
Zero can be passed for any individual parameter. However, the arrays
x
and var
must be the same length.
Likewise, pi
and rng
must be the same
length.
In other words, you must provide starting values for
either the primal or dual variables x
and pi
.
If you provide values for dj
, then you must provide
the corresponding values for x
.
If you provide values for slack
, then you must provide
the corresponding values for pi
.
This information is exploited at the next call to
IloCplex::solve
,
to construct a starting point for the
algorithm, provided that the AdvInd
parameter
is set to a value greater than or equal to one. In
particular, if the extracted model is an LP, and the root algorithm is dual
or primal, the information is used to construct a starting basis for the
simplex method for the original model, if AdvInd
is set to
1 (one). If AdvInd
is set to 2, the information is used to construct a starting basis for the
presolved model.
If the extracted model is a MIP, only x
values can be used.
Values may be specified for any subset of the integer and continuous
variables in the model, either through a single invocation
of setVectors
,
or incrementally through multiple calls.
When optimization commences or resumes, CPLEX will attempt to
find a feasible MIP solution that is compatible with the set of specified
x
values. When start values are not provided for all integer
variables, CPLEX tries to extend the partial solution to a
complete solution
by solving a MIP on the unspecified variables. The parameter
SubMIPNodeLim
controls the amount of effort CPLEX expends in
trying to solve this secondary MIP. If CPLEX finds
a complete feasible solution, that solution becomes the incumbent. If the
specified values are infeasible, they are retained for use in a subsequent
solution repair heuristic. The amount of effort spent in this heuristic
can be controlled by the parameter RepairTries
.
This method initializes the goal stack of the root node with
goal
before starting the branch & cut search. The search
tree will be defined by the execute method of goal
and its
subgoals. See the concept Goals and the nested class
IloCplex::GoalI
for more information.
This method solves the model currently extracted to the invoking
IloCplex
object. The method returns
IloTrue
if it finds a solution (not necessarily an optimal
one).
After the invoking algorithm has solved the extracted MIP model to a
feasible (but not necessarily optimal) solution as a MIP, this member
function solves the relaxation of the model obtained by fixing all the
integer variables of the extracted MIP to the values of a solution.
The current solution is used if the soln
argument is
omitted or given the value 1; otherwise, the solution pool member
indexed by soln
is used.
The method tuneParam
tunes the parameters of
an instance of IloCplex
for improved optimizer
performance on the current model, or a set of models if
the filename
argument is used.
Tuning is carried out by CPLEX making a number
of trial runs with a variety parameter settings.
Parameters and associated values which should not be
changed by the tuning process are specified in the parameter set
fixedset
.
After tuneParam
has finished, the IloCplex
parameters will be set to the tuned and fixed settings
which can be queried or written to a file.
There will not be a solution to the current model.
The parameter
TuningRepeat
specifies how many problem variations
for CPLEX to try while tuning when tuning the current model.
Using a number of variations can give more
robust results when tuning is applied to a single model.
Note that the tuning evaluation measure is meaningful only when
TuningRepeat
is larger than one or when a set of
models is being tuned.
A few of the parameter settings control the tuning process. They are specified in the table below; other parameter settings are ignored.
Parameter  Use 
TiLim  Limits the total time spent tuning 
TuningTiLim  Limits the time of each trial run 
TuningMeasure  Controls the tuning evaluation measure 
TuningRepeat  Sets the number of repeated problem variations 
TuningDisplay  Controls the level of the tuning display 
All callbacks, except the tuning callback, will be ignored.
Tuning will monitor the method abort
and terminate when an abort has been issued.
IloInt
value specifying the
completion status of the tuning. The values returned
are from the enumeration TuningStatus
.
This method instructs the invoking IloCplex
object to use
cb
as a callback. If a callback of the same type as
cb
is already being used by the invoking
IloCplex
object, the previously used callback will be
overridden. If the callback object cb
is already being used
by another IloCplex
object, a copy of cb
will be
used instead. A handle to the callback that is installed in the invoking
IloCplex
object is returned. See
IloCplex::CallbackI
for a discussion of how to implement callbacks.
This method instructs the invoking IloCplex
object to use
the aborter object abort
to control termination of its
solving and tuning
methods. If an aborter is already being used by the invoking
IloCplex
object, the previously used aborter will be
overridden. A handle to the aborter that is installed in the invoking
IloCplex
object is returned.
See Also:
Writes the current simplex basis to the file specified by
name
.
By convention, the file extension is .bas
.
The BAS file format is documented in the reference manual
ILOG CPLEX File Formats.
Writes a conflict file named filename
.
Writes filters from the invoking model to a file in FLT format. This format is documented in the reference manual ILOG CPLEX File Formats.
Writes MIP start information to the file denoted by name
.
The MIP start written corresponds to the current solution if the
soln
parameter is omitted; otherwise, it corresponds to
the solution pool member indexed by soln
.
By convention, the file extension is .mst
.
The MST file format is documented in the reference manual
ILOG CPLEX File Formats as well as the stylesheet
solution.xsl
and schema solution.xsd
found in the include
directory of the product.
Writes MIP start information with all members of the
solution pool to the file denoted by name
.
By convention, the file extension is .mst
.
The MST file format is documented in the reference manual
ILOG CPLEX File Formats as well as the stylesheet
solution.xsl
and schema solution.xsd
found in the include
directory of the product.
Writes a priority order to the file filename
.
If a priority order has been associated with the CPLEX
problem object, or the parameter MipOrdType
is
nonzero, this method
writes the priority order into the specified file.
By convention, the file extension is .ord
.
The ORD file format is documented in the reference manual
ILOG CPLEX File Formats.
Writes the parameter name and its current setting
into the file specified by name
for all the
CPLEX parameters that are not currently
set at their default.
By convention, the file extension is .prm
.
The PRM file format is documented in the reference manual
ILOG CPLEX File Formats.
Writes a solution file
for the current problem into the file specified by name
.
The solution written is the current solution if the
soln
parameter is omitted; otherwise, it is
the solution pool member indexed by soln
.
By convention, the file extension is .sol
.
The SOL file format is documented in the reference manual
ILOG CPLEX File Formats as well as the stylesheet
solution.xsl
and schema solution.xsd
found in the include directory of the product.
Writes a solution file with all members of the solution pool
for the current problem into the file specified by name
.
By convention, the file extension is .sol
.
The SOL file format is documented in the reference manual
ILOG CPLEX File Formats as well as the stylesheet
solution.xsl
and schema solution.xsd
found in the include directory of the product.
Inner Enumeration Detail 

The enumeration IloCplex::Algorithm
lists the
algorithms available in CPLEX to solve continuous models as controlled
by the parameters
IloCplex::RootAlg
and IloCplex::NodeAlg
.
These values are also returned by IloCplex::getAlgorithm
to specify the algorithm used to generate the current solution.
The values FeasOpt
and MIP
are returned
by IloCplex::getAlgorithm
but should not be used with
IloCplex::RootAlg
nor with IloCplex::NodeAlg
.
See Also:
IloCplex, IloCplex::getAlgorithm, IloCplex::getSubAlgorithm, IloCplex::IntParam, RootAlg, NodeAlg
Fields 

NoAlg 
= CPX_ALG_NONE

AutoAlg 
= CPX_ALG_AUTOMATIC

Primal 
= CPX_ALG_PRIMAL

Dual 
= CPX_ALG_DUAL

Barrier 
= CPX_ALG_BARRIER

Sifting 
= CPX_ALG_SIFTING

Concurrent 
= CPX_ALG_CONCURRENT

Network 
= CPX_ALG_NET

FeasOpt 
= CPX_ALG_FEASOPT

MIP 
= CPX_ALG_MIP

The enumeration IloCplex::BasisStatus
lists
values that the status of variables or range constraints may assume in a
basis. NotABasicStatus
is not a valid status for a variable.
A basis containing such a status does not constitute a valid basis.
The basis status
of a ranged constraint corresponds to the basis status of the corresponding
slack or artificial variable that IloCplex
manages for
it. FreeOrSuperbasic
specifies that the variable is nonbasic,
but not at a bound.
See Also:
IloCplex, IloCplex::BasisStatusArray
Fields 

NotABasicStatus  
Basic  
AtLower  
AtUpper  
FreeOrSuperbasic 
The enumeration IloCplex::BoolParam
lists the parameters of
CPLEX that require Boolean values. Boolean values are also known in certain
contexts as binary values or as zeroone (01) values.
Use these values with the
methods that accept Boolean parameters:
IloCplex::getParam
and
IloCplex::setParam
.
See the reference manual ILOG CPLEX Parameters for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
Fields 

PreInd 
= CPX_PARAM_PREIND

ReverseInd 
= deprecated

XXXInd 
= deprecated

MIPOrdInd 
= CPX_PARAM_MIPORDIND

MPSLongNum 
= CPX_PARAM_MPSLONGNUM

LBHeur 
= CPX_PARAM_LBHEUR

PerInd 
= CPX_PARAM_PERIND

PreLinear 
= CPX_PARAM_PRELINEAR

DataCheck 
= CPX_PARAM_DATACHECK

QPmakePSDInd 
= CPX_PARAM_QPMAKEPSDIND

MemoryEmphasis 
= CPX_PARAM_MEMORYEMPHASIS

NumericalEmphasis 
= CPX_PARAM_NUMERICALEMPHASIS

The enumeration IloCplex::BranchDirection
lists values that
can be used for specifying branch directions either with the branch
direction parameter IloCplex::BrDir
or with the methods
IloCplex::setDirection
and
IloCplex::setDirections
. The branch
direction specifies which direction to explore first after branching on
one variable.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
IloCplex, IloCplex::BranchDirectionArray
Fields 

BranchGlobal 
= CPX_BRANCH_GLOBAL

BranchDown 
= CPX_BRANCH_DOWN

BranchUp 
= CPX_BRANCH_UP

This enumeration lists the values that tell the status of a constraint or bound with respect to a conflict.
ConflictPossibleMember
ConflictMember
The value ConflictExcluded
is internal, undocumented,
not available to users.
Fields 

ConflictExcluded  
ConflictPossibleMember  
ConflictMember 
The enumeration IloCplex::CplexStatus
lists values that
the status of an IloCplex
algorithm can assume.
The methods
IloCplex::getCplexStatus
and
IloCplex::getCplexSubStatus
access the status values,
providing information about what the algorithm learned about the active
model in the most recent invocation of the method solve
or
feasOpt
.
The status may also tell why the algorithm terminated.
See the group optim.cplex.solutionstatus in the Callable Library Reference Manual, where they are listed in alphabetic order, or the topic Interpreting Solution Status Codes in the Overview of the APIs, where they are listed in numeric order, for more information about these values. Also see the ILOG CPLEX User's Manual for examples of their use.
See also the enumeration IloAlgorithm::Status
in the
ILOG CPLEX Reference Manual.
See Also:
Fields 

Unknown  
Optimal 
= CPX_STAT_OPTIMAL

Unbounded 
= CPX_STAT_UNBOUNDED

Infeasible 
= CPX_STAT_INFEASIBLE

InfOrUnbd 
= CPX_STAT_INForUNBD

OptimalInfeas 
= CPX_STAT_OPTIMAL_INFEAS

NumBest 
= CPX_STAT_NUM_BEST

FeasibleRelaxedSum 
= CPX_STAT_FEASIBLE_RELAXED_SUM

OptimalRelaxedSum 
= CPX_STAT_OPTIMAL_RELAXED_SUM

FeasibleRelaxedInf 
= CPX_STAT_FEASIBLE_RELAXED_INF

OptimalRelaxedInf 
= CPX_STAT_OPTIMAL_RELAXED_INF

FeasibleRelaxedQuad 
= CPX_STAT_FEASIBLE_RELAXED_QUAD

OptimalRelaxedQuad 
= CPX_STAT_OPTIMAL_RELAXED_QUAD

AbortRelaxed 
= CPXMIP_ABORT_RELAXED

AbortObjLim 
= CPX_STAT_ABORT_OBJ_LIM

AbortPrimObjLim 
= CPX_STAT_ABORT_PRIM_OBJ_LIM

AbortDualObjLim 
= CPX_STAT_ABORT_DUAL_OBJ_LIM

AbortItLim 
= CPX_STAT_ABORT_IT_LIM

AbortTimeLim 
= CPX_STAT_ABORT_TIME_LIM

AbortUser 
= CPX_STAT_ABORT_USER

OptimalFaceUnbounded 
= CPX_STAT_OPTIMAL_FACE_UNBOUNDED

OptimalTol 
= CPXMIP_OPTIMAL_TOL

SolLim 
= CPXMIP_SOL_LIM

PopulateSolLim 
= CPXMIP_POPULATESOL_LIM

NodeLimFeas 
= CPXMIP_NODE_LIM_FEAS

NodeLimInfeas 
= CPXMIP_NODE_LIM_INFEAS

FailFeas 
= CPXMIP_FAIL_FEAS

FailInfeas 
= CPXMIP_FAIL_INFEAS

MemLimFeas 
= CPXMIP_MEM_LIM_FEAS

MemLimInfeas 
= CPXMIP_MEM_LIM_INFEAS

FailFeasNoTree 
= CPXMIP_FAIL_FEAS_NO_TREE

FailInfeasNoTree 
= CPXMIP_FAIL_INFEAS_NO_TREE

ConflictFeasible 
= CPX_STAT_CONFLICT_FEASIBLE

ConflictMinimal 
= CPX_STAT_CONFLICT_MINIMAL

ConflictAbortContradiction 
= CPX_STAT_CONFLICT_ABORT_CONTRADICTION

ConflictAbortTimeLim 
= CPX_STAT_CONFLICT_ABORT_TIME_LIM

ConflictAbortItLim 
= CPX_STAT_CONFLICT_ABORT_IT_LIM

ConflictAbortNodeLim 
= CPX_STAT_CONFLICT_ABORT_NODE_LIM

ConflictAbortObjLim 
= CPX_STAT_CONFLICT_ABORT_OBJ_LIM

ConflictAbortMemLim 
= CPX_STAT_CONFLICT_ABORT_MEM_LIM

ConflictAbortUser 
= CPX_STAT_CONFLICT_ABORT_USER

Feasible 
= CPX_STAT_FEASIBLE

OptimalPopulated 
= CPXMIP_OPTIMAL_POPULATED

OptimalPopulatedTol 
= CPXMIP_OPTIMAL_POPULATED_TOL

The enumeration IloCplex::CutType
lists
the values that may be used in querying the number of
cuts used in a mixed integer optimization with
getNcuts()
.
Fields 

CutCover  
CutGubCover  
CutFlowCover  
CutClique  
CutFrac  
CutMir  
CutFlowPath  
CutDisj  
CutImplBd  
CutZeroHalf  
CutLocalCover  
CutTighten  
CutObjDisj  
CutUser  
CutTable  
CutSolnPool 
This enumeration lists the possible settings for the delete mode of
IloCplex
as controlled by the method
IloCplex::setDeleteMode
and queried by the method
IloCplex::getDeleteMode
.
IloCplex::LeaveBasis
With the default setting IloCplex::LeaveBasis
,
an existing basis will remain unchanged if variables or
constraints are removed from the
loaded LP model. This choice generally renders the basis
unusable for a restart when CPLEX is
solving the modified LP and the advanced indicator (parameter
IloCplex::AdvInd
) is set to IloTrue
.
IloCplex::FixBasis
In contrast, with delete mode set to IloCplex::FixBasis
,
the invoking object will do basis pivots in order to maintain
a valid basis when variables or constraints are removed. This choice
makes the delete operation more
computationintensive, but may give a better
starting point for reoptimization
after modification of the extracted model.
If no basis is present in the invoking object, the setting of the delete mode has no effect.
See Also:
Fields 

LeaveBasis  
FixBasis 
The enumeration IloCplex::DualPricing
lists values that the
dual pricing parameter IloCplex:DPriInd
can assume in
IloCplex
for use with the dual simplex algorithm. Use
these values with the method
IloCplex::setParam(IloCplex::DPriInd, value)
when
you set the dual pricing indicator.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
Fields 

DPriIndAuto 
= CPX_DPRIIND_AUTO

DPriIndFull 
= CPX_DPRIIND_FULL

DPriIndSteep 
= CPX_DPRIIND_STEEP

DPriIndFullSteep 
= CPX_DPRIIND_FULLSTEEP

DPriIndSteepQStart 
= CPX_DPRIIND_STEEPQSTART

DPriIndDevex 
= CPX_DPRIIND_DEVEX

IloCplex
is the class for the CPLEX
algorithms in ILOG CPLEX. The enumeration IloCplex::IntParam
lists the parameters of CPLEX that require integer values. Use these values
with the methods
IloCplex::getParam
and
IloCplex::setParam
.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
Fields 

AdvInd 
= CPX_PARAM_ADVIND

RootAlg 
= CPX_PARAM_STARTALG, CPX_PARAM_LPMETHOD, CPX_PARAM_QPMETHOD

NodeAlg 
= CPX_PARAM_SUBALG

MIPEmphasis 
= CPX_PARAM_MIPEMPHASIS

AggFill 
= CPX_PARAM_AGGFILL

AggInd 
= CPX_PARAM_AGGIND

BasInterval 
= CPX_PARAM_BASINTERVAL

ClockType 
= CPX_PARAM_CLOCKTYPE

CraInd 
= CPX_PARAM_CRAIND

DepInd 
= CPX_PARAM_DEPIND

PreDual 
= CPX_PARAM_PREDUAL

PrePass 
= CPX_PARAM_PREPASS

RelaxPreInd 
= CPX_PARAM_RELAXPREIND

RepeatPresolve 
= CPX_PARAM_REPEATPRESOLVE

Symmetry 
= CPX_PARAM_SYMMETRY

DPriInd 
= CPX_PARAM_DPRIIND

PriceLim 
= CPX_PARAM_PRICELIM

SimDisplay 
= CPX_PARAM_SIMDISPLAY

ItLim 
= CPX_PARAM_ITLIM

NetFind 
= CPX_PARAM_NETFIND

PerLim 
= CPX_PARAM_PERLIM

PPriInd 
= CPX_PARAM_PPRIIND

ReInv 
= CPX_PARAM_REINV

ScaInd 
= CPX_PARAM_SCAIND

Threads 
= CPX_PARAM_THREADS

ParallelMode 
= CPX_PARAM_PARALLELMODE

SingLim 
= CPX_PARAM_SINGLIM

Reduce 
= CPX_PARAM_REDUCE

NzReadLim 
= CPX_PARAM_NZREADLIM

ColReadLim 
= CPX_PARAM_COLREADLIM

RowReadLim 
= CPX_PARAM_ROWREADLIM

QPNzReadLim 
= CPX_PARAM_QPNZREADLIM

SiftDisplay 
= CPX_PARAM_SIFTDISPLAY

SiftAlg 
= CPX_PARAM_SIFTALG

SiftItLim 
= CPX_PARAM_SIFTITLIM

BrDir 
= CPX_PARAM_BRDIR

Cliques 
= CPX_PARAM_CLIQUES

CoeRedInd 
= CPX_PARAM_COEREDIND

Covers 
= CPX_PARAM_COVERS

MIPDisplay 
= CPX_PARAM_MIPDISPLAY

MIPInterval 
= CPX_PARAM_MIPINTERVAL

IntSolLim 
= CPX_PARAM_INTSOLLIM

NodeFileInd 
= CPX_PARAM_NODEFILEIND

NodeLim 
= CPX_PARAM_NODELIM

NodeSel 
= CPX_PARAM_NODESEL

VarSel 
= CPX_PARAM_VARSEL

BndStrenInd 
= CPX_PARAM_BNDSTRENIND

HeurFreq 
= CPX_PARAM_HEURFREQ

RINSHeur 
= CPX_PARAM_RINSHEUR

FPHeur 
= CPX_PARAM_FPHEUR

RepairTries 
= CPX_PARAM_REPAIRTRIES

SubMIPNodeLim 
= CPX_PARAM_SUBMIPNODELIM

MIPOrdType 
= CPX_PARAM_MIPORDTYPE

BBInterval 
= CPX_PARAM_BBINTERVAL

FlowCovers 
= CPX_PARAM_FLOWCOVERS

ImplBd 
= CPX_PARAM_IMPLBD

Probe 
= CPX_PARAM_PROBE

GUBCovers 
= CPX_PARAM_GUBCOVERS

StrongCandLim 
= CPX_PARAM_STRONGCANDLIM

StrongItLim 
= CPX_PARAM_STRONGITLIM

FracCand 
= CPX_PARAM_FRACCAND

FracCuts 
= CPX_PARAM_FRACCUTS

FracPass 
= CPX_PARAM_FRACPASS

PreslvNd 
= CPX_PARAM_PRESLVND

FlowPaths 
= CPX_PARAM_FLOWPATHS

MIRCuts 
= CPX_PARAM_MIRCUTS

DisjCuts 
= CPX_PARAM_DISJCUTS

ZeroHalfCuts 
= CPX_PARAM_ZEROHALFCUTS

AggCutLim 
= CPX_PARAM_AGGCUTLIM

CutPass 
= CPX_PARAM_CUTPASS

EachCutLim 
= CPX_PARAM_EACHCUTLIM

DiveType 
= CPX_PARAM_DIVETYPE

MIPSearch 
= CPX_PARAM_MIPSEARCH

MIQCPStrat 
= CPX_PARAM_MIQCPSTRAT

SolnPoolCapacity 
= CPX_PARAM_SOLNPOOLCAPACITY

SolnPoolReplace 
= CPX_PARAM_SOLNPOOLREPLACE

SolnPoolIntensity 
= CPX_PARAM_SOLNPOOLINTENSITY

PopulateLim 
= CPX_PARAM_POPULATELIM

BarAlg 
= CPX_PARAM_BARALG

BarColNz 
= CPX_PARAM_BARCOLNZ

BarDisplay 
= CPX_PARAM_BARDISPLAY

BarItLim 
= CPX_PARAM_BARITLIM

BarMaxCor 
= CPX_PARAM_BARMAXCOR

BarOrder 
= CPX_PARAM_BARORDER

BarCrossAlg 
= CPX_PARAM_BARCROSSALG

BarStartAlg 
= CPX_PARAM_BARSTARTALG

NetItLim 
= CPX_PARAM_NETITLIM

NetPPriInd 
= CPX_PARAM_NETPPRIIND

NetDisplay 
= CPX_PARAM_NETDISPLAY

ConflictDisplay 
= CPX_PARAM_CONFLICTDISPLAY

FeasOptMode 
= CPX_PARAM_FEASOPTMODE

TuningMeasure 
= CPX_PARAM_TUNINGMEASURE

TuningRepeat 
= CPX_PARAM_TUNINGREPEAT

TuningDisplay 
= CPX_PARAM_TUNINGDISPLAY

The enumeration IloCplex::MIPEmphasisType
lists the values
that the MIP emphasis parameter IloCplex::MIPEmphasis
can assume in an instance of IloCplex
for
use when it is solving MIP problems. Use these values with the method
IloCplex::setParam(IloCplex::MIPEmphasis, value)
when you set MIP emphasis.
With the default setting of IloCplex::MIPEmphasisBalance
,
IloCplex
tries to compute the branch & cut algorithm in
such a way as to find a proven optimal solution quickly. For a discussion
about various settings, refer to the ILOG CPLEX User's Manual.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
Fields 

MIPEmphasisBalanced 
= CPX_MIPEMPHASIS_BALANCED

MIPEmphasisOptimality 
= CPX_MIPEMPHASIS_OPTIMALITY

MIPEmphasisFeasibility 
= CPX_MIPEMPHASIS_FEASIBILITY

MIPEmphasisBestBound 
= CPX_MIPEMPHASIS_BESTBOUND

MIPEmphasisHiddenFeas 
= CPX_MIPEMPHASIS_HIDDENFEAS

The enumeration IloCplex::MIPsearch
lists values that
the dynamic search parameter IloCplex::MIPSearch
can assume in
IloCplex
.
Use these values with the method
IloCplex::setParam(IloCplex::MIPSearch,
value)
.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about this parameter. Also see the user's manual for examples of their use.
See Also:
Fields 

AutoSearch 
= CPX_MIPSEARCH_AUTO

Traditional 
= CPX_MIPSEARCH_TRADITIONAL

Dynamic 
= CPX_MIPSEARCH_DYNAMIC

The enumeration IloCplex::NodeSelect
lists values that the
parameter IloCplex::NodeSel
can assume in
IloCplex
. Use these values with the method
IloCplex::setParam(IloCplex::NodeSel, value)
.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
Fields 

DFS 
= CPX_NODESEL_DFS

BestBound 
= CPX_NODESEL_BESTBOUND

BestEst 
= CPX_NODESEL_BESTEST

BestEstAlt 
= CPX_NODESEL_BESTEST_ALT

The enumeration IloCplex::NumParam
lists the parameters of
CPLEX that require numeric values. Use these values with the member
functions: IloCplex::getParam
and
IloCplex::setParam
.
See the reference manual ILOG CPLEX Parameters information about these parameters. Also see the ILOG CPLEX User's Manual for more examples of their use.
See Also:
Fields 

EpMrk 
= CPX_PARAM_EPMRK

EpOpt 
= CPX_PARAM_EPOPT

EpPer 
= CPX_PARAM_EPPER

EpRHS 
= CPX_PARAM_EPRHS

NetEpOpt 
= CPX_PARAM_NETEPOPT

NetEpRHS 
= CPX_PARAM_NETEPRHS

TiLim 
= CPX_PARAM_TILIM

TuningTiLim 
= CPX_PARAM_TUNINGTILIM

BtTol 
= CPX_PARAM_BTTOL

CutLo 
= CPX_PARAM_CUTLO

CutUp 
= CPX_PARAM_CUTUP

EpGap 
= CPX_PARAM_EPGAP

EpInt 
= CPX_PARAM_EPINT

EpAGap 
= CPX_PARAM_EPAGAP

EpRelax 
= CPX_PARAM_EPRELAX

ObjDif 
= CPX_PARAM_OBJDIF

ObjLLim 
= CPX_PARAM_OBJLLIM

ObjULim 
= CPX_PARAM_OBJULIM

PolishTime 
= CPX_PARAM_POLISHTIME

ProbeTime 
= CPX_PARAM_PROBETIME

RelObjDif 
= CPX_PARAM_RELOBJDIF

CutsFactor 
= CPX_PARAM_CUTSFACTOR

TreLim 
= CPX_PARAM_TRELIM

SolnPoolGap 
= CPX_PARAM_SOLNPOOLGAP

SolnPoolAGap 
= CPX_PARAM_SOLNPOOLAGAP

WorkMem 
= CPX_PARAM_WORKMEM

BarEpComp 
= CPX_PARAM_BAREPCOMP

BarQCPEpComp 
= CPX_PARAM_BARQCPEPCOMP

BarGrowth 
= CPX_PARAM_BARGROWTH

BarObjRng 
= CPX_PARAM_BAROBJRNG

EpLin 
= CPX_PARAM_EPLIN

The enumeration IloCplex::ParallelMode
lists values that
the parallel mode parameter IloCplex::ParallelMode
can assume in
IloCplex
for use on multiprocessor or multithread
platforms, if your application is licensed for parallel optimization.
Use these values with the method
IloCplex::setParam(IloCplex::ParallelMode,
value)
.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about this parameter. Also see the user's manual for examples of their use.
See Also:
Fields 

Opportunistic 
= CPX_PARALLEL_OPPORTUNISTIC

AutoParallel 
= CPX_PARALLEL_AUTO

Deterministic 
= CPX_PARALLEL_DETERMINISTIC

The enumeration IloCplex::PrimalPricing
lists values that
the primal pricing parameter IloCplex::PPriInd
can assume in
IloCplex
for use with the primal simplex algorithm. Use these
values with the method
IloCplex::setParam(IloCplex::PPriInd, value)
when setting the primal pricing indicator.
See the reference manual ILGO CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
Fields 

PPriIndPartial 
= CPX_PPRIIND_PARTIAL

PPriIndAuto 
= CPX_PPRIIND_AUTO

PPriIndDevex 
= CPX_PPRIIND_DEVEX

PPriIndSteep 
= CPX_PPRIIND_STEEP

PPriIndSteepQStart 
= CPX_PPRIIND_STEEPQSTART

PPriIndFull 
= CPX_PPRIIND_FULL

The enumeration IloCplex::Quality
lists types of quality
measures that can be queried for a solution with method
IloCplex::getQuality
.
See the group optim.cplex.solutionquality in the ILOG CPLEX Callable Library Reference Manual for more information about these values. Also see the ILOG CPLEX User's Manual for examples of their use.
See Also:
Fields 

MaxPrimalInfeas 
= CPX_MAX_PRIMAL_INFEAS

MaxScaledPrimalInfeas 
= CPX_MAX_SCALED_PRIMAL_INFEAS

SumPrimalInfeas 
= CPX_SUM_PRIMAL_INFEAS

SumScaledPrimalInfeas 
= CPX_SUM_SCALED_PRIMAL_INFEAS

MaxDualInfeas 
= CPX_MAX_DUAL_INFEAS

MaxScaledDualInfeas 
= CPX_MAX_SCALED_DUAL_INFEAS

SumDualInfeas 
= CPX_SUM_DUAL_INFEAS

SumScaledDualInfeas 
= CPX_SUM_SCALED_DUAL_INFEAS

MaxIntInfeas 
= CPX_MAX_INT_INFEAS

SumIntInfeas 
= CPX_SUM_INT_INFEAS

MaxPrimalResidual 
= CPX_MAX_PRIMAL_RESIDUAL

MaxScaledPrimalResidual 
= CPX_MAX_SCALED_PRIMAL_RESIDUAL

SumPrimalResidual 
= CPX_SUM_PRIMAL_RESIDUAL

SumScaledPrimalResidual 
= CPX_SUM_SCALED_PRIMAL_RESIDUAL

MaxDualResidual 
= CPX_MAX_DUAL_RESIDUAL

MaxScaledDualResidual 
= CPX_MAX_SCALED_DUAL_RESIDUAL

SumDualResidual 
= CPX_SUM_DUAL_RESIDUAL

SumScaledDualResidual 
= CPX_SUM_SCALED_DUAL_RESIDUAL

MaxCompSlack 
= CPX_MAX_COMP_SLACK

SumCompSlack 
= CPX_SUM_COMP_SLACK

MaxX 
= CPX_MAX_X

MaxScaledX 
= CPX_MAX_SCALED_X

MaxPi 
= CPX_MAX_PI

MaxScaledPi 
= CPX_MAX_SCALED_PI

MaxSlack 
= CPX_MAX_SLACK

MaxScaledSlack 
= CPX_MAX_SCALED_SLACK

MaxRedCost 
= CPX_MAX_RED_COST

MaxScaledRedCost 
= CPX_MAX_SCALED_RED_COST

SumX 
= CPX_SUM_X

SumScaledX 
= CPX_SUM_SCALED_X

SumPi 
= CPX_SUM_PI

SumScaledPi 
= CPX_SUM_SCALED_PI

SumSlack 
= CPX_SUM_SLACK

SumScaledSlack 
= CPX_SUM_SCALED_SLACK

SumRedCost 
= CPX_SUM_RED_COST

SumScaledRedCost 
= CPX_SUM_SCALED_RED_COST

Kappa 
= CPX_KAPPA

ObjGap 
= CPX_OBJ_GAP

DualObj 
= CPX_DUAL_OBJ

PrimalObj 
= CPX_PRIMAL_OBJ

ExactKappa 
= CPX_EXACT_KAPPA

The enumeration Relaxation
lists the values that can be
taken by the parameter FeasOptMode
.
This parameter controls several aspects of how the method
feasOpt
performs its relaxation.
The method feasOpt
works in two phases. In its first phase,
it attempts to find a minimumpenalty relaxation of a given
infeasible model.
If you want feasOpt
to stop after this first phase, choose
a value with Min
in its symbolic name.
If you want feasOpt
to continue beyond its first phase
to find a solution that is optimal with respect to the original objective
function, subject to the constraint that the penalty of the
relaxation must not exceed the value found in the
first phase, then choose a value with Opt
in its
symbolic name.
In both phases, the suffixes Sum
, Inf
,
and Quad
specify the relaxation metric:
Sum
tells feasOpt
to mimimize the weighted sum of
the required relaxations of bounds and constraints according to
the formula
penalty = sum (penalty_i times relaxation_amount_i)
Inf
tells feasOpt
to minimize the weighted number
of bounds and constraints that are relaxed according to the formula
penalty = sum (penalty_i times relaxation_indicator_i)
Quad
tells feasOpt
to mimimize the weighted sum of
the squares of required relaxations of bounds and constraints
according to the formula
penalty = sum (penalty_i times relaxation_amount_i times relaxation_amount_i)
Weights are determined by the preference values you provide
as input to the method feasOpt
.
When IloAnd
is used to group constraints
as input to feasOpt
, the relaxation
penalty is computed on groups instead of on individual constraints.
For example, all constraints in a group can be relaxed for a total
penalty of one unit under the various Inf
metrics.
Fields 

MinSum 
= CPX_FEASOPT_MIN_SUM

OptSum 
= CPX_FEASOPT_OPT_SUM

MinInf 
= CPX_FEASOPT_MIN_INF

OptInf 
= CPX_FEASOPT_OPT_INF

MinQuad 
= CPX_FEASOPT_MIN_QUAD

OptQuad 
= CPX_FEASOPT_OPT_QUAD

The enumeration IloCplex::StringParam
lists the parameters
of CPLEX that require a character string as a value. Use these values with
the methods IloCplex::getParam
and
IloCplex::setParam
.
See the reference manual ILOG CPLEX Parameter Table and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
Fields 

WorkDir 
= CPX_PARAM_WORKDIR

This enumeration lists the values that are returned by
tuneParam
.
TuningComplete
TuningAbort
TuningTimeLim
The value ConflictExcluded
is internal, undocumented,
not available to users.
Fields 

TuningComplete  
TuningAbort  
TuningTimeLim 
The enumeration IloCplex::VariableSelect
lists values that
the parameter IloCplex::VarSel
can assume in
IloCplex
. Use these values with the method
IloCplex::setParam(IloCplex::VarSel, value)
.
See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.
See Also:
Fields 

MinInfeas 
= CPX_VARSEL_MININFEAS

DefaultVarSel 
= CPX_VARSEL_DEFAULT

MaxInfeas 
= CPX_VARSEL_MAXINFEAS

Pseudo 
= CPX_VARSEL_PSEUDO

Strong 
= CPX_VARSEL_STRONG

PseudoReduced 
= CPX_VARSEL_PSEUDOREDUCED

Inner Typedef Detail 

IloArray< BasisStatus > BasisStatusArray
This type defines an arraytype for IloCplex::BasisStatus
.
The fully qualified name of a basis status array is
IloCplex::BasisStatusArray
.
See Also:
IloCplex, IloCplex::BasisStatus
IloArray< BranchDirection > BranchDirectionArray
This type defines an arraytype for
IloCplex::BranchDirection
.
The fully qualified name of a branch direction array is
IloCplex::BranchDirectionArray
.
See Also:
IloCplex, IloCplex::BranchDirection
IloArray< ConflictStatus > ConflictStatusArray
This type defines an arraytype for
IloCplex::ConflictStatus
.
See Also:
IloCplex, IloCplex::ConflictStatus
CplexStatus Status
An enumeration for the classIloAlgorithm
.
IloAlgorithm
is the base class of algorithms
in Concert Technology,
and IloAlgorithm::Status
is an enumeration limited
in scope to the class
IloAlgorithm
. The member function
IloAlgorithm::getStatus
returns a status showing
information about the current model and the solution.
Unknown
specifies that the algorithm
has no information about the solution of the model.
Feasible
specifies that the algorithm
found a feasible solution
(that is, an assignment of values to variables
that satisfies the constraints of
the model, though it may not necessarily be optimal).
The member functions
IloAlgorithm::getValue
access this feasible solution.
Optimal
specifies that the algorithm
found an optimal solution
(that is, an assignment of values to variables that satisfies
all the constraints of the model and that is proved optimal
with respect to the objective of the model).
The member functions
IloAlgorithm::getValue
access
this optimal solution.
Infeasible
specifies that the algorithm
proved the model infeasible;
that is, it is not possible to find an assignment of values
to variables satisfying all the constraints in the model.
Unbounded
specifies that the algorithm
proved the model unbounded.
InfeasibleOrUnbounded
specifies that the
model is infeasible or unbounded.
Error
specifies that an error occurred and,
on platforms that support exceptions, that an exception has been thrown.
See Also the enumeration IloCplex::Status
in the ILOG CPLEX Reference Manual for status specific to
the CPLEX algorithms.
See Also: