Overview | Group | Tree | Graph | Deprecated | 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 constructed 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 semi-definite (or negative semi-definite in the maximization
case) and represents the quadratic terms of the objective function.
The matrices Q_i must be positive semi-definite and represent the quadratic
terms of the i-th quadratic constraint. The a_i are vectors containing
the corresponding linear terms.
For details about the Q_i, see the chapter about quadratically
constrained programs (QCP) in
the 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 CPLEX
User's Manual for more information about branch and 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
CPLEX Parameters 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 IloCplex::Param
hierarchy,
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
.
After the presolve is completed, IloCplex
solves the first
node relaxation and (in cases of a true MIP) enters the branch-and-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-and-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-and-cut tree,
usually there is a
set of fractional-valued variables available to pick from for branching.
IloCplex
has several built-in 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-and-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 re-optimized.
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 classes
IloCplex::UserCutCallbackI
and
IloCplex::LazyConstraintCallbackI
allow you
to add your own problem-specific cuts during search. This callback also
allows you to generate and add local cuts, that is cuts that are valid
only 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
user-written 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
CPLEX Reference Manual of the C++ API.
See also Goals among the Concepts in this manual. See also goals in the 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::MIPEmphasisType, IloCplex::NodeSelect, IloCplex::PrimalPricing, IloCplex::Quality, IloCplex::CplexStatus, IloCplex::VariableSelect, IloCplex::GoalI
Attribute Summary | |
---|---|
public static const char *const | BendersAnnotation |
public static const int | IncumbentId |
Inherited Methods from IloAlgorithm |
---|
clear, end, error, extract, getEnv, getIntValue, getIntValues, getModel, getObjValue, getStatus, getTime, getValue, getValue, getValue, getValue, getValues, getValues, IloAlgorithm, 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 .
|
Attribute Detail |
---|
This constant defines the name of an annotation specifying a Benders decomposition.
This constant identifies the incumbent solution for a MIP in methods which require a solution index.
Method Detail |
---|
This constructor creates a CPLEX algorithm. The new
instance of IloCplex
has no IloModel
loaded
(or extracted) to it.
This constructor creates a 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);
This constructor creates a remote CPLEX object in a given environment for a user-written distributed application.
This constructor is available only from the C++ application programming interface (API) of CPLEX. In other words, it is not available from other components of IBM ILOG CPLEX Optimization Studio.
The argument transport
specifies a communication
protocol for CPLEX to use. See the user manual for acceptable values.
This constructor is defined as a template with template argument
I
which specifies the type of the argc
argument (usually int
). The constructor being a template
has the technical advantage that it will not create any code unless you
use it. Consequently, it will not generate any references to remote
object libraries unless you actually use this constructor.
env | A handle to the CPLEX environment. |
transport | The type of transport protocol. |
argc | The argument count specific to the transport protocol. |
argv | The argument vector specific to the transport protocol. |
This constructor creates a remote CPLEX object for a given model in a user-written distributed application.
This constructor is available only from the C++ application programming interface (API) of CPLEX. In other words, it is not available from other components of IBM ILOG CPLEX Optimization Studio.
The argument transport
specifies a communication
protocol for CPLEX to use. An acceptable value for the argument
transport
is one of these types:
local
CPLEX ignores the arguments argc
and argv
and returns a handle to
a local instance of the CPLEX Callable Library.
process
CPLEX creates a new process which instantiates
the CPLEX Callable Library. CPLEX communicates with the newly
created process either by pipes or sockets. The pipes can be
named or unnamed.
mpi
CPLEX assumes that your application
is running a message passing interface (MPI)
and uses MPI to communicate between processes.
This constructor is defined as a template with template argument
I
which specifies the type of the argc
argument (usually int
). The constructor being a template
has the technical advantage that it will not create any code unless you
use it. Consequently, it will not generate any references to remote
object libraries unless you actually use this constructor.
model | A handle to the model. |
transport | The type of transport protocol. |
argc | The argument count specific to the transport protocol. |
argv | The argument vector specific to the transport protocol. |
Prefer the method IloCplex::addLazyConstraint
instead of this method.
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 the cut is only copied
when you invoke the method addCut
.
Thus, con
may be deleted or modified
after addCut
has been called, but
the invoking IloCplex
object will not be notified
about the change.
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
as-needed basis. A solution computed by IloCplex
is guaranteed
to satisfy all cuts added with this method.
Prefer the method IloCplex::addLazyConstraints
instead of this method.
This method adds the constraints in con
as
cuts to the invoking IloCplex
object. The observations about
IloCplex::addCut
apply 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.
A diversity filter drives the search for multiple solutions toward new solutions that satisfy a measure of diversity specified in the filter.
This diversity measure applies only to binary variables.
Potential new solutions are compared to a reference set.
You must specify which variables are to be compared.
You do so with the argument vars
designating
the indices of variables to include in the diversity measure.
A reference set
is the set of values specified by the argument refval
.
You may optionally specify weights (that is, coefficients to form a linear expression in terms of the variables) in the diversity measure; if you do not specify weights, all differences between the reference set and potential new solutions will be weighted by the value 1.0 (one). CPLEX computes the diversity measure by summing the pair-wise weighted absolute differences from the reference values, like this:
differences(x) = sum {weight[i] times |x[vars[i]] - refval[i]|}.
A diversity filter makes sure that the solutions satisfy the constraint:
lower bound <= differences(x) <= upper bound
You may specify both a lower and upper bound on diversity.
In order to say, Give me solutions that are
close to this one, within this specified set of variables,
specify a lower_bound
of 0.0 (zero) and a finite
upper_bound
.
CPLEX then looks for solutions that differ from the reference
values by at most the value of upper_bound
, within
the specified set of variables.
In order to say, Give me solutions that are different
from this one, specify a finite lower_bound
and an infinite (that is, very large) upper_bound
on the diversity.
CPLEX then looks for solutions that differ from the reference values
by at least the value of lower_bound
, within the
specified set of variables.
vars | An array of integer variables in the diversity measure. |
weights | An array of weights corresponding to the variables to be used in the diversity measure. May be NULL, in which case CPLEX uses weights of 1.0 (one). |
refval | An array of reference values for the the variables in the diversity filter to compare with a solution when CPLEX computes the diversity measure. |
fname | The name of the filter. May be NULL. |
This method returns the index of the added filter.
This method creates and installs a named diversity filter for the designated numeric variables with the specified lower and upper bounds, reference values, and weights.
A diversity filter drives the search for multiple solutions toward new solutions that satisfy a measure of diversity specified in the filter.
This diversity measure applies only to binary variables.
Potential new solutions are compared to a reference set.
You must specify which variables are to be compared.
You do so with the argument vars
designating
the indices of variables to include in the diversity measure.
A reference set
is the set of values specified by the argument refval
.
You may optionally specify weights (that is, coefficients to form a linear expression in terms of the variables) in the diversity measure; if you do not specify weights, all differences between the reference set and potential new solutions will be weighted by the value 1.0 (one). CPLEX computes the diversity measure by summing the pair-wise weighted absolute differences from the reference values, like this:
differences(x) = sum {weight[i] times |x[vars[i]] - refval[i]|}.
A diversity filter makes sure that the solutions satisfy the constraint:
lower bound <= differences(x) <= upper bound
You may specify both a lower and upper bound on diversity.
In order to say, Give me solutions that are
close to this one, within this specified set of variables,
specify a lower_bound
of 0.0 (zero) and a finite
upper_bound
.
CPLEX then looks for solutions that differ from the reference
values by at most the value of upper_bound
, within
the specified set of variables.
In order to say, Give me solutions that are different
from this one, specify a finite lower_bound
and an infinite (that is, very large) upper_bound
on the diversity.
CPLEX then looks for solutions that differ from the reference values
by at least the value of lower_bound
, within the
specified set of variables.
vars | An array of numeric variables in the diversity measure. |
weights | An array of weights corresponding to the variables to be used in the diversity measure. May be NULL, in which case CPLEX uses weights of 1.0 (one). |
refval | An array of reference values for the the variables in the diversity filter to compare with a solution when CPLEX computes the diversity measure. |
fname | The name of the filter. May be NULL. |
This method returns the index of the added filter.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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. CPLEX copies the
constraint con
into the lazy constraint pool;
the original constraint 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.
Tip For best performance, add all of your lazy constraints in one call rather than adding them individually.
Only constraints that have not already
been extracted as part of the model can be added as lazy constraints.
An attempt to add a lazy constraint that has already been extracted
as part of the model throws the exception
IloCplex::ExtractedConstraintException
.
Lazy constraints added with addLazyConstraint
are typically
constraints of the model that are not expected to be violated
when left out.
The idea is that the LPs that are solved when the MIP is being solved
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
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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. Observations about
IloCplex::addLazyConstraint
apply to each of the lazy constraints in the array con
.
Tip For best performance, add all of your lazy constraints in one call rather than adding them individually.
Only constraints that have not already been extracted
as part of the model can be added as lazy constraints.
An attempt to add as a lazy constraint any constraint that has
already been extracted to the model throws the exception
IloCplex::ExtractedConstraintException
.
Adds a named MIP start with the specified level of effort defined by the specified variables and their corresponding values to the current problem.
Unlike the method setStart
, the method
addMIPStart
is not incremental.
In other words, each call of addMIPStart
creates a new MIP start.
There is no method to create a MIP start from a multidimensional
array of variables. In order to create a MIP start from a
multidimensional array of variables, you first must copy all those
variables into a flat array. The following sample assumes a matrix
of m by n dimensions with the starting value for
x[i][j]
in start[i][j]
.
IloNumVarArray startVar(env); IloNumArray startVal(env); for (int i = 0; i < m; ++i) for (int j = 0; j < n; ++j) { startVar.add(x[i][j]); startVal.add(start[i][j]); } cplex.addMIPStart(startVar, startVal); startVal.end(); startVar.end();
Creates a named range filter, using the specified lower bound, upper bound, integer variables, and weights, adds the filter to the solution pool of the invoking model, and returns the index of the filter.
A range filter drives the search for multiple solutions toward new
solutions that satisfy criteria specified as a ranged linear expression
in the filter. A range filter sets a lower and an upper bound on a
linear expression consisting of variables designated in the array
vars
and coefficient values designated in the argument
weights
, like this:
lower bound <= sum{weights[i] times vars[i]} <= upper bound
A range filter applies to variables of any type; that is, binary, general integer, continuous.
This method returns the index of the added filter.
This method 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.
A range filter drives the search for multiple solutions toward new
solutions that satisfy criteria specified as a ranged linear expression
in the filter. A range filter sets a lower and an upper bound on a
linear expression consisting of variables designated in the array
vars
and coefficient values designated in the argument
weights
, like this:
lower bound <= sum{weights[i] times vars[i]} <= upper bound
A range filter applies to variables of any type; that is, binary, general integer, continuous.
This method returns the index of the added filter.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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. CPLEX places a copy of the
constraint con
in the user cut pool. However,
the constraint 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.
Tip For best performance, add all of your cuts in one call rather than adding them individually.
Only constraints that have not already
been extracted as part of the model can be added as user cuts.
An attempt to add a constraint that
has already been extracted as part of the model throws the exception
IloCplex::ExtractedConstraintException
.
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.
Do not use addUserCut
for lazy constraints, that is, constraints whose absence may potentially
change the solution of the problem. Use
IloCplex::addLazyConstraint
when you add such a constraint.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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. The observations in
IloCplex::addUserCut
apply to each of the
user cuts in the array con
.
Tip For best performance, add all of your cuts in one call rather than adding them individually.
Only constraints that have not already
been extracted as part of the model can be added as user cuts.
An attempt to add a constraint that
has already been extracted as part of the model throws the exception
IloCplex::ExtractedConstraintException
.
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 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
by the argument
vars
, this method will return possibly tightened bounds in the
corresponding elements of arrays redlb
and redub
.
Similarly, for every constraint specified
by the argument rngs
,
this method will return a Boolean value reporting
whether or not the constraint is redundant
in the model in the corresponding element of array
redundant
.
For a semicontinuous or semi-integer variable, this method produces the lower bound of the variable, not the semicontinuous or semi-integer lower bound. If this method produces a lower bound less than or equal to zero, then the variable persists as a semicontinuous or semi-integer variable. In contrast, if this method produces a lower bound strictly greater than zero, then basic presolve has concluded that zero can be eliminated from the domain of the variable. Consequently, it is possible to change the type of the variable from semicontinuous to continuous or from semi-integer to integer. Afterwards, you can use the tightened bound without affecting the feasible region of the model.
Changes the MIP start designated by its index by assigning corresponding values to the designated variables and by associating the specified level of effort.
Changes the MIP start designated by its index by assigning corresponding values to the designated variables.
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 CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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 CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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
.
Reads a virtual machine configuration from a string.
The value
xmlstring
must be a string conforming to the VMC file
format. It must be given in an encoding that terminates the string with
a single NUL
byte.
If xmlstring
can be parsed successfully,
then the corresponding
configuration is installed into this instance of IloCplex
.
In case of error, a previously installed virtual machine configuration is
unchanged.
If a virtual machine configuration is installed into an instance of
IloCplex
, and the extracted model is a MIP then
the solve
method of this instance uses
parallel distributed MIP optimization to solve the problem.
This function is implemented as a template so that it does not create
references to the CPLEX distributed parallel MIP API unless you
actually use the function.
The type of its argument must be convertible to
char const *
.
See Also:
xmlstring |
The string containing the virtual machine configuration.
|
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 designated number of MIP starts, starting from the MIP start specified by its index.
Deletes all names from the extracted model.
Executing this method affects only the names stored in the extracted copy
of the IloCplex
model and not the original Concert model.
Names in the Concert model remain unaffected by this method.
Subsequent name changes of extracted instances of the class
IloExtractable
will continue to be
tracked in the extracted IloCplex
model.
This convention means that at the first change
of such a name, IloCplex
creates default names for all other
extractables in the IloCplex
object
(but not the Concert model).
Deletes the specified 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.
Deletes any virtual machine configuration (VMC) installed in this instance.
This is an advanced method. Advanced methods typically demand a profound understanding of the algorithms used by CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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 the dual simplex optimizer.
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 CPXXdualfarkas
, documented
in the reference manual of the Callable Library.
rng | output array. The function will automatically resize the array |
y | output array. The function will automatically resize the array |
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:
.sav
.mps
.lp
.sav.gz
.mps.gz
.lp.gz
.bz2
If no name has been assigned to a variable or range
(that is, the method IloExtractable::getName
returns null
for that variable or range), IloCplex
uses
a default name when it writes 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 CPLEX File Formats for more detail and the CPLEX User's Manual for additional information about file formats.
This method is the asynchronous version of
IloCplex::feasOpt
. In other words,
this method performs the same operation as
IloCplex::feasOpt
, but it can run
asynchronously. The method returns an instance of
IloCplex::FeasOptHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
FeasOptHandle::joinFeasOpt
in order
to clean up resources and prevent memory leaks. Likewise,
you must join in order to query the return value.
See Also:
cts | See |
prefs | See |
async |
Flag to indicate whether the operation should be synchronously or asynchronously.
|
This method is the asynchronous version of
IloCplex::feasOpt
. In other words,
this method performs the same operation as
IloCplex::feasOpt
, but it can run
asynchronously. The method returns an instance of
IloCplex::FeasOptHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
the the operation is executed synchronously. However, you must still
join the returned handle by means of the method
FeasOptHandle::joinFeasOpt
in order
to clean up resources and prevent memory leaks.
Likewise, you must join in order to query the return value.
See Also:
rngs | See |
rnglb | See |
rngub | See |
async | Flag to indicate whether the operation should be synchronously or asynchronously. |
This method is the asynchronous version of
IloCplex::feasOpt
. In other words,
this method performs the same operation as
IloCplex::feasOpt
, but it can run
asynchronously. The method returns an instance of
IloCplex::FeasOptHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
FeasOptHandle::joinFeasOpt
in order
to clean up resources and prevent memory leaks.
Likewise, you must join in order to
query the return value.
See Also:
vars | See |
varlb | See |
varub | See |
async | Flag to indicate whether the operation should be synchronously or asynchronously. |
This method is the asynchronous version of
IloCplex::feasOpt
. In other words,
this method performs the same operation as
IloCplex::feasOpt
, but it can run
asynchronously. The method returns an instance of
IloCplex::FeasOptHandle
that represents
the operation started. To start the operation asynchronously, call this
this method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returns handle by means of the method
FeasOptHandle::joinFeasOpt
in order
to clean up resources and prevent memory leaks.
Likewise, you must join in order to
query the return value.
See Also:
vars | See |
varlb | See |
varub | See |
async | Flag to indicate whether the operation should be synchronously or asynchronously. |
This method is the asynchronous version of
IloCplex::feasOpt
. In other words,
this method performs the same operation as
IloCplex::feasOpt
, but it can run
asynchronously with the remote object. The method returns an instance of
IloCplex::FeasOptHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
FeasOptHandle::joinFeasOpt
in order to
clean up resources and prevent memory leaks.
Likewise, you must join in order to
query the return value.
See Also:
rngs | See |
rnglb | See |
rngub | See |
vars | See |
varlb | See |
varub | See |
async | Flag to indicate whether the operation should be synchronously or asynchronously. |
This method is the asynchronous version of
IloCplex::feasOpt
. In other words,
this method performs the same operation as
IloCplex::feasOpt
, but it can run
asynchronously. The method returns an instance of
IloCplex::FeasOptHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you still must
join the returned handle by means of the method
FeasOptHandle::joinFeasOpt
to clean up resources and prevent memory leaks. Likewise, you still
must join in order to query the return value.
See Also:
rngs | See |
rnglb | See |
rngub | See |
vars | See |
varlb | See |
varub | See |
async | Flag to indicate whether the operation executes synchronously or asynchronously. |
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 minimum-cost 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.
If feasOpt
finds a feasible solution,
it returns the solution and the corresponding objective
in terms of the original model.
The parameters CutUp
, CutLo
,
ObjULim
, ObjLLim
do not influence this method.
If you want to study infeasibilities introduced by those parameters,
consider adding an objective function constraint to your model to
enforce their effect before you invoke 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 parameters CutUp
, CutLo
,
ObjULim
, ObjLLim
do not influence this method.
If you want to study infeasibilities introduced by those parameters,
consider adding an objective function constraint to your model to
enforce their effect before you invoke this method.
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 parameters CutUp
, CutLo
,
ObjULim
, ObjLLim
do not influence this method.
If you want to study infeasibilities introduced by those parameters,
consider adding an objective function constraint to your model to
enforce their effect before you invoke this method.
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 minimum-cost 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 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.
If feasOpt
finds a feasible solution,
it returns the solution and the corresponding objective
in terms of the original model.
The parameters CutUp
, CutLo
,
ObjULim
, ObjLLim
do not influence this method.
If you want to study infeasibilities introduced by those parameters,
consider adding an objective function constraint to your model to
enforce their effect before you invoke this method.
See Also:
long
-valued annotation
with number specified by num
.
If no such annotation is available, this method returns
an anotation for which the method isValid
returns false.
The identifying numbers of annotations are renumbered when
annotations are deteted.
long
-valued annotation
of the specified name. If no such annotation is available,
this method returns an anotation for which the method
isValid
returns false.
IloNum
-valued annotation
with number specified by num
.
If no such annotation is available, this method returns
an anotation for which the method isValid
returns false.
The identifying numbers of annotations are renumbered when
annotations are deteted.
IloNum
-valued annotation
of the specified name. If no such annotation is available,
this method returns an anotation for which the method
isValid
returns false.
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.
Returns a handle to the aborter being used by the invoking
IloCplex
object.
For CPLEX to use an aborter, your application must explicitly
create an instance of the class IloCplex::Aborter
and
set that instance with the method
IloCplex::use(IloCplex::Aborter)
. Otherwise, when no
aborter is in use, the method getAborter
returns an
empty handle. The following sample shows how to test whether an
aborter is currently in use; that is, how to test for an empty handle.
if (cplex.getAborter().getImpl()) std::cout << "There is an aborter installed." << std::endl; else std::cout << "No aborter installed." << std::endl;
See Also:
This method returns the algorithm type that was used to solve the most recent model in cases where it was not a MIP.
value[i]
is the value assigned to
the constraint ctr[i]
.
value[i]
is the value assigned to
the variable var[i]
.
value[i]
is the value assigned to
the variable var[i]
.
ctr
by the specified numeric annotation.
obj
by the specified numeric annotation.
var
by the specified numeric annotation.
var
by the specified numeric annotation.
ctr
by the specified
annotation. The value[i]
is the value assigned to
the constraint ctr[i]
.
value[i]
is the value assigned to
the variable var[i]
.
value[i]
is the value assigned to
the variable var[i]
.
ctr
by the specified annotation.
obj
by the specified annotation.
var
by the specified annotation.
var
by the specified annotation.
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.
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.
This method accesses the currently best known bound of all the remaining open nodes in a branch-and-cut tree.
It is computed for a minimization problem as the minimum objective function value of all remaining unexplored nodes. Similarly, it is computed for a maximization problem as the maximum objective function value of all remaining unexplored nodes.
For a regular MIP optimization, this value is also the best known bound on the optimal solution value of the MIP problem. In fact, when a problem has been solved to optimality, this value matches the optimal solution value.
However, for the method populate
, the value can also exceed
the optimal solution value if CPLEX has already solved the model
to optimality but continues to search for additional solutions.
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 CPLEX status of the invoking
algorithm. For possible CPLEX values, see the enumeration type
IloCplex::CplexStatus
.
See also the topic Interpreting Solution Quality in the 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 a time stamp.
To measure elapsed time in seconds between a starting point and ending point of an operation, take the time stamp at the starting point; take the time stamp at the ending point; subtract the starting time stamp from the ending time stamp.
This computation measures either wall clock time (also known as
real time) or CPU time, depending on the parameter ClockType
.
The absolute value of the time stamp is not meaningful.
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,
this method returns
+IloInfinity
or -IloInfinity
,
depending on the optimization sense.
This method returns the default setting of the specified
parameter
.
This method returns the current delete mode of the invoking
IloCplex
object.
This method returns a deterministic time stamp in ticks.
To measure elapsed deterministic time in ticks between a starting point and ending point of an operation, take the deterministic time stamp at the starting point; take the deterministic time stamp at the ending point; subtract the starting deterministic time stamp from the ending deterministic time stamp.
The absolute value of the deterministic time stamp is not meaningful.
This method returns the branch direction previously assigned to
variable var
with the 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.
The value returned by this method is meaningful not only for linear programs (LPs), but also for second order cone programs (SOCPs). See the topic Accessing dual values and reduced costs in SOCP in the CPLEX User's Manual to see how to use the value returned by this method for second order cone programs (SOCPs).
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]
.
The values returned by this method are meaningful not only for linear programs, but also for second order cone programs (SOCPs). See the topic Accessing dual values and reduced costs in SOCP in the CPLEX User's Manual to see how to use the values returned by this method for second order cone programs.
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, this method returns 0 (zero).
This method returns the node number where the current incumbent was
found. If the invoking IloCplex
object is an LP or a
QP, this method returns 0 (zero).
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.
This method returns the maximum allowed value for the parameter
parameter
.
This method returns the minimum allowed value for the parameter
parameter
.
This method accesses the relative objective gap for a MIP optimization.
For a minimization problem, this value is computed by
(bestinteger - bestobjective) / (1e-10 + |bestinteger|)
where bestinteger
is the value returned by
IloCplex::getObjValue
and bestobjective
is the value returned by
IloCplex::getBestObjValue
.
For a maximization problem, the value is computed by:
(bestobjective - bestinteger) / (1e-10 + |bestinteger|)
Returns the level of effort associated with the MIP start
identified by mipstartindex
. Furthermore, if vals
is a non-empty handle, the MIPStart values for the variables listed in
vars
are returned, where 0.0 is used if a variable has no
MIPStart value associated to it in the specified MIPstart. If isset
is a nonzero handle, isset[i]
returns a boolean value indicating
whether or not a MIPstart value for variable vars[i]
is provided
in the specified MIPstart or not.
Returns the index of the MIP start designated by its name.
Returns the name of the MIP start identified by its index.
This method returns the requested floating point valued solution information of a subproblem of a multiobjective optimization.
This method returns the requested 64-bit integer valued solution information of a subproblem of a multiobjective optimization.
This method returns the requested integer valued solution information of a subproblem of a multiobjective optimization.
This method returns the number of subproblems that were successfully solved during the last optimization of a multiobjective problem.
This method returns the number of barrier iterations from the last solve.
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 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 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 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 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 indicator constraints extracted from the active model for the invoking algorithm.
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 iterations that occurred
during the last call to the method
IloCplex::solve
in
the invoking algorithm.
This method returns the number of lazy constraints added to the
invoking IloCplex
object with the methods
IloCplex::addLazyConstraint
and
IloCplex::addLazyConstraints
.
Returns the number of MIP starts associated with the current problem.
This method returns the number of branch-and-cut 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 branch-and-cut 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 branch-and-cut nodes that remain to
be processed in the current solution. If the invoking IloCplex
object is not a MIP, it returns 0.
This method returns the number of branch-and-cut nodes that remain to
be processed in the current solution. If the invoking IloCplex
object is not a MIP, it returns 0.
This method returns the number of nonzeros extracted to the constraint matrix A of the invoking algorithm.
This method returns the number of nonzeros extracted to the constraint matrix A of the invoking algorithm.
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
.
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 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 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 semi-integer 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
, 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 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 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 user cuts added to the
invoking IloCplex
object with the methods
IloCplex::addUserCut
and
IloCplex::addUserCuts
.
This method returns the number of logical cores on the platform where CPLEX is currently running.
This method returns the instance of IloObjective
that has been extracted to the invoking instance of IloCplex
.
If no objective has been extracted, the method returns an empty handle.
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 performs objective 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 current setting of parameter
in
the invoking algorithm.
See the CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX User's Manual for examples of their use.
Returns a parameter set showing the parameters that have been changed from their default values.
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.
For a quadratically constrained program (QCP), this method returns
the dual slack vector of quadratic constraint range
as
a sparse vector.
The dual slack vector is returned as a sparse vector in
vals
and vars
. Both arrays will be resized
by the method to the number of nonzero elements in the sparse vector.
When the method returns, vals
holds only nonzero
values and vals[i]
is the coefficient for variable
vars[i]
in the dual slack vector of range
The value returned by this method is valid only if the problem solved is a quadratically constrained program (QCP).
range | The quadratic constraint for which the dual slack vector is to be queried. |
vals |
The array in which the nonzero coefficients of the dual slack vector will be stored.
|
vars | The array in which the variables corresponding to |
These methods return the requested quality measure for
a member of the solution pool. Use the soln
argument
with a value of -1 to return the quality measure 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.
A solution, though not necessarily a feasible or optimal solution, must be available in the CPLEX problem object for any quality measure except kappa statistics. You can query kappa statistics in the absence of a solution, but to do so, the following conditions must hold:
IloCplex::Param::MIP::Strategy::KappaStats
must be turned on.
Otherwise, (that is, if those conditions do not hold) CPLEX
throws an exception returning
the error CPXERR_NO_KAPPASTATS
specifying that no kappa
statistics are available.
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.
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 sensitivity 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,
respectively, 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 nonzero values of the unbounded direction into the
array vals
, and it puts the corresponding
variables of the extracted model into the array vars
.
CPLEX modifies these arrays, resizing them if necessary. Any previous values in them will be overwritten.
This method returns the reduced cost associated with
var
in the invoking algorithm.
The value returned by this method is defined to be the dual multiplier for bound constraints on the specified variable.
This method returns the reduced cost associated with
var
in the invoking algorithm.
The value returned by this method is defined to be the dual multiplier for bound constraints on the specified variable.
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]
.
The values returned by this method are defined to be the dual multipliers for bound constraints on the specified variables.
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]
.
The values returned by this method are defined to be the dual multipliers for bound constraints on the specified variables.
This method accesses the object that handles remote worker info messages.
See Also:
IloCplex::setRemoteInfoHandler, IloCplex::removeRemoteInfoHandler
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.
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 CPLEX status, see the method
IloCplex::getCplexStatus
.
See also the topic Interpreting Solution Quality in the 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.
For special considerations about integrality, truncation, and rounding applicable to this method, see the concept Integer values, integrality tolerance, and round-off in CPLEX Optimizers.
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
(negative one)
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]
.
For special considerations about integrality, truncation, and rounding applicable to this method, see the concept Integer values, integrality tolerance, and round-off in CPLEX Optimizers.
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 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 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]
.
For special considerations about integrality, truncation, and rounding applicable to this method, see the concept Integer values, integrality tolerance, and round-off in CPLEX Optimizers.
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]
.
For special considerations about integrality, truncation, and rounding applicable to this method, see the concept Integer values, integrality tolerance, and round-off in CPLEX Optimizers.
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 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 returns the version of IloCplex
as an
integer in the format vvrrmmff, where vv is the version, rr is the
release, mm is the modification, and ff is the fixpack number. For
example, for CPLEX version 12.5.0.1, the returned value is 12050001
long
-valued annotation of the
specified name is available in the IloCplex
object.
IloNum
-valued annotation of the
specified name is available in the IloCplex
object.
Tests whether this instance has loaded a virtual machine configuration (VMC).
true
if a virtual machine configuration
has been loaded into this instance, false
otherwise.
This method reads a model from the file specified by
filename
into model
. Typically,
model
is 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.
The newly created modeling objects belong to the environment of the model; they do not belong to the model itself. As a result, they do not end when the model ends. Instead, they remain in the environment.
This method is a simplification of the method importModel
.
This method does not provide arrays to return special ordered sets (SOS).
In continuous models where you already know that no SOS will be present,
you can use this simpler method.
This method is a simplification of the method importModel
.
It does not provide arrays for general constraints, such as
IloIfThen
constraints. Use this method only
in models where you know that no such constraints will be present.
In case implication indicator constraints (designated in LP file format
by the symbol ->
) are present, CPLEX
creates a mathematically
equivalent problem without IloIfThen
constraints.
This method reads a model from the file specified by
filename
into model
. Typically
model
is 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.
The newly created modeling objects belong to the environment of the model; they do not belong to the model itself. As a result, they do not end when the model ends. Instead, they remain in the environment.
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
; the special
ordered sets (SOS) it has read in the arrays sos1
and
sos2
; and any other general constraints it has read in array
cons
. These "general constraints" are IloIfThen
constraints, which are created for implication indicator constraints
(designated by the symbol ->
in LP file format)
found in the model file.
CPLEX resizes these arrays for you to accommodate 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 have been added to 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:
.sav
.mps
.lp
.sav.gz
.mps.gz
.lp.gz
.bz2
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 (mixed-integer 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 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
.
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
.
long
for the specified
name and
assigns the specified default value defval
to all
modeling objects in the current IloCplex
object.
IloNum
for the
specified name and assigns the specified default value to
all modeling objects in the current IloCplex
object.
long
IloNum
.
This method is the asynchronous version of
IloCplex::populate
. In other words,
this method performs the same operation as
IloCplex::populate
, but it can run
asynchronously. The method returns an instance of
IloCplex::PopulateHandle
that represents
the operation started. To start the operation asynchronously, call this
this method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
PopulateHandle::joinPopulate
in order
to clean up resources and prevent memory leaks. Likewise,
you must join in order to query the return value.
See Also:
async |
Flag to indicate whether the operation should be synchronously or asynchronously.
|
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.
DetTiLim
, 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 re-uses 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 is the asynchronous version of
IloCplex::presolve
. In other words,
this method performs the same operation as
IloCplex::presolve
, but it can run
asynchronously. The method returns an instance of
IloCplex::PresolveHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
PresolveHandle::joinPresolve
in order
to clean up resources and prevent memory leaks. Likewise, you
must join in order to query the return value.
See Also:
alg | See |
async |
Flag to indicate whether the operation should be synchronously or asynchronously.
|
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 CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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 CPLEX. Thus they incur a higher risk of incorrect behavior in your application, behavior that can be difficult to debug. Therefore, the team 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
semi-definite Q matrix (negative semi-definite 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.
IloCplex
object.
INLINE implementations of annotation API
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
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 CPLEX File Formats.
This method reads the MST 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 .mst
.
The MST file format is documented in the reference manual
CPLEX File Formats 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
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
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
CPLEX File Formats.
Deprecated. Use readStartInfo
instead.
Reads a solution from the SOL file denoted by
name
and copies this information into a CPLEX problem
object, as starting information.
This information can be used to cross over in a barrier optimization, to restart the simplex method with an advanced basis, or to specify variable values for a MIP start.
The CPLEX parameter AdvInd
must be set to a
nonzero value (such as its default setting: 1 (one))
in order for the information read from a solution file to be used
with the next invocation of the method solve
.
By convention, the file extension is .sol
.
The SOL file format is documented in the reference manual
CPLEX File Formats 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 CPLEX User's Manual.
Reads starting information from the SOL file denoted by
name
and copies this information into a CPLEX problem
object.
This information can be used to cross over in a barrier optimization, to restart the simplex method with an advanced basis, or to specify variable values for a MIP start.
The CPLEX parameter AdvInd
must be set to a
nonzero value (such as its default setting: 1 (one))
in order for the information read from a solution file to be used
with the next invocation of the method solve
.
By convention, the file extension is .sol
.
The SOL file format is documented in the reference manual
CPLEX File Formats 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 CPLEX User's Manual.
Reads a virtual machine configuration from a file.
The function reads the virtual machine configuration in file
(which must be in the VMC file format).
If file
can be parsed successfully then the
configuration is installed into this instance of
IloCplex
.
In case of error, a previously installed virtual machine configuration
remains unchanged.
If a virtual machine configuration has been installed into an instance of
IloCplex
, and the extracted model is a MIP, then
the solve
method of this instance
uses parallel distributed MIP to solve the problem.
This function is implemented as a template so that it does not create
references to the CPLEX distributed parallel MIP API unless you
actually use the function.
The type of its argument must be convertible to
char const *
.
See Also:
file |
The name of the file containing the virtual machine configuration.
|
This method is the asynchronous version of
IloCplex::refineConflict
. In other words,
this method performs the same operation as
IloCplex::refineConflict
, but it can run
asynchronously. The method returns an instance of
IloCplex::RefineConflictHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
RefineConflictHandle::joinRefineConflict
in order
to clean up resources and prevent memory leaks. Likewise,
you must join in order to query the return value.
See Also:
cons | |
prefs | |
async |
Flag to indicate whether the operation should be synchronously or asynchronously.
|
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.
To check whether the bounds of a variable cause a conflict, use an
instance of the class IloBound
to specify the lower and
upper bounds of the variable in question. Use those bounds like
constraints among the arguments you pass to
refineConflict
.
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.
The parameters CutUp
, CutLo
,
ObjULim
, ObjLLim
do not influence this method.
If you want to study infeasibilities introduced by those parameters,
consider adding an objective function constraint to your model to
enforce their effect before you invoke this method.
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 containing the preferences for the groups or constraints. |
This method is the asynchronous version of
IloCplex::refineMIPStartConflict
.
In other words,
this method performs the same operation as
IloCplex::refineMIPStartConflict
,
but it can run asynchronously. The method returns an instance of
IloCplex::RefineMIPStartConflictHandle
that represents the operation started.
To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
IloCplex::RefineMIPStartConflictHandle::joinRefineConflict
in order to clean up resources and prevent memory leaks. Likewise,
you must join in order to query the return value.
See Also:
IloCplex::refineMIPStartConflict
mipstartindex | The index of this MIP start among the MIP starts associated with this problem. |
cons | |
prefs | |
async |
Flag to indicate whether the operation should be synchronously or asynchronously.
|
This method accepts a MIP start, designated by its index, and identifies a minimal conflict for the infeasibility of that MIP start or for a subset of the constraints in the model inferred from that MIP start.
The parameters CutUp
, CutLo
,
ObjULim
, ObjLLim
do not influence this method.
If you want to study infeasibilities introduced by those parameters,
consider adding an objective function as a constraint to your model to
enforce their effect before you invoke this method.
When the MIP start was added to the current model, an effort level may have been associated with it to specify to CPLEX how much effort to expend in transforming the MIP start into a feasible solution. This method respects effort levels except level 1 (one): check feasibility. It does not check feasibility. Instead, CPLEX increases the effort level to 2 in order to solve the fixed model.
When this method returns, you can query the conflict with the method
IloCplex::getConflict
and write the conflict to a file in LP format with the method
IloCplex::writeConflict
.
mipstartindex | The index of this MIP start among the MIP starts associated with this problem. |
cons | An array of constraints among which to look for a conflict. The constraints may be any constraint in the MIP start, or a group of constraints organized by |
prefs | An array containing the preferences for the groups or constraints. |
This method instructs the invoking IloCplex
object to
discontinue using cb
as a callback.
This method removes the aborter object abort
from the
invoking IloCplex
object.
This method removes any remote worker info message handler.
See Also:
IloCplex::setRemoteInfoHandler, IloCplex::getRemoteInfoHandler
value[i]
as the value of the numeric annotation
of the constraint ctr[i]
for the specified numeric annotation.
value[i]
as the value of the numeric annotation
of the integer variable var[i]
for the
specified numeric annotation.
value[i]
as the value of the numeric annotation
of the numeric variable var[i]
for the
specified numeric annotation.
value
as the value of the numeric annotation
of the constraint ctr
for the specified numeric annotation.
value
as the value of the numeric annotation
of the objective obj
for the specified numeric annotation.
value
as the value of the numeric annotation
of the integer variable var
for the specified
numeric annotation.
value
as the value of the numeric annotation
of the numeric variable var
for the
specified numeric annotation.
value
as the
value of the annotation
of the respective constraint in the array ctr
for the specified annotation.
value
as the
value of the annotation
of the respective variable in the array var
for the specified annotation.
value
as the
value of the annotation
of the respective variable in the array var
for the specified annotation.
value
as the value of the annotation
of the constraint ctr
for the specified annotation.
value
as the value of the annotation
of the objective obj
for the specified annotation.
value
as the value of the annotation
of the variable var
for the specified annotation.
value
as the value of the annotation
of the variable var
for the specified annotation.
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 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 user-assigned priority is 0 (zero).
The parameter MIPOrdInd
by default specifies that
user-assigned priority orders should be taken into account.
When MIPOrdInd
is reset to its nondefault value
0 (zero), CPLEX ignores user-assigned priorities.
To remove user-assigned 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 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 user-assigned priority is 0 (zero).
The parameter MIPOrdInd
by default specifies that
user-assigned priority orders should be taken into account.
When MIPOrdInd
is reset to its nondefault value
0 (zero), CPLEX ignores user-assigned priorities.
To remove user-assigned 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 CPLEX User's Manual.
This method registers a handler for remote worker info messages. Any previously installed handler will be overwritten.
See Also:
IloCplex::getRemoteInfoHandler, IloCplex::removeRemoteInfoHandler
handler |
The handler to install.
|
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 argument. However, the arrays
x
and var
must be the same length.
Likewise, pi
and rng
must be the same
length.
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
.
CPLEX uses this information 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 1 (one). In
particular, if the extracted model is an LP, and the root algorithm is dual
or primal, CPLEX uses the information 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.
When CPLEX is solving a MIP, this information is not used. Use
addMIPStart
to define one or more starting solution
candidates.
This method initializes the goal stack of the root node with
goal
before starting the branch-and-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, and it can do so asynchronously.
To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
join
in order to clean up resources and prevent memory leaks. Likewise, you
you must join this operation in order
to clean up resources and prevent memory leaks. Furthermore, you must
still join in order to query the return value.
The method returns
IloTrue
if it finds a solution (not necessarily an optimal
one).
This method solves the model currently extracted to the invoking
IloCplex
object using the multi-objective optimizer using
the provided IloCplex::ParameterSet
s for solving the
submodels.
The method returns IloTrue
if it finds a solution
(not necessarily an optimal one).
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).
This method is the asynchronous version
of IloCplex::solveFixed
. In other words,
this method performs the same operation as
IloCplex::solveFixed
, but it can run
asynchronously. The method returns an instance of
IloCplex::SolveFixedHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you still must
join the returned handle by means of the method
SolveFixedHandle::joinSolveFixed
in order to
to clean up resources and prevent memory leaks. Furthermore, you must
still join in order to query the return value.
See Also:
soln | See |
async |
Flag to indicate whether the operation executes synchronously or asynchronously.
|
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.
A call to this method causes CPLEX to view the extracted MIP
model as a continuous model, so that you can obtain
information normally available
for a continuous solution but normally unavailable for MIP models.
CPLEX continues to view the model as continuous until a call to
another method restores the model as a MIP. For example, a call to
IloCplex::solve
restores the model back to MIP and solves
the model immediately, provided the advanced start parameter has
not been disabled.
Performs a low-level transport control operation on a remote object worker.
If this instance of IloCplex
is associated with a remote
object worker, then the function performs the low-level control operation
specified by ctrl
on the transport that connects to that
remote object worker.
For further details about ctrl
, data
, and
values allowed for these arguments, see the reference documentation of
CPXXtransportctrlint
in the Callable Library (C API)
reference manual.
See Also:
IloCplex::transportctrl, IloCplex::transportctrl
ctrl |
Identifies the control operation to perform.
|
data |
Input/output for the operation identified by ctrl .
|
Performs a low-level transport control operation on a remote object worker.
If this instance of IloCplex
is associated with a remote
object worker, then the function performs the low-level control operation
specified by ctrl
on the transport that connects to that
remote object worker.
For further details about ctrl
, data
, and
values allowed for these arguments, see the reference documentation of
CPXXtransportctrlint
in the Callable Library (C API)
reference manual.
See Also:
IloCplex::transportctrl, IloCplex::transportctrl
ctrl |
Identifies the control operation to perform.
|
data |
Input/output for the operation identified by ctrl .
|
Performs a low-level transport control operation on a remote object worker.
If this instance of IloCplex
is associated with a remote
object worker, then the function performs the low-level control operation
specified by ctrl
on the transport that connects to that
remote object worker.
For further details about ctrl
, data
, and
values allowed for these arguments, see the reference documentation of
CPXXtransportctrlint
in the Callable Library (C API)
reference manual.
See Also:
IloCplex::transportctrl, IloCplex::transportctrl
ctrl |
Identifies the control operation to perform.
|
data |
Input/output for the operation identified by ctrl .
|
This method is the asynchronous version of
IloCplex::tuneParam
.
In other words, this method performs the same operation as
IloCplex::tuneParam
,
but it can run asynchronously. The method returns an instance of
IloCplex::TuneParamHandle
that represents
the operation started. To start the operation asynchronously, call this
method with its argument
with async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
TuneParamHandle::joinTuneParam
in order
to clean up resources and prevent memory leaks. Likewise, you must
join in order to query the return value.
See Also:
fixedset | See |
async |
Flag to indicate whether the operation runs synchronously or asynchronously.
|
This method is the asynchronous version of
IloCplex::tuneParam
. In other words,
this method performs the same operation as
IloCplex::tuneParam
, but it can run
asynchronously. The method returns an instance of
IloCplex::TuneParamHandle
that represents
the operation started. To start the operation asynchronously, call this
method with the argument
async=true
. If async
is false
,
CPLEX executes the operation synchronously. However, you must still
join the returned handle by means of the method
TuneParamHandle::joinTuneParam
in order
to clean up resources and to prevent memory leaks. Likewise, you
must join in order to query the return value.
See Also:
async |
Flag to indicate whether the operation runs synchronously or asynchronously.
|
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 |
DetTiLim | Limits the total deterministic time spent tuning |
TuningTiLim | Limits the time of each trial run |
TuningDetTiLim | Limits the deterministic 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
.
During optimization, CPLEX will invoke the callback with information
about a particular modeling assistance warning. Call this with
callback = null
to clear the current callback. To register a
callback, provide this method with a non-null callback
.
The callback function will only be invoked if the CPLEX parameter
IloCplex::Param::Read::DataCheck
is set to
IloCplex::Assist
. In addition, the parameter
IloCplex::Param::Read::WarningLimit
controls the number
of times each type of modeling assistance warning will be reported
(the rest will be ignored). See CPX_PARAM_DATACHECK
and
CPX_PARAM_WARNLIM
in the Parameters of CPLEX Reference
Manual.
This function will always clear any current callback, even
if setting the new callback fails. Thus at most one callback can be
registered with a single instance of IloCplex
.
See Also:
IloModelingAssistance::Callback
callback |
The new callback to be set or null to clear
the callback.
|
callback = null
or contextMask = 0
to clear the current callback.
To register a callback invoke this method with callback
argument different from null
and a contextMask
different from 0 (zero). The value of contextMask
can be the
bitwise OR of values from Callback.Context.Id.
Note: The function will always clear any current callback, even
if setting the new callback fails. Thus at most one callback can be
registered with a single instance of IloCplex
.
the callback.
the callback or 0
(zero) to clear the
callback.
callback |
The new callback to be set or null to clear
the callback.
|
contextMask |
A bitmask that specifies in which contexts to invoke
the callback or 0 (zero) to clear the
callback.
|
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. The method returns
a handle to the aborter that is installed in the invoking
IloCplex
object.
See Also:
Invokes a user function on a remote object worker.
If this instance of IloCplex
is associated
with a remote object worker,
then the user function on that worker is invoked. Otherwise, the
method throws an exception.
All arguments are passed verbatim to the user function on the
remote object. See the CPLEX User's Manual especially
the topic about user functions and the remote object for further details.
You may want to use the classes Serializer
and Deserializer
to handle
data that is passed into and returned from that function, like this:
// Call a user function that takes two int arguments and returns a double double wrapper(IloCplex cplex, int in1, int in2) { Serializer s; s.add(in1); s.add(in2); char buffer[8]; CPXLONG outlen = 0; int status = cplex.userfunction (0, s.getRawLength(), s.getRawData(), sizeof (buffer), &outlen, static_cast<void *>buffer)); if ( status != 0 ) throw status; Deserializer d(static_cast<void *>buffer), outlen); double result; d.get(&result, 1); return result; }
See Also:
IloCplex::Serializer, IloCplex::Deserializer
IloCplex
object to the file with
the specified name.
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
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 CPLEX File Formats.
Writes MIP start information to the file denoted by
name
. The designated MIP starts
begin with the one designated by the index
first
and continue to the specified number
num
of members.
All MIP starts will be written if the
first
and num
arguments are
omitted. All MIP starts starting with first
will be written if the num
argument is
omitted.
By convention, the file extension is .mst
.
The MST file format is documented in the reference manual
CPLEX File Formats as well as the stylesheet
solution.xsl
and schema solution.xsd
found in the include
directory of the product.
The parameter WriteLevel
tells CPLEX the
level of detail to write to the file. The enumeration
IloCplex::WriteLevelType
lists
values that may be used.
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
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
CPLEX File Formats.
The method writes a solution
for the current problem into the file specified by name
.
The solution written is the current solution if the argument
soln
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
CPLEX File Formats as well as the stylesheet
solution.xsl
and schema solution.xsd
found in the include directory of the product.
The parameter WriteLevel
tells CPLEX the
level of detail to write to the file. The enumeration
IloCplex::WriteLevelType
lists
values that may be used.
Writes a formatted file containing all members of the solution pool
for the current problem into the file specified by name
and does so in SOL format.
By convention, the file extension is .sol
.
The SOL file format is documented in the reference manual
CPLEX File Formats as well as the stylesheet
solution.xsl
and schema solution.xsd
found in the include directory of the product.
The parameter WriteLevel
tells CPLEX the
level of detail to write to the file. The enumeration
IloCplex::WriteLevelType
lists
values that may be used.
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
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 = -1 | |
Basic = 1 | |
AtLower = 0 | |
AtUpper = 2 | |
FreeOrSuperbasic = 3 |
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 zero-one (0-1) values.
Use these values with the
methods that accept Boolean parameters:
IloCplex::getParam
and
IloCplex::setParam
.
See the CPLEX Parameters Reference Manual for more information about these parameters. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
BoolParam_MIN = 0 | |
BoolParam_MAX = INT_MAX | |
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
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 CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX 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 |
The enumeration IloCplex::CalcQCPDuals
lists values that
the QCP dual presolve parameter IloCplex:QCPDual
can assume.
Use these values with the method
IloCplex::setParam(IloCplex::CalcQCPDuals, value)
when
you set the QCP dual presolve parameter.
See Also:
Fields |
---|
QCPDualsNo = CPX_QCPDUALS_NO | |
QCPDualsIfPossible = CPX_QCPDUALS_IFPOSSIBLE | |
QCPDualsForce = CPX_QCPDUALS_FORCE |
The enumeration IloCplex::ConflictAlgorithm
lists values that the conflict algorithm parameter
IloCplex::Param::Conflict::Algorithm
accepts in IloCplex
for use with the conflict refiner.
Use these values with the method
IloCplex::setParam(IloCplex::Param::Conflict::Algorithm, value)
when you set the conflict algorithm parameter.
See the CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about this parameter. Also see the CPLEX User's Manual for examples of its use.
See Also:
Fields |
---|
ConflictAuto = CPX_CONFLICTALG_AUTO | |
ConflictFast = CPX_CONFLICTALG_FAST | |
ConflictPropagate = CPX_CONFLICTALG_PROPAGATE | |
ConflictPresolve = CPX_CONFLICTALG_PRESOLVE | |
ConflictIIS = CPX_CONFLICTALG_IIS | |
ConflictLimitedSolve = CPX_CONFLICTALG_LIMITSOLVE | |
ConflictSolve = CPX_CONFLICTALG_SOLVE |
This enumeration lists the values that tell the status of a constraint or bound with respect to a conflict.
ConflictPossibleMember
ConflictMember
ConflictExcluded
Fields |
---|
ConflictExcluded = CPX_CONFLICT_EXCLUDED | |
ConflictPossibleMember = CPX_CONFLICT_POSSIBLE_MEMBER | |
ConflictMember = CPX_CONFLICT_MEMBER |
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 CPLEX User's Manual for examples of their use.
See also the enumeration IloAlgorithm::Status
in the
Reference Manual of the C++ API.
See Also:
Fields |
---|
Unknown = 0 | |
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 | |
AbortDetTimeLim = CPX_STAT_ABORT_DETTIME_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 | |
ConflictAbortDetTimeLim = CPX_STAT_CONFLICT_ABORT_DETTIME_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 | |
RelaxationUnbounded = CPXMIP_ABORT_RELAXATION_UNBOUNDED | |
FirstOrder = CPX_STAT_FIRSTORDER | |
MultiObjOptimal = CPX_STAT_MULTIOBJ_OPTIMAL | |
MultiObjNonOptimal = CPX_STAT_MULTIOBJ_NON_OPTIMAL | |
MultiObjInfeasible = CPX_STAT_MULTIOBJ_INFEASIBLE | |
MultiObjUnbounded = CPX_STAT_MULTIOBJ_UNBOUNDED | |
MultiObjInfOrUnbd = CPX_STAT_MULTIOBJ_INForUNBD | |
MultiObjStopped = CPX_STAT_MULTIOBJ_STOPPED |
The symbolic values of this enumeration specify how CPLEX manages cuts added by the user.
UseCutForce
: The cut is added and never removed.
UseCutPurge
:
The cut is added, but CPLEX may purge (eliminate) the cut later.
UseCutFilter
:
The cut is treated exactly as other cuts added by CPLEX.
That is, CPLEX applies its filtering process to the cut.
As a consequence of the filtering process, CPLEX may decide
not to add the cut to the relaxation, for example, if CPLEX
deems other cuts more effective, or if the cut is too dense,
or other possible filtering criteria).
Fields |
---|
UseCutForce = CPX_USECUT_FORCE | |
UseCutPurge = CPX_USECUT_PURGE | |
UseCutFilter = CPX_USECUT_FILTER |
The enumeration IloCplex::CutType
lists
the values that can be used in querying the number of
cuts used in a mixed integer optimization with
getNcuts()
.
Fields |
---|
CutCover = CPX_CUT_COVER | |
CutGubCover = CPX_CUT_GUBCOVER | |
CutFlowCover = CPX_CUT_FLOWCOVER | |
CutClique = CPX_CUT_CLIQUE | |
CutFrac = CPX_CUT_FRAC | |
CutMir = CPX_CUT_MIR | |
CutFlowPath = CPX_CUT_FLOWPATH | |
CutDisj = CPX_CUT_DISJ | |
CutImplBd = CPX_CUT_IMPLBD | |
CutZeroHalf = CPX_CUT_ZEROHALF | |
CutMCF = CPX_CUT_MCF | |
CutLiftProj = CPX_CUT_LANDP | |
CutUser = CPX_CUT_USER | |
CutTable = CPX_CUT_TABLE | |
CutSolnPool = CPX_CUT_SOLNPOOL | |
CutLocalImplBd = CPX_CUT_LOCALIMPLBD | |
CutBQP = CPX_CUT_BQP | |
CutRLT = CPX_CUT_RLT | |
CutBenders = CPX_CUT_BENDERS |
The enumeration IloCplex::DataCheckType
lists values
that the data consistency checking parameter
IloCplex:DataCheck
can assume in IloCplex
.
Use these values with the method
IloCplex::setParam(IloCplex::DataCheck, value)
.
See the CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about this parameters. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
Off = CPX_DATACHECK_OFF |
= CPX_DATACHECK_OFF
|
Warn = CPX_DATACHECK_WARN |
= CPX_DATACHECK_WARN
|
Assist = CPX_DATACHECK_ASSIST |
= CPX_DATACHECK_ASSIST
|
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
computation-intensive, 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::DistMIPRampupDuration
lists values that
the distributed MIP rampup parameter
IloCplex::Param::DistMIP::Rampup::Duration
can assume in IloCplex
for use with the distributed MIP
optimizer. Use these values with the method
IloCplex::setParam(IloCplex::Param::DistMIP::Rampup::Duration, value)
when you set the distributed MIP rampup duration.
See the CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
RampupDisabled = CPX_RAMPUP_DISABLED | |
RampupAuto = CPX_RAMPUP_AUTO | |
RampupDynamic = CPX_RAMPUP_DYNAMIC | |
RampupInfinite = CPX_RAMPUP_INFINITE |
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 CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX 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
algorithms in CPLEX. The enumeration IloCplex::IntParam
lists the parameters of CPLEX that require integer values that always
fit into a 32bit signed integer. Use these values with the methods
IloCplex::getParam
and
IloCplex::setParam
.
See the CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
IntParam_MIN = 0 | |
IntParam_MAX = INT_MAX | |
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
IloCplex
is the class for the
algorithms in CPLEX. The enumeration IloCplex::LongParam
lists the parameters of CPLEX that require integer values that do not
always fit into a 32bit signed integer. Use these values with the methods
IloCplex::getParam
and
IloCplex::setParam
.
See the CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
LongParam_MIN = 0 | |
LongParam_MAX = INT_MAX | |
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
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-and-cut algorithm in
such a way as to find a proven optimal solution quickly. For a discussion
about various settings, refer to the CPLEX User's Manual.
See the CPLEX Parameters Reference Manual and the information about the MIP emphasis parameter. Also see the CPLEX User's Manual for examples of the use of these values.
See Also:
Fields |
---|
MIPEmphasisBalanced = CPX_MIPEMPHASIS_BALANCED | |
MIPEmphasisOptimality = CPX_MIPEMPHASIS_OPTIMALITY | |
MIPEmphasisFeasibility = CPX_MIPEMPHASIS_FEASIBILITY | |
MIPEmphasisBestBound = CPX_MIPEMPHASIS_BESTBOUND | |
MIPEmphasisHiddenFeas = CPX_MIPEMPHASIS_HIDDENFEAS MIPEmphasisHeuristic = CPX_MIPEMPHASIS_HEURISTIC |
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 CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about this parameter. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
AutoSearch = CPX_MIPSEARCH_AUTO | |
Traditional = CPX_MIPSEARCH_TRADITIONAL | |
Dynamic = CPX_MIPSEARCH_DYNAMIC |
This enumeration defines
the possible levels of effort for CPLEX to expend when
CPLEX evaluates a MIP start. Use these values with the
member functions
IloCplex::addMIPStart
,
getMIPStart
, or
changeMIPStart
.
CPXPARAM_MIP_Limits_RepairTries
(that is, IloCplex::Param::MIP::Limits::RepairTries
).
Fields |
---|
MIPStartAuto = CPX_MIPSTART_AUTO | |
MIPStartCheckFeas = CPX_MIPSTART_CHECKFEAS | |
MIPStartSolveFixed = CPX_MIPSTART_SOLVEFIXED | |
MIPStartSolveMIP = CPX_MIPSTART_SOLVEMIP | |
MIPStartRepair = CPX_MIPSTART_REPAIR | |
MIPStartNoCheck = CPX_MIPSTART_NOCHECK |
The enumeration IloCplex::MultiObjInt64Info
lists types of
solution information of type IloInt64
that can be retrieved
about the solution of a subproblem solved during multiobjective
optimization. This information can be queried for each priority
level with method
IloCplex::getMultiObjInfo
.
See the documentation of multiobjective information in the Callable Library Reference Manual for more information about these values. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
MultiObjNbarierIterations = CPX_MULTIOBJ_BARITCNT | |
MultiObjNsiftingIterations = CPX_MULTIOBJ_SIFTITCNT | |
MultiObjNsiftingPhase1Iterations = CPX_MULTIOBJ_SIFTPHASE1CNT | |
MultiObjNdegenerateIterations = CPX_MULTIOBJ_DEGCNT | |
MultiObjNiterations = CPX_MULTIOBJ_ITCNT | |
MultiObjNphase1Iterations = CPX_MULTIOBJ_PHASE1CNT | |
MultiObjNprimalPushes = CPX_MULTIOBJ_PPUSH | |
MultiObjNprimalExchanges = CPX_MULTIOBJ_PEXCH | |
MultiObjNdualPushes = CPX_MULTIOBJ_DPUSH | |
MultiObjNdualExchanges = CPX_MULTIOBJ_DEXCH | |
MultiObjNnodes = CPX_MULTIOBJ_NODECNT | |
MultiObjNnodesLeft = CPX_MULTIOBJ_NODELEFTCNT |
The enumeration IloCplex::MultiObjIntInfo
lists types of
solution information of type IloInt
that can be retrieved
about the solution of a subproblem solved during multiobjective
optimization. This information can be queried for each priority
level with method
IloCplex::getMultiObjInfo
.
See the documentation of multiobjective optimization in the Callable Library Reference Manual for more information about these values. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
MultiObjError = CPX_MULTIOBJ_ERROR | |
MultiObjStatus = CPX_MULTIOBJ_STATUS | |
MultiObjMethod = CPX_MULTIOBJ_METHOD | |
MultiObjPriority = CPX_MULTIOBJ_PRIORITY |
The enumeration IloCplex::MultiObjNumInfo
lists types of
solution information of type IloNum
that can be retrieved
about the solution of a subproblem solved during multiobjective
optimization. This information can be queried for each priority
level with method
IloCplex::getMultiObjInfo
.
See the documentation of multiobjective optimization in the Callable Library Reference Manual for more information about these values. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
MultiObjTime = CPX_MULTIOBJ_TIME | |
MultiObjDetTime = CPX_MULTIOBJ_DETTIME | |
MultiObjObjValue = CPX_MULTIOBJ_OBJVAL | |
MultiObjBestObjValue = CPX_MULTIOBJ_BESTOBJVAL |
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 CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX 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 CPLEX Parameters Reference Manual for more information about these parameters. Also see the CPLEX User's Manual for more examples of their use.
See Also:
Fields |
---|
NumParam_MIN = 0 | |
NumParam_MAX = INT_MAX | |
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
The enumeration IloCplex::OptimalityTargetType
lists the values
that the solution target parameter IloCplex::OptimalityTarget
can assume in an instance of IloCplex
. Use these values with
the method IloCplex::setParam(IloCplex::OptimalityTarget, value)
when you set solution target.
With the default setting of IloCplex::OptimalityTarget
,
IloCplex
tries to compute an optimal solution of a convex
problem. For a discussion about various settings, refer to the CPLEX
User's Manual.
See the CPLEX Parameters Reference Manual for information about these parameters. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
OptimalityAuto = CPX_OPTIMALITYTARGET_AUTO | |
OptimalityOptimalConvex = CPX_OPTIMALITYTARGET_OPTIMALCONVEX | |
OptimalityFirstOrder = CPX_OPTIMALITYTARGET_FIRSTORDER | |
OptimalityOptimalGlobal = CPX_OPTIMALITYTARGET_OPTIMALGLOBAL |
The enumeration IloCplex::ParallelMode
lists values that
the parallel mode parameter IloCplex::ParallelMode
can assume in
IloCplex
for use on multiprocessor or multithread
platforms.
Use these values with the method
IloCplex::setParam(IloCplex::ParallelMode,
value)
.
See the CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about this parameter. Also see the CPLEX 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 CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX 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 the method
IloCplex::getQuality
.
See the documentation of solution quality in the Callable Library Reference Manual for more information about these values. Also see the 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 | |
KappaStable = CPX_KAPPA_STABLE | |
KappaSuspicious = CPX_KAPPA_SUSPICIOUS | |
KappaUnstable = CPX_KAPPA_UNSTABLE | |
KappaIllposed = CPX_KAPPA_ILLPOSED | |
KappaMax = CPX_KAPPA_MAX | |
KappaAttention = CPX_KAPPA_ATTENTION |
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 minimum-penalty 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 minimize 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 minimize 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::SolutionType
lists values
that the parameter IloCplex::Param::SolutionType
can assume
in IloCplex
for solving Linear Programming problems (LPs).
Use these values with the method
IloCplex::setParam(IloCplex::Param::SolutionType, value)
when you set the solution type.
See the CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
AutoSolution = CPX_AUTO_SOLN | |
BasicSolution = CPX_BASIC_SOLN | |
NonBasicSolution = CPX_NONBASIC_SOLN |
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 CPLEX Parameters Reference Manual and the CPLEX User's Manual for more information about these parameters. Also see the CPLEX User's Manual for examples of their use.
See Also:
Fields |
---|
StringParam_MIN = 0 | |
StringParam_MAX = INT_MAX | |
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
CPXDEPRECATEDENUMVAL = (12090000) = CPX_PARAM_EPMRK | Deprecated:
Since V12.9.0
|
This enumeration lists the values that are returned by
tuneParam
.
TuningComplete
TuningAbort
TuningTimeLim
TuningDetTimeLim
Fields |
---|
TuningComplete = 0 | |
TuningAbort = CPX_TUNE_ABORT | |
TuningTimeLim = CPX_TUNE_TILIM | |
TuningDetTimeLim = CPX_TUNE_DETTILIM |
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 CPLEX Parameters Reference Manual for CPLEX User's Manual for more information about these parameters. Also see the CPLEX 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 |
Values of this enumeration specify how much detail CPLEX includes when it writes MIP starts and solutions to a formatted file.
Fields |
---|
Auto = CPX_WRITELEVEL_AUTO | |
AllVars = CPX_WRITELEVEL_ALLVARS | |
DiscreteVars = CPX_WRITELEVEL_DISCRETEVARS | |
NonzeroVars = CPX_WRITELEVEL_NONZEROVARS | |
NonZeroDiscreteVars = CPX_WRITELEVEL_NONZERODISCRETEVARS |
Inner Typedef Detail |
---|
IloArray< BasisStatus > BasisStatusArray
This type defines an array-type 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 array-type 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 array-type 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. In order to check whether the model
is feasible, remove the objective, and reoptimize.
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: