IloCplex derives from the class IloAlgorithm. Use it to solve LP (linear programming), QP (programs with quadratic terms in the objective function), QCP (quadratically constrained programming), and MIP (mixed integer programming) Mathematical Programming models. 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. Perhaps the most important one is IloCplex::RootAlg, which determines the algorithm used to solve the root relaxation. Possible settings, as defined in 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 indicating 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 indicates 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 retrive 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.

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 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 model variables 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 indicating 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 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.

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.

This method writes the model that has been extracted to the invoking algorithm in the file filename. The name of the file must include an extension that ILOG CPLEX recognizes as a file format for a model. Supported formats are .sav, .lp and .mps. See the reference manual ILOG CPLEX File Formats for more detail and the ILOG CPLEX User's Manual for additional information about file formats.

Attempts to find a feasible relaxation of an active model by relaxing the bounds of the constraints specified in rngs as specified in rnglb and rngub. This is a special version of the method feasOpt(IloRangeArray, IloNumArray, IloNumArray, IloNumVarArray, IloNumArray, IloNumArray, IloBool)

The method returns IloTrue if a feasible relaxation is found along with a solution for it.

Attempts to find a feasible relaxation of an active model by relaxing the bounds of the variables specified in vars as specified in varlb and varub. This is a special version of the method feasOpt(IloRangeArray, IloNumArray, IloNumArray, IloNumVarArray, IloNumArray, IloNumArray, IloBool)

The method returns IloTrue if a feasible relaxation is found, along with a solution for it.

The method feasOpt computes a minimal relaxation of the bounds of variables and constraints that make the active model feasible. For each bound, the user may specify a preferred value indicating how much a relaxation of that bound is acceptable. A negative or 0 (zero) value indicates that the corresponding bound must not be relaxed. Typically, values greater than or equal to 1 (one) should be used. The preference value for relaxing the lower and upper bound of constraint rngs[i] must be provided in rnglb[i] and rngub[i], respectively. Similarly, the preference value for relaxing the lower and upper bound of constraint vars[i] must be provided in varlb[i] and varub[i], respectively.

If enough variables or constraints were allowed to be relaxed, the function will return IloTrue and IloFalse otherwise. In case of success, the routine returns with suggested relaxed values that would make the active model feasible. These bounds are chosen in such a way that the relaxation is minimal in the sense that the sum of (relaxation amount)/(preference value) over all variables and constraints is minimized.

The bounds that make the model feasible are returned in the same arrays as the preference values are passed into this method. That is, after successfull termination of the method feasOpt, rnglb[i] and rngub[i] contain the lower and upper bound to use for the constraint rngs[i] in order to make the model feasible. Similarly, varlb[i] and varub[i] contain the lower and upper bound to use for variable vars[i] in order to make the model feasible. If bounds were not allowed to be relaxed or did not need to be relaxed in order to make the model feasible, the original bounds are returned.

The active model is not changed by this method.

If feasOpt successfully finds a relaxation that made the model feasible, it also installs a solution vector that would be feasible, had the model been relaxed as specified with the returned relaxed bounds. This solution can be queried with the conventional query methods.

When the optind parameter is IloTrue, this method also tries to find the optimal solution of the minimally relaxed model. That is, it finds the solution that is optimal with respect to the original objective function, but requires only minimal relaxation. With the default setting of the parameter optind the original objective funciton is not evaluated.

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.

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.

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

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

This method is used to access 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::setDirectionor 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.

This method returns the dual value associated with 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].

The method getFormulationBigValue returns the current setting of the large value used to set a bound on otherwise unbounded expressions appearing in logical constraints. Such a value is sometimes referred to as Big M.

By default, this value is 1e6. You can change that default setting by means of the method setFormulationBigValue.

In order to transform a logical constraint automatically into an equivalent MIP representation, it is sometimes necessary to set a finite upper or lower bound on an otherwise unbounded term. When such a bound does not already exist, CPLEX uses the value returned by this method for that purpose. For example, consider the following disjunction (that is, or-statement):

 (x == 1) || (x ≥ 2)
 

It is necessary to have an upper bound on x. If the upper bound on x is IloInfinity, CPLEX will use the value returned by getFormulationBigValue in the transformed representation of logical formulations.

This method returns the epsilon value that is used to model strict relations. In order to model a strict inequality, such as x < b in a MIP, IloCplex uses x ≤ b - eps as a surrogate, where eps is the value returned by this method.

If an LP model has been proven to be infeasible, this method can compute an irreducibly inconsistent set (IIS). The variables and range constraints in the IIS are returned in the arrays var and rng, respectively.

For each variable var[i], cstat[i] gives the IIS status for that variable in the IIS, where the meaning of cstat[i] is:

IloCplex::Lower the lower bound of the variable participates in the IIS

IloCplex::Upper the upper bound of the variable participates in the IIS

IloCplex::Both both variable bounds participate in the IIS

Similarly, for each range constraint rng[i], rstat[i] gives the IIS status for that constraint in the IIS, where the meaning of rstat[i] is:

IloCplex::Lower the lower bound of the constraint participates in the IIS

IloCplex::Upper the upper bound of the constraint participates in the IIS

IloCplex::Both range is equality constraint and participates in the IIS.

The statuses IloCplex::Lower and IloCplex::Upper are needed only for constraints that are truly ranged, that is, where both bounds are finite but different.

By definition, if any of the bounds or constraints participating in the IIS is removed, the IIS becomes feasible. However, this does not mean that the model also becomes feasible by doing so. Instead, there may be yet another source of infeasiblity in the model.

If the LP has been proven infeasible but no basis is available, IloCplex automatically invokes the primal simplex optimizer to compute the basis needed for the IIS-finding algorithm.

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

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 non-zeros 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 IloNumVar, etc. in the model that is extracted. This is because piecewise linear functions are extracted to a set of SOS.

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 clique cuts that have been added to the problem. If the invoking IloCplex object is not a MIP, 0 is returned.

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 non-linear constraints and expressions may introduce new variables.

This method returns the number of cover cuts that have been added to the problem. If the invoking IloCplex object is not a MIP, 0 is returned.

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 dual superbasic variables in the current solution of the invoking IloCplex object.

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 non-linear 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 method queries the way piecewise linear expressions are represented when CPLEX automatically transforms them during extraction.

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.

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 method 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 range constraint where the maximum infeasibility (bound violation) occurs. If this information is also requested, pointers to IloNumVar or IloConstraint objects may be passed for the optional parameters where the relevant variable or range will be written.

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 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 constraint range in the current 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.

This method puts the slack values associated with the constraints indicated 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. Array val is resized to the same size as array con, and val[i] will contain the slack value for constraint con[i].

This method returns the status of the invoking algorithm. For its ILOG CPLEX status, see the method IloCplex::getCplexStatus.

This method returns the algorithm type that was used to solve most recent node of a MIP.

This method puts the solution values of the integer variables indicated 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 indicated 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 indicated 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 indicating the version of IloCplex.

This method reads a model from the file indicated by filename into model. The invoking IloCplex object is not affected when calling this method unless model is its active model.

This method is an simplification of the importModel method that does not provide arrays to return SOS's. This method is more easy to use in the case that you are dealing with continuous models, because in this case you already know that no SOS's will be present.

This method reads a model from the file indicated by filename into model. Note, that the invoking IloCplex object is not affected when calling this method unless model is its active model. 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 it has read in the arrays sos1 and sos2.

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.

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.

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 indicated 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 the MST file indicated by name and copies the MIP start information into the invoking IloCplex object. The parameter MIPStart must be turned on in order for the MIP start information to be used to with a subsequent MIP optimization. The default value for the parameter is off.

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

This method reads a priority order from an 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 MipOrdType 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 indicated 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 branch-and-bound progress information from a prior run, contained in the TRE file indicated by name, into a CPLEX problem object. The parameter AdvInd must set to a nonzero value be on (e.g. its default value), in order for the tree to be used for starting a subsequent optimization.

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

Reads a barrier solution from the VEC file indicated by name and copies this information into a CPLEX problem object. This routine is typically used to initiate a crossover from the barrier solution. The parameter AdvInd must set to a nonzero value (e.g. its default setting) in order for the vector file to take effect for starting a crossover at the next invokation of a simplex algorithm with method solve.

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

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 indicated 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 to first explore the branch indicated by dir[i] after branching on variable var[i].

This method sets the large value used to set a bound on any otherwise unbounded expressions appearing in logical constraints. Such a value is sometimes referred to as Big M. By default, it is set to 1e6.

The method getFormulationBigValue returns the current setting of the large value.

In order to transform a logical constraint autmatically into an equivalent MIP formulation, it is sometimes necessary to set a finite upper or lower bound on an otherwise unbounded term. When such a bound does not already exist, CPLEX uses the value set by this method for that purpose. For example, consider the following disjunction (that is, an or-statement):

 (x == 1) || (x ≥ 2)
 

It is necessary to have an upper bound on x. If the upper bound on x is IloInfinity, CPLEX will use the value controlled by this method in the transformed representation of logical formulations.

This method sets the epsilon value that is used to model strict relations. In order to model a strict inequality such as x < b in a MIP, IloCplex uses x ≤ b - eps as a surrogate, where eps is the value controlled by this method.

This method allows you to control the way piecewise linear expressions are represented when CPLEX automatically transforms them during extraction.

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.

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 values assigned to them are given preference over variables that don't. Priorities must be positive integers.

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 values assigned to them are given preference over variables that don't. Priorities must be positive integers.

This method allows a user to specify a starting point for the following invocation of the IloCplex::solve method. Zero can be passed for any of the parameters. However, if x or dj is not zero, var must not be zero either. Similarly, if slack or pi is not zero, rng must not be zero either.

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

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, and a value must be specified for all variables of type ILOINT. If the provided values are compatible with an integer feasible solution, that solution becomes the incumbent for the next search; otherwise, the starting information is ignored. The parameter IloCplex::MIPStart must be turned on (that is, set to IloTrue) for the starting point to take effect.

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 the current solution.

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.

Writes the current Simplex basis to the file indicated by name.

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

Writes MIP start information to a file indicated by name

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

This method 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, or a MIP feasible solution exists, this method writes the priority order into the indicated 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 indicated 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 in text format for the current problem to the file indicated by name.

Writes the branch-and-bound tree from the last optimization to a file speified by name in TRE format.

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

This method writes solution information from a barrier optimization (without crossover) into the file indicated by name. By convention, the file extension is .vec. The VEC file format is documented in the reference manual ILOG CPLEX File Formats.

The enumeration IloCplex::Algorithm lists the available algorithms in CPLEX to solve continuous models as controlled by the parameters IloCplex::RootAlg and 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.

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.

The enumeration IloCplex::CplexStatus lists values that the status of an IloCplex algorithm can assume. These values can be accessed via the method IloCplex::getCplexStatus and IloCplex::getCplexSubStatus and provide information about what the algorithm learned about the active model in the most recent invocation of the method solve or feasOpt. It 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 Concert Technology Reference Manual.

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

The enumeration IloCplex::IISStatus lists values that indicate the status that variables and constraints can assume in an irreducibly inconsistent set (IIS) in IloCplex.

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::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 PWLFormulation defines symbolic constants that represent various ways of representing piecewise linear expressions in a MIP. Which of these ways to use is controlled by the method setPWLFormulation. All of these formulations have the same theoretical strength. However, in practice, the effectiveness for solving a particular model may vary dramatically, depending on the formulation being used. These are the various formulations:

• Disjunctive, the default, represents a tight formulation of the logical disjunction underlying the function that is being made piecewise linear.
• LambdaSOS represents a transformation of a piecewise linear expression in which a variable is created for each breakpoint, and a special ordered set of type 2 (SOS2) is added for those variables.
• LambdaBin represents a transformation of a piecewise linear expression similar to LambdaSOS in which, however, the SOS2 constraint is replaced by a set of linear constraints defined over additional binary variables.
• Delta indicates a cumulative formulation.

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

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::IISStatus. The fully qualified name of a basis status array is IloCplex::IISStatusArray.