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 constucted not only from variables, but also from constraints.

IloCplex will automatically transform all of these constructs into an equivalent representation amenable to IloCplex. Such models can be represented in the following way:

     Minimize (or Maximize)   c'x + x'Qx
     subject to               L <= Ax <= U
                      a_i'x + x'Q_i x <= r_i, for i = 1, ..., q
                              l <=  x <= u.
  

That is, in fact, the standard math programming matrix representation that IloCplex uses internally. A is the matrix of linear constraint coefficients, and L and U are the vectors of lower and upper bounds on the vector of variables in the array x. The Q matrix must be positive 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 correponding linear terms. For details about the Q_i, see the chapter about quadratically constrained programs (QCP) in the ILOG CPLEX User's Manual.

Special ordered sets (SOS) fall outside the conventional representation in terms of A and Q matrices and are stored separately.

If the model contains integer, Boolean, or semi-continuous variables, or if the model has special ordered sets (SOSs), the model is referred to as a mixed integer program (MIP). You can query whether the active model is a MIP with the method IloCplex::isMIP.

A model with quadratic terms in the objective is referred to as a mixed integer quadratic program (MIQP) if it is also a MIP, and a quadratic program (QP) otherwise. You can query whether the active model has a quadratic objective by calling method IloCplex::isQO.

A model with quadratic constraints is referred to as a mixed integer quadratically constrained program (MIQCP) if it is also a MIP, and as a quadratically constrained program (QCP) otherwise. You can query whether the active model is quadratically constrained by calling the method IloCplex::isQC. A QCP may or may not have a quadratic objective; that is, a given problem may be both QP and QCP. Likewise, a MIQCP may or may not have a quadratic objective; that is, a given problem may be both MIQP and MIQCP.

If there are no quadratic terms in the objective, no integer constraints, and the problem is not quadratically constrained, and all variables are continuous it is called a linear program (LP).

Information related to the matrix representation of the model can be queried through these methods:

• IloCplex::getNcols for querying the number of columns of A,
• IloCplex::getNrows for querying the number of rows of A; that is, the number of linear constraints,
• IloCplex::getNQCs for querying the number of quadratic constraints,
• IloCplex::getNNZs for querying the number of nonzero elements in A, and
• IloCplex::getNSOSs for querying the number of special ordered sets (SOSs).

Additional information about the active model can be obtained through iterators defined on the different types of modeling objects in the extracted or active model.

IloCplex effectively treats all models as MIQCP models. That is, it allows the most general case, although the solution algorithms make efficient use of special cases, such as taking advantage of the absence of quadratic terms in the formulation. The method IloCplex::solve begins by solving the root relaxation of the MIQCP model, where all integrality constraints and SOSs are ignored. If the model has no integrality constraints or SOSs, then the optimization is complete once the root relaxation is solved. Otherwise, IloCplex uses a branch and cut procedure to reintroduce the integrality constraints or SOSs. See the ILOG CPLEX User's Manual for more information about branch & cut.

Most users can simply call solve to solve their models. However, several parameters are available for users who require more control. These parameters are documented in the ILOG CPLEX Parameter Reference Manual. Perhaps the most important parameter is IloCplex::RootAlg, which determines the algorithm used to solve the root relaxation. Possible settings, as defined in the class IloCplex::Algorithm, are:

• IloCplex::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 nested enumerations IloCplex::IntParam, IloCplex::DoubleParam, and IloCplex#StringParam for further information. Parameters are set with the method setParam.

Even higher levels of control can be achieved through goals (see IloCplex::Goal) or through callbacks (see IloCplex::Callback and its extensions).

Information about a Solution

The solve method returns an IloBool value specifying whether (IloTrue) or not (IloFalse) a solution (not necessarily the optimal one) has been found. Further information about the solution can be queried with the method getStatus. The return code of type IloAlgorithm::Status specifies whether the solution is feasible, bounded, or optimal, or if the model has been proven to be infeasible or unbounded.

The method IloCplex::getCplexStatus provides more detailed information about the status of the optimizer after solve returns. For example, it can provide information on why the optimizer terminated prematurely (time limit, iteration limit, or other similar limits). The methods IloCplex::isPrimalFeasible and IloCplex::isDualFeasible can determine whether a primal or dual feasible solution has been found and can be queried.

The most important solution information computed by IloCplex are usually the solution vector and the objective function value. The method IloCplex::getValue queries the solution vector. The method IloCplex::getObjValue queries the objective function value. Most optimizers also compute additional solution information, such as dual values, reduced costs, simplex bases, and others. This additional information can also be queried through various methods of IloCplex. If you attempt to retrieve solution information that is not available from a particular optimizer, IloCplex will throw an exception.

If you are solving an LP and a basis is available, the solution can be further analyzed by performing sensitivity analysis. This information tells you how sensitive the solution is with respect to changes in variable bounds, constraint bounds, or objective coefficients. The information is computed and accessed with the methods IloCplex::getBoundSA, IloCplex::getRangeSA, IloCplex::getRHSSA, and IloCplex::getObjSA.

An important consideration when you access solution information is the numeric quality of the solution. Since IloCplex performs arithmetic operations using finite precision, solutions are always subject to numeric errors. For most problems, numeric errors are well within reasonable tolerances. However, for numerically difficult models, you are advised to verify the quality of the solution using the method IloCplex::getQuality, which offers a variety of quality measures.

More about Solving Problems

By default when the method IloCplex::solve is called, IloCplex first presolves the model; that is, it transforms the model into a smaller, yet equivalent model. This operation can be controlled with the following parameters:

• IloCplex::PreInd,
• IloCplex::PreDual,
• IloCplex::AggInd, and
• IloCplex::AggFill.

For the rare occasion when a user wants to monitor progress during presolve, the callback class IloCplex::PresolveCallbackI is provided.

After the presolve is completed, IloCplex solves the first node relaxation and (in cases of a true MIP) enters the branch & cut process. IloCplex provides callback classes that allow the user to monitor solution progress at each level. Callbacks derived from IloCplex::ContinuousCallbackI or one of its derived classes are called regularly during the solution of a node relaxation (including the root), and callbacks derived from IloCplex::MIPCallbackI or one of its derived callbacks are called regularly during branch & cut search. All callbacks provide the option to abort the current optimization.

Branch Priorities and Directions

When a branch occurs at a node in the branch & cut tree, usually there is a set of 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 & 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 class IloCplex::CutCallbackI allows 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 only valid within the subtree where they have been added.

Instead of using callbacks, you can use goals to add your own cuts during the optimization.

Heuristics

After a node has been processed, that is, the LP has been solved and no more cuts were generated, IloCplex may try to construct an integer feasible solution from the LP solution at that node. The parameter IloCplex::HeurFreq and other parameters provide some control over this activity. In addition, goals or the callback class IloCplex::HeuristicCallbackI make it possible to call 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 ILOG Concert Reference Manual.

See also Goals among the Concepts in this manual. See also goals in the ILOG CPLEX User's Manual.

This constructor creates an ILOG CPLEX algorithm. The new IloCplex object has no IloModel loaded (or extracted) to it.

This constructor creates an ILOG CPLEX algorithm and extracts model for that algorithm.

When you create an algorithm (an instance of IloCplex, for example) and extract a model for it, you can write either this line:

 IloCplex cplex(model);

or these two lines:

 IloCplex cplex(env);

 cplex.extract(model);

This method is used to create and return a goal that applies the node selection strategy defined by eval to the search strategy defined by goal. The resulting goal will use the node strategy defined by eval for the subtree generated by goal.

This method creates and returns a goal that puts the search specified by goal under the limit defined by limit. Only the subtree controlled by goal will be subjected to limit limit.

This method adds con as a cut to the invoking IloCplex object. The cut is not extracted as the regular constraints in a model, but is only copied when invoking the method addCut. Thus, con may be deleted or modified after addCut has been called and the change will not be notified to the invoking IloCplex object.

When columns are deleted from the extracted model, all cuts are deleted as well and need to be reextracted if they should be considered. Cuts are not part of the root problem, but are considered on an as-needed basis. A solution computed by IloCplex is guaranteed to satisfy all cuts added with this method.

This method adds the constraints in con as cuts to the invoking IloCplex object. Everything said for IloCplex::addCut applies equally to each of the cuts given in array con.

Creates and installs a named diversity filter for the designated integer variables with the specified lower and upper cutoff values, reference values, and weights.

Creates and installs a named diversity filter for the designated numeric variables with the specified lower and upper cutoff values, reference values, and weights.

This method adds con as a lazy constraint to the invoking IloCplex object. The constraint con is copied into the lazy constraint pool; the con itself is not part of the pool, so changes to con after it has been copied into the lazy constraint pool will not affect the lazy constraint pool.

Lazy constraints added with addLazyConstraint are typically constraints of the model that are not expected to be violated when left out. The idea behind this is that the LPs that are solved when solving the MIP can be kept smaller when these constraints are not included. IloCplex will, however, include a lazy constraint in the LP as soon as it becomes violated. In other words, the solution computed by IloCplex makes sure that all the lazy constraints that have been added are satisfied.

By contrast, if the constraint does not change the feasible region of the extracted model but only strengthens the formulation, it is referred to as a user cut. While user cuts can be added to IloCplex with addLazyConstraint, it is generally preferable to do so with addUserCuts. It is an error, however, to add lazy constraints by means of the method addUserCuts.

When columns are deleted from the extracted model, all lazy constraints are deleted as well and need to be recopied into the lazy constraint pool. Use of this method in place of addCuts allows for further presolve reductions

This method adds a set of lazy constraints to the invoking IloCplex object. Everything said for IloCplex::addLazyConstraint applies to each of the lazy constraints given in array con.

This method is equivalent to IloCplex::addCuts.

Creates a named range filter, using the specified lower cutoff, upper cutoff, integer variables, and weights, adds the filter to the solution pool of the invoking model, and returns the index of the filter.

Creates a named range filter, using the specified lower cutoff, upper cutoff, numeric variables, and weights, adds the filter to the solution pool of the invoking model, and returns its index.

This method adds con as a user cut to the invoking IloCplex object. The constraint con is copied into the user cut pool; the con itself is not part of the pool, so changes to con after it has been copied into the user cut pool will not affect the user cut pool.

Cuts added with addUserCut must be real cuts, in that the solution of a MIP does not depend on whether the cuts are added or not. Instead, they are there only to strengthen the formulation.

When columns are deleted from the extracted model, all user cuts are deleted as well and need to be recopied into the user cut pool.

This method adds a set of user cuts to the invoking IloCplex object. Everything said for IloCplex::addUserCut applies to each of the user cuts given in array con.

This method can be used to compute tighter bounds for the variables of a model and to detect redundant constraints in the model extracted to the invoking IloCplex object. For every variable specified in parameter vars, it will return possibly tightened bounds in the corresponding elements of arrays redlb and redub. Similarly, for every constraint specified in parameter rngs, this method will return a Boolean value reporting whether or not it is redundant in the model in the corresponding element of array redundant.

This method deletes all cuts that have previously been added to the invoking IloCplex object with the methods addCut and addCuts.

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

This method removes any existing branching direction assignment from variable var.

This method removes any existing branching direction assignments from all variables in the array var.

Deletes the speficied filter from the solution pool.

This method removes any existing priority order assignments from all variables in the array var.

This method removes any existing priority order assignment from variable var.

Deletes the specified solution from the solution pool and renumbers the indices of the remaining solutions in the pool.

Deletes a range of solutions from the solution pool and renumbers the indices of the remaining solutions in the pool.

This method returns a Farkas proof of infeasibility for the active LP model after it has been proven to be infeasible by one of the simplex optimizers. For every constraint i of the active LP this method computes a value y[i] such that y'A >= y'b, where A denotes the constraint matrix. For more detailed information about the Farkas proof of infeasibility, see the C routine CPXdualfarkas, documented in the reference manual of the Callable Library.

The value of y'b - y'A z for the vector z defined such that z[j] = ub[j] if y'A[j] > 0 and z[j] = lb[j] if y'A[j] < 0 for all variables j.

This method writes the active model (that is, the model that has been extracted by the invoking algorithm) to the file filename. The file format is determined by the extension of the file name. The following extensions are recognized on most platforms:

• .sav
• .mps
• .lp
• .sav.gz (if gzip is properly installed)
• .mps.gz (if gzip is properly installed)
• .lp.gz (if gzip is properly installed)

Microsoft Windows does not support gzipped files for this API.

If no name has been assigned to a variable or range (that is, the method getName returns null for that variable or range), IloCplex uses a default name when writing the model to the file (or to the optimization log). Default names are of the form IloXj for variables and IloCi, where i and j are internal indices of IloCplex.

See the reference manual ILOG CPLEX File Formats for more detail and the ILOG CPLEX User's Manual for additional information about file formats.

The method feasOpt computes a minimal relaxation of constraints in the active model in order to make the model feasible. On successful completion, the method installs a solution vector that is feasible for the 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.

Attempts to find a minimum feasible relaxation of the active model by relaxing the bounds of the constraints specified in rngs. Preferences are specified in rnglb and rngub on input.

The method returns IloTrue if it finds a feasible relaxation.

Attempts to find a minimum feasible relaxation of the active model by relaxing the bounds of the variables specified in vars as specified in varlb and varub.

The method returns IloTrue if it finds a feasible relaxation.

The method feasOpt computes a minimal relaxation of the range and variable bounds of the active model in order to make the model feasible. On successful completion, the method installs a solution vector that is feasible for the minimum-cost relaxation. This solution can be queried with query methods, such as IloCplex::getValues or IloCplex::getInfeasibility or

The method feasOpt provides several different metrics for determining what constitutes a minimum relaxation. The metric is specified by the parameter FeasOptMode. The method feasOpt can also optionally perform a second optimization phase where the original objective is optimized, subject to the constraint that the associated relaxation metric must not exceed the relaxation value computed in the first phase.

The user may specify values (known as preferences) to express relative preferences for relaxing bounds. A larger preference specifies a greater willingness to relax the corresponding bound. Internally, feasOpt uses the reciprocal of the preference to weight the relaxations of the associated bounds in the phase one cost function. A negative or 0 (zero) value as a preference specifies that the corresponding bound must not be relaxed. The preference for relaxing the lower bound of constraint rngs[i] should be provided in rnglb[i]; and likewise the preference for relaxing the upper bound of constraint rngs[i] in rngub[i]. Similarly, the preference for relaxing the lower bound of variable vars[i] should be provided in varlb[i], and the preference for relaxing its upper bound in varub[i].

Arrays rngs and vars need not contain all ranges and variables in the model. If a range or variable is not present, its bounds are not relaxed. Only constraints directly added to the model can be specified.

If enough variables or constraints were allowed to be relaxed, the function will return IloTrue; otherwise, it returns IloFalse.

The active model is not changed by this method.

This method frees the presolved problem. Under the default setting of parameter Reduce, the presolved problem is freed when an optimal solution is found; however, it is not freed if Reduce has been set to 1 (primal reductions) or to 2 (dual reductions). In these instances, the function freePresolve can be used when necessary to free it manually.

Computes A times X, where A is the corresponding LP constraint matrix.

For the constraints in con, this method places the values of the expressions, or, equivalently, the activity levels of the constraints for the current solution of the invoking IloCplex object into the array val. Array val is resized to the same size as array con, and val[i] will contain the slack value for constraint con[i]. All ranges in con must be part of the extracted model.

Computes A times X, where A is the corresponding LP constraint matrix.

This method returns the value of the expression of the constraint range, or, equivalently, its activity level, for the current solution of the invoking IloCplex object. The range must be part of the extracted model.

Returns a handle to the aborter being used by the invoking IloCplex object.

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

This method returns the basis status of the implicit slack or artificial variable created for the constraint con.

This method returns the basis status for the variable var.

This method returns the basis status for the variable var.

This method puts the basis status of each variable in var into the corresponding element of the array cstat, and it puts the status of each row in con (an array of ranges or constraints) into the corresponding element of the array rstat. Arrays rstat and cstat are resized accordingly.

This method puts the basis status of each constraint in con into the corresponding element of the array stat. Array stat is resized accordingly.

This method puts the basis status of each variable in var into the corresponding element of the array stat. Array stat is resized accordingly.

For the given set of variables vars, bound sensitivity information is computed. When the method returns, the element lblower[j] and lbupper[j] will contain the lowest and highest value the lower bound of variable vars[j] can assume without affecting the optimality of the solution. Likewise, ublower[j] and ubupper[j] will contain the lowest and highest value the upper bound of variable vars[j] can assume without affecting the optimality of the solution. The arrays lblower, lbupper, ublower, and ubupper will be resized to the size of array vars. The value 0 (zero) can be passed for any of the return arrays if the information is not desired.

Returns the conflict status for the constraint con.

Possible return values are:

IloCplex::ConflictMember the constraint has been proven to participate in the conflict.

IloCplex::ConflictPossibleMember the constraint has not been proven not to participate in the conflict; in other words, it might participate, though it might not.

The constraint con must be one that has previously been passed to refineConflict including IloAnd constraints.

Returns the conflict status for each of the constraints specified in cons.

The element i is the conflict status for the constraint cons[i] and can take the following values:

IloCplex::ConflictMember the constraint has been proven to participate in the conflict.

IloCplex::ConflictPossibleMember the constraint has not been proven not to participate in the conflict; in other words, it might participate, though it might not.

The constraints passed in cons must be among the same ones that have previously been passed to refineConflict, including IloAnd constraints.

This method returns the ILOG CPLEX status of the invoking algorithm. For possible ILOG CPLEX values, see the enumeration type IloCplex::CplexStatus.

See also the topic Interpreting Solution Quality in the ILOG CPLEX User's Manual for more information about a status associated with infeasibility or unboundedness.

This method accesses the solution status of the last node problem that was solved in the event of an error termination in the previous invocation of IloCplex::solve. The method IloCplex::getCplexSubStatus returns 0 in the event of a normal termination. If the invoking IloCplex object is continuous, this is equivalent to the status returned by the method IloCplex::getCplexStatus.

This method returns the MIP cutoff value being used during the MIP optimization. In a minimization problem, all nodes are pruned that have an optimal solution value of the continuous relaxation that is larger than the current cutoff value. The cutoff is updated with the incumbent. If the invoking IloCplex object is an LP or QP, +IloInfinity or -IloInfinity is returned, depending on the optimization sense.

These method return the default setting for the parameter parameter.

This method returns the current delete mode of the invoking IloCplex object.

This method returns the branch direction previously assigned to variable var with method IloCplex::setDirection or IloCplex::setDirections. If no direction has been assigned, IloCplex::BranchGlobal will be returned.

This method returns the branch directions previously assigned to variables listed in var with the method setDirection or setDirections. When the function returns, dir[i] will contain the branch direction assigned for variables var[i]. If no branch direction has been assigned to var[i], dir[i] will be set to IloCplex::BranchGlobal.

This method returns the diverging variable or constraint, in a case where the primal Simplex algorithm has determined the problem to be infeasible. The returned extractable is either an IloNumVar or an IloConstraint object extracted to the invoking IloCplex optimizer; it is of type IloNumVar if the diverging column corresponds to a variable, or of type IloConstraint if the diverging column corresponds to the slack variable of a constraint.

Given the index of a diversity filter associated with the solution pool, this method returns the lower cutoff value of that filter.

Accesses the reference values declared in a diversity filter specified by its index in the solution pool.

Given the index of a diversity filter associated with the solution pool, this method returns the lower cutoff value of that filter.

Accesses the weights declared in a diversity filter specified by its index in the solution pool.

This method returns the dual value associated with the constraint range in the current solution of the invoking algorithm.

This method puts the dual values associated with the ranges in the array con into the array val. Array val is resized to the same size as array con, and val[i] will contain the dual value for constraint con[i].

Accesses the index of a filter specified by its name.

Given the index of a filter associated with the solution pool, this method returns the type of that filter.

Accesses the variables of a diversity filter specified by its index.

This method returns the node number where the current incumbent was found. If the invoking IloCplex object is an LP or a QP, 0 (zero) is returned.

This method puts the infeasibility values of the integer variables in array var for the current solution into the array infeas. The infeasibility value is 0 (zero) if the variable bounds are satisfied. If the infeasibility value is negative, it specifies the amount by which the lower bound of the variable must be changed; if the value is positive, it specifies the amount by which the upper bound of the variable must be changed. This method does not check for integer infeasibility. The array infeas is automatically resized to the same length as array var, and infeas[i] will contain the infeasibility value for variable var[i]. This method returns the maximum absolute infeasibility value over all integer variables in var.

This method puts the infeasibility values of the numeric variables in array var for the current solution into the array infeas. The infeasibility value is 0 (zero) if the variable bounds are satisfied. If the infeasibility value is negative, it specifies the amount by which the lower bound of the variable must be changed; if the value is positive, it specifies the amount by which the upper bound of the variable must be changed. The array infeas is automatically resized to the same length as array var, and infeas[i] will contain the infeasibility value for variable var[i]. This method returns the maximum absolute infeasibility value over all numeric variables in var.

This method puts the infeasibility values of the current solution for the constraints specified by the array con into the array infeas. The infeasibility value is 0 (zero) if the constraint is satisfied. More specifically, for a range with finite lower bound and upper bound, if the infeasibility value is negative, it specifies the amount by which the lower bound of the range must be changed; if the value is positive, it specifies the amount by which the upper bound of the range must be changed. For a more general constraint such as IloOr, IloAnd, IloSOS1, or IloSOS2, the infeasibility value returned is the maximal absolute infeasibility value over all range constraints and variables created by the extraction of the queried constraint. Array infeas is resized to the same size as array range, and infeas[i] will contain the infeasibility value for constraint range[i]. This method returns the maximum absolute infeasibility value over all constraints in con.

This method returns the infeasibility of the integer variable var in the current solution. The infeasibility value returned is 0 (zero) if the variable bounds are satisfied. If the infeasibility value is negative, it specifies the amount by which the lower bound of the variable must be changed; if the value is positive, it specifies the amount by which the upper bound of the variable must be changed. This method does not check for integer infeasibility.

This method returns the infeasibility of the numeric variable var in the current solution. The infeasibility value returned is 0 (zero) if the variable bounds are satisfied. If the infeasibility value is negative, it specifies the amount by which the lower bound of the variable must be changed; if the value is positive, it specifies the amount by which the upper bound of the variable must be changed.

This method returns the infeasibility of the current solution for the constraint code. The infeasibility value is 0 (zero) if the constraint is satisfied. More specifically, for a range with finite lower bound and upper bound, if the infeasibility value is negative, it specifies the amount by which the lower bound of the range must be changed; if the value is positive, it specifies the amount by which the upper bound of the range must be changed. For a more general constraint such as IloOr, IloAnd, IloSOS1, or IloSOS2, the infeasibility value returned is the maximal absolute infeasibility value over all range constraints and variables created by the extraction of the queried constraint.

These method return the maximum allowed value for the parameter parameter.

These method return the minimum allowed value for the parameter parameter.

This method returns the number of nonzeros extracted to the constraint matrix A of the invoking algorithm.

This method returns the number of quadratic constraints extracted from the active model for the invoking algorithm. This number may be different from the total number of constraints in the active model because linear constraints are not accounted for in this function.

This method returns the number of SOSs extracted for the invoking algorithm. There may be differences in the number returned by this function and the number of numeric variables (that is, instances of the class IloNumVar, and so forth) in the model that is extracted because piecewise linear functions are extracted as a set of SOSs.

This method returns the number of barrier iterations from the last solve.

This method returns the number of binary variables in the matrix representation of the active model in the invoking IloCplex object.

This method returns the number of columns extracted for the invoking algorithm. There may be differences in the number returned by this function and the number of object of type IloNumVar and its subclasses in the model that is extracted. This is because automatic transformation of nonlinear constraints and expressions may introduce new variables.

This method returns the number of dual exchange operations in the crossover of the last call to method solve or solveFixed, if barrier with crossover has been used for solving an LP or QP.

This method returns the number of dual push operations in the crossover of the last call to IloCplex::solve or IloCplex::solveFixed, if barrier with crossover was used for solving an LP or QP.

This method returns the number of primal exchange operations in the crossover of the last call of method IloCplex::solve or IloCplex::solveFixed, if barrier with crossover was used for solving an LP of QP.

This method returns the number of primal push operations in the crossover of the last call of method IloCplex::solve or IloCplex::solveFixed, if barrier with crossover was used for solving an LP or QP.

This method returns the number of cuts of the specified type in use at the end of the previous mixed integer optimization. If the invoking IloCplex object is not a MIP, it returns 0.

This method returns the number of dual superbasic variables in the current solution of the invoking IloCplex object.

Returns the number of filters currently associated with the solution pool.

This method returns the number of integer variables in the matrix representation of the active model in the invoking IloCplex object.

This method returns the number of iterations that occurred during the last call to the method IloCplex::solve in the invoking algorithm.

This method returns the number of 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.

If a simplex method was used for solving continuous model, this method returns the number of iterations in phase 1 of the last call to IloCplex::solve or IloCplex::solveFixed.

This method returns the number of primal superbasic variables in the current solution of the invoking IloCplex object.

This method returns the number of rows extracted for the invoking algorithm. There may be differences in the number returned by this function and the number of 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 semi-continuous 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 in order to achieve primal feasibility.

This method performs objecitve sensitivity analysis for the variables specified in array vars. When this method returns lower[i] and upper[i] will contain the lowest and highest value the objective function coefficient for variable vars[i] can assume without affecting the optimality of the solution. The arrays lower and upper will be resized to the size of array vars. If any of the information is not requested, 0 (zero) can be passed for the corresponding array parameter.

This member function returns the numeric value of the objective function for the solution pool member indexed by soln. The soln argument may be omitted or given a value of -1 in order to access the current solution.

This method returns the instance of IloObjective that has been extracted to the invoking instance of IloCplex. If no objective has been extracted, an empty handle is returned.

If you need only the current value of the objective, for example to use in a callback, consider one of these methods instead:

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

This method returns the current setting of parameter in the invoking algorithm.

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

Returns a parameter set corresponding to the present parameter state.

If the method fails, an exception of type IloException, or one of its derived classes, is thrown.

This method returns query branch priorities previously assigned to variables listed in var with the method setPriority or setPriorities. When the function returns, pri[i] will contain the priority value assigned for variables var[i]. If no priority has been assigned to var[i], pri[i] will contain 0 (zero).

This method returns the priority previously assigned to the variable var with the method setPriority or setPriorities. It returns 0 (zero) if no priority has been assigned.

These methods return the requested quality measure for a member of the solution pool. The soln argument may be given a value of -1 to return the quality meausre for the current solution.

Some quality measures are related to a variable or a constraint. For example, IloCplex::MaxPrimalInfeas is related to the variable or constraint where the maximum infeasibility (bound violation) occurs. If this information is also requested, pointers to instances of IloNumVar or IloConstraint may be passed as optional arguments specifying where the relevant variable or range will be written. However, if the constraint has been implicitly created (for example, because of automatic linearization), a null handle will be returned for these arguments.

These methods return the requested quality measure.

Some quality measures are related to a variable or a constraint. For example, IloCplex::MaxPrimalInfeas is related to the variable or constraint where the maximum infeasibility (bound violation) occurs. If this information is also requested, pointers to instances of IloNumVar or IloConstraint may be passed as optional arguments specifying where the relevant variable or range will be written. However, if the constraint has been implicitly created (for example, because of automatic linearization), a null handle will be returned for these arguments.

This method performs righthand side sensitivity analysis for the constraints specified in array cons. The constraints must be of the form cons[i]: expr[i] rel rhs[i]. When this method returns lower[i] and upper[i] will contain the lowest and highest value rhs[i] can assume without affecting the optimality of the solution. The arrays lower and upper will be resized to the size of array cons. If any of the information is not requested, 0 (zero) can be passed for the corresponding array parameter.

Accesses the coefficients (that is, the weights) declared in the range filter specified by its index.

Given the index of a range filter associated with the solution pool, this method returns the lower bound of that filter.

Given the index of a range filter associated with the solution pool, this method returns the upper bound of that filter.

This method performs sensistivity analysis for the upper and lower bounds of the ranged constraints passed in the array con. When the method returns, lblower[i] and lbupper[i] will contain, respecitively, the lowest and the highest value that the lower bound of constraint con[i] can assume without affecting the optimality of the solution. Similarly, ublower[i] and ubupper[i] will contain, respectively, the lowest and the highest value that the upper bound of the constraint con[i] can assume without affecting the optimality of the solution. The arrays lblower, lbupper, ublower, and ubupper will be resized to the size of array con. If any of the information is not requested, 0 can be passed for the corresponding array parameter.

This method returns an unbounded direction (also known as a ray) corresponding to the present basis for an LP that has been determined to be an unbounded problem. CPLEX puts the the variables of the extracted model into the array vars and it puts the corresponding values of the unbounded direction into the array vals.

This method returns the reduced cost associated with var in the invoking algorithm.

This method returns the reduced cost associated with var in the invoking algorithm.

This method puts the reduced costs associated with the numeric variables of the array var into the array val. The array val is automatically resized to the same length as array var, and val[i] will contain the reduced cost for variable var[i].

This method puts the reduced costs associated with the variables in the array var into the array val. Array val is resized to the same size as array var, and val[i] will contain the reduced cost for variable var[i].

This method returns the slack value associated with the constraint range for a solution of the invoking algorithm. For a range with finite lower and upper bounds, the slack value consists of the difference between the expression of the range and its lower bound. The current solution is used if the soln argument is omitted or given the value -1; otherwise, the solution pool member indexed by soln is used.

This method puts the slack values associated with the constraints specified by the array con into the array val. For a ranged constraint with finite lower and upper bounds, the slack value consists of the difference between the expression in the range and its lower bound. The current solution is used if the soln argument is omitted or given the value -1; otherwise, the solution pool member indexed by soln is used. Array val is resized to the same size as array con, and val[i] will contain the slack value for constraint con[i].

Computes the mean of the objective values of the solutions currently in the solution pool.

Accesses the number of solutions that have been replaced according to the solution pool replacement strategy.

Accesses the number of solutions currently in the solution pool.

This method returns the status of the invoking algorithm.

For its ILOG CPLEX status, see the method IloCplex::getCplexStatus.

See also the topic Interpreting Solution Quality in the ILOG CPLEX User's Manual for more information about a status associated with infeasibility or unboundedness.

This method returns the type of the algorithm type that was used to solve most recent node of a MIP in the case of termination because of an error during mixed integer optimization.

This method returns the value of the objective using the solution pool member indexed by soln. The soln argument may be omitted or given a value of -1 in order to access the current solution.

This method returns the value of the expression using the solution pool member indexed by soln. The soln argument may be omitted or given a value of -1 in order to access the current solution.

This method returns the value from the solution pool member indexed by soln for the integer variable specified by var. The soln argument may be omitted or given a value of -1 in order to access the current solution.

This method returns the value from the solution pool member indexed by soln for the numeric variable specified by var. The soln argument may be omitted or given a value of -1 in order to access the current solution.

This method puts the values from the solution pool member indexed by soln for the integer variables specified by the array var into the array val. The soln argument may be omitted or given a value of -1 in order to access the current solution. Array val is resized to the same size as array var, and val[i] will contain the solution value for variable var[i].

This method puts the values from the solution pool member indexed by soln for the numeric variables specified by the array var into the array val. The soln argument may be omitted or given a value of -1 in order to access the current solution. Array val is resized to the same size as array var, and val[i] will contain the solution value for variable var[i].

This method puts the values from the solution pool member indexed by soln for the numeric variables specified by the array var into the array val. The soln argument may be omitted or given a value of -1 in order to access the current solution. Array val is resized to the same size as array var, and val[i] will contain the solution value for variable var[i].

This method puts the solution values of the integer variables specified by the array var into the array val. Array val is resized to the same size as array var, and val[i] will contain the solution value for variable var[i].

This method puts the solution values of the integer variables specified by the array var into the array val. Array val is resized to the same size as array var, and val[i] will contain the solution value for variable var[i].

This member function accepts an array of variables vars and puts the corresponding values into the array vals; the corresponding values come from the current solution of the invoking algorithm. The array vals must be a clean, empty array when you pass it to this member function.

If there are no values to return for vars, this member function raises an error. On platforms that support C++ exceptions, when exceptions are enabled, this member function throws the exception NotExtractedException in such a case.

This method puts the solution values of the numeric variables specified by the array var into the array val. Array val is resized to the same size as array var, and val[i] will contain the solution value for variable var[i].

This method returns a string specifying the version of IloCplex.

This method reads a model from the file specified by filename into model. Typically model will be an empty, unextracted model on entry to this method. The invoking IloCplex object is not affected when you call this method unless model is its extracted model; follow this method with a call to IloCplex::extract in order to extract the imported model to the invoking IloCplex object.

When this methods reads a file, new modeling objects, as required by the input file, are created and added to any existing modeling objects in the model passed as an argument. Note that any previous modeling objects in model are not removed; precede the call to importModel with explicit calls to IloModel::remove if you need to remove them.

This method is a simplification of the method importModel that does not provide arrays to return SOSs. This method is easier to use in the case where you are dealing with continuous models because in such a case you already know that no SOS will be present.

This method reads a model from the file specified by filename into model. Typically model will be an empty, unextracted model on entry to this method. The invoking IloCplex object is not affected when you call this method unless model is its extracted model; follow this method with a call to IloCplex::extract in order to extract the imported model to the invoking IloCplex object.

When this methods reads a file, new modeling objects, as required by the input file, are created and added to any existing modeling objects in the model passed as an argument. Note that any previous modeling objects in model are not removed; precede the call to importModel with explicit calls to IloModel::remove if you need to remove them.

As this method reads a model from a file, it places the objective it has read in obj, the variables it has read in the array vars, * the ranges it has read in the array rngs; and the Special Ordered Sets (SOS) it has read in the arrays sos1 and sos2.

The format of the file is determined by the extension of the file name. The following extensions are recognized on most platforms:

• .sav
• .mps
• .lp
• .sav.gz (if gzip is properly installed)
• .mps.gz (if gzip is properly installed)
• .lp.gz (if gzip is properly installed)

Microsoft Windows does not support gzipped files for this API.

This method returns IloTrue if a dual feasible solution is recorded in the invoking IloCplex object and can be queried.

This method returns IloTrue if the invoking algorithm has extracted a model that is a MIP (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 ILOG CPLEX User's Manual.

This method returns IloTrue if the invoking algorithm has extracted a model that has quadratic objective function terms. Otherwise, it returns IloFalse.

The method populate generates multiple solutions to a mixed integer programming (MIP) model. In other words, it populates the solution pool of the model currently extracted by the invoking IloCplex object. Like the method solve, this method returns IloTrue if it finds a solution (not necessarily an optimal solution).

The algorithm that populates the solution pool works in two phases:

In the first phase, it solves the model to optimality (or some stopping criterion set by the user) while it sets up a branch and cut tree for the second phase.

In the second phase, it generates multiple solutions by using the information computed and stored in the first phase and by continuing to explore the tree.

The amount of preparation in the first phase and the intensity of exploration in the second phase are controlled by the solution pool intensity parameter SolnPoolIntensity.

Optimality is not a stopping criterion for the populate method. Even if the optimality gap is zero, this method will still try to find alternative solutions. The stopping criteria for populate are these:

• Popoulate 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.
• 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 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 ILOG CPLEX File Formats.

Reads solution pool filters from a file in FLT format and copies the filters into an instance of IloCplex. This format is documented in the reference manual ILOG CPLEX File Formats.

Reads the SOL file denoted by name and copies the MIP start information into the invoking IloCplex object. The parameter AdvInd must be turned on (its default: 1 (one)) in order for the MIP start information to be used to with a subsequent MIP optimization.

By convention, the file extension is .sol. The SOL file format is documented in the ILOG CPLEX File Formats Reference Manual and in the stylesheet solution.xsl and schema solution.xsd in the include directory of the product. Examples of its use appear in the examples distributed with the product and in the ILOG CPLEX User's Manual.

This method reads a priority order from a file in ORD format into the invoking IloCplex object. The names in the ORD file must match the names in the active model. The priority order will be associated with the model. The parameter MipOrdInd must be nonzero for the next invocation of the method IloCplex::solve to take the order into account.

By convention, the file extension is .ord. The ORD file format is documented in the reference manual ILOG CPLEX File Formats.

Reads parameters and their settings from the file specified by name and applies them to the invoking IloCplex object. Parameters not listed in the parameter file will be reset to their default setting.

By convention, the file extension is .prm. The PRM file format is documented in the reference manual ILOG CPLEX File Formats.

Reads a solution from the SOL file denoted by name and copies this information into a CPLEX problem object. This routine is able to initiate a crossover from the barrier solution, to restart the simplex method with an advanced basis or to specify variable values for a MIP start. The parameter AdvInd must set to a nonzero value (such as its default setting: 1 (one)) in order for the solution file to take effect with the method solve.

By convention, the file extension is .sol. The SOL file format is documented in the ILOG CPLEX File Format Reference Manual and in the stylesheet solution.xsl and schema solution.xsd in the include directory of the product. Examples of its use appear in the examples distributed with the product and in the ILOG CPLEX User's Manual.

The method refineConflict identifies a minimal conflict for the infeasibility of the current model or for a subset of the constraints of the current model. Since the conflict is minimal, removal of any one of these constraints will remove that particular cause for infeasibility. There may be other conflicts in the model; consequently, repair of a given conflict does not guarantee feasibility of the remaining model.

The constraints among which to look for a conflict are passed to this method through the argument cons. Only constraints directly added to the model can be specified.

Constraints may also be grouped by IloAnd. If any constraint in a group participates in the conflict, the entire group is determined to do so. No further detail about the constraints within that group is returned.

Groups or constraints may be assigned preference. A group or constraint with a higher preference is more likely to be included in the conflict. However, no guarantee is made when a minimal conflict is returned that other conflicts containing groups or constraints with higher preference do not exist.

When this method returns, the conflict can be queried with the methods getConflict. The method writeConflict can write a file in LP format containing the conflict.

This method removes the aborter object abort from the invoking IloCplex object.

This method uses the array cstats to set the basis status of the variables in the array var; it uses the array rstats to set the basis status of the ranges in the array con.

This method resets all CPLEX parameters to their default values.

This method sets the delete mode in the invoking IloCplex object to mode.

This method sets the preferred branching direction for variable var to dir. This setting will cause CPLEX first to explore the branch specified by dir after branching on variable var.

This method sets the preferred branching direction for each variable in the array var to the corresponding value in the array dir. This will cause CPLEX first to explore the branch specified by dir[i] after branching on variable var[i].

This method sets parameter to value in the invoking algorithm. See the ILOG CPLEX User's Manual for more detailed information about parameters and for examples of their use.

Sets the parameter state using a parameter set.

If the method fails, an exception of type IloException, or one of its derived classes, is thrown.

This method sets the priority order for all variables in the array var to the corresponding value in the array pri. During branching, integer variables with higher priorities are given preference over integer variables with lower priorities. Further, variables that have priority assigned to them are given preference over variables that do not. Priorities must be nonnegative integers. By default, the priority of a variable without a user-assigned priority is 0 (zero). The parameter MIPOrdInd by default specifies that user-assigned priority orders should be taken into account. When MIPOrdInd is reset to its nondefault value 0 (zero), CPLEX ignores user-assigned priorities. To remove user-assigned priority from a variable, see the method IloCplex::delPriorities. For more detail about how priorities are applied, see the topic Issuing Priority Orders in the ILOG CPLEX User's Manual.

This method sets the priority order for the variable var to pri. During branching, integer variables with higher priorities are given preference over integer variables with lower priorities. Further, variables that have priority assigned to them are given preference over variables that do not. Priorities must be nonnegative integers. By default, the priority of a variable without a user-assigned priority is 0 (zero). The parameter MIPOrdInd by default specifies that user-assigned priority orders should be taken into account. When MIPOrdInd is reset to its nondefault value 0 (zero), CPLEX ignores user-assigned priorities. To remove user-assigned priority from a variable, see the method IloCplex::delPriority. For more detail about how priorities are applied, see the topic Issuing Priority Orders in the ILOG CPLEX User's Manual.

This method allows a user to specify a starting point for the following invocation of the method IloCplex::solve.

For all variables in var, x[i] specifies the starting value for the variable var[i]. Similarly, dj[i] specifies the starting reduced cost for variable var[i]. For all ranged constraints specified in rng, slack[i] specifies the starting slack value for rng[i]. Similarly, pi[i] specifies the starting dual value for rng[i].

Zero can be passed for any individual parameter. However, the arrays x and var must be the same length. Likewise, pi and rng must be the same length.

In other words, you must provide starting values for either the primal or dual variables x and pi. If you provide values for dj, then you must provide the corresponding values for x. If you provide values for slack, then you must provide the corresponding values for pi.

This information is exploited at the next call to IloCplex::solve, to construct a starting point for the algorithm, provided that the AdvInd parameter is set to a value greater than or equal to one. In particular, if the extracted model is an LP, and the root algorithm is dual or primal, the information is used to construct a starting basis for the simplex method for the original model, if AdvInd is set to 1 (one). If AdvInd is set to 2, the information is used to construct a starting basis for the presolved model.

If the extracted model is a MIP, only x values can be used. Values may be specified for any subset of the integer and continuous variables in the model, either through a single invocation of setVectors, or incrementally through multiple calls. When optimization commences or resumes, CPLEX will attempt to find a feasible MIP solution that is compatible with the set of specified x values. When start values are not provided for all integer variables, CPLEX tries to extend the partial solution to a complete solution by solving a MIP on the unspecified variables. The parameter SubMIPNodeLim controls the amount of effort CPLEX expends in trying to solve this secondary MIP. If CPLEX finds a complete feasible solution, that solution becomes the incumbent. If the specified values are infeasible, they are retained for use in a subsequent solution repair heuristic. The amount of effort spent in this heuristic can be controlled by the parameter RepairTries.

This method initializes the goal stack of the root node with goal before starting the branch & cut search. The search tree will be defined by the execute method of goal and its subgoals. See the concept Goals and the nested class IloCplex::GoalI for more information.

This method solves the model currently extracted to the invoking IloCplex object. The method returns IloTrue if it finds a solution (not necessarily an optimal one).

After the invoking algorithm has solved the extracted MIP model to a feasible (but not necessarily optimal) solution as a MIP, this member function solves the relaxation of the model obtained by fixing all the integer variables of the extracted MIP to the values of a solution. The current solution is used if the soln argument is omitted or given the value -1; otherwise, the solution pool member indexed by soln is used.

The method tuneParam tunes the parameters of an instance of IloCplex for improved optimizer performance on the current model, or a set of models if the filename argument is used. Tuning is carried out by CPLEX making a number of trial runs with a variety parameter settings. Parameters and associated values which should not be changed by the tuning process are specified in the parameter set fixedset.

After tuneParam has finished, the IloCplex parameters will be set to the tuned and fixed settings which can be queried or written to a file. There will not be a solution to the current model.

The parameter TuningRepeat specifies how many problem variations for CPLEX to try while tuning when tuning the current model. Using a number of variations can give more robust results when tuning is applied to a single model.

Note that the tuning evaluation measure is meaningful only when TuningRepeat is larger than one or when a set of models is being tuned.

A few of the parameter settings control the tuning process. They are specified in the table below; other parameter settings are ignored.

All callbacks, except the tuning callback, will be ignored. Tuning will monitor the method abort and terminate when an abort has been issued.

IloInt value specifying the completion status of the tuning. The values returned are from the enumeration TuningStatus.

This method instructs the invoking IloCplex object to use cb as a callback. If a callback of the same type as cb is already being used by the invoking IloCplex object, the previously used callback will be overridden. If the callback object cb is already being used by another IloCplex object, a copy of cb will be used instead. A handle to the callback that is installed in the invoking IloCplex object is returned. See IloCplex::CallbackI for a discussion of how to implement callbacks.

This method instructs the invoking IloCplex object to use the aborter object abort to control termination of its solving and tuning methods. If an aborter is already being used by the invoking IloCplex object, the previously used aborter will be overridden. A handle to the aborter that is installed in the invoking IloCplex object is returned.

Writes the current simplex basis to the file specified by name.

By convention, the file extension is .bas. The BAS file format is documented in the reference manual ILOG CPLEX File Formats.

Writes a conflict file named filename.

Writes filters from the invoking model to a file in FLT format. This format is documented in the reference manual ILOG CPLEX File Formats.

Writes MIP start information to the file denoted by name. The MIP start written corresponds to the current solution if the soln parameter is omitted; otherwise, it corresponds to the solution pool member indexed by soln.

By convention, the file extension is .mst. The MST file format is documented in the reference manual ILOG CPLEX File Formats as well as the stylesheet solution.xsl and schema solution.xsd found in the include directory of the product.

Writes MIP start information with all members of the solution pool to the file denoted by name.

By convention, the file extension is .mst. The MST file format is documented in the reference manual ILOG CPLEX File Formats as well as the stylesheet solution.xsl and schema solution.xsd found in the include directory of the product.

Writes a priority order to the file filename.

If a priority order has been associated with the CPLEX problem object, or the parameter MipOrdType is nonzero, this method writes the priority order into the specified file.

By convention, the file extension is .ord. The ORD file format is documented in the reference manual ILOG CPLEX File Formats.

Writes the parameter name and its current setting into the file specified by name for all the CPLEX parameters that are not currently set at their default.

By convention, the file extension is .prm. The PRM file format is documented in the reference manual ILOG CPLEX File Formats.

Writes a solution file for the current problem into the file specified by name. The solution written is the current solution if the soln parameter is omitted; otherwise, it is the solution pool member indexed by soln.

By convention, the file extension is .sol. The SOL file format is documented in the reference manual ILOG CPLEX File Formats as well as the stylesheet solution.xsl and schema solution.xsd found in the include directory of the product.

Writes a solution file with all members of the solution pool for the current problem into the file specified by name.

By convention, the file extension is .sol. The SOL file format is documented in the reference manual ILOG CPLEX File Formats as well as the stylesheet solution.xsl and schema solution.xsd found in the include directory of the product.

The enumeration IloCplex::Algorithm lists the algorithms available in CPLEX to solve continuous models as controlled by the parameters IloCplex::RootAlg and IloCplex::NodeAlg.

These values are also returned by IloCplex::getAlgorithm to specify the algorithm used to generate the current solution. The values FeasOpt and MIP are returned by IloCplex::getAlgorithm but should not be used with IloCplex::RootAlg nor with IloCplex::NodeAlg.

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

The enumeration IloCplex::BoolParam lists the parameters of CPLEX that require Boolean values. Boolean values are also known in certain contexts as binary values or as zero-one (0-1) values. Use these values with the methods that accept Boolean parameters: IloCplex::getParam and IloCplex::setParam.

See the reference manual ILOG CPLEX Parameters for more information about these parameters. Also see the user's manual for examples of their use.

The enumeration IloCplex::BranchDirection lists values that can be used for specifying branch directions either with the branch direction parameter IloCplex::BrDir or with the methods IloCplex::setDirection and IloCplex::setDirections. The branch direction specifies which direction to explore first after branching on one variable.

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

This enumeration lists the values that tell the status of a constraint or bound with respect to a conflict.

• ConflictPossibleMember
• ConflictMember

The value ConflictExcluded is internal, undocumented, not available to users.

The enumeration IloCplex::CplexStatus lists values that the status of an IloCplex algorithm can assume. The methods IloCplex::getCplexStatus and IloCplex::getCplexSubStatus access the status values, providing information about what the algorithm learned about the active model in the most recent invocation of the method solve or feasOpt. The status may also tell why the algorithm terminated.

See the group optim.cplex.solutionstatus in the Callable Library Reference Manual, where they are listed in alphabetic order, or the topic Interpreting Solution Status Codes in the Overview of the APIs, where they are listed in numeric order, for more information about these values. Also see the ILOG CPLEX User's Manual for examples of their use.

See also the enumeration IloAlgorithm::Status in the ILOG CPLEX Reference Manual.

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

This enumeration lists the possible settings for the delete mode of IloCplex as controlled by the method IloCplex::setDeleteMode and queried by the method IloCplex::getDeleteMode.

• IloCplex::LeaveBasis

With the default setting IloCplex::LeaveBasis, an existing basis will remain unchanged if variables or constraints are removed from the loaded LP model. This choice generally renders the basis unusable for a restart when CPLEX is solving the modified LP and the advanced indicator (parameter IloCplex::AdvInd) is set to IloTrue.

• IloCplex::FixBasis

In contrast, with delete mode set to IloCplex::FixBasis, the invoking object will do basis pivots in order to maintain a valid basis when variables or constraints are removed. This choice makes the delete operation more computation-intensive, but may give a better starting point for reoptimization after modification of the extracted model.

If no basis is present in the invoking object, the setting of the delete mode has no effect.

The enumeration IloCplex::DualPricing lists values that the dual pricing parameter IloCplex:DPriInd can assume in IloCplex for use with the dual simplex algorithm. Use these values with the method IloCplex::setParam(IloCplex::DPriInd, value) when you set the dual pricing indicator.

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

IloCplex is the class for the CPLEX algorithms in ILOG CPLEX. The enumeration IloCplex::IntParam lists the parameters of CPLEX that require integer values. Use these values with the methods IloCplex::getParam and IloCplex::setParam.

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

The enumeration IloCplex::MIPEmphasisType lists the values that the MIP emphasis parameter IloCplex::MIPEmphasis can assume in an instance of IloCplex for use when it is solving MIP problems. Use these values with the method IloCplex::setParam(IloCplex::MIPEmphasis, value) when you set MIP emphasis.

With the default setting of IloCplex::MIPEmphasisBalance, IloCplex tries to compute the branch & cut algorithm in such a way as to find a proven optimal solution quickly. For a discussion about various settings, refer to the ILOG CPLEX User's Manual.

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

The enumeration IloCplex::MIPsearch lists values that the dynamic search parameter IloCplex::MIPSearch can assume in IloCplex. Use these values with the method IloCplex::setParam(IloCplex::MIPSearch, value).

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about this parameter. Also see the user's manual for examples of their use.

The enumeration IloCplex::NodeSelect lists values that the parameter IloCplex::NodeSel can assume in IloCplex. Use these values with the method IloCplex::setParam(IloCplex::NodeSel, value).

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

The enumeration IloCplex::NumParam lists the parameters of CPLEX that require numeric values. Use these values with the member functions: IloCplex::getParam and IloCplex::setParam.

See the reference manual ILOG CPLEX Parameters information about these parameters. Also see the ILOG CPLEX User's Manual for more examples of their use.

The enumeration IloCplex::ParallelMode lists values that the parallel mode parameter IloCplex::ParallelMode can assume in IloCplex for use on multiprocessor or multithread platforms, if your application is licensed for parallel optimization. Use these values with the method IloCplex::setParam(IloCplex::ParallelMode, value).

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about this parameter. Also see the user's manual for examples of their use.

The enumeration IloCplex::PrimalPricing lists values that the primal pricing parameter IloCplex::PPriInd can assume in IloCplex for use with the primal simplex algorithm. Use these values with the method IloCplex::setParam(IloCplex::PPriInd, value) when setting the primal pricing indicator.

See the reference manual ILGO CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

The enumeration IloCplex::Quality lists types of quality measures that can be queried for a solution with method IloCplex::getQuality.

See the group optim.cplex.solutionquality in the ILOG CPLEX Callable Library Reference Manual for more information about these values. Also see the ILOG CPLEX User's Manual for examples of their use.

The enumeration Relaxation lists the values that can be taken by the parameter FeasOptMode. This parameter controls several aspects of how the method feasOpt performs its relaxation.

The method feasOpt works in two phases. In its first phase, it attempts to find a minimum-penalty relaxation of a given infeasible model. If you want feasOpt to stop after this first phase, choose a value with Min in its symbolic name. If you want feasOpt to continue beyond its first phase to find a solution that is optimal with respect to the original objective function, subject to the constraint that the penalty of the relaxation must not exceed the value found in the first phase, then choose a value with Opt in its symbolic name.

In both phases, the suffixes Sum, Inf, and Quad specify the relaxation metric:

• Sum tells feasOpt to mimimize the weighted sum of the required relaxations of bounds and constraints according to the formula penalty = sum (penalty_i times relaxation_amount_i)
• Inf tells feasOpt to minimize the weighted number of bounds and constraints that are relaxed according to the formula penalty = sum (penalty_i times relaxation_indicator_i)
• Quad tells feasOpt to mimimize the weighted sum of the squares of required relaxations of bounds and constraints according to the formula penalty = sum (penalty_i times relaxation_amount_i times relaxation_amount_i)

Weights are determined by the preference values you provide as input to the method feasOpt.

When IloAnd is used to group constraints as input to feasOpt, the relaxation penalty is computed on groups instead of on individual constraints. For example, all constraints in a group can be relaxed for a total penalty of one unit under the various Inf metrics.

The enumeration IloCplex::StringParam lists the parameters of CPLEX that require a character string as a value. Use these values with the methods IloCplex::getParam and IloCplex::setParam.

See the reference manual ILOG CPLEX Parameter Table and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

This enumeration lists the values that are returned by tuneParam.

• TuningComplete
• TuningAbort
• TuningTimeLim

The value ConflictExcluded is internal, undocumented, not available to users.

The enumeration IloCplex::VariableSelect lists values that the parameter IloCplex::VarSel can assume in IloCplex. Use these values with the method IloCplex::setParam(IloCplex::VarSel, value).

See the reference manual ILOG CPLEX Parameters and the ILOG CPLEX User's Manual for more information about these parameters. Also see the user's manual for examples of their use.

This type defines an array-type for IloCplex::BasisStatus. The fully qualified name of a basis status array is IloCplex::BasisStatusArray.

This type defines an array-type for IloCplex::BranchDirection. The fully qualified name of a branch direction array is IloCplex::BranchDirectionArray.

This type defines an array-type for IloCplex::ConflictStatus.

IloAlgorithm is the base class of algorithms in Concert Technology, and IloAlgorithm::Status is an enumeration limited in scope to the class IloAlgorithm. The member function IloAlgorithm::getStatus returns a status showing information about the current model and the solution.

Unknown specifies that the algorithm has no information about the solution of the model.

Feasible specifies that the algorithm found a feasible solution (that is, an assignment of values to variables that satisfies the constraints of the model, though it may not necessarily be optimal). The member functions IloAlgorithm::getValue access this feasible solution.

Optimal specifies that the algorithm found an optimal solution (that is, an assignment of values to variables that satisfies all the constraints of the model and that is proved optimal with respect to the objective of the model). The member functions IloAlgorithm::getValue access this optimal solution.

Infeasible specifies that the algorithm proved the model infeasible; that is, it is not possible to find an assignment of values to variables satisfying all the constraints in the model.

Unbounded specifies that the algorithm proved the model unbounded.

InfeasibleOrUnbounded specifies that the model is infeasible or unbounded.

Error specifies that an error occurred and, on platforms that support exceptions, that an exception has been thrown.

See Also the enumeration IloCplex::Status in the ILOG CPLEX Reference Manual for status specific to the CPLEX algorithms.