IloCplex derives from the class IloAlgorithm. Use it to solve Mathematical Programming models, such as:

• LP (linear programming) problems,
• QP (programs with quadratic terms in the objective function),
• QCP (quadratically constrained programming), including the special case of SOCP (second order cone programming) problems, and
• MIP (mixed integer programming) problems.

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:

• variables: objects of type IloNumVar and its extensions IloIntVar and IloSemiContVar
• range constraints: objects of type IloRange
• other relational constraints: objects of type IloConstraint of the form expr1 relation expr2, where the relation is one of ==, >=, <=, or !=
• objective function: one object of type IloObjective
• variable type conversions: objects of type IloConversion
• special ordered sets: objects of type 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:

• minimum:IloMin
• maximum:IloMax
• absolute value:IloAbs
• piecewise linear functions:IloPiecewiseLinear

Expressions that evaluate only to 0 (zero) and 1 (one) are referred to as Boolean expressions. Such expressions also support:

• negation:operator !
• conjunction:operator && or, equivalently, IloAnd
• disjunction: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::Auto IloCplex automatically selects an algorithm. This is the default setting.
• IloCplex::Primal Use the primal simplex algorithm. This option is not available for quadratically constrained problems (QCPs).
• IloCplex::Dual Use the dual simplex algorithm. This option is not available for quadratically constrained problems (QCPs).
• IloCplex::Network Use network simplex on the embedded network part of the model, followed by dual simplex on the entire model. This option is not available for quadratically constrained problems.
• IloCplex::Barrier Use the barrier algorithm.
• IloCplex::Sifting Use the sifting algorithm. This option is not available for quadratic problems. If selected nonetheless, IloCplex defaults to the IloCplex::Auto setting.
• IloCplex::Concurrent Use the several algorithms concurrently. This option is not available for quadratic problems. If selected nonetheless, 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.

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.

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 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.

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.

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.

This method returns the index of the added filter.

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 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 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.

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 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 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 *.

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 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.

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.

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.

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.

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.

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.

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.

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.

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.

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;
 

This method returns the algorithm type that was used to solve the most recent model in cases where it was not a MIP.

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.

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 IloRanges and IloConstraints 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.

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:

• ContinuousCallbackI::getObjValue
• ControlCallbackI::getObjValue
• GoalI::getObjValue
• IncumbentCallbackI::getObjValue
• NetworkCallbackI::getObjValue
• NodeCallbackI::getObjValue
• NodeEvaluatorI::getObjValue

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).

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:

• The subproblems must be solved with a simplex optimizer.
• The parameter IloCplex::Param::MIP::Strategy::KappaStats must be turned on.
• CPLEX has already processed at least one LP-basis during branch and cut.

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.

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.

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

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.

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.

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.

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:

• Populate limit PopulateLim. This parameter controls how many solutions are generated before the method stops. Its default value is 20.
• Time limit TiLim, as in standard MIP optimization.
• Deterministic time limit DetTiLim, as in standard MIP optimization.
• Node limit NodeLim, as in standard MIP optimization.
• In the absence of other stopping criteria, 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.

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 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 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.

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.

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 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 *.

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.

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.

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.

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.

This method instructs the invoking IloCplex object to discontinue using cb as a callback.