### Table of Contents

- Introduction
- Usage
- Summary of XPRESS Options
- General LP / MIP / QP Options
- Hardware Related Options
- Presolve Options
- Scaling Options
- LP Options
- QP Options
- Newton-barrier Options
- MIP Options
- MIP Cuts Options
- MIP Heuristics Options
- MIP Solution Pool Options
- General NLP / MINLP Options
- NLP Presolve Options
- NLP Augmentation and Linearization Options
- NLP Barrier Options
- NLP Penalty Options
- NLP Step Bounds Options
- NLP Variable Update Options
- NLP Termination Options
- NLP Multistart Options
- NLP Derivative Options
- NLP Log Options
- MINLP Options

- Detailed Descriptions of XPRESS Options
- Helpful Hints
- Setting up a GAMS/XPRESS-Link license

# Introduction

The GAMS/XPRESS solver is based on the XPRESS Optimization Subroutine Library, and runs only in conjunction with the GAMS modeling system. GAMS/XPRESS (also simply referred to as XPRESS) is a versatile, high-performance optimization system. The system integrates:

- a powerful simplex-based LP solver.
- a MIP module with cut generation for integer programming problems.
- a barrier module implementing a state-of-the-art interior point algorithm for very large LP problems.
- a sequential linear programming solver (SLP) for (mixed-integer) nonlinear programs NLP, CNS and MINLP.

The GAMS/XPRESS solver is installed automatically with your GAMS system. Without a license, it will run in student or demonstration mode (i.e. it will solve small models only). If your GAMS license includes XPRESS, there is no size or algorithm restriction imposed by the license, nor is any separate licensing procedure required. XPRESS SLP requires a GAMS license that includes XPRESS for continuous nonlinear models or for mixed-integer nonlinear models. In order to use XPRESS Knitro, the GAMS license must include GAMS/Knitro in addition to the XPRESS license for (mixed-integer) nonlinear models.

# Usage

To explicitly request that a model be solved with XPRESS, insert the statement

option LP = xpress; { or MIP, RMIP, NLP, CNS, DNLP, RMINLP, MINLP, QCP, MIQCP, or RMIQCP }

somewhere before the solve statement. If XPRESS has been selected as the default solver (e.g. during GAMS installation) for the model type in question, the above statement is not necessary.

The standard GAMS options (e.g. iterlim, optcr) can be used to control XPRESS. For more details, see section Controlling a Solver via GAMS Options. Please note however that - apart from reslim - these are only used for linear and quadratic programs and not the nonlinear solves. Termination conditions for XPRESS SLP can be set in SLP Termination Options.

In addition, XPRESS-specific options can be specified by using a solver option file. While the content of an option file is solver-specific, the details of how to create an option file and instruct the solver to use it are not. This topic is covered in section The Solver Options File.

An example of a valid XPRESS option file is:

* sample XPRESS options file algorithm simplex presolve 0 IterLim 50000

In general this is enough knowledge to solve your models. In some cases you may want to use some of the XPRESS options to gain further performance improvements or for other reasons.

## Linear and Quadratic Programming

The options advBasis, lpFlags, defaultAlg, basisOut, mpsOutputFile, reform, reRun, and reslim control the behavior of the GAMS/XPRESS link. The options crash, lpIterlimit, presolve, scaling, threads, and trace set XPRESS library control variables, and can be used to fine-tune XPRESS. See section General LP / MIP / QP Options for more details of XPRESS general options.

### LP

See section LP Options for more details of XPRESS library control variables which can be used to fine-tune the XPRESS LP solver.

### MIP

In some cases, the branch-and-bound MIP algorithm will stop with a proven optimal solution or when unboundedness or (integer) infeasibility is detected. In most cases, however, the global search is stopped through one of the generic GAMS options:

- iterlim (on the cumulative pivot count) or reslim (in seconds of CPU time),
- optca & optcr (stopping criteria based on gap between best integer solution found and best possible) or
- nodlim (on the total number of nodes allowed in the B&B tree).

It is also possible to set the maxNode and maxMipSol options to stop the global search: see section MIP Options for XPRESS control variables for MIP. The options loadMipSol, mipCleanup, mipTrace, mipTraceNode, and mipTraceTime control the behavior of the GAMS/XPRESS link on MIP models. The other options in section MIP Options set XPRESS library control variables, and can be used to fine-tune the XPRESS MIP solver.

### MIP Solution Pool

Typically, XPRESS finds a number of integer feasible points during its global search, but only the final solution is available. The MIP solution pool capability makes it possible to store multiple integer feasible points (aka solutions) for later processing. The MIP solution pool operates in one of two modes: by default `(solnpoolPop = 1)`

the global search is not altered, but with `(solnpoolPop = 2)`

a selected set (potentially all) of the integer feasible solutions are enumerated.

The MIP enumeration proceeds until all MIP solutions are enumerated or cut off, or until a user-defined limit is reached. Whenever a new solution is generated by the enumerator, it is presented to the solution pool manager. If there is room in the pool, the new solution is added. If the pool is full, a * cull round * is performed to select a number of solutions to be thrown out - these solutions can be those stored in the pool and/or the new solution. Solutions can be selected for culling based on their MIP objective value and/or the overall diversity of the solutions in the pool. If neither is chosen, a default choice is made to throw out one solution based on objective values. Whenever a solution is thrown out based on its MIP objective, the enumeration space is pruned based on the cutoff defined by this objective value.

By default, the capacity of the pool is set very large, as is the number of cull rounds to perform, so selecting only `solnpoolPop = 2`

will result in full enumeration. However, many different strategies can be executed by setting the solution pool options. For example, to choose the \(N\)-best solutions, simply set the solution pool capacity to \(N\). When the pool is full, new solutions will force a cull round, and the default is to reject one solution based on its objective and update the cutoff accordingly. To generate all solutions with an objective as good as \(X\), leave the pool capacity set at a high level but set the cutoff to \(X\) using the `mipabscutoff`

option. To return the \(N\)-first solutions, set the solution pool capacity to \(N\) and `solnpoolCullRounds = 0`

: as soon as the pool is full the enumeration will stop on the cull round limit.

A number of other strategies for controlling the solution pool behavior are possible by combining different options. Several working examples are provided in the GAMS Test Library in models `xpress03.gms`

, `xpress04.gms`

, and `xpress05.gms`

.

See section MIP Solution Pool Options for XPRESS control variables for MIP Solution Pool.

### Newton-Barrier

The barrier method is invoked by default for quadratic problems, and can be selected for linear models by using one of the options

algorithm barrier defaultalg 4

The barrier method is likely to use more memory than the simplex method. No warm start is done, so if an advanced basis exists, you may not wish to use the barrier solver.

See section Newton-barrier Options for XPRESS control variables for the Newton-Barrier method.

## Nonlinear Programming

XPRESS can solve nonlinear programs of type NLP, CNS and MINLP (and its relaxed version) using the sequential linear programming solver XPRESS SLP or the interior-point / sequential quadratic programming solver XPRESS Knitro. Convexity is not required, but for non-convex programs XPRESS will in general find local optimal solutions only. The XPRESS multistart can be used to increase the likelihood of finding a good solution by starting from many different initial points.

XPRESS SLP solves nonlinear programs by successive linearization of the nonlinearities. These linearizations, which can be controlled by the options in NLP Augmentation and Linearization Options, are solved by the LP or QCP solver. Therefore, XPRESS user options for LP or QCP are also relevant when solving nonlinear programs. Note, that the NLP Presolve is independent from the LP presolve that is executed in each XPRESS SLP iteration.

### Termination

In most cases it is sufficient to control the termination of XPRESS SLP by xslp_iterLimit, reslim, xslp_validationTarget_k and xslp_ValidationTarget_r as the latter two automatically control the other XPRESS SLP convergence measures on default. More experienced users may want to modify the other convergence measures, which group into:

- Strict convergence: Describes the numerical behaviour of convergence in the formal, mathematical sense. User options: xslp_cTol, xslp_aTol_a, xslp_aTol_r.
- Extended convergence: Measures the quality of the linearization, including the effect of changes to the nonlinear terms that contribute to a variable in the linearization: User options: xslp_mTol_a, xslp_mTol_r, xslp_iTol_a, xslp_iTol_r, xslp_sTol_a, xslp_sTol_r.

When each variable has converged in one of the above cases, XPRESS SLP terminates based on the following stopping criteria:

- Baseline static objective convergence measure that compares changes in the objective over a given number of iterations relative to the average objective value. User options: xslp_vCount, xslp_vLimit, xslp_vTol_a, xslp_vTol_r.
- Static objective convergence measure that is applied when there are no unconverged variables in active constraints. User options: slpOCount, xslp_oTol_a, xslp_oTol_r.
- Static objective convergence measure that is applied when a pratical solution (all variables have converged and there are no active step bounds) has been found. User options: xslp_xCount, xslp_xLimit, xslp_xTol_a, xslp_xTol_r.
- Extended convergence continuation that is applied when a practical solution has been found. It checks if it is worth continuing. User options: xslp_wCount, xslp_wTol_a, xslp_wTol_r.

The user option slpConvergenceOps enables/disables the different convergence measures and stopping conditions.

### Output

The output or logging can be controlled by the NLP Log Options. The default XPRESS SLP iteration output shows:

`It`

: Iteration number.`LP`

: The LP status of the linearization (`O`

: optimal;`I`

: infeasible;`U`

: unbounded;`X`

: interrupted)`NetObj`

: The net objective of the SLP iteration.`ValObj`

: The original objective function value.`ErrorSum`

: Sum of the error delta variables. A measure of infeasibility.`ErrorCost`

: The value of the weighted error delta variables in the objective. A measure of the effort needed to push the model towards feasibility.`Validate`

: Relative feasibility measure (calculated only if convergence is likely)`KKT`

: Relative optimality measure (calculated only if convergence is likely)`Unconv`

: The number of SLP variables that are not converged.`Ext`

: The number of SLP variables that are converged, but only by extended criteria.`Action`

: Special actions (`0`

: failed line search;`B`

: enforcing step bounds;`E`

: some infeasible rows were enforced;`G`

: global variables were fixed;`P`

: solution needed polishing, postsolve instability;`P!`

: solution polishing failed;`R`

: penalty error vectors removed;`V`

: feasibility validation induces further iterations;`K`

: optimality validation induces further iterations)`T`

: Time.

### XPRESS Knitro

Nonlinear programs can also be solved by XPRESS Knitro using the option xslp_solver. In this case, the nonlinear program is passed to Knitro after the NLP Presolve. Setting xslp_solver to auto will enable XPRESS to choose XPRESS SLP or XPRESS Knitro automatically based on the problem instance. XPRESS Knitro options can be specified in a Knitro solver option file, which needs to be selected in knitroOptFile. Note, that XPRESS Knitro does not support all Knitro options. Specified but unsupported options trigger a warning and are then ignored.

For more information about this nonlinear programming solver, see the GAMS/Knitro documentation.

# Summary of XPRESS Options

## General LP / MIP / QP Options

Option | Description | Default |
---|---|---|

advBasis | Use advanced basis provided by GAMS | `auto` |

algorithm | Choose between simplex and barrier algorithm | `simplex` |

basisOut | Directs optimizer to output an MPS basis file | `none` |

clamping | Allows for the adjustment of returned solution values such that they are always within bounds | `0` |

clamping_dual | Adjust primal slack values to always be within constraint bounds | `0` |

clamping_primal | Adjust primal solution to always be within primal bounds | `0` |

clamping_rdj | Adjust reduced costs to always be within dual bounds implied by the primal solution | `0` |

clamping_slacks | Adjust dual solution to always be within the dual bounds implied by the slacks | `0` |

cpuTime | How time should be measured when timings are reported in the log and when checking against time limits | `0` |

globalBoundingBox | If a nonlinear problem cannot be solved due to appearing unbounded, it can automatically be regularized by the application of a bounding box on the variables | `1e+06` |

inputTol | Tolerance on input values elements | `0` |

ioTimeout | Maximum number of seconds to wait for an I/O operation before it is cancelled | `30` |

lpIterLimit | Maximum number of iterations that will be performed by primal simplex or dual simplex before the optimization process terminates | `maxint` |

lpRefineIterLimit | Simplex iteration limit the solution refiner can spend in attempting to increase the accuracy of an LP solution | `auto` |

maxScaleFactor | Determines the maximum scaling factor that can be applied during scaling | `64` |

mpsNameLength | Maximum length of MPS names in characters | `0` |

mpsOutputFile | Name of MPS output file | `none` |

numericalEmphasis | How much emphasis to place on numerical stability instead of solve speed | `auto` |

outputControls | Toggles the printing of all control settings at the beginning of the search | `1` |

outputLog | Controls the level of output produced by the Optimizer during optimization | `1` |

outputTol | Zero tolerance on print values | `1e-05` |

qextractalg | quadratic extraction algorithm in GAMS interface | `0` |

randomSeed | Sets the initial seed to use for the pseudo-random number generator in the Optimizer | `1` |

refineOps | Specifies when the solution refiner should be executed to reduce solution infeasibilities | `19` |

refineOps_iterativeRefiner | Apply the iterative refiner to refine the solution | `0` |

refineOps_lpOptimal | Run the solution refiner on an optimal solution of a continuous problem | `1` |

refineOps_lpPresolve | Run the solution refiner on an optimal solution before postsolve on a continuous problem | `1` |

refineOps_mipFixGlobals | Refine MIP solutions such that rounding them keeps the problem feasible when reoptimized | `0` |

refineOps_mipFixGlobalsTarget | Attempt to refine MIP solutions such that rounding them keeps the problem feasible when reoptimized, but accept integers solutions even if refinement fails | `0` |

refineOps_mipNodeLp | Run the solution refiner on each node of the MIP search | `0` |

refineOps_mipSolution | Run the solution refiner when a new solution is found during a tree search | `1` |

refineOps_refinerPrecision | Use higher precision in the iterative refinement | `0` |

refineOps_refinerUseDual | If set, the iterative refiner will use the dual simplex algorithm | `0` |

refineOps_refinerUsePrimal | If set, the iterative refiner will use the primal simplex algorithm | `0` |

reform | Substitute out objective var and equ when possible | `1` |

reRun | Rerun with primal simplex when not optimal/feasible | `0` |

reslim | Overrides GAMS reslim option | |

solTimeLimit | Maximum time in seconds that the Optimizer will run a MIP solve before it terminates, given that a solution has been found | `1e+20` |

timeLimit | Maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time | `1e+20` |

trace | Display the infeasibility diagnosis during presolve | `0` |

writePrtSol | Directs optimizer to output a "printsol" file | `0` |

## Hardware Related Options

Option | Description | Default |
---|---|---|

barCores | If set to a positive integer it determines the number of physical CPU cores assumed to be present in the system by the barrier algorithm | `auto` |

barOrderThreads | If set to a positive integer it determines the number of concurrent threads for the sparse matrix ordering algorithm in the Newton-barrier method | `auto` |

barThreads | If set to a positive integer it determines the number of threads implemented to run the Newton-barrier algorithm | `auto` |

concurrentThreads | Determines the number of threads used by the concurrent solver | `auto` |

coresPerCpu | Used to override the detected value of the number of cores on a CPU | `auto` |

cpuPlatform | Newton Barrier: Selects the AMD, Intel x86 or ARM vectorization instruction set that Barrier should run optimized code for | `-1` |

crossoverThreads | Determines the maximum number of threads that parallel crossover is allowed to use | `auto` |

dualThreads | Determines the maximum number of threads that dual simplex is allowed to use | `auto` |

heurThreads | Branch and Bound: Number of threads to dedicate to running heuristics on the root node | `0` |

maxMemoryHard | Sets the maximum amount of memory in megabytes the optimizer should allocate | `unlimited` |

maxMemorySoft | When resourceStrategy is enabled, this control sets the maximum amount of memory in megabytes the optimizer targets to allocate | `unlimited` |

mipThreads | If set to a positive integer it determines the number of threads implemented to run the parallel MIP code | `auto` |

relaxTreeMemoryLimit | When the memory used by the branch and bound search tree exceeds the target specified by the treeMemoryLimit control, the optimizer will try to reduce this by writing nodes to the tree file | `0.1` |

resourceStrategy | Controls whether the optimizer is allowed to make nondeterministic decisions if memory is running low in an effort to preserve memory and finish the solve | `0` |

threads | Default number of threads used during optimization | `1` |

treeCompression | When writing nodes to the global file, the optimizer can try to use data-compression techniques to reduce the size of the tree file on disk | `2` |

treeMemoryLimit | Soft limit, in megabytes, for the amount of memory to use in storing the branch and bound search tree | `auto` |

treeMemorySavingTarget | When the memory used by the branch-and-bound search tree exceeds the limit specified by the treeMemoryLimit control, the optimizer will try to save memory by writing lower-rated sections of the tree to the tree file | `0.4` |

## Presolve Options

Option | Description | Default |
---|---|---|

barPresolveOps | Newton barrier: Controls the Newton-Barrier specific presolve operations | `0` |

barPresolveOps_extra | Extra effort is spent in barrier specific presolve | `0` |

barPresolveOps_full | Do full matrix eliminations (reduce matrix size) | `0` |

barPresolveOps_standard | Use standard presolve | `0` |

dualize | Whether presolve should form the dual of the problem | `auto` |

dualizeOps | Bit-vector control for adjusting the behavior when a problem is dualized | `1` |

elimFillin | Amount of fill-in allowed when performing an elimination in presolve | `10` |

elimTol | Markowitz tolerance for the elimination phase of the presolve | `0.001` |

indLinBigM | During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough | `100000` |

indPreLinBigM | During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough | `100` |

lpFolding | Simplex and barrier: Whether to fold an LP problem before solving it | `auto` |

maxImpliedBound | Presolve: When tighter bounds are calculated during MIP preprocessing, only bounds whose absolute value are smaller than maxImpliedBound will be applied to the problem | `1e+08` |

mipPresolve | Branch and Bound: Type of integer processing to be performed | `-1` |

mipPresolve_allowChangeBounds | If node preprocessing is allowed to change bounds on continuous columns | `1` |

mipPresolve_allowTreeRestart | [Unused] This bit is no longer used to control restarts | `1` |

mipPresolve_dualReductions | Dual reductions will be performed at each node | `1` |

mipPresolve_globalCoefTightening | Allow global (non-bound) tightening of the problem during the tree search | `1` |

mipPresolve_logicPreprocessing | Primal reductions will be performed at each node | `1` |

mipPresolve_objBasedReductions | Objective function will be used to find reductions at each node | `1` |

mipPresolve_reducedCostFixing | Reduced cost fixing will be performed at each node | `1` |

mipPresolve_symmetryReductions | Allow that symmetry is used to presolve the node problem | `1` |

preAnalyticCenter | Determines if analytic centers should be computed and used for variable fixing and the generation of alternative reduced costs (-1: Auto 0: Off, 1: Fixing, 2: Redcost, 3: Both) | `auto` |

preBasisRed | Determines if a lattice basis reduction algorithm should be attempted as part of presolve | `0` |

preBndRedCone | Determines if second order cone constraints should be used for inferring bound reductions on variables when solving a MIP | `auto` |

preBndRedQuad | Determines if convex quadratic contraints should be used for inferring bound reductions on variables when solving a MIP | `auto` |

preCliqueStrategy | Determines how much effort to spend on clique covers in presolve | `-1` |

preCoefElim | Presolve: Specifies whether the optimizer should attempt to recombine constraints in order to reduce the number of non zero coefficients when presolving a mixed integer problem | `2` |

preComponents | Presolve: Determines whether small independent components should be detected and solved as individual subproblems during root node processing | `auto` |

preComponentsEffort | Presolve: Adjusts the overall effort for the independent component presolver | `1` |

preConeDecomp | Presolve: Decompose regular and rotated cones with more than two elements and apply Outer Approximation on the resulting components | `auto` |

preConfiguration | MIP Presolve: Determines whether binary rows with only few repeating coefficients should be reformulated | `auto` |

preConvertSeparable | Presolve: Reformulate problem with non-diagonal quadratic objective and/or constraints as diagonal quadratic or second-order conic constraints | `auto` |

preDomCol | Presolve: Determines the level of dominated column removal reductions to perform when presolving a mixed integer problem | `auto` |

preDomRow | Presolve: Determines the level of dominated row removal reductions to perform when presolving a problem | `auto` |

preDupRow | Presolve: Determines the type of duplicate rows to look for and eliminate when presolving a problem | `auto` |

preElimQuad | Presolve: Allows for elimination of quadratic variables via doubleton rows | `auto` |

preFolding | Presolve: Determines if a folding procedure should be used to aggregate continuous columns in an equitable partition | `auto` |

preImplications | Presolve: Determines whether to use implication structures to remove redundant rows | `auto` |

preLinDep | Presolve: Determines whether to check for and remove linearly dependent equality constraints when presolving a problem | `auto` |

preObjCutDetect | Presolve: Determines whether to check for constraints that are parallel or near parallel to a linear objective function, and which can safely be removed | `1` |

preProbing | Presolve: Amount of probing to perform on binary variables during presolve | `auto` |

presolve | Determines whether presolving should be performed prior to starting the main algorithm | `1` |

presolveMaxGrow | Limit on how much the number of non-zero coefficients is allowed to grow during presolve, specified as a ratio of the number of non-zero coefficients in the original problem | `0.1` |

presolveOps | Specifies the operations which are performed during the presolve | `511` |

presolveOps_dualReductions | Dual reductions | `1` |

presolveOps_duplicateColRemoval | Duplicate column removal | `1` |

presolveOps_duplicateRowRemoval | Duplicate row removal | `1` |

presolveOps_forcingRowRemoval | Forcing row removal | `1` |

presolveOps_linDependRowRemoval | Linearly dependant row removal | `0` |

presolveOps_noAdvIpReductions | No advanced IP reductions | `0` |

presolveOps_noGlobalDomainChange | No semi-continuous variable detection | `0` |

presolveOps_noIntVarAndSosDetect | No integer variable and SOS detection | `0` |

presolveOps_noIntVarEliminations | No eliminations on integers | `0` |

presolveOps_noIpReductions | No IP reductions | `0` |

presolveOps_redundantRowRemoval | Redundant row removal | `1` |

presolveOps_singletonColRemoval | Singleton column removal | `1` |

presolveOps_singletonRowRemoval | Singleton row removal | `1` |

presolveOps_strongDualReductions | Strong dual reductions | `1` |

presolveOps_variableEliminations | Variable eliminations | `1` |

presolvePasses | Number of reduction rounds to be performed in presolve | `1` |

rootPresolve | Determines if presolving should be performed on the problem after the tree search has finished with root cutting and heuristics | `auto` |

siftPresolveOps | Determines the presolve operations for solving the subproblems during the sifting algorithm | `-1` |

## Scaling Options

Option | Description | Default |
---|---|---|

autoScaling | Whether the Optimizer should automatically select between different scaling algorithms | `auto` |

barFreeScale | Defines how the barrier algorithm scales free variables | `1e-06` |

barObjScale | Defines how the barrier scales the objective | `auto` |

barRhsScale | Defines how the barrier scales the right hand side | `auto` |

objScaleFactor | Custom objective scaling factor, expressed as a power of 2 | `0` |

scaling | Determines how the Optimizer will rescale a model internally before optimization | `163` |

scaling_beforePresolve | Scale before presolve | `0` |

scaling_bigM | Treat big-M rows as normal rows | `0` |

scaling_byMaxElemNotGeoMean | 0: scale by geometric mean | `1` |

scaling_colScaling | Column scaling | `1` |

scaling_curtisReid | Curtis-Reid | `0` |

scaling_disableGlobalObjScaling | Do not apply automatic objective scaling | `0` |

scaling_ignoreQuadRowPart | Exclude the quadratic part of constraint when calculating scaling factors | `0` |

scaling_maximum | Maximum | `0` |

scaling_noAggressiveQScaling | Disable aggressive quadratic scaling | `0` |

scaling_noScalingColsDown | Do not scale columns down | `0` |

scaling_noScalingRowsUp | Do not scale rows up | `0` |

scaling_rhsScaling | RHS scaling | `0` |

scaling_rowScaling | Row scaling | `1` |

scaling_rowScalingAgain | Row scaling again | `0` |

scaling_simplexObjScaling | Scale objective function for the simplex method | `1` |

scaling_slackScaling | Enable explicit linear slack scaling | `0` |

## LP Options

Option | Description | Default |
---|---|---|

algAfterNetwork | Algorithm to be used for the clean up step after the network simplex solver | `auto` |

autoPerturb | Simplex: Indicates whether automatic perturbation is performed | `auto` |

bigM | Infeasibility penalty used if the "Big M" method is implemented | `auto` |

bigMMethod | Simplex: Whether to use the "Big M" method, or the standard phase I (achieving feasibility) and phase II (achieving optimality) | `1` |

crash | Simplex: Determines the type of crash used when the algorithm begins | `2` |

defaultAlg | Selects the algorithm that will be used to solve the LP | `auto` |

dualGradient | Simplex: Dual simplex pricing method | `auto` |

dualPerturb | Factor by which the problem will be perturbed prior to optimization by dual simplex | `auto` |

dualStrategy | Bit-vector control specifies the dual simplex strategy | `1` |

etaTol | Tolerance on eta elements | `1e-13` |

feasTol | Determines when a solution is treated as feasible | `1e-06` |

feasTolPerturb | Determines how much a feasible primal basic solution is allowed to be perturbed when performing basis changes | `1e-06` |

feasTolTarget | Target feasibility tolerance for the solution refiner | `0` |

forceParallelDual | Dual simplex: Specifies whether the dual simplex solver should always use the parallel simplex algorithm | `0` |

invertFreq | Simplex: Frequency with which the basis will be inverted | `auto` |

invertMin | Simplex: Minimum number of iterations between full inversions of the basis matrix | `3` |

lpFlags | Bit-vector control which defines the algorithm for solving an LP problem or the initial LP relaxation of a MIP problem | `0` |

lpFlags_barrier | Use the barrier method | `0` |

lpFlags_dual | Use the dual simplex method | `0` |

lpFlags_network | Use the network simplex method | `0` |

lpFlags_primal | Use the primal simplex method | `0` |

lpLog | Simplex: Frequency at which the simplex log is printed | `100` |

lpLogDelay | Time interval between two LP log lines | `1` |

lpLogStyle | Simplex: Style of the simplex log | `1` |

markowitzTol | Markowitz tolerance used for the factorization of the basis matrix | `0.01` |

matrixTol | Zero tolerance on matrix elements | `1e-09` |

netStallLimit | Limit the number of degenerate pivots of the network simplex algorithm, before switching to either primal or dual simplex, depending on algAfterNetwork | `auto` |

optimalityTol | Simplex: Zero tolerance for reduced costs | `1e-06` |

optimalityTolTarget | Target optimality tolerance for the solution refiner | `0` |

penalty | Minimum absolute penalty variable coefficient | `auto` |

pivotTol | Simplex: Zero tolerance for matrix elements | `1e-09` |

ppFactor | Partial pricing candidate list sizing parameter | `1` |

pricingAlg | Simplex: Determines the primal simplex pricing method | `auto` |

primalOps | Primal simplex: Allows fine tuning the variable selection in the primal simplex solver | `-1` |

primalPerturb | Factor by which the problem will be perturbed prior to optimization by primal simplex | `auto` |

primalUnshift | Determines whether primal is allowed to call dual to unshift | `0` |

relPivotTol | Simplex: Minimum size of pivot element relative to largest element in column | `1e-06` |

sifting | Determines whether to enable sifting algorithm with the dual simplex method | `auto` |

siftPasses | Determines how quickly we allow to grow the worker problems during the sifting algorithm | `4` |

siftSwitch | Determines which algorithm to use for solving the subproblems during sifting | `-1` |

## QP Options

Option | Description | Default |
---|---|---|

eigenvalueTol | Quadratic matrix is considered not to be positive semi-definite, if its smallest eigenvalue is smaller than the negative of this value | `1e-06` |

ifCheckConvexity | Determines if the convexity of the problem is checked before optimization | `1` |

qSimplexOps | Controls the behavior of the quadratic simplex solvers | `0` |

quadraticUnshift | Determines whether an extra solution purification step is called after a solution found by the quadratic simplex (either primal or dual) | `auto` |

repairIndefInitEq | Controls if the optimizer should make indefinite quadratic matrices positive definite when it is possible | `1` |

## Newton-barrier Options

Option | Description | Default |
---|---|---|

algAfterCrossover | Algorithm to be used for the final clean up step after the crossover | `auto` |

barAlg | Determines which barrier algorithm is to be used to solve the problem | `auto` |

barCrash | Newton barrier: Determines the type of crash used for the crossover | `4` |

barDualStop | Newton barrier: Convergence parameter, representing the tolerance for dual infeasibilities | `auto` |

barFailIterLimit | Newton barrier: Maximum number of consecutive iterations that fail to improve the solution in the barrier algorithm | `auto` |

barGapStop | Newton barrier: Convergence parameter, representing the tolerance for the relative duality gap | `auto` |

barGapTarget | Newton barrier: Target tolerance for the relative duality gap | `auto` |

barIndefLimit | Newton Barrier: Limits the number of consecutive indefinite barrier iterations that will be performed | `15` |

barIterLimit | Newton barrier: Maximum number of iterations | `500` |

barKernel | Newton barrier: Defines how centrality is weighted in the barrier algorithm | `0` |

barObjPerturb | Defines how the barrier perturbs the objective | `1e-06` |

barOrder | Newton barrier: Controls the Cholesky factorization in the Newton-Barrier | `auto` |

barOutput | Newton barrier: Level of solution output provided | `1` |

barPerturb | Newton barrier: In numerically challenging cases it is often advantageous to apply perturbations on the KKT system to improve its numerical properties | `0` |

barPrimalStop | Newton barrier: Convergence parameter, indicating the tolerance for primal infeasibilities | `auto` |

barRefIter | Newton barrier: After terminating the barrier algorithm, further refinement steps can be performed | `0` |

barRegularize | Determines how the barrier algorithm applies regularization on the KKT system | `-1` |

barStart | Newton barrier: Controls the computation of the starting point for the barrier algorithm | `auto` |

barStepStop | Newton barrier: Convergence parameter, representing the minimal step size | `1e-16` |

choleskyAlg | Newton barrier: Type of Cholesky factorization used | `auto` |

choleskyTol | Newton barrier: Tolerance for pivot elements in the Cholesky decomposition of the normal equations coefficient matrix, computed at each iteration of the barrier algorithm | `1e-15` |

crossover | Newton barrier: Determines whether the barrier method will cross over to the simplex method when at optimal solution has been found, to provide an end basis and advanced sensitivity analysis information | `auto` |

crossoverAccuracyTol | Newton barrier: Determines how crossover adjusts the default relative pivot tolerance | `1e-06` |

crossoverIterLimit | Newton barrier: Maximum number of iterations that will be performed in the crossover procedure before the optimization process terminates | `2147483647` |

crossoverOps | Newton barrier: Bit vector for adjusting the behavior of the crossover procedure | `0` |

denseColLimit | Newton barrier: Controls trigger point for special treatment of dense columns in Cholesky factorization | `auto` |

## MIP Options

Option | Description | Default |
---|---|---|

backTrack | Branch and Bound: Specifies how to select the next node to work on when a full backtrack is performed | `3` |

backtrackTie | Branch and Bound: Specifies how to break ties when selecting the next node to work on when a full backtrack is performed | `-1` |

branchChoice | Once a MIP entity has been selected for branching, this control determines which of the branches is solved first | `0` |

branchDisj | Branch and Bound: Determines whether the optimizer should attempt to branch on general split disjunctions during the branch and bound search | `auto` |

branchStructural | Branch and Bound: Determines whether the optimizer should search for special structure in the problem to branch on during the branch and bound search | `auto` |

breadthFirst | Number of nodes to include in the best-first search before switching to the local first search (nodeSelection = 4) | `11` |

deterministic | Selects whether to use a deterministic or opportunistic mode when solving a problem using multiple threads | `1` |

feasibilityPump | Branch and Bound: Decides if the Feasibility Pump heuristic should be run at the top node | `auto` |

fixoptfile | name of option file which is read just before solving the fixed problem | |

genConsAbsTransformation | Specifies the reformulation method for absolute value general constraints at the beginning of the search | `auto` |

genConsDualReductions | Parameter specifies whether dual reductions should be applied to reduce the number of columns and rows added when transforming general constraints to MIP structs | `1` |

historyCosts | Branch and Bound: How to update the pseudo cost for a MIP entity when a strong branch or a regular branch is applied | `auto` |

loadMipSol | Loads a MIP solution (the initial point) | `0` |

localChoice | Controls when to perform a local backtrack between the two child nodes during a dive in the branch and bound tree | `auto` |

maxLocalBacktrack | Branch-and-Bound: How far back up the current dive path the optimizer is allowed to look for a local backtrack candidate node | `auto` |

maxMipSol | Branch and Bound: Limit on the number of integer solutions to be found by the Optimizer | `0` |

maxMipTasks | Branch-and-Bound: The maximum number of tasks to run in parallel during a MIP solve | `auto` |

maxNode | Branch and Bound: Maximum number of nodes that will be explored | `maxint` |

maxStallTime | Maximum time in seconds that the Optimizer will continue to search for improving solution after finding a new incumbent | `0` |

mipAbsCutoff | Branch and Bound: If the user knows that they are interested only in values of the objective function which are better than some value, this can be assigned to mipAbsCutoff | `auto` |

mipAbsStop | Branch and Bound: Absolute tolerance determining whether the tree search will continue or not | `0` |

mipAddCutoff | Branch and Bound: Amount to add to the objective function of the best integer solution found to give the new CURRMIPCUTOFF | `0` |

mipCleanup | Clean up the MIP solution (round-fix-solve) to get duals | `1` |

mipComponents | Determines whether disconnected components in a MIP should be solved as separate MIPs | `auto` |

mipConcurrentNodes | Sets the node limit for when a winning solve is selected when concurrent MIP solves are enabled | `auto` |

mipConcurrentSolves | Selects the number of concurrent solves to start for a MIP | `0` |

mipDualReductions | Branch and Bound: Limits operations that can reduce the MIP solution space | `1` |

mipFracReduce | Branch and Bound: Specifies how often the optimizer should run a heuristic to reduce the number of fractional integer variables in the node LP solutions | `auto` |

mipKappaFreq | Branch and Bound: Specifies how frequently the basis condition number (also known as kappa) should be calculated during the branch-and-bound search | `0` |

mipLog | MIP log print control | `-100` |

mipRampUp | Controls the strategy used by the parallel MIP solver during the ramp-up phase of a branch-and-bound tree search | `auto` |

mipRefineIterLimit | Defines an effort limit expressed as simplex iterations for the MIP solution refiner | `auto` |

mipRelCutoff | Branch and Bound: Percentage of the LP solution value to be added to the value of the objective function when an integer solution is found, to give the new value of CURRMIPCUTOFF | `0` |

mipRelStop | Branch and Bound: Determines when the branch and bound tree search will terminate | `0.0001` |

mipRestart | Branch and Bound: Controls strategy for in-tree restarts | `auto` |

mipRestartFactor | Branch and Bound: Fine tune initial conditions to trigger an in-tree restart | `1` |

mipRestartGapThreshold | Branch and Bound: Initial gap threshold to delay in-tree restart | `0.02` |

mipstopexpr | Stopping expression for branch and bound | |

mipTol | Branch and Bound: Tolerance within which a decision variable′s value is considered to be integral | `5e-06` |

mipToltarget | Target mipTol value used by the automatic MIP solution refiner as defined by refineOps | `0` |

mipTrace | Name of MIP trace file | `none` |

mipTraceNode | Node interval between MIP trace file entries | `100` |

mipTraceTime | Time interval, in seconds, between MIP trace file entries | `5` |

miqcpAlg | Determines which algorithm is to be used to solve mixed integer quadratic constrained and mixed integer second order cone problems | `auto` |

nodeProbingEffort | Adjusts the overall level of node probing | `1` |

nodeSelection | Branch and Bound: Determines which nodes will be considered for solution once the current node has been solved | `auto` |

objGoodEnough | Stop once an objective this good is found | `none` |

pseudoCost | Branch and Bound: Default pseudo cost used in estimation of the degradation associated with an unexplored node in the tree search | `0.01` |

qcRootAlg | Determines which algorithm is to be used to solve the root of a mixed integer quadratic constrained or mixed integer second order cone problem, when outer approximation is used | `auto` |

sbBest | Number of infeasible MIP entities to initialize pseudo costs for on each node | `auto` |

sbEffort | Adjusts the overall amount of effort when using strong branching to select an infeasible MIP entity to branch on | `1` |

sbEstimate | Branch and Bound: How to calculate pseudo costs from the local node when selecting an infeasible MIP entity to branch on | `auto` |

sbIterLimit | Number of dual iterations to perform the strong branching for each entity | `auto` |

sbSelect | Size of the candidate list of MIP entities for strong branching | `-2` |

sosRefTol | Minimum relative gap between the ordering values of elements in a special ordered set | `1e-06` |

symmetry | Adjusts the overall amount of effort for symmetry detection | `1` |

symSelect | Adjusts the overall amount of effort for symmetry detection | `-1` |

varSelection | Branch and Bound: Determines the formula used to calculate the estimate of each integer variable, and thus which integer variable is selected to be branched on at a given node | `auto` |

## MIP Cuts Options

Option | Description | Default |
---|---|---|

autoCutting | Automatically decide whether to generate cutting planes at local nodes in the tree | `auto` |

conflictCuts | Branch and Bound: Specifies how cautious or aggressive the optimizer should be when searching for and applying conflict cuts | `auto` |

coverCuts | Branch and Bound: Number of rounds of lifted cover inequalities at the top node | `auto` |

cutDepth | Branch and Bound: Sets the maximum depth in the tree search at which cuts will be generated | `auto` |

cutFactor | Limit on the number of cuts and cut coefficients the optimizer is allowed to add to the matrix during tree search | `auto` |

cutFreq | Branch and Bound: Frequency at which cuts are generated in the tree search | `auto` |

cutSelect | Bit vector providing detailed control of the cuts created for the root node of a MIP solve | `-1` |

cutSelect_clique | Clique cuts | `1` |

cutSelect_cover | Lifted cover cuts | `1` |

cutSelect_disableCutRows | Disable cutting from cut rows | `1` |

cutSelect_farkas | Farkas cuts | `1` |

cutSelect_flowpath | Flow path cuts | `1` |

cutSelect_gomory | Strong Chvatal-Gomory cuts | `1` |

cutSelect_gubCover | Lifted GUB cover cuts | `1` |

cutSelect_implication | Implication cuts | `1` |

cutSelect_indicator | Indicator constraint cuts | `1` |

cutSelect_liftAndProject | Turn on automatic Lift-and-Project cutting strategy | `1` |

cutSelect_mir | Mixed Integer Rounding (MIR) cuts | `1` |

cutSelect_mirRowAggregation | Turn on row aggregation for MIR cuts | `1` |

cutSelect_zeroHalf | Zero-half cuts | `1` |

cutStrategy | Branch and Bound: Cut strategy | `auto` |

gomCuts | Branch and Bound: Number of rounds of Gomory or lift-and-project cuts at the top node | `auto` |

lnpBest | Number of infeasible MIP entities to create lift-and-project cuts for during each round of Gomory cuts at the top node (see gomCuts) | `50` |

lnpIterLimit | Number of iterations to perform in improving each lift-and-project cut | `auto` |

maxCutTime | Maximum amount of time allowed for generation of cutting planes and reoptimization | `0` |

netCuts | Determines the addition of multi-commodity network cuts to a problem | `0` |

qcCuts | Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation | `auto` |

treeCoverCuts | Branch and Bound: Number of rounds of lifted cover inequalities generated at nodes other than the top node in the tree | `auto` |

treeCutSelect | Bit vector providing detailed control of the cuts created during the tree search of a MIP solve | `-1` |

treeCutSelect_clique | Clique cuts | `1` |

treeCutSelect_cover | Lifted cover cuts | `1` |

treeCutSelect_disableCutRows | Disable cutting from cut rows | `1` |

treeCutSelect_farkas | Farkas cuts | `1` |

treeCutSelect_flowpath | Flow path cuts | `1` |

treeCutSelect_gomory | Strong Chvatal-Gomory cuts | `1` |

treeCutSelect_gubCover | Lifted GUB cover cuts | `1` |

treeCutSelect_implication | Implication cuts | `1` |

treeCutSelect_indicator | Indicator constraint cuts | `1` |

treeCutSelect_liftAndProject | Turn on automatic Lift and Project cutting strategy | `1` |

treeCutSelect_mir | Mixed Integer Rounding (MIR) cuts | `1` |

treeCutSelect_mirRowAggregation | Turn on row aggregation for MIR cuts | `1` |

treeCutSelect_zeroHalf | Zero-half cuts | `1` |

treeGomCuts | Branch and Bound: Number of rounds of Gomory cuts generated at nodes other than the first node in the tree | `auto` |

treeQCCuts | Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for nodes other than the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation | `auto` |

## MIP Heuristics Options

Option | Description | Default |
---|---|---|

feasibilityJump | MIP: Decides if the Feasibility Jump heuristic should be run | `1` |

heurBeforeLp | Branch and Bound: Determines whether primal heuristics should be run before the initial LP relaxation has been solved | `auto` |

heurDiveIterLimit | Branch and Bound: Simplex iteration limit for reoptimizing during the diving heuristic | `auto` |

heurDiveRandomize | Level of randomization to apply in the diving heuristic | `0` |

heurDiveSoftRounding | Branch and Bound: Enables a more cautious strategy for the diving heuristic, where it tries to push binaries and integer variables to their bounds using the objective, instead of directly fixing them | `auto` |

heurDiveSpeedUp | Branch and Bound: Changes the emphasis of the diving heuristic from solution quality to diving speed | `-1` |

heurDiveStrategy | Branch and Bound: Chooses the strategy for the diving heuristic | `auto` |

heurEmphasis | Branch and Bound: Specifies an emphasis for the search w.r.t. primal heuristics and other procedures that affect the speed of convergence of the primal-dual gap | `-1` |

heurForceSpecialObj | Branch and Bound: Whether local search heuristics without objective or with an auxiliary objective should always be used, despite the automatic selection of the Optimizer | `0` |

heurFreq | Branch and Bound: Frequency at which heuristics are used in the tree search | `-1` |

heurSearchEffort | Adjusts the overall level of the local search heuristics | `1` |

heurSearchFreq | Branch and Bound: How often the local search heuristic should be run in the tree | `auto` |

heurSearchRootCutFreq | How frequently to run the local search heuristic during root cutting | `auto` |

heurSearchRootSelect | Bit vector control for selecting which local search heuristics to apply on the root node of a MIP solve | `117` |

heurSearchTreeSelect | Bit vector control for selecting which local search heuristics to apply during the tree search of a MIP solve | `17` |

## MIP Solution Pool Options

Option | Description | Default |
---|---|---|

solnpool | Solution pool file name | `none` |

solnpoolCapacity | Limit on number of solutions to store | `999999999` |

solnpoolCullDiversity | Cull N solutions based on solution diversity | `-1` |

solnpoolCullObj | Cull N solutions based on objective values | `-1` |

solnpoolCullRounds | Terminate solution generation after N culling rounds | `999999999` |

solnpoolDupPolicy | Policy to use when handling storage of duplicate solutions | `0` |

solnpoolmerge | Solution pool file name for merged solutions | `none` |

solnpoolnumsym | Maximum number of variable symbols when writing merged solutions | `10` |

solnpoolPop | Controls method used to populate the solution pool | `1` |

solnpoolPrefix | File name prefix for GDX solution files | `soln` |

solnpoolVerbosity | Controls verbosity of solution pool routines | `0` |

## General NLP / MINLP Options

Option | Description | Default |
---|---|---|

knitroOptFile | Option file for NLP solver KNITRO | |

xslp_algorithm | Bit map describing the SLP algorithm(s) to be used | `166` |

xslp_algorithm_cascadeBounds | Step bounds are updated to accomodate cascaded values (otherwise cascaded values are pushed to respect step bounds) | `0` |

xslp_algorithm_clampExtendedActiveSB | Apply clamping when converged on extended criteria only with some variables having active step bounds | `0` |

xslp_algorithm_clampExtendedAll | Apply clamping when converged on extended criteria only | `0` |

xslp_algorithm_dynamicDamping | Use dynamic damping | `0` |

xslp_algorithm_escalatePenalties | Escalate penalties | `0` |

xslp_algorithm_estimateStepBounds | Estimate step bounds from early SLP iterations | `1` |

xslp_algorithm_holdValues | Do not update values which are converged within strict tolerance | `0` |

xslp_algorithm_maxCostOption | Continue optimizing after penalty cost reaches maximum | `0` |

xslp_algorithm_noLPPolishing | Skip the solution polishing step if the LP postsolve returns a slightly infeasible, but claimed optimal solution | `0` |

xslp_algorithm_noStepBounds | Do not apply step bounds | `0` |

xslp_algorithm_quickConvergenceCheck | Quick convergence check | `1` |

xslp_algorithm_resetDeltaZ | Reset xslp_delta_z to zero when converged and continue SLP | `0` |

xslp_algorithm_residualErrors | Accept a solution which has converged even if there are still significant active penalty error vectors | `0` |

xslp_algorithm_retainPreviousValue | Retain previous value when cascading if determining row is zero | `1` |

xslp_algorithm_stepBoundsAsRequired | Apply step bounds to SLP delta vectors only when required | `1` |

xslp_algorithm_switchToPrimal | Use the primal simplex algorithm when all error vectors become inactive | `0` |

xslp_calcThreads | Number of threads used for formula and derivatives evaluations | `auto` |

xslp_filter | Bit map for controlling solution updates | `3` |

xslp_filterKeepBest | Retrain solution best according to the merit function | `1` |

xslp_filterZeroLineSearch | Force minimum step sizes in line search | `0` |

xslp_filterZeroLineSearchTR | Accept the trust region step is the line search returns a zero step size | `0` |

xslp_findIV | Option for running a heuristic to find a feasible initial point | `auto` |

xslp_infinity | Value returned by a divide-by-zero in a formula | `1e+10` |

xslp_primalIntegralRef | Reference solution value to take into account when calculating the primal integral | `1e+20` |

xslp_scale | When to re-scale the SLP problem | `1` |

xslp_scaleCount | Iteration limit used in determining when to re-scale the SLP matrix | `0` |

xslp_solver | Selects the library to use for local solves | `auto` |

xslp_threads | Default number of threads to be used | `auto` |

xslp_zero | Absolute tolerance | `1e-15` |

## NLP Presolve Options

Option | Description | Default |
---|---|---|

xslp_linQuadBR | Use linear and quadratic constraints and objective function to further reduce bounds on all variables | `auto` |

xslp_postsolve | Determines whether postsolving should be performed automatically | `-1` |

xslp_presolve | Determines whether presolving should be performed prior to starting the main algorithm | `1` |

xslp_presolveLevel | Determines the level of changes presolve may carry out on the problem | `4` |

xslp_presolveOps | Bitmap indicating the SLP presolve actions to be taken | `2104` |

xslp_presolveOps_domain | Bound tightening based on function domains | `1` |

xslp_presolveOps_eliminations | Allow eliminations on determined variables | `1` |

xslp_presolveOps_fixAll | Explicitly fix all columns identified as fixed | `0` |

xslp_presolveOps_fixZero | Explicitly fix columns identified as fixed to zero | `0` |

xslp_presolveOps_general | Generic SLP presolve | `0` |

xslp_presolveOps_intBounds | MISLP bound tightening | `1` |

xslp_presolveOps_noCoefficients | Do not presolve coefficients | `0` |

xslp_presolveOps_noDeltas | Do not remove delta variables | `0` |

xslp_presolveOps_noDualSide | Avoid reductions that can not be dual postsolved | `0` |

xslp_presolveOps_noLinear | Avoid performing linear reductions at the nlp level | `0` |

xslp_presolveOps_noSimplifier | Avoid simplifying nonlinear expressions | `0` |

xslp_presolveOps_setBounds | SLP bound tightening | `1` |

xslp_presolveZero | Minimum absolute value for a variable which is identified as nonzero during SLP presolve | `1e-09` |

xslp_probing | Determines whether probing on a subset of variables should be performed prior to starting the main algorithm | `auto` |

## NLP Augmentation and Linearization Options

Option | Description | Default |
---|---|---|

xslp_augmentation | Bit map describing the SLP augmentation method(s) to be used | `12` |

xslp_augmentation_allErrorVectors | Penalty error vectors on all non-linear inequality constraints | `1` |

xslp_augmentation_allRowErrorVectors | Penalty error vectors on all constraints | `0` |

xslp_augmentation_aMeanWeight | Use arithmetic means to estimate penalty weights | `0` |

xslp_augmentation_equalityErrorVectors | Penalty error vectors on all non-linear equality constraints | `1` |

xslp_augmentation_evenHanded | Even handed augmentation | `0` |

xslp_augmentation_minimum | Minimum augmentation | `0` |

xslp_augmentation_noUpdateIfOnlyIV | Intial values do not imply an SLP variable | `0` |

xslp_augmentation_penaltyDeltaVectors | Penalty vectors to exceed step bounds | `0` |

xslp_augmentation_sbFromAbsValues | Estimate step bounds from absolute values of row coefficients | `0` |

xslp_augmentation_sbFromValues | Estimate step bounds from values of row coefficients | `0` |

xslp_augmentation_stepBoundRows | Row-based step bounds | `0` |

xslp_delta_x | Minimum absolute value of delta coefficients to be retained | `1e-06` |

xslp_feasTolTarget | When set, this defines a target feasibility tolerance to which the linearizations are solved to | `not set` |

xslp_optimalityTolTarget | When set, this defines a target optimality tolerance to which the linearizations are solved to | `not set` |

xslp_unfinishedLimit | Number of consecutive SLP iterations that may have an unfinished status before the solve is terminated | `3` |

xslp_zeroCriterion | Bitmap determining the behavior of the placeholder deletion procedure | `0` |

xslp_zeroCriterionCount | Number of consecutive times a placeholder entry is zero before being considered for deletion | `0` |

xslp_zeroCriterionStart | SLP iteration at which criteria for deletion of placeholder entries are first activated | `0` |

xslp_zeroCriterion_deltaNBDRRow | Remove placeholders in a basic delta variable if the determining row for the corresponding SLP variable is nonbasic | `0` |

xslp_zeroCriterion_deltaNBUpdateRow | Remove placeholders in a basic delta variable if its update row is nonbasic and the corresponding SLP variable is nonbasic | `0` |

xslp_zeroCriterion_nbDelta | Remove placeholders in nonbasic delta variables | `0` |

xslp_zeroCriterion_nbSLPVar | Remove placeholders in nonbasic SLP variables | `0` |

xslp_zeroCriterion_print | Print information about zero placeholders | `0` |

xslp_zeroCriterion_slpVarNBUpdateRow | Remove placeholders in a basic SLP variable if its update row is nonbasic | `0` |

## NLP Barrier Options

Option | Description | Default |
---|---|---|

xslp_barCrossOverStart | Default crossover activation behaviour for barrier start | `0` |

xslp_barLimit | Number of initial SLP iterations using the barrier method | `0` |

xslp_barStallingLimit | Number of iterations to allow numerical failures in barrier before switching to dual | `3` |

xslp_barStallingObjLimit | Number of iterations over which to measure the objective change for barrier iterations with no crossover | `3` |

xslp_barStallingTol | Required change in the objective when progress is measured in barrier iterations without crossover | `0.05` |

xslp_barStartOps | Controls behaviour when the barrier is used to solve the linearizations | `-1` |

xslp_barStartOps_allowInteriorSol | If a non-vertex converged solution found by barrier without crossover can be returned as a final solution | `1` |

xslp_barStartOps_stallingNumerical | Fall back to dual simplex if too many numerical problems are reported by the barrier | `1` |

xslp_barStartOps_stallingObjective | Check objective progress when no crossover is applied | `1` |

## NLP Penalty Options

Option | Description | Default |
---|---|---|

xslp_deltaCost | Initial penalty cost multiplier for penalty delta vectors | `200` |

xslp_deltaCostFactor | Factor for increasing cost multiplier on total penalty delta vectors | `1.3` |

xslp_deltaMaxCost | Maximum penalty cost multiplier for penalty delta vectors | `1e+20` |

xslp_enforceCostShrink | Factor by which to decrease the current penalty multiplier when enforcing rows | `1e-05` |

xslp_enforceMaxCost | Maximum penalty cost in the objective before enforcing most violating rows | `1e+11` |

xslp_errorCost | Initial penalty cost multiplier for penalty error vectors | `200` |

xslp_errorCostFactor | Factor for increasing cost multiplier on total penalty error vectors | `1.3` |

xslp_errorMaxCost | Maximum penalty cost multiplier for penalty error vectors | `1e+20` |

xslp_errorTol_a | Absolute tolerance for error vectors | `1e-05` |

xslp_errorTol_p | Absolute tolerance for printing error vectors | `0.0001` |

xslp_escalation | Factor for increasing cost multiplier on individual penalty error vectors | `1.25` |

xslp_eTol_a | Absolute tolerance on penalty vectors | `0.0001` |

xslp_eTol_r | Relative tolerance on penalty vectors | `0.0001` |

xslp_evTol_a | Absolute tolerance on total penalty costs | `-1` |

xslp_evTol_r | Relative tolerance on total penalty costs | `-1` |

xslp_granularity | Base for calculating penalty costs | `4` |

xslp_maxWeight | Maximum penalty weight for delta or error vectors | `100` |

xslp_minWeight | Minimum penalty weight for delta or error vectors | `0.01` |

xslp_objToPenaltyCost | Factor to estimate initial penalty costs from objective function | `0` |

xslp_penaltyInfoStart | Iteration from which to record row penalty information | `3` |

## NLP Step Bounds Options

Option | Description | Default |
---|---|---|

xslp_clampShrink | Shrink ratio used to impose strict convergence on variables converged in extended criteria only | `0.3` |

xslp_clampValidationTol_a | Absolute validation tolerance for applying xslp_clampShrink | `not set` |

xslp_clampValidationTol_r | Relative validation tolerance for applying xslp_clampShrink | `not set` |

xslp_defaultStepBound | Minimum initial value for the step bound of an SLP variable if none is explicitly given | `16` |

xslp_djTol | Tolerance on DJ value for determining if a variable is at its step bound | `1e-06` |

xslp_expand | Multiplier to increase a step bound | `2` |

xslp_minSBFactor | Factor by which step bounds can be decreased beneath xslp_aTol_a | `1` |

xslp_sameCount | Number of steps reaching the step bound in the same direction before step bounds are increased | `3` |

xslp_sbStart | SLP iteration after which step bounds are first applied | `8` |

xslp_shrink | Multiplier to reduce a step bound | `0.5` |

xslp_shrinkBias | Defines an overwrite / adjustment of step bounds for improving iterations | `not set` |

## NLP Variable Update Options

Option | Description | Default |
---|---|---|

xslp_damp | Damping factor for updating values of variables | `1` |

xslp_dampExpand | Multiplier to increase damping factor during dynamic damping | `1` |

xslp_dampMax | Maximum value for the damping factor of a variable during dynamic damping | `1` |

xslp_dampMin | Minimum value for the damping factor of a variable during dynamic damping | `1` |

xslp_dampShrink | Multiplier to decrease damping factor during dynamic damping | `1` |

xslp_dampStart | SLP iteration at which damping is activated | `0` |

xslp_lsIterLimit | Number of iterations in the line search | `0` |

xslp_lsPatternLimit | Number of iterations in the pattern search preceding the line search | `0` |

xslp_lsStart | Iteration in which to active the line search | `8` |

xslp_lsZeroLimit | Maximum number of zero length line search steps before line search is deactivated | `5` |

xslp_meritLambda | Factor by which the net objective is taken into account in the merit function | `0` |

xslp_sameDamp | Number of steps in same direction before damping factor is increased | `3` |

## NLP Termination Options

Option | Description | Default |
---|---|---|

xslp_aTol_a | Absolute delta convergence tolerance | `auto` |

xslp_aTol_r | Relative delta convergence tolerance | `auto` |

xslp_convergenceOps | Bit map describing which convergence tests should be carried out | `7167` |

xslp_convergenceOps_aTol | Execute the delta tolerance checks | `1` |

xslp_convergenceOps_cTol | Execute the closure tolerance checks | `1` |

xslp_convergenceOps_extendedScaling | Take scaling of individual variables / rows into account | `0` |

xslp_convergenceOps_iTol | Execute the impact tolerance checks | `1` |

xslp_convergenceOps_mTol | Execute the matrix tolerance checks | `1` |

xslp_convergenceOps_oTol | Execute the objective range + active step bound check | `1` |

xslp_convergenceOps_sTol | Execute the slack impact tolerance checks | `1` |

xslp_convergenceOps_validation | Execute the validation target convergence checks | `1` |

xslp_convergenceOps_validationK | Execute the first order optimality target convergence checks | `1` |

xslp_convergenceOps_vTol | Execute the objective range checks | `1` |

xslp_convergenceOps_wTol | Execute the convergence continuation check | `1` |

xslp_convergenceOps_xTol | Execute the objective range + constraint activity check | `1` |

xslp_cTol | Closure convergence tolerance | `auto` |

xslp_ecfCheck | Check feasibility at the point of linearization for extended convergence criteria | `1` |

xslp_ecfTol_a | Absolute tolerance on testing feasibility at the point of linearization | `auto` |

xslp_ecfTol_r | Relative tolerance on testing feasibility at the point of linearization | `auto` |

xslp_infeasLimit | Maximum number of consecutive infeasible SLP iterations which can occur before Xpress-SLP terminates | `3` |

xslp_iterLimit | Maximum number of SLP iterations | `auto` |

xslp_iTol_a | Absolute impact convergence tolerance | `auto` |

xslp_iTol_r | Relative impact convergence tolerance | `auto` |

xslp_mTol_a | Absolute effective matrix element convergence tolerance | `auto` |

xslp_mTol_r | Relative effective matrix element convergence tolerance | `auto` |

xslp_mvTol | Marginal value tolerance for determining if a constraint is slack | `auto` |

xslp_oCount | Number of SLP iterations over which to measure objective function variation for static objective (2) convergence criterion | `5` |

xslp_oTol_a | Absolute static objective (2) convergence tolerance | `auto` |

xslp_oTol_r | Relative static objective (2) convergence tolerance | `auto` |

xslp_sTol_a | Absolute slack convergence tolerance | `auto` |

xslp_sTol_r | Relative slack convergence tolerance | `auto` |

xslp_stopOutOfRange | Stop optimization and return error code if internal function argument is out of range | `0` |

xslp_validationTarget_k | Optimality target tolerance | `1e-06` |

xslp_validationTarget_r | Feasiblity target tolerance | `1e-06` |

xslp_vCount | Number of SLP iterations over which to measure static objective (3) convergence | `0` |

xslp_vLimit | Number of SLP iterations after which static objective (3) convergence testing starts | `0` |

xslp_vTol_a | Absolute static objective (3) convergence tolerance | `auto` |

xslp_vTol_r | Relative static objective (3) convergence tolerance | `auto` |

xslp_wCount | Number of SLP iterations over which to measure the objective for the extended convergence continuation criterion | `0` |

xslp_wTol_a | Absolute extended convergence continuation tolerance | `auto` |

xslp_wTol_r | Relative extended convergence continuation tolerance | `auto` |

xslp_xCount | Number of SLP iterations over which to measure static objective (1) convergence | `5` |

xslp_xLimit | Number of SLP iterations up to which static objective (1) convergence testing starts | `100` |

xslp_xTol_a | Absolute static objective function (1) tolerance | `auto` |

xslp_xTol_r | Relative static objective function (1) tolerance | `auto` |

## NLP Multistart Options

Option | Description | Default |
---|---|---|

xslp_msMaxBoundRange | Defines the maximum range inside which initial points are generated by multistart presets | `1000` |

xslp_multistartPreset | Enable multistart | `0` |

xslp_multistart_maxSolves | Maximum number of jobs to create during the multistart search | `unlimited` |

xslp_multistart_maxTime | Maximum total time to be spent in the mutlistart search | `unlimited` |

xslp_multistart_poolsize | Maximum number of problem objects allowed to pool up before synchronization in the deterministic multistart | `2` |

xslp_multistart_seed | Random seed used for the automatic generation of initial point when loading multistart presets | `0` |

xslp_multistart_threads | Maximum number of threads to be used in multistart | `auto` |

## NLP Derivative Options

Option | Description | Default |
---|---|---|

xslp_cdTol_a | Absolute tolerance for deducing constant derivatives | `1e-08` |

xslp_cdTol_r | Relative tolerance for deducing constant derivatives | `1e-08` |

xslp_deltaZLimit | Number of SLP iterations during which to apply xslp_delta_z | `0` |

xslp_delta_a | Absolute perturbation of values for calculating numerical derivatives | `0.001` |

xslp_delta_r | Relative perturbation of values for calculating numerical derivatives | `0.001` |

xslp_delta_z | Tolerance used when calculating derivatives | `1e-05` |

xslp_delta_zero | Absolute zero acceptance tolerance used when calculating derivatives | `-1` |

xslp_derivatives | Bitmap describing the method of calculating derivatives | `1` |

xslp_hessian | Second order differentiation mode when using analytical derivatives | `-1` |

xslp_jacobian | First order differentiation mode when using analytical derivatives | `-1` |

## NLP Log Options

Option | Description | Default |
---|---|---|

xslp_analyze | Bit map activating additional options supporting model / solution path analyzis | `0` |

xslp_analyze_extendedFinalSummary | Include an extended iteration summary | `0` |

xslp_analyze_infeasibleIteration | Run infeasibility analysis on infeasible iterations | `0` |

xslp_analyze_saveFile | Create an Xpress SLP save file at every xslp_autosave iterations | `0` |

xslp_analyze_saveIterBasis | Write the initial basis of the linearizations to disk at every xslp_autosave iterations | `0` |

xslp_analyze_saveLinearizations | Write the linearizations to disk at every xslp_autosave iterations | `0` |

xslp_autosave | Frequency with which to save the model | `0` |

xslp_log | Level of printing during SLP iterations | `0` |

xslp_slpLog | Frequency with which SLP status is printed | `1` |

## MINLP Options

Option | Description | Default |
---|---|---|

xslp_cutStrategy | Determines whihc cuts to apply in the MISLP search when the default SLP-in-MIP strategy is used | `0` |

xslp_heurStrategy | Branch and Bound: MINLP heuristic strategy | `auto` |

xslp_mipAlgorithm | Bitmap describing the MISLP algorithms to be used | `17` |

xslp_mipAlgorithm_finalFixSLP | Fix step bounds according to xslp_mipFixStepBounds after MIP solution is found | `0` |

xslp_mipAlgorithm_finalRelaxSLP | Relax step bounds according to xslp_mipRelaxStepBounds after MIP solution is found | `0` |

xslp_mipAlgorithm_initialFixSLP | Fix step bounds according to xslp_mipFixStepBounds after initial node | `0` |

xslp_mipAlgorithm_initialRelaxSLP | Relax step bounds according to xslp_mipRelaxStepBounds after initial node | `0` |

xslp_mipAlgorithm_initialSLP | Solve initial SLP to convergence | `1` |

xslp_mipAlgorithm_nodeFixSLP | Fix step bounds according to xslp_mipFixStepBounds at each node | `0` |

xslp_mipAlgorithm_nodeLimitSLP | Limit iterations at each node to xslp_mipIterLimit | `0` |

xslp_mipAlgorithm_nodeRelaxSLP | Relax step bounds according to xslp_mipRelaxStepBounds at each node | `1` |

xslp_mipAlgorithm_slpThenMIP | Use MIP on converged SLP solution and then SLP on the resulting MIP solution | `0` |

xslp_mipAlgorithm_withinSLP | Use MIP at each SLP iteration instead of SLP at each node | `0` |

xslp_mipCutOffCount | Number of SLP iterations to check when considering a node for cutting off | `5` |

xslp_mipCutOffLimit | Number of SLP iterations to check when considering a node for cutting off | `10` |

xslp_mipCutOff_a | Absolute objective function cutoff for MIP termination | `1e-05` |

xslp_mipCutOff_r | Absolute objective function cutoff for MIP termination | `1e-05` |

xslp_mipDefaultAlgorithm | Default algorithm to be used during the tree search in MISLP | `auto` |

xslp_mipErrorTol_a | Absolute penalty error cost tolerance for MIP cut-off | `0` |

xslp_mipErrorTol_r | Relative penalty error cost tolerance for MIP cut-off | `0` |

xslp_mipFixStepBounds | Bitmap describing the step-bound fixing strategy during MISLP | `0` |

xslp_mipFixStepBounds_coef | Fix step bounds on SLP variables appearing in coefficients | `0` |

xslp_mipFixStepBounds_coefOnly | Fix step bounds on SLP variables appearing only in coefficients | `0` |

xslp_mipFixStepBounds_structAll | Fix step bounds on all structural SLP variables | `0` |

xslp_mipFixStepBounds_structNotCoef | Fix step bounds on structural SLP variables which are not in coefficients | `0` |

xslp_mipIterLimit | Maximum number of SLP iterations at each node | `0` |

xslp_mipLog | Frequency with which MIP status is printed | `0` |

xslp_mipOCount | Number of SLP iterations at each node over which to measure objective function variation | `5` |

xslp_mipOTol_a | Absolute objective function tolerance for MIP termination | `1e-05` |

xslp_mipOTol_r | Relative objective function tolerance for MIP termination | `1e-05` |

xslp_mipRelaxStepBounds | Bitmap describing the step-bound relaxation strategy during MISLP | `15` |

xslp_mipRelaxStepBounds_coef | Relax step bounds on SLP variables appearing in coefficients | `1` |

xslp_mipRelaxStepBounds_coefOnly | Relax step bounds on SLP variables appearing only in coefficients | `1` |

xslp_mipRelaxStepBounds_structAll | Relax step bounds on all structural SLP variables | `1` |

xslp_mipRelaxStepBounds_structNotCoef | Relax step bounds on structural SLP variables which are not in coefficients | `1` |

# Detailed Descriptions of XPRESS Options

**advBasis** *(boolean)*: Use advanced basis provided by GAMS ↵

Default:

`auto`

**algAfterCrossover** *(integer)*: Algorithm to be used for the final clean up step after the crossover ↵

Default:

`auto`

value meaning `1`

Automatically determined. `2`

Dual simplex. `3`

Primal simplex. `4`

Concurrent.

**algAfterNetwork** *(integer)*: Algorithm to be used for the clean up step after the network simplex solver ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `2`

Dual simplex. `3`

Primal simplex.

**algorithm** *(string)*: Choose between simplex and barrier algorithm ↵

This option is used to select the barrier method to solve LPs. By default the barrier method will do a crossover to find a basic solution.

Default:

`simplex`

value meaning `barrier`

Use the barrier algorithm `simplex`

Use the simplex algorithm

**autoCutting** *(integer)*: Automatically decide whether to generate cutting planes at local nodes in the tree ↵

If the cutFreq control is set, no automatic selection will be made and local cutting will be enabled.

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disabled. `1`

Enabled.

**autoPerturb** *(boolean)*: Simplex: Indicates whether automatic perturbation is performed ↵

If this is set to 1, the problem will be perturbed whenever the simplex method encounters an excessive number of degenerate pivot steps, thus preventing the Optimizer being hindered by degeneracies.

Default:

`auto`

value meaning `0`

No perturbation performed. `1`

Automatic perturbation is performed.

**autoScaling** *(integer)*: Whether the Optimizer should automatically select between different scaling algorithms ↵

If the scaling control is set, no automatic scaling will be applied.

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disabled. `1`

Cautious strategy. Non-standard scaling will only be selected if it appears to be clearly superior. `2`

Moderate strategy. `3`

Aggressive strategy. Standard scaling will only be selected if it appears to be clearly superior.

**backTrack** *(integer)*: Branch and Bound: Specifies how to select the next node to work on when a full backtrack is performed ↵

Note When two nodes are rated the same according to the backTrack selection, a secondary rating is performed using the method set by backtrackTie.

Default:

`3`

value meaning `-1`

Automatically determined. `1`

Unused. `2`

Select the node with the best estimated solution. `3`

Select the node with the best bound on the solution. `4`

Select the deepest node in the search tree (equivalent to depth-first search). `5`

Select the highest node in the search tree (equivalent to breadth-first search). `6`

Select the earliest node created. `7`

Select the latest node created. `8`

Select a node randomly. `9`

Select the node whose LP relaxation contains the fewest number of infeasible MIP entities. `10`

Combination of 2 and 9. `11`

Combination of 2 and 4. `12`

Combination of 3 and 4.

**backtrackTie** *(integer)*: Branch and Bound: Specifies how to break ties when selecting the next node to work on when a full backtrack is performed ↵

The options are the same as for the backTrack control.

Default:

`-1`

value meaning `-1`

Default selection. `1`

Unused. `2`

Select the node with the best estimated solution. `3`

Select the node with the best bound on the solution. `4`

Select the deepest node in the search tree (equivalent to depth-first search). `5`

Select the highest node in the search tree (equivalent to breadth-first search). `6`

Select the earliest node created. `7`

Select the latest node created. `8`

Select a node randomly. `9`

Select the node whose LP relaxation contains the fewest number of infeasible MIP entities. `10`

Combination of 2 and 9. `11`

Combination of 2 and 4. `12`

Combination of 3 and 4.

**barAlg** *(integer)*: Determines which barrier algorithm is to be used to solve the problem ↵

The automatic setting uses 1 for LP and QP problems and 3 for QCQP problems. Usually the detection of primal or dual infeasibility is more robust with settings 2 or 3, therefore, it is advantageous to use one of these values if the model is presumably infeasible.

Default:

`auto`

value meaning `-1`

Determined automatically. `0`

Unused. `1`

Use the infeasible-start barrier algorithm. `2`

Use the homogeneous self-dual barrier algorithm. `3`

Start with 2 and optionally switch to 1 during the execution.

**barCores** *(integer)*: If set to a positive integer it determines the number of physical CPU cores assumed to be present in the system by the barrier algorithm ↵

If the value is set to the default value (-1), Xpress will automatically detect the number of cores.

The control is provided for cross-hardware reproducibility purposes. The count does not include logical cores created by Hyper-Threading.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**barCrash** *(integer)*: Newton barrier: Determines the type of crash used for the crossover ↵

During the crash procedure, an initial basis is determined which attempts to speed up the crossover. A good choice at this stage will significantly reduce the number of iterations required to crossover to an optimal solution. The possible values increase proportionally to their time-consumption.

Default:

`4`

value meaning `0`

Turns off all crash procedures. `1-6`

Available strategies with 1 being conservative and 6 being aggressive.

**barDualStop** *(real)*: Newton barrier: Convergence parameter, representing the tolerance for dual infeasibilities ↵

If the difference between the constraints and their bounds in the dual problem falls below this tolerance in absolute value, optimization will stop and the current solution will be returned.

Range: [

`0`

, ∞]Default:

`auto`

**barFailIterLimit** *(integer)*: Newton barrier: Maximum number of consecutive iterations that fail to improve the solution in the barrier algorithm ↵

Default:

`auto`

value meaning `0`

Determined automatically `>0`

Maximum number of consecutive barrier iterations allowed without progress.

**barFreeScale** *(real)*: Defines how the barrier algorithm scales free variables ↵

When using smaller values the barrier algorithm scales free variables more aggressively which can improve performance but may impact numerical stability.

Range: [

`0`

, ∞]Default:

`1e-06`

**barGapStop** *(real)*: Newton barrier: Convergence parameter, representing the tolerance for the relative duality gap ↵

When the difference between the primal and dual objective function values falls below this tolerance, the Optimizer determines that the optimal solution has been found.

Range: [

`0`

, ∞]Default:

`auto`

**barGapTarget** *(real)*: Newton barrier: Target tolerance for the relative duality gap ↵

The barrier algorithm will keep iterating until either barGapTarget is satisfied or until no further improvements are possible. In the latter case, if barGapStop is satisfied, it will declare the problem optimal.

When a solution returned by the barrier algorithm has not converged tightly enough for an application, for example if the dual solution is not accurate enough or crossover is taking too long, setter barGapTarget to a small value often resolves the problem, without the risk of the solve failing due to a complementarity level not being numerically achievable. Typical suggested values can be between 1-10 and 1-18.

Range: [

`0`

, ∞]Default:

`auto`

**barIndefLimit** *(integer)*: Newton Barrier: Limits the number of consecutive indefinite barrier iterations that will be performed ↵

The optimizer will try to minimize (resp. maximize) a QP problem even if the Q matrix is not positive (resp. negative) semi-definite. However, the optimizer may detect that the Q matrix is indefinite and this can result in the optimizer not converging. This control specifies how many indefinite iterations may occur before the optimizer stops and reports that the problem is indefinite. It is usual to specify a value greater than one, and only stop after a series of indefinite matrices, as the problem may be found to be indefinite incorrectly on a few iterations for numerical reasons.

Range: {

`1`

, ..., ∞}Default:

`15`

**barIterLimit** *(integer)*: Newton barrier: Maximum number of iterations ↵

While the simplex method usually performs a number of iterations which is proportional to the number of constraints (rows) in a problem, the barrier method standardly finds the optimal solution to a given accuracy after a number of iterations which is independent of the problem size. The penalty is rather that the time for each iteration increases with the size of the problem. barIterLimit specifies the maximum number of iterations which will be carried out by the barrier.

Range: {

`0`

, ..., ∞}Default:

`500`

**barKernel** *(real)*: Newton barrier: Defines how centrality is weighted in the barrier algorithm ↵

Increasing this parameter may increase the number of iterations, therefore the recommended range is [1,2] and [-2,-1].

Default:

`0`

value meaning `>=+1.0`

Increases the emphasis on centrality when larger value is set. `<=-1.0`

Selects a value adaptively in every iteration from [+1, -barKernel].

**barObjPerturb** *(real)*: Defines how the barrier perturbs the objective ↵

The perturbation scale should be set carefully with consideration to the optimality tolerance. The parameter affects only the barrier solve.

Default:

`1e-06`

value meaning `0`

Turn off objective perturbation. `>0`

Let the optimizer decide if the objective is perturbed or not and use the parameter value as the scale of the perturbation. `<0`

Always perturb the objective by the absolute value of the parameter.

**barObjScale** *(real)*: Defines how the barrier scales the objective ↵

The scaling perfromed by the barrier is applied on top of any other scaling in the problem and only affects the barrier solve.

Default:

`auto`

value meaning `-1`

Let the optimizer decide. `0`

Scale by geometric mean. `>=0`

Scale such that the largest objective coefficient′s largest element does not exceed this number. In quadratic problems, the quadratic diagonal is used as reference valuses instead of the linear objective.

**barOrder** *(integer)*: Newton barrier: Controls the Cholesky factorization in the Newton-Barrier ↵

Default:

`auto`

value meaning `0`

Choose automatically. `1`

Minimum degree method. This selects diagonal elements with the smallest number of nonzeros in their rows or columns. `2`

Minimum local fill method. This considers the adjacency graph of nonzeros in the matrix and seeks to eliminate nodes that minimize the creation of new edges. `3`

Nested dissection method. This considers the adjacency graph and recursively seeks to separate it into non-adjacent pieces.

**barOrderThreads** *(integer)*: If set to a positive integer it determines the number of concurrent threads for the sparse matrix ordering algorithm in the Newton-barrier method ↵

Larger values than barCores will be automatically reduced to the value of barCores.

Range: {

`0`

, ..., ∞}Default:

`auto`

**barOutput** *(boolean)*: Newton barrier: Level of solution output provided ↵

Output is provided either after each iteration of the algorithm, or else can be turned off completely by this parameter.

Default:

`1`

value meaning `0`

No output. `1`

At each iteration.

**barPerturb** *(real)*: Newton barrier: In numerically challenging cases it is often advantageous to apply perturbations on the KKT system to improve its numerical properties ↵

barPerturb controlls how much perturbation is allowed during the barrier iterations. By default no perturbation is allowed. Set this parameter with care as larger perturbations may lead to less efficient iterates and the best settings are problem-dependent.

Range: [

`0`

, ∞]Default:

`0`

**barPresolveOps** *(integer)*: Newton barrier: Controls the Newton-Barrier specific presolve operations ↵

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`0`

value meaning `bit 0 = 1`

Equivalent to barPresolveOps_standard. `bit 1 = 2`

Equivalent to barPresolveOps_extra. `bit 2 = 4`

Equivalent to barPresolveOps_full.

**barPresolveOps_extra** *(boolean)*: Extra effort is spent in barrier specific presolve ↵

See also barPresolveOps.

Default:

`0`

**barPresolveOps_full** *(boolean)*: Do full matrix eliminations (reduce matrix size) ↵

See also barPresolveOps.

Default:

`0`

**barPresolveOps_standard** *(boolean)*: Use standard presolve ↵

See also barPresolveOps.

Default:

`0`

**barPrimalStop** *(real)*: Newton barrier: Convergence parameter, indicating the tolerance for primal infeasibilities ↵

If the difference between the constraints and their bounds in the primal problem falls below this tolerance in absolute value, the Optimizer will terminate and return the current solution.

Range: [

`0`

, ∞]Default:

`auto`

**barRefIter** *(integer)*: Newton barrier: After terminating the barrier algorithm, further refinement steps can be performed ↵

Such refinement steps are especially helpful if the solution is near to the optimum and can improve primal feasibility and decrease the complementarity gap. It is also often advantageous for the crossover algorithm. barRefIter specifies the maximum number of such refinement iterations.

Range: {

`0`

, ..., ∞}Default:

`0`

**barRegularize** *(integer)*: Determines how the barrier algorithm applies regularization on the KKT system ↵

The parameter is a bit set but value -1 (the default value) is treated in a special way: if the parameter is set to -1 then the solver will automatically select the bits it deems most useful.

Default:

`-1`

value meaning `bit 0 = 1`

Standard regularization is turned on/off. `bit 1 = 2`

Reduced regularization is turned on/off. This option reduces the perturbation effect of the standard regularization. `bit 2 = 4`

Forces to keep dependent rows in the KKT system. `bit 3 = 8`

Forces to preserve degenerate rows in the KKT system. `bit 4 = 16`

Restrict regularization to infeasible iterates. `bit 5 = 32`

Disable iterative regularizations. `bit 6 = 64`

Apply iterative regularization more often.

**barRhsScale** *(real)*: Defines how the barrier scales the right hand side ↵

The scaling perfromed by the barrier is applied on top of any other scaling in the problem and only affects the barrier solve.

Default:

`auto`

value meaning `-1`

Let the optimizer decide. `0`

Scale by geometric mean. `>=0`

Scale such that the largest right hand side coefficient′s largest element does not exceed this number.

**barStart** *(integer)*: Newton barrier: Controls the computation of the starting point for the barrier algorithm ↵

Default:

`auto`

value meaning `-1`

Uses the available solution for warm-start. `0`

Determine automatically. `1`

Uses simple heuristics to compute the starting point based on the magnitudes of the matrix entries. `2`

Uses the pseudoinverse of the constraint matrix to determine primal and dual initial solutions. Less sensitive to scaling and numerically more robust, but in several case less efficient than 1. `3`

Uses the unit starting point for the homogeneous self-dual barrier algorithm.

**barStepStop** *(real)*: Newton barrier: Convergence parameter, representing the minimal step size ↵

On each iteration of the barrier algorithm, a step is taken along a computed search direction. If that step size is smaller than barStepStop, the Optimizer will terminate and return the current solution.

If the barrier method is making small improvements on barGapStop on later iterations, it may be better to set this value higher, to return a solution after a close approximation to the optimum has been found.

Range: [

`0`

, ∞]Default:

`1e-16`

**barThreads** *(integer)*: If set to a positive integer it determines the number of threads implemented to run the Newton-barrier algorithm ↵

If the value is set to the default value (-1), the threads control will determine the number of threads used.

There is a practical upper limit of 50 on the number of parallel threads the optimizer will create.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**basisOut** *(string)*: Directs optimizer to output an MPS basis file ↵

In general this option is not used in a GAMS environment, as GAMS maintains basis information for you automatically.

Default:

`none`

**bigM** *(real)*: Infeasibility penalty used if the "Big M" method is implemented ↵

Range: [

`0`

, ∞]Default:

`auto`

**bigMMethod** *(boolean)*: Simplex: Whether to use the "Big M" method, or the standard phase I (achieving feasibility) and phase II (achieving optimality) ↵

In the "Big M" method, the objective coefficients of the variables are considered during the feasibility phase, possibly leading to an initial feasible basis which is closer to optimal. The side-effects involve possible round-off errors due to the presence of the "Big M" factor in the problem.

Default:

`1`

value meaning `0`

For phase I / phase II. `1`

If "Big M" method to be used.

**branchChoice** *(integer)*: Once a MIP entity has been selected for branching, this control determines which of the branches is solved first ↵

Default:

`0`

value meaning `0`

Minimum estimate branch first. `1`

Maximum estimate branch first. `2`

If an incumbent solution exists, solve the branch satisfied by that solution first. Otherwise solve the minimum estimate branch first (option 0). `3`

Solve first the branch that forces the value of the branching variable to move farther away from the value it had at the root node. If the branching entity is not a simple variable, solve the minimum estimate branch first (option 0).

**branchDisj** *(integer)*: Branch and Bound: Determines whether the optimizer should attempt to branch on general split disjunctions during the branch and bound search ↵

Note Split disjunctions are a special form of disjunctions that can be written as ∑j mj xj ≤ m0 v ∑j mj xj ≥ m0+1 The split disjunctions created by the optimizer will use a combination of binary or integer variables xj, with integer coefficients mj. Split disjunctions for branching will always be created with a default priority value of 400 instead of the default value of 500 for regular entity branches.

Default:

`auto`

value meaning `-1`

Automatic selection of the strategy. `0`

Disabled. `1`

Cautious strategy. Disjunctive branches will be created only for general integers with a wide range. `2`

Moderate strategy. `3`

Aggressive strategy. Disjunctive branches will be created for both binaries and integers.

**branchStructural** *(integer)*: Branch and Bound: Determines whether the optimizer should search for special structure in the problem to branch on during the branch and bound search ↵

Structural branches will often involve branching on more than a single MIP entity at a time. As a result of a structural branch, a parent node could therefore end up with more than two child nodes, unlike the standard single entity branches. Structural branches will always be created with a default priority value of 400 instead of the default value of 500 for regular entity branches.

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disabled. `1`

Enabled.

**breadthFirst** *(integer)*: Number of nodes to include in the best-first search before switching to the local first search (nodeSelection = 4) ↵

Range: {

`0`

, ..., ∞}Default:

`11`

**choleskyAlg** *(integer)*: Newton barrier: Type of Cholesky factorization used ↵

Default:

`auto`

value meaning `bit 0 = 1`

Matrix blocking: 0: automatic setting; 1: manual setting. `bit 1 = 2`

If manual selection of matrix blocking: 0: multi-pass; 1: single-pass. `bit 2 = 4`

Nonseparable QP relaxation: 0: off; 1: on. `bit 3 = 8`

Corrector weight: 0: automatic setting; 1: manual setting. `bit 4 = 16`

If manual selection of corrector weight: 0: off; 1: on. `bit 5 = 32`

Refinement: 0: automatic setting; 1: manual setting. `bit 6 = 64`

Preconditioned conjugate gradient method (PCGM): 0: PCGM off; 1: PCGM on. `bit 7 = 128`

Preconditioned quasi minimal residual (QMR) to refine solution: 0: QMR off; 1: QMR on. `bit 8 = 256`

Perform refinement on the augmented system 0: off; 1: on. `bit 9 = 512`

Force highest accuracy in refinement 0: off; 1: on.

**choleskyTol** *(real)*: Newton barrier: Tolerance for pivot elements in the Cholesky decomposition of the normal equations coefficient matrix, computed at each iteration of the barrier algorithm ↵

If the absolute value of the pivot element is less than or equal to choleskyTol, it merits special treatment in the Cholesky decomposition process.

Range: [

`0`

, ∞]Default:

`1e-15`

**clamping** *(integer)*: Allows for the adjustment of returned solution values such that they are always within bounds ↵

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`0`

value meaning `-1`

Determined automatically. `0`

Equivalent to clamping_primal. `1`

Equivalent to clamping_dual. `2`

Equivalent to clamping_slacks. `3`

Equivalent to clamping_rdj.

**clamping_dual** *(boolean)*: Adjust primal slack values to always be within constraint bounds ↵

See also clamping.

Default:

`0`

**clamping_primal** *(boolean)*: Adjust primal solution to always be within primal bounds ↵

Slacks if provided will be adjusted accordingly.

See also clamping.

Default:

`0`

**clamping_rdj** *(boolean)*: Adjust reduced costs to always be within dual bounds implied by the primal solution ↵

See also clamping.

Default:

`0`

**clamping_slacks** *(boolean)*: Adjust dual solution to always be within the dual bounds implied by the slacks ↵

Reduced costs, if provided, will be adjusted accordingly.

See also clamping.

Default:

`0`

**concurrentThreads** *(integer)*: Determines the number of threads used by the concurrent solver ↵

Default:

`auto`

value meaning `-1`

Determined automatically `>0`

Number of threads to use.

**conflictCuts** *(integer)*: Branch and Bound: Specifies how cautious or aggressive the optimizer should be when searching for and applying conflict cuts ↵

Conflict cuts are in-tree cuts derived from nodes found to be infeasible or cut off, which can be used to cut off other branches of the search tree.

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disable conflict cuts. `1`

Cautious application of conflict cuts. `2`

Medium application of conflict cuts. `3`

Aggressive application of conflict cuts.

**coresPerCpu** *(integer)*: Used to override the detected value of the number of cores on a CPU ↵

The cache size (either detected or specified via the CACHESIZE control) used in Barrier methods will be divided by this amount, and this scaled-down value will be the amount of cache allocated to each Barrier thread.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**coverCuts** *(integer)*: Branch and Bound: Number of rounds of lifted cover inequalities at the top node ↵

A lifted cover inequality is an additional constraint that can be particularly effective at reducing the size of the feasible region without removing potential integral solutions. The process of generating these can be carried out a number of times, further reducing the feasible region, albeit incurring a time penalty. There is usually a good payoff from generating these at the top node, since these inequalities then apply to every subsequent node in the tree search.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**cpuPlatform** *(integer)*: Newton Barrier: Selects the AMD, Intel x86 or ARM vectorization instruction set that Barrier should run optimized code for ↵

On AMD / Intel x86 platforms the SSE2, AVX and AVX2 instruction sets are supported while on ARM platforms the NEON architecture extension can be activated.

Generic code, SSE2 and AVX optimized code will all result in the same solution path. Using AVX2 or NEON might result in a different solution path.

Default:

`-1`

value meaning `-2`

Highest supported [Generic, SSE2, AVX or AVX2]. `-1`

Highest supported solve path consistent code [Generic, SSE2 or AVX]. `0`

Use generic code compatible with all CPUs. `1`

Use SSE2 / NEON optimized code. `2`

Use AVX optimized code. `3`

Use AVX2 optimized code.

**cpuTime** *(integer)*: How time should be measured when timings are reported in the log and when checking against time limits ↵

Default:

`0`

value meaning `-1`

Disable the timer. `0`

Use elapsed time. `1`

Use process time.

**crash** *(integer)*: Simplex: Determines the type of crash used when the algorithm begins ↵

During the crash procedure, an initial basis is determined which is as close to feasibility and triangularity as possible. A good choice at this stage will significantly reduce the number of iterations required to find an optimal solution. The possible values increase proportionally to their time-consumption.

For primal simplex the non-bit-vector choices are relevant.

For dual simplex the bit-vector choices are relevant.

Default:

`2`

value meaning `0`

Turns off all crash procedures. `1`

For singletons only (one pass). `2`

For singletons only (multi pass). `3`

Multiple passes through the matrix considering slacks. `4`

Multiple (≤ 10) passes through the matrix but only doing slacks at the very end. `bit 0 = 1`

Perform standard crash. `bit 1 = 2`

Perform additional numerical checks during crash. `bit 2 = 4`

Extend the set of column candidates for crash. `bit 3 = 8`

Extend the set of row candidates for crash. `bit 4 = 16`

Force crash, i.e., consider all suitable columns/rows as candidates for crash. `n>10`

As for value 4 but performing at most n - 10 passes.

**crossover** *(integer)*: Newton barrier: Determines whether the barrier method will cross over to the simplex method when at optimal solution has been found, to provide an end basis and advanced sensitivity analysis information ↵

The full primal and dual solution is available whether or not crossover is used. The crossover must not be disabled if the barrier is used to reoptimize nodes of a MIP. By default crossover will not be performed on QP and MIQP problems.

Default:

`auto`

value meaning `-1`

Determined automatically. `0`

No crossover. `1`

Primal crossover first. `2`

Dual crossover first.

**crossoverAccuracyTol** *(real)*: Newton barrier: Determines how crossover adjusts the default relative pivot tolerance ↵

When re-inversion is necessary, crossover will compare the recalculated working basic solution with the assumed ones just before re-inversion took place. If the error is above this threshold, crossover will adjust the relative pivot tolerance to address the build-up of numerical inaccuracies.

The full primal and dual solution is available whether or not crossover is used. The crossover must not be disabled if the barrier is used to reoptimize nodes of a MIP. By default crossover will not be performed on QP and MIQP problems.

Range: [

`0`

, ∞]Default:

`1e-06`

**crossoverIterLimit** *(integer)*: Newton barrier: Maximum number of iterations that will be performed in the crossover procedure before the optimization process terminates ↵

Range: {

`0`

, ..., ∞}Default:

`2147483647`

**crossoverOps** *(integer)*: Newton barrier: Bit vector for adjusting the behavior of the crossover procedure ↵

Default:

`0`

value meaning `bit 0 = 1`

Returned solution when the crossover terminates prematurely: 0: Return the last basis from the crossover; 1: Return the barrier solution. `bit 1 = 2`

Select the crossover stages to be performed: 0: Perform both crossover stages; 1: Skip second crossover stage. `bit 2 = 4`

Set crossover behaviour: 0: Force to perform all pivots; 1: Skip pivots that are numerically less reliable. `bit 3 = 8`

Set crossover behaviour: 0: Perform standard crossover; 1: Perform a slower, but numerically more careful crossover.

**crossoverThreads** *(integer)*: Determines the maximum number of threads that parallel crossover is allowed to use ↵

If crossoverThreads is set to the default value (-1), the barThreads control will determine the number of threads used.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**cutDepth** *(integer)*: Branch and Bound: Sets the maximum depth in the tree search at which cuts will be generated ↵

Generating cuts can take a lot of time, and is often less important at deeper levels of the tree since tighter bounds on the variables have already reduced the feasible region. A value of 0 signifies that no cuts will be generated.

Does not affect cutting on the root node.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**cutFactor** *(real)*: Limit on the number of cuts and cut coefficients the optimizer is allowed to add to the matrix during tree search ↵

The cuts and cut coefficients are limited by cutFactor times the number of rows and coefficients in the initial matrix.

A value of 0.0 prevents cuts from being added, and a value of e.g. 1.0 will allow the problem to grow to twice the initial number of rows and coefficients.

Default:

`auto`

value meaning `-1`

Let the optimizer decide on the maximum amount of cuts based on cutStrategy. `>=0`

Multiple of number of rows and coefficients to use.

**cutFreq** *(integer)*: Branch and Bound: Frequency at which cuts are generated in the tree search ↵

If the depth of the node modulo cutFreq is zero, then cuts will be generated.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**cutSelect** *(integer)*: Bit vector providing detailed control of the cuts created for the root node of a MIP solve ↵

Use treeCutSelect to control cuts during the tree search.

The default value is -1 which enables all bits. Any bits not listed in the above table should be left in their default ′on′ state, since the interpretation of such bits might change in future versions of the optimizer.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`-1`

value meaning `bit 5 = 32`

Equivalent to cutSelect_clique. `bit 6 = 64`

Equivalent to cutSelect_mir. `bit 7 = 128`

Equivalent to cutSelect_cover. `bit 8 = 256`

Equivalent to cutSelect_mirRowAggregation. `bit 11 = 2048`

Equivalent to cutSelect_flowpath. `bit 12 = 4096`

Equivalent to cutSelect_implication. `bit 13 = 8192`

Equivalent to cutSelect_liftAndProject. `bit 14 = 16384`

Equivalent to cutSelect_disableCutRows. `bit 15 = 32768`

Equivalent to cutSelect_gubCover. `bit 16 = 65536`

Equivalent to cutSelect_zeroHalf. `bit 17 = 131072`

Equivalent to cutSelect_indicator. `bit 18 = 262144`

Equivalent to cutSelect_gomory. `bit 20 = 1048576`

Equivalent to cutSelect_farkas.

**cutSelect_clique** *(boolean)*: Clique cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_cover** *(boolean)*: Lifted cover cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_disableCutRows** *(boolean)*: Disable cutting from cut rows ↵

See also cutSelect.

Default:

`1`

**cutSelect_farkas** *(boolean)*: Farkas cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_flowpath** *(boolean)*: Flow path cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_gomory** *(boolean)*: Strong Chvatal-Gomory cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_gubCover** *(boolean)*: Lifted GUB cover cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_implication** *(boolean)*: Implication cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_indicator** *(boolean)*: Indicator constraint cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_liftAndProject** *(boolean)*: Turn on automatic Lift-and-Project cutting strategy ↵

See also cutSelect.

Default:

`1`

**cutSelect_mir** *(boolean)*: Mixed Integer Rounding (MIR) cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_mirRowAggregation** *(boolean)*: Turn on row aggregation for MIR cuts ↵

See also cutSelect.

Default:

`1`

**cutSelect_zeroHalf** *(boolean)*: Zero-half cuts ↵

See also cutSelect.

Default:

`1`

**cutStrategy** *(integer)*: Branch and Bound: Cut strategy ↵

A more aggressive cut strategy, generating a greater number of cuts, will result in fewer nodes to be explored, but with an associated time cost in generating the cuts. The fewer cuts generated, the less time taken, but the greater subsequent number of nodes to be explored.

Default:

`auto`

value meaning `-1`

Automatic selection of the cut strategy. `0`

No cuts. `1`

Conservative cut strategy. `2`

Moderate cut strategy. `3`

Aggressive cut strategy.

**defaultAlg** *(integer)*: Selects the algorithm that will be used to solve the LP ↵

Please note that this will affect how the MIP node LP problems are solved during the global search.

Default:

`auto`

value meaning `1`

Automatically determined. `2`

Dual simplex. `3`

Primal simplex. `4`

Newton barrier.

**denseColLimit** *(integer)*: Newton barrier: Controls trigger point for special treatment of dense columns in Cholesky factorization ↵

Columns with more than denseColLimit elements are considered to be dense. Such columns will be handled specially in the Cholesky factorization of this matrix.

Range: {

`0`

, ..., ∞}Default:

`auto`

**deterministic** *(integer)*: Selects whether to use a deterministic or opportunistic mode when solving a problem using multiple threads ↵

In deterministic mode thread synchronization is performed in deterministic order, which guarantees that repeated solves of the same problems under the same starting conditions will always produce the same outcome. This assumes that there are no non-deterministic events affecting the solve, such as interruption due to time limits or non-deterministic interaction through callback functions. In opportunistic mode the solver will always schedule work on any available thread. This can produce higher CPU utilization, but will sacrifice reproducability.

Default:

`1`

value meaning `0`

Use opportunistic mode. `1`

Use deterministic mode. `2`

Use deterministic mode, except allow the initial concurrent continuous solve of a MIP to be opportunistic.

**dualGradient** *(integer)*: Simplex: Dual simplex pricing method ↵

Default:

`auto`

value meaning `-1`

Determine automatically. `0`

Devex. `1`

Steepest edge. `2`

Direct steepest edge. `3`

Sparse Devex.

**dualize** *(integer)*: Whether presolve should form the dual of the problem ↵

Default:

`auto`

value meaning `-1`

Determine automatically. `0`

Solve the primal problem. `1`

Solve the dual problem.

**dualizeOps** *(boolean)*: Bit-vector control for adjusting the behavior when a problem is dualized ↵

Default:

`1`

value meaning `bit 0 = 1`

Swap the simplex algorithm to run. If dual simplex is selected for the original problem then primal simplex will be run on the dualized problem, and simiarly if primal simplex is selected.

**dualPerturb** *(real)*: Factor by which the problem will be perturbed prior to optimization by dual simplex ↵

A value of 0.0 results in no perturbation prior to optimization. Note the interconnection to the autoPerturb control. If autoPerturb is set to 1, the decision whether to perturb or not is left to the Optimizer. When the problem is automatically perturbed in dual simplex, however, the value of dualPerturb will be used for perturbation.

Range: [-∞, ∞]

Default:

`auto`

**dualStrategy** *(integer)*: Bit-vector control specifies the dual simplex strategy ↵

Default:

`1`

value meaning `bit 0 = 1`

Switch to primal when re-optimization goes dual infeasible and numerically unstable. `bit 1 = 2`

When dual intend to switch to primal, stop the solve instead of switching to primal. `bit 2 = 4`

Use more aggressive cut-off in MIP search. `bit 3 = 8`

Use dual simplex to remove cost perturbations. `bit 4 = 16`

Enable more aggressive dual pivoting strategy. `bit 5 = 32`

Keep using dual simplex even when it′s numerically unstable.

**dualThreads** *(integer)*: Determines the maximum number of threads that dual simplex is allowed to use ↵

If dualThreads is set to the default value (-1), the threads control will determine the number of threads used.

When solving a linear MIP, the dual simplex algorithm will use multiple threads only when solving the initial LP relaxation or when reoptimizing between rounds of cuts on the root node. The parallel dual simplex algorithm differs from the sequential dual simplex algorithm and might follow a different solve path. For dualThreads > 1 the solve path is independent of the number of threads used, although the practical limit for observing performance benefits is around dualThreads = 8.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**eigenvalueTol** *(real)*: Quadratic matrix is considered not to be positive semi-definite, if its smallest eigenvalue is smaller than the negative of this value ↵

Range: [

`0`

, ∞]Default:

`1e-06`

**elimFillin** *(integer)*: Amount of fill-in allowed when performing an elimination in presolve ↵

Range: {

`0`

, ..., ∞}Default:

`10`

**elimTol** *(real)*: Markowitz tolerance for the elimination phase of the presolve ↵

Range: [

`0`

, ∞]Default:

`0.001`

**etaTol** *(real)*: Tolerance on eta elements ↵

During each iteration, the basis inverse is premultiplied by an elementary matrix, which is the identity except for one column - the eta vector. Elements of eta vectors whose absolute value is smaller than etaTol are taken to be zero in this step.

Range: [

`0`

, ∞]Default:

`1e-13`

**feasibilityJump** *(boolean)*: MIP: Decides if the Feasibility Jump heuristic should be run ↵

Default:

`1`

value meaning `0`

Turned off. `1`

Run the heuristic.

**feasibilityPump** *(integer)*: Branch and Bound: Decides if the Feasibility Pump heuristic should be run at the top node ↵

Default:

`auto`

value meaning `-1`

Automatic. `0`

Turned off. `1`

Always try the Feasibility Pump. `2`

Try the Feasibility Pump only if other heuristics have failed to find an integer solution.

**feasTol** *(real)*: Determines when a solution is treated as feasible ↵

If the amount by which a constraint′s activity violates its right-hand side or ranged bound is less in absolute magnitude than feasTol, then the constraint is treated as satisfied. Similarly, if the amount by which a column violates its bounds is less in absolute magnitude than feasTol, those bounds are also treated as satisfied.

Range: [

`0`

, ∞]Default:

`1e-06`

**feasTolPerturb** *(real)*: Determines how much a feasible primal basic solution is allowed to be perturbed when performing basis changes ↵

The tolerance feasTol is always considered as an upper limit for the perturbations, but in some cases smaller value can be more desirable.

Range: [

`0`

, ∞]Default:

`1e-06`

**feasTolTarget** *(real)*: Target feasibility tolerance for the solution refiner ↵

Zero and negative values are ignored, and the value of feasTol is used.

Use very small values like 1e-100 to state the refinement should continue as long as an improvement is made. Use very large values like 1e+100 to disable only this aspect of the refiner.

Refining solutions to match the feastoltarget can influence and worsen their objective value in case the previous objective could only be achieved through slight infeasibilities.

Range: [-∞, ∞]

Default:

`0`

**fixoptfile** *(string)*: name of option file which is read just before solving the fixed problem ↵

**forceParallelDual** *(boolean)*: Dual simplex: Specifies whether the dual simplex solver should always use the parallel simplex algorithm ↵

By default, when using a single thread, the dual simplex solver will execute a dedicated sequential simplex algorithm.

Default:

`0`

value meaning `0`

Disabled. `1`

Enabled. Force the dual simplex solver to use the parallel algorithm.

**genConsAbsTransformation** *(integer)*: Specifies the reformulation method for absolute value general constraints at the beginning of the search ↵

Default:

`auto`

value meaning `-1`

Automatic. `0`

Use a formulation based on indicator constraints. `1`

Use a formulation based on SOS1-contraints.

**genConsDualReductions** *(boolean)*: Parameter specifies whether dual reductions should be applied to reduce the number of columns and rows added when transforming general constraints to MIP structs ↵

Default:

`1`

value meaning `0`

Disabled. No dual reductions, add columns and rows. `1`

Enabled. Only add neccessary columns and rows, drop those implied by the objective sense.

**globalBoundingBox** *(real)*: If a nonlinear problem cannot be solved due to appearing unbounded, it can automatically be regularized by the application of a bounding box on the variables ↵

If this control is set to a negative value, in a second solving attempt all original variables will be bounded by the absolute value of this control. If set to a positive value, there will be a third solving attempt afterwards, if necessary, in which also all auxiliary variables are bounded by this value.

Default:

`1e+06`

value meaning `0`

Disabled. Problem will return unbounded. `n<0`

Enabled. Apply lower and upper bounds of this magnitude to all original variables if initial LP is unbounded. `n>0`

Enabled. Apply lower and upper bounds of this magnitude to all original and auxiliary variables if initial LP and first regularization are unbounded.

**gomCuts** *(integer)*: Branch and Bound: Number of rounds of Gomory or lift-and-project cuts at the top node ↵

Range: {

`-1`

, ..., ∞}Default:

`auto`

**heurBeforeLp** *(integer)*: Branch and Bound: Determines whether primal heuristics should be run before the initial LP relaxation has been solved ↵

It is possible that a heuristic will find an optimal integer solution that will result in the LP relaxation solution being cut off. If dedicated heuristic threads are enabled through the heurThreads control, then the initial heuristics will be run in parallel with the LP solve, instead of before.

Default:

`auto`

value meaning `-1`

Automatic - let the optimizer decide if heuristics should be run. `0`

Disabled. `1`

Enabled.

**heurDiveIterLimit** *(real)*: Branch and Bound: Simplex iteration limit for reoptimizing during the diving heuristic ↵

Default:

`auto`

value meaning `0`

No iteration limit. `>=1`

Fixed iteration limit. `<0`

Automatic selection of the iteration limit based on the problem size. The absolute value is used as a multiplier on the automatic selection.

**heurDiveRandomize** *(real)*: Level of randomization to apply in the diving heuristic ↵

The diving heuristic uses priority weights on rows and columns to determine the order in which to e.g. round fractional columns, or the direction in which to round them. This control determines by how large a random factor these weights should be changed.

Default:

`0`

value meaning `0.0-1.0`

Amount of randomization (0.0=none, 1.0=full)

**heurDiveSoftRounding** *(integer)*: Branch and Bound: Enables a more cautious strategy for the diving heuristic, where it tries to push binaries and integer variables to their bounds using the objective, instead of directly fixing them ↵

This can be useful when the default diving heuristics fail to find any feasible solutions.

Default:

`auto`

value meaning `-1`

Automatic selection. `0`

Do not use soft rounding. `1`

Cautious use of the soft rounding strategy. `2`

More aggressive use of the soft rounding strategy.

**heurDiveSpeedUp** *(integer)*: Branch and Bound: Changes the emphasis of the diving heuristic from solution quality to diving speed ↵

Default:

`-1`

value meaning `-2`

Automatic selection biased towards quality `-1`

Automatic selection biased towards speed. `0-4`

Manual emphasis bias from emphasis on quality (0) to emphasis on speed (4).

**heurDiveStrategy** *(integer)*: Branch and Bound: Chooses the strategy for the diving heuristic ↵

Default:

`auto`

value meaning `-1`

Automatic selection of strategy. `0`

Disables the diving heuristic. `1-18`

Available pre-set strategies for rounding infeasible MIP entities and reoptimizing during the heuristic dive.

**heurEmphasis** *(integer)*: Branch and Bound: Specifies an emphasis for the search w.r.t. primal heuristics and other procedures that affect the speed of convergence of the primal-dual gap ↵

For problems where the goal is to achieve a small gap but not neccessarily solving them to optimality, it is recommended to set heurEmphasis to 1. This setting triggers many additional heuristic calls, aiming for reducing the gap at the beginning of the search, typically at the expense of an increased time for proving optimality.

Default:

`-1`

value meaning `-1`

Optimizer default strategy. `0`

Disables all heuristics. `1`

Focus on reducing the primal-dual gap in the early part of the search. `2`

Extremely aggressive search heuristics.

**heurForceSpecialObj** *(boolean)*: Branch and Bound: Whether local search heuristics without objective or with an auxiliary objective should always be used, despite the automatic selection of the Optimizer ↵

Deactivated by default.

Default:

`0`

value meaning `0`

Disabled. `1`

Enabled. Run special objective heuristics on large problems and even if incumbent exists.

**heurFreq** *(integer)*: Branch and Bound: Frequency at which heuristics are used in the tree search ↵

Heuristics will only be used at a node if the depth of the node is a multiple of heurFreq.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**heurSearchEffort** *(real)*: Adjusts the overall level of the local search heuristics ↵

heurSearchEffort is used as a multiplier on the default amount of work the local search heuristics should do. A higher value means the local search heuristics will be run more often and that they are allowed to search larger neighborhoods.

Range: [

`0`

, ∞]Default:

`1`

**heurSearchFreq** *(integer)*: Branch and Bound: How often the local search heuristic should be run in the tree ↵

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disabled in the tree. `n>0`

Number of nodes between each run.

**heurSearchRootCutFreq** *(integer)*: How frequently to run the local search heuristic during root cutting ↵

This is given as how many cut rounds to perform between runs of the heuristic. Set to zero to avoid applying the heuristic during root cutting. Branch and Bound: This specifies how often the local search heuristic should be run in the tree.

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disabled heuristic during cutting. `n>0`

Number of cutting rounds between each run.

**heurSearchRootSelect** *(integer)*: Bit vector control for selecting which local search heuristics to apply on the root node of a MIP solve ↵

Use heurSearchTreeSelect to control local search heuristics during the tree search.

Some of the local search heuristics will benefit from having an existing incumbent solution, but it is not required.

Default:

`117`

value meaning `bit 0 = 1`

Local search with a large neighborhood. Potentially slow but is good for finding solutions that differs significantly from the incumbent. `bit 1 = 2`

Local search with a small neighborhood centered around a node LP solution. `bit 2 = 4`

Local search with a small neighborhood centered around an integer solution. This heuristic will often provide smaller, incremental improvements to an incumbent solution. `bit 3 = 8`

Local search with a neighborhood set up through the combination of multiple integer solutions. `bit 4 = 16`

Unused `bit 5 = 32`

Local search without an objective function. Called seldom and only when no feasible solution is available. `bit 6 = 64`

Local search with an auxiliary objective function. Called seldom and only when no feasible solution is available.

**heurSearchTreeSelect** *(integer)*: Bit vector control for selecting which local search heuristics to apply during the tree search of a MIP solve ↵

Use heurSearchRootSelect to control local search heuristics on the root node.

Some of the local search heuristics will benefit from having an existing incumbent solution, but it is not required.

Default:

`17`

value meaning `bit 0 = 1`

Local search with a large neighborhood. Potentially slow but is good for finding solutions that differs significantly from the incumbent. `bit 1 = 2`

Local search with a small neighborhood centered around a node LP solution. `bit 2 = 4`

Local search with a small neighborhood centered around an integer solution. This heuristic will often provide smaller, incremental improvements to an incumbent solution. `bit 3 = 8`

Local search with a neighborhood set up through the combination of multiple integer solutions. `bit 4 = 16`

Unused `bit 5 = 32`

Local search without an objective function. Called seldom and only when no feasible solution is available. `bit 6 = 64`

Local search with an auxiliary objective function. Called seldom and only when no feasible solution is available.

**heurThreads** *(integer)*: Branch and Bound: Number of threads to dedicate to running heuristics on the root node ↵

When heuristic threads are enable, the heuristics will be run in parallel with the initial LP solve, if possible, and in parallel with the root cutting.

Default:

`0`

value meaning `-1`

Automatically determined from the threads control. `0`

Disabled. Heuristics will be run sequentially with the root LP solve and cutting. `>=1`

Number of root threads to dedicate to parallel heuristics.

**historyCosts** *(integer)*: Branch and Bound: How to update the pseudo cost for a MIP entity when a strong branch or a regular branch is applied ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

No update. `1`

Update using only regular branches from the root to the current node. `2`

Same as 1, but update with strong branching results as well. `3`

Update using any regular branching or strong branching information from all nodes solves before the current node.

**ifCheckConvexity** *(boolean)*: Determines if the convexity of the problem is checked before optimization ↵

Applies to quadratic, mixed integer quadratic and quadratically constrained problems. Checking convexity takes some time, thus for problems that are known to be convex it might be reasonable to switch the checking off.

Default:

`1`

value meaning `0`

Turn off convexity checking. `1`

Turn on convexity checking.

**indLinBigM** *(real)*: During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough ↵

This control defines the largest BigM for which such a linearized version will be added to the problem in addition to the original constraint. If the BigM is even smaller than indPreLinBigM, then the original indicator constraint will additionally be dropped from the problem.

indLinBigM should always be at least as large as indPreLinBigM. For any value less or equal to indPreLinBigM, indicator constraints will never be duplicated and only indPreLinBigM is taken into account for linearization.

Range: [

`0`

, ∞]Default:

`100000`

**indPreLinBigM** *(real)*: During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough ↵

This control defines the largest BigM for which the original constraint will be replaced by the linearized version. If the BigM is larger than indPreLinBigM but smaller than indLinBigM, the linearized row will be added but the original indicator constraint is kept as a numerically stable way to check feasibility.

Replacing an indicator constraint with a BigM row has a side effect on tolerances. In the indicator constraint form, the constraint part is satisfied with feasTol tolerance; while after changing it to BigM form, the constraint also includes the binary indicator variable (with a coefficient up to indPreLinBigM and an integrality tolerance of mipTol), therefore the constraint part of the indicator contraint is satisfied with tolerance feasTol+mipTol*indPreLinBigM.

Range: [

`0`

, ∞]Default:

`100`

**inputTol** *(real)*: Tolerance on input values elements ↵

If any value is less than or equal to inputTol in absolute value, it is treated as zero. For the internal zero tolerance see matrixTol.

This control needs to be set before inputting the problem, as it has no effect afterwards.

Range: [

`0`

, ∞]Default:

`0`

**invertFreq** *(integer)*: Simplex: Frequency with which the basis will be inverted ↵

The basis is maintained in a factorized form and on most simplex iterations it is incrementally updated to reflect the step just taken. This is considerably faster than computing the full inverted matrix at each iteration, although after a number of iterations the basis becomes less well-conditioned and it becomes necessary to compute the full inverted matrix. The value of invertFreq specifies the maximum number of iterations between full inversions.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**invertMin** *(integer)*: Simplex: Minimum number of iterations between full inversions of the basis matrix ↵

See the description of invertFreq for details.

Range: {

`0`

, ..., ∞}Default:

`3`

**ioTimeout** *(integer)*: Maximum number of seconds to wait for an I/O operation before it is cancelled ↵

Range: {

`0`

, ..., ∞}Default:

`30`

**knitroOptFile** *(string)*: Option file for NLP solver KNITRO ↵

**lnpBest** *(integer)*: Number of infeasible MIP entities to create lift-and-project cuts for during each round of Gomory cuts at the top node (see gomCuts) ↵

Range: {

`0`

, ..., ∞}Default:

`50`

**lnpIterLimit** *(integer)*: Number of iterations to perform in improving each lift-and-project cut ↵

By setting the number to zero a Gomory cut will be created instead.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**loadMipSol** *(boolean)*: Loads a MIP solution (the initial point) ↵

If true, the initial point provided by GAMS will be passed to the optimizer to be treated as an integer feasible point. The optimizer uses the values for the discrete variables only: the level values for the continuous variables are ignored and are calculated by fixing the integer variables and reoptimizing. In some cases, loading an initial MIP solution can improve performance. In addition, there will always be a feasible solution to return.

Default:

`0`

**localChoice** *(integer)*: Controls when to perform a local backtrack between the two child nodes during a dive in the branch and bound tree ↵

Default:

`auto`

value meaning `1`

Never backtrack from the first child, unless it is dropped (infeasible or cut off). `2`

Always solve both child nodes before deciding which child to continue with. `3`

Automatically determined.

**lpFlags** *(integer)*: Bit-vector control which defines the algorithm for solving an LP problem or the initial LP relaxation of a MIP problem ↵

When more than one bit is set, then the LP problem will be solved with the concurrent solver. When this control and

`algorithm`

is set at the same time,`algorithm`

will overrule the value of this control.Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`0`

value meaning `bit 0 = 1`

Equivalent to lpFlags_dual. `bit 1 = 2`

Equivalent to lpFlags_primal. `bit 2 = 4`

Equivalent to lpFlags_barrier. `bit 3 = 8`

Equivalent to lpFlags_network.

**lpFlags_barrier** *(boolean)*: Use the barrier method ↵

See also lpFlags.

Default:

`0`

**lpFlags_dual** *(boolean)*: Use the dual simplex method ↵

See also lpFlags.

Default:

`0`

**lpFlags_network** *(boolean)*: Use the network simplex method ↵

See also lpFlags.

Default:

`0`

**lpFlags_primal** *(boolean)*: Use the primal simplex method ↵

See also lpFlags.

Default:

`0`

**lpFolding** *(integer)*: Simplex and barrier: Whether to fold an LP problem before solving it ↵

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disable LP folding. `1`

Enable LP folding. Attempt to fold all LP problems and MIP initial relaxations.

**lpIterLimit** *(integer)*: Maximum number of iterations that will be performed by primal simplex or dual simplex before the optimization process terminates ↵

Synonym: iterlim

For MIP problems, this is the maximum total number of iterations over all nodes explored by the Branch and Bound method.

Range: {

`0`

, ..., ∞}Default:

`maxint`

**lpLog** *(integer)*: Simplex: Frequency at which the simplex log is printed ↵

This control only has an effect if lpLogStyle is set to 0.

Default:

`100`

value meaning `0`

Log displayed at the end of the optimization only. `n<0`

Detailed output every - n iterations. `n>0`

Summary output every n iterations.

**lpLogDelay** *(real)*: Time interval between two LP log lines ↵

This control only has an effect if lpLogStyle is set to 1.

Range: [

`0`

, ∞]Default:

`1`

**lpLogStyle** *(boolean)*: Simplex: Style of the simplex log ↵

Default:

`1`

value meaning `0`

Simplex log is printed based on simplex iteration count, at a fixed frequency as specified by the lpLog control. `1`

Simplex Log is printed based on an estimation of elapsed time, determined by an internal deterministic timer.

**lpRefineIterLimit** *(integer)*: Simplex iteration limit the solution refiner can spend in attempting to increase the accuracy of an LP solution ↵

The solution refiner iteratively attempts to increase the accuracy of the solution until either both feasTolTarget and optimalityTolTarget is satisfied, or accuracy cannot further be increased, or the effort limit determined by lpRefineIterLimit is exhausted.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**markowitzTol** *(real)*: Markowitz tolerance used for the factorization of the basis matrix ↵

Range: [

`0`

, ∞]Default:

`0.01`

**matrixTol** *(real)*: Zero tolerance on matrix elements ↵

If the value of a matrix element is less than or equal to matrixTol in absolute value, it is treated as zero. The control applies when solving a problem, for an input tolerance see inputTol.

Range: [

`0`

, ∞]Default:

`1e-09`

**maxCutTime** *(real)*: Maximum amount of time allowed for generation of cutting planes and reoptimization ↵

The limit is checked during generation and no further cuts are added once this limit has been exceeded.

Default:

`0`

value meaning `0`

No time limit. `>0`

Stop cut generation after the given number of seconds.

**maxImpliedBound** *(real)*: Presolve: When tighter bounds are calculated during MIP preprocessing, only bounds whose absolute value are smaller than maxImpliedBound will be applied to the problem ↵

For numerically challenging MIP problems, it can sometimes help make the solve more stable by reducing the value of maxImpliedBound to something smaller - e.g. 1.0E+06. It is not recommended to increase this parameter beyond the default of 1.0E+08.

Range: [

`0`

, ∞]Default:

`1e+08`

**maxLocalBacktrack** *(integer)*: Branch-and-Bound: How far back up the current dive path the optimizer is allowed to look for a local backtrack candidate node ↵

If this control is set to k, then the candidate set of nodes for a local backtrack will consist of all active nodes in the subtree rooted at height k above the current node. For example, a setting of 1 will result in only sibling nodes of the current node being considered.

Default:

`auto`

value meaning `-1`

Automatic. `n>0`

Local backtrack limit.

**maxMemoryHard** *(integer)*: Sets the maximum amount of memory in megabytes the optimizer should allocate ↵

If this limit is exceeded, the solve will terminate. This control is designed to make the optimizer stop in a controlled manner, so that the problem object is valid once termination occurs. The solve state will be set to incomplete. This is different to an out of memory condition in which case the optimizer returns an error. The optimizer may still allocate memory once the limit is exceeded to be able to finsish the operations and stop in a controlled manner. When resourceStrategy is enabled, the control also has the same effect as maxMemorySoft and will cause the optimizer to try preserving memory when possible.

Range: {

`0`

, ..., ∞}Default:

`unlimited`

**maxMemorySoft** *(integer)*: When resourceStrategy is enabled, this control sets the maximum amount of memory in megabytes the optimizer targets to allocate ↵

This may change the solving path, but will not cause the solve to terminate early. To set a hard version of the same, please set maxMemoryHard.

Range: {

`0`

, ..., ∞}Default:

`unlimited`

**maxMipSol** *(integer)*: Branch and Bound: Limit on the number of integer solutions to be found by the Optimizer ↵

It is possible that during optimization the Optimizer will find the same objective solution from different nodes. However, maxMipSol refers to the total number of integer solutions found, and not necessarily the number of distinct solutions.

Setting maxMipSol=1 can alter the solution path as this will put the emphasis on finding any feasible solution by triggering additional heuristics.

Range: {

`0`

, ..., ∞}Default:

`0`

**maxMipTasks** *(integer)*: Branch-and-Bound: The maximum number of tasks to run in parallel during a MIP solve ↵

The MIP solver will create smaller tasks from individual active nodes or based on local search heuristics. These are tasks that will be executed in parallel by the number of threads set by mipThreads.

If maxMipTasks is set to a fixed, positive value, the branch-and-bound tree nodes will always be solved in the same deterministic way, independent of the actual number of executing threads implied by mipThreads. How a MIP is solved will still depend on the number of threads used for solving the continuous relaxation and therefore on the settings for the controls barThreads, barCores, dualThreads and concurrentThreads). To obtain a MIP solve that is completely independent of the number of threads, it is sufficient to set maxMipTasks, forceParallelDual, barThreads and barCores. The concurrent LP solver should be avoided in this case.

While you can set this control to large value, the implementation will limit the number of tasks for performance reasons. This limit is currently 32 on 32bit platforms and 256 on 64 bit platforms.

Default:

`auto`

value meaning `-1`

Task limit determined automatically from mipThreads. `>0`

Fixed task limit.

**maxNode** *(integer)*: Branch and Bound: Maximum number of nodes that will be explored ↵

Range: {

`0`

, ..., ∞}Default:

`maxint`

**maxScaleFactor** *(integer)*: Determines the maximum scaling factor that can be applied during scaling ↵

The maximum is provided as an exponent of a power of 2.

Default:

`64`

value meaning `0-64`

The maximum is provided an exponent of a power of 2.

**maxStallTime** *(real)*: Maximum time in seconds that the Optimizer will continue to search for improving solution after finding a new incumbent ↵

Default:

`0`

value meaning `0`

No stall time limit. `>0`

If an integer solution has been found, stop MIP search after the given number of seconds without a new incumbent. No effect as long as no solution was found.

**mipAbsCutoff** *(real)*: Branch and Bound: If the user knows that they are interested only in values of the objective function which are better than some value, this can be assigned to mipAbsCutoff ↵

This allows the Optimizer to ignore solving any nodes which may yield worse objective values, saving solution time.

Range: [-∞, ∞]

Default:

`auto`

**mipAbsStop** *(real)*: Branch and Bound: Absolute tolerance determining whether the tree search will continue or not ↵

It will terminate if | MIPOBJVAL - BESTBOUND| ≤ mipAbsStop where MIPOBJVAL is the value of the best solution′s objective function, and BESTBOUND is the current best solution bound. For example, to stop the tree search when a MIP solution has been found and the Optimizer can guarantee it is within 100 of the optimal solution, set mipAbsStop to 100.

Range: [

`0`

, ∞]Default:

`0`

**mipAddCutoff** *(real)*: Branch and Bound: Amount to add to the objective function of the best integer solution found to give the new CURRMIPCUTOFF ↵

Once an integer solution has been found whose objective function is equal to or better than CURRMIPCUTOFF, improvements on this value may not be interesting unless they are better by at least a certain amount. If mipAddCutoff is nonzero, it will be added to CURRMIPCUTOFF each time an integer solution is found which is better than this new value. This cuts off sections of the tree whose solutions would not represent substantial improvements in the objective function, saving processor time. The control mipAbsStop provides a similar function but works in a different way.

Range: [-∞, ∞]

Default:

`0`

**mipCleanup** *(boolean)*: Clean up the MIP solution (round-fix-solve) to get duals ↵

If nonzero, clean up the integer solution obtained, i.e. round and fix the discrete variables and re-solve as an LP to get some marginal values for the discrete vars.

Default:

`1`

**mipComponents** *(integer)*: Determines whether disconnected components in a MIP should be solved as separate MIPs ↵

There can be significant performence benefits from solving disconnected components individual instead of being part of the main branch-and-bound search.

If there are no constraints linking two variables, either directly or indirectly through other variables, they are said to belong to two separate disconnected components. When a problem contains disconnected components of signficant size, it can be advantageous to solve each component as a separate MIP. When significant disconnected components are detected in the problem, the solver will switch to a different solve mode where each component is solved separately. This switch will happen after the root node processing has completed and when the solve is about to enter the branch-and-bound search.

Solving disconnected components separately is not compatible with concurrent MIP solves. If concurrent MIP solves has been turned off, disconnected components will be solved as part of the standard branch-and-bound search in each concurrent solve.

Disabling MIP dual reductions through mipDualReductions will also disable the separate solve of disconnected components.

Default:

`auto`

value meaning `-1`

Automatic - let the solver decide. `0`

Disable solving disconnected components separately. `1`

Solve disconnected components separately.

**mipConcurrentNodes** *(integer)*: Sets the node limit for when a winning solve is selected when concurrent MIP solves are enabled ↵

When multiple MIP solves are started, they each run up to the mipConcurrentNodes node limit and only one winning solve is selected for contuinuing the search with.

Default:

`auto`

value meaning `-1`

Automatic - let the solver decide on a node limit. `>0`

Number of nodes each concurrent solve should complete before a winner is selected.

**mipConcurrentSolves** *(integer)*: Selects the number of concurrent solves to start for a MIP ↵

Each solve will use a unique random seed for its random number generator, but will otherwise apply the same user controls. The first concurrent solve to complete will have solved the MIP and all the concurrent solves will be terminated at this point. Using concurrent solves can be advantageous when a MIP displays a high level of performance variability.

A node limit is imposed on each concurrent solve, through mipConcurrentNodes. When a concurrent solve reaches this node limit, it will be suspended until all concurrent solves have reached the limit. At this point a winner will be declared, based on which solve made the most progress towards optimality and only the winning solve will continue, using all threading resources. If a concurrent solve completes its MIP search before reaching the node limit, all solves will be stopped.

Default:

`0`

value meaning `-1`

Enabled. The number of concurrent solves depends on mipThreads. `n>1`

Enabled. The number of concurrent solves to start is given by n. `0, 1`

Disabled

**mipDualReductions** *(integer)*: Branch and Bound: Limits operations that can reduce the MIP solution space ↵

The mipDualReductions control, when set to a value different from 1 will adjust the values of other controls in order to prevent MIP solver operations that can result in the removal of dominated solutions. For example, dual reductions during preprocessing attempts to remove dominated solutions based on objective arguments, assuming that all constraints are known to the Optimizer. If a problem is detected to have symmetries, the solver might also remove some symmetrical solutions from the search space. In both cases, the set of feasible MIP solutions might be reduced. With default settings, it is only guaranteed that at least one optimal solution remains.

When attempting to collect the n-best solutions, it is recommended to set mipDualReductions=2. This will ensure that the only solutions missed by the enumeration are those that only differ from an existing solution in the values of the continuous variables.

Default:

`1`

value meaning `0`

Prevent all dual reductions. `1`

Allow all dual reductions. `2`

Allow dual reductions on continuous variables only.

**mipFracReduce** *(integer)*: Branch and Bound: Specifies how often the optimizer should run a heuristic to reduce the number of fractional integer variables in the node LP solutions ↵

This heuristic is only applicable to problems that are dual degenerate. These are problems that contain multiple solutions with identical objective function value. The more dual degenerate a problem is, the more likely it will be for this heuristic to have an improving effect.

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disabled. `1`

Run before and after cutting on the root node. `2`

Run also during root cutting. `3`

Run also during the tree search.

**mipKappaFreq** *(integer)*: Branch and Bound: Specifies how frequently the basis condition number (also known as kappa) should be calculated during the branch-and-bound search ↵

The condition number is calculated as the norm of the basis matrix multiplied by the norm of its inverse. This uses the Froebenius norm.

A summary will be printed at the end of the solve, summarizing the collected condition numbers collected:

- Nodes kappa stable: No. of stable sampled nodes (kappa <
`10^7`

)- Nodes kappa suspicius: No. of suspicious sampled nodes (
`10^7`

≤ kappa <`10^10`

)- Nodes kappa unstable: No. of unstable sampled nodes (
`10^10`

≤ kappa <`10^13`

)- Nodes kappa ill-posed: No. of ill-posed sampled nodes (
`10^13`

≤ kappa)- Largest kappa seen: The largest condition number calculated through all sampled nodes.
- Kappa attention level: A measure of how ill-posed the problem is (between 0 and 1).
Default:

`0`

value meaning `0`

Do not calculate condition numbers. `1`

Calculate conditions numbers on every node, including after each round of root cutting. `n>1`

Calculate a condition number once per node of every n′th level of the branch-and-bound tree.

**mipLog** *(integer)*: MIP log print control ↵

Default:

`-100`

value meaning `0`

No printout during MIP tree search. `1`

Only print out summary statement at the end. `2`

Print out detailed log at all solutions found. `3`

Print out detailed log at each node. `-n`

Print out summary log at each n th node.

**mipPresolve** *(integer)*: Branch and Bound: Type of integer processing to be performed ↵

If set to 0, no processing will be performed.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`-1`

value meaning `bit 0 = 1`

Equivalent to mipPresolve_reducedCostFixing. `bit 1 = 2`

Equivalent to mipPresolve_logicPreprocessing. `bit 2 = 4`

[Unused] This bit is no longer used to control probing. Refer to the integer control preProbing for setting probing level during presolve. `bit 3 = 8`

Equivalent to mipPresolve_allowChangeBounds. `bit 4 = 16`

Equivalent to mipPresolve_dualReductions. `bit 5 = 32`

Equivalent to mipPresolve_globalCoefTightening. `bit 6 = 64`

Equivalent to mipPresolve_objBasedReductions. `bit 7 = 128`

Equivalent to mipPresolve_allowTreeRestart. `bit 8 = 256`

Equivalent to mipPresolve_symmetryReductions.

**mipPresolve_allowChangeBounds** *(boolean)*: If node preprocessing is allowed to change bounds on continuous columns ↵

See also mipPresolve.

Default:

`1`

**mipPresolve_allowTreeRestart** *(boolean)*: [Unused] This bit is no longer used to control restarts ↵

Refer to the integer control mipRestart for disabling tree restarts.

See also mipPresolve.

Default:

`1`

**mipPresolve_dualReductions** *(boolean)*: Dual reductions will be performed at each node ↵

See also mipPresolve.

Default:

`1`

**mipPresolve_globalCoefTightening** *(boolean)*: Allow global (non-bound) tightening of the problem during the tree search ↵

See also mipPresolve.

Default:

`1`

**mipPresolve_logicPreprocessing** *(boolean)*: Primal reductions will be performed at each node ↵

Uses constraints of the node to tighten the range of variables, often resulting in fixing their values. This greatly simplifies the problem and may even determine optimality or infeasibility of the node.

See also mipPresolve.

Default:

`1`

**mipPresolve_objBasedReductions** *(boolean)*: Objective function will be used to find reductions at each node ↵

See also mipPresolve.

Default:

`1`

**mipPresolve_reducedCostFixing** *(boolean)*: Reduced cost fixing will be performed at each node ↵

This can simplify the node before it is solved, by deducing that certain variables′ values can be fixed based on additional bounds imposed on other variables at this node.

See also mipPresolve.

Default:

`1`

**mipPresolve_symmetryReductions** *(boolean)*: Allow that symmetry is used to presolve the node problem ↵

See also mipPresolve.

Default:

`1`

**mipRampUp** *(integer)*: Controls the strategy used by the parallel MIP solver during the ramp-up phase of a branch-and-bound tree search ↵

The branch-and-bound tree search starts from the single root node, and only through branching on this root node and the resulting child nodes, are enough active nodes created to produce sufficient tasks to keep all MIP workers busy. This is referred to as the ramp-up phase of a parallel MIP. In a typical MIP solve, the solutions found during the initial dives will typically provide a significant improvement over the root heuristic solutions. It can therefore be advantageous to let these initial dives run as fast as possible, by limiting resource contention. This can be accomplished by restricting the number of parallel tasks and thereby reducing the memory bus contention. The mipRampUp control can be used to turn this initial task restriction of a parallel MIP solve on or off.

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

No special treatment during the ramp-up phase. Always run with the maximal number of tasks. `1`

Limit the number of tasks until the initial dives have completed.

**mipRefineIterLimit** *(integer)*: Defines an effort limit expressed as simplex iterations for the MIP solution refiner ↵

The limit is per reoptimizations in the MIP refiner.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**mipRelCutoff** *(real)*: Branch and Bound: Percentage of the LP solution value to be added to the value of the objective function when an integer solution is found, to give the new value of CURRMIPCUTOFF ↵

The effect is to cut off the search in parts of the tree whose best possible objective function would not be substantially better than the current solution. The control mipRelStop provides a similar functionality but works in a different way.

Range: [

`0`

, ∞]Default:

`0`

**mipRelStop** *(real)*: Branch and Bound: Determines when the branch and bound tree search will terminate ↵

Branch and bound tree search will stop if: | MIPOBJVAL - BESTBOUND| ≤ mipRelStop x max(| BESTBOUND|,| MIPOBJVAL|) where MIPOBJVAL is the value of the best solution′s objective function and BESTBOUND is the current best solution bound. For example, to stop the tree search when a MIP solution has been found and the Optimizer can guarantee it is within 5% of the optimal solution, set mipRelStop to 0.05.

This control is a stopping criteria only and different values of the control will not affect the solution path before termination. Unlike other stopping criteria, like time and node count, termination on mipRelStop will cause the final solution to be declared optimal and the problem to be returned to its original state.

Tolerances, such as mipRelCutoff and mipAbsCutoff, determine how much the objective value of a new MIP solution has to differ from the incumbent for it to be accepted. These controls therefore also influence the final gap at the end of a MIP solve.

Range: [

`0`

, ∞]Default:

`0.0001`

**mipRestart** *(integer)*: Branch and Bound: Controls strategy for in-tree restarts ↵

Default:

`auto`

value meaning `-1`

Determined automatically (XPRS_MIPRESTART_DEFAULT). `0`

Disable in-tree restarts (XPRS_MIPRESTART_OFF). `1`

Allow in-tree restarts at normal aggressiveness (XPRS_MIPRESTART_MODERATE). `2`

Allow in-tree restarts at higher aggressiveness (more likely to trigger a restart) (XPRS_MIPRESTART_AGGRESSIVE).

**mipRestartFactor** *(real)*: Branch and Bound: Fine tune initial conditions to trigger an in-tree restart ↵

Use a value > 1 to increase the aggressiveness with which the Optimizer restarts. Use a value < 1 to relax the aggressiveness with which the Optimizer restarts. Note that this control does not affect the initial condition on the gap, which must be set separately.

Range: [

`0`

, ∞]Default:

`1`

**mipRestartGapThreshold** *(real)*: Branch and Bound: Initial gap threshold to delay in-tree restart ↵

The restart is delayed initially if the gap, given as a fraction between 0 and 1, is below this threshold. The optimizer adjusts the threshold every time a restart is delayed. Note that there are other criteria that can delay or prevent a restart.

Range: [

`0`

,`1`

]Default:

`0.02`

**mipstopexpr** *(string)*: Stopping expression for branch and bound ↵

If the provided logical expression is true, the branch-and-bound is aborted. Supported values are: resusd, nodusd, objest, objval. Supported operators are: +, -, *, /, ^, %, !=, ==, <, <=, >, >=, !, &&, \( \vert \vert \), (, ), abs, ceil, exp, floor, log, log10, pow, sqrt . Example:

nodusd >= 1000 && abs(objest - objval) / abs(objval) < 0.1

**mipThreads** *(integer)*: If set to a positive integer it determines the number of threads implemented to run the parallel MIP code ↵

If mipThreads is set to the default value (-1), the threads control will determine the number of threads used.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**mipTol** *(real)*: Branch and Bound: Tolerance within which a decision variable′s value is considered to be integral ↵

Range: [

`0`

, ∞]Default:

`5e-06`

**mipToltarget** *(real)*: Target mipTol value used by the automatic MIP solution refiner as defined by refineOps ↵

Negative and zero values are ignored.

Refining solutions to match the miptoltarget can influence and worsen their objective value in case the previous objective could only be achieved through slight infeasibilities.

Range: [-∞, ∞]

Default:

`0`

**mipTrace** *(string)*: Name of MIP trace file ↵

A miptrace file with the specified name will be created. This file records the best integer and best bound values every mipTraceNode nodes and at mipTraceTime-second intervals.

Default:

`none`

**mipTraceNode** *(integer)*: Node interval between MIP trace file entries ↵

Default:

`100`

**mipTraceTime** *(real)*: Time interval, in seconds, between MIP trace file entries ↵

Default:

`5`

**miqcpAlg** *(integer)*: Determines which algorithm is to be used to solve mixed integer quadratic constrained and mixed integer second order cone problems ↵

Default:

`auto`

value meaning `-1`

Determined automatically. `0`

Use the barrier algorithm in the branch and bound algorithm. `1`

Use outer approximations in the branch and bound algorithm.

**mpsNameLength** *(integer)*: Maximum length of MPS names in characters ↵

Internally it is rounded up to the smallest multiple of 8. MPS names are right padded with blanks. Maximum value is 64.

Range: {

`0`

, ..., ∞}Default:

`0`

**mpsOutputFile** *(string)*: Name of MPS output file ↵

If specified XPRESS-MP will generate an MPS file corresponding to the GAMS model: the argument is the file name to be used. You can prefix the file name with an absolute or relative path.

Default:

`none`

**netCuts** *(integer)*: Determines the addition of multi-commodity network cuts to a problem ↵

The parameter is defined as a bit string, and values 1, 2, 4 can be summed up if the user wants more classes of cuts to be added.

If the user wants to add both cut-set inequalities and lifted flow-cover inequalities but not node cut-set inequalities, the value of the control should be set to 1+4=5.

Default:

`0`

value meaning `-1`

Automatically determined. `0`

Do not add these cuts. `1`

Add cut-set inequalities. `2`

Add node cut-set inequalities, i.e., cut-set inequalities that are based on a network cut defined on a single network node. `4`

Add lifted flow-cover inequalities.

**netStallLimit** *(integer)*: Limit the number of degenerate pivots of the network simplex algorithm, before switching to either primal or dual simplex, depending on algAfterNetwork ↵

Default:

`auto`

value meaning `-1`

Automatically determined limit `0`

No limit. `n>0`

Limit to n network simplex iterations.

**nodeProbingEffort** *(real)*: Adjusts the overall level of node probing ↵

nodeProbingEffort is used as a multiplier on the default amount of work node probing should do. Setting the control to zero disables node probing.

Range: [

`0`

, ∞]Default:

`1`

**nodeSelection** *(integer)*: Branch and Bound: Determines which nodes will be considered for solution once the current node has been solved ↵

Default:

`auto`

value meaning `1`

Local first: Choose between descendant and sibling nodes if available; choose from all outstanding nodes otherwise. `2`

Best first: Choose from all outstanding nodes. `3`

Local depth first: Choose between descendant and sibling nodes if available; choose from the deepest nodes otherwise. `4`

Best first, then local first: Best first is used for the first breadthFirst nodes, after which local first is used. `5`

Pure depth first: Choose from the deepest outstanding nodes.

**numericalEmphasis** *(integer)*: How much emphasis to place on numerical stability instead of solve speed ↵

Default:

`auto`

value meaning `-1`

Automatic. The emphasis might be influenced by the setting of other controls. `0`

Emphasize speed. `1`

Mild emphasis on numerical stability. `2`

Medium emphasis on numerical stability. `3`

Strong emphasis on numerical stability.

**objGoodEnough** *(real)*: Stop once an objective this good is found ↵

Default:

`none`

**objScaleFactor** *(integer)*: Custom objective scaling factor, expressed as a power of 2 ↵

When set, it overwrites the automatic objective scaling factor. A value of 0 means no objective scaling. This control is applied for the full solve, and is independent of any extra scaling that may occur specifically for the barrier or simplex solvers. As it is a power of 2, to scale by 16, set the value of the control to 4.

Range: {

`0`

, ..., ∞}Default:

`0`

**optimalityTol** *(real)*: Simplex: Zero tolerance for reduced costs ↵

On each iteration, the simplex method searches for a variable to enter the basis which has a negative reduced cost. The candidates are only those variables which have reduced costs less than the negative value of optimalityTol.

Range: [

`0`

, ∞]Default:

`1e-06`

**optimalityTolTarget** *(real)*: Target optimality tolerance for the solution refiner ↵

Zero and negative values are ignored, and the value of optimalityTol is used.

Use very small values like 1e-100 to state the refinement should continue as long as an improvement is made. Use very large values like 1e+100 to disable only this aspect of the refiner.

Refining solutions to match the optimalitytoltarget can influence and increase their infeasibility in case the previous feasibility could only be achieved through slight dual violations.

Range: [-∞, ∞]

Default:

`0`

**outputControls** *(boolean)*: Toggles the printing of all control settings at the beginning of the search ↵

This includes the printing of controls that have been explicitly assigned to their default value. All unset controls are omitted as they keep their default value.

Setting outputControls to 0 has no effect on the function XPRSdumpcontrols

Default:

`1`

value meaning `0`

Turn off printing of user-specified control settings. `1`

Print controls.

**outputLog** *(integer)*: Controls the level of output produced by the Optimizer during optimization ↵

Default:

`1`

value meaning `0`

Turn all output off. `1`

Print all messages. `3`

Print error and warning messages. `4`

Print error messages only.

**outputTol** *(real)*: Zero tolerance on print values ↵

Range: [

`0`

, ∞]Default:

`1e-05`

**penalty** *(real)*: Minimum absolute penalty variable coefficient ↵

Range: [

`0`

, ∞]Default:

`auto`

**pivotTol** *(real)*: Simplex: Zero tolerance for matrix elements ↵

On each iteration, the simplex method seeks a nonzero matrix element to pivot on. Any element with absolute value less than pivotTol is treated as zero for this purpose.

Range: [

`0`

, ∞]Default:

`1e-09`

**ppFactor** *(real)*: Partial pricing candidate list sizing parameter ↵

Range: [

`0`

, ∞]Default:

`1`

**preAnalyticCenter** *(integer)*: Determines if analytic centers should be computed and used for variable fixing and the generation of alternative reduced costs (-1: Auto 0: Off, 1: Fixing, 2: Redcost, 3: Both) ↵

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disable analytic center presolving. `1`

Use analytic center for variable fixing only. `2`

Use analytic center for reduced cost computation only. `3`

Use analytic centers for both, variable fixing and reduced cost computation.

**preBasisRed** *(integer)*: Determines if a lattice basis reduction algorithm should be attempted as part of presolve ↵

Default:

`0`

value meaning `-1`

Automatic. `0`

Disable basis reduction. `1`

Enable basis reduction.

**preBndRedCone** *(integer)*: Determines if second order cone constraints should be used for inferring bound reductions on variables when solving a MIP ↵

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disable bound reductions from second order cone constraints. `1`

Enable bound reductions from second order cone constraints.

**preBndRedQuad** *(integer)*: Determines if convex quadratic contraints should be used for inferring bound reductions on variables when solving a MIP ↵

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disable bound reductions from quadratic constraints. `1`

Enable bound reductions from quadratic constraints.

**preCliqueStrategy** *(integer)*: Determines how much effort to spend on clique covers in presolve ↵

Range: {

`-1`

, ..., ∞}Default:

`-1`

**preCoefElim** *(integer)*: Presolve: Specifies whether the optimizer should attempt to recombine constraints in order to reduce the number of non zero coefficients when presolving a mixed integer problem ↵

Default:

`2`

value meaning `0`

Disabled. `1`

Remove as many coefficients as possible. `2`

Cautious eliminations. Will not perform a reduction if it might destroy problem structure useful to e.g. heuristics or cutting.

**preComponents** *(integer)*: Presolve: Determines whether small independent components should be detected and solved as individual subproblems during root node processing ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disable detection of independent components. `1`

Enable detection of independent components.

**preComponentsEffort** *(real)*: Presolve: Adjusts the overall effort for the independent component presolver ↵

This control affects working limits for the subproblem solving as well as thresholds when it is called. Increase to put more emphasis on component presolving.

Range: [

`0`

, ∞]Default:

`1`

**preConeDecomp** *(integer)*: Presolve: Decompose regular and rotated cones with more than two elements and apply Outer Approximation on the resulting components ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disable cone decomposition. `1`

Enable cone decomposition by replacing large cones with small ones in the presolved problem. `2`

Similar to 1, plus decomposition is enabled even if the cone variable is fixed. `3`

Cones are decomposed within the Outer Approximation domain only, i.e., the problem maintains the original cones.

**preConfiguration** *(integer)*: MIP Presolve: Determines whether binary rows with only few repeating coefficients should be reformulated ↵

The reformulation enumerates the extremal feasible configurations of a row and introduces new columns and rows to model the choice between these extremal configurations. This presolve operation can be disabled as part of the (advanced) IP reductions presolveOps.

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disable configuration presolving.

**preConvertSeparable** *(integer)*: Presolve: Reformulate problem with non-diagonal quadratic objective and/or constraints as diagonal quadratic or second-order conic constraints ↵

This control is only used in MIQPs and MIQCQPs, and has no effect when used on continuous quadratic problems.

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disable reformulation. `1`

Enable reformulation to diagonal quadratic constraints. `2`

Similar to 1, plus reduction to second-order cones. `3`

Similar to 2, plus the objective function is converted to a constraint and treated as a quadratic constraint.

**preDomCol** *(integer)*: Presolve: Determines the level of dominated column removal reductions to perform when presolving a mixed integer problem ↵

Only binary columns will be checked.

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disabled. `1`

Cautious strategy. `2`

All candidate binaries will be checked for domination.

**preDomRow** *(integer)*: Presolve: Determines the level of dominated row removal reductions to perform when presolving a problem ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disabled. `1`

Cautious strategy. `2`

Medium strategy. `3`

Aggressive strategy. All candidate row combinations will be considered.

**preDupRow** *(integer)*: Presolve: Determines the type of duplicate rows to look for and eliminate when presolving a problem ↵

Duplicate rows can also be disabled by clearing the corresponding bit of the presolveOps integer control.

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Do not eliminate duplicate rows. `1`

Eliminate only rows that are identical in all variables. `2`

Same as option 1 plus eliminate duplicate rows with simple penalty variable expressions. (MIP only). `3`

Same as option 2 plus eliminate duplicate rows with more complex penalty variable expressions. (MIP only).

**preElimQuad** *(integer)*: Presolve: Allows for elimination of quadratic variables via doubleton rows ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Do not eliminate duplicate rows. `1`

Eliminate at least one quadratic variable for each doubleton row.

**preFolding** *(integer)*: Presolve: Determines if a folding procedure should be used to aggregate continuous columns in an equitable partition ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disabled. `1`

Enabled.

**preImplications** *(integer)*: Presolve: Determines whether to use implication structures to remove redundant rows ↵

If implication sequences are detected, they might also be used in probing.

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Do not use implications for sparsification. `1`

Use implications to remove reduandant rows.

**preLinDep** *(integer)*: Presolve: Determines whether to check for and remove linearly dependent equality constraints when presolving a problem ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Do not check for linearly dependent equality constraints. `1`

Check for and remove linearly dependent equality constraints.

**preObjCutDetect** *(boolean)*: Presolve: Determines whether to check for constraints that are parallel or near parallel to a linear objective function, and which can safely be removed ↵

This reduction applies to MIPs only.

Default:

`1`

value meaning `0`

Disable check and reductions. `1`

Enable check and reductions.

**preProbing** *(integer)*: Presolve: Amount of probing to perform on binary variables during presolve ↵

This is done by fixing a binary to each of its values in turn and analyzing the implications.

Default:

`auto`

value meaning `-1`

Let the optimizer decide on the amount of probing. `0`

Disabled. `1`

Light probing â€” only few implications will be examined. `2`

Full probing â€” all implications for all binaries will be examined. `3`

Full probing and repeat as long as the problem is significantly reduced.

**presolve** *(integer)*: Determines whether presolving should be performed prior to starting the main algorithm ↵

Presolve attempts to simplify the problem by detecting and removing redundant constraints, tightening variable bounds, etc. In some cases, infeasibility may even be determined at this stage, or the optimal solution found.

Memory for presolve is dynamically resized. If the Optimizer runs out of memory for presolve, an error message (245) is produced. Presolve settings 2 and 3 can sometimes make the barrier solves more efficient.

Default:

`1`

value meaning `-1`

Presolve applied, but a problem will not be declared infeasible if primal infeasibilities are detected. The problem will be solved by the LP optimization algorithm, returning an infeasible solution, which can sometimes be helpful. `0`

Presolve not applied. `1`

Presolve applied. `2`

Presolve applied, but redundant bounds are not removed. This can sometimes increase the efficiency of the barrier algorithm. `3`

Presolve is applied, and bounds detected to be redundant are always removed.

**presolveMaxGrow** *(real)*: Limit on how much the number of non-zero coefficients is allowed to grow during presolve, specified as a ratio of the number of non-zero coefficients in the original problem ↵

Range: [

`0`

, ∞]Default:

`0.1`

**presolveOps** *(integer)*: Specifies the operations which are performed during the presolve ↵

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`511`

value meaning `bit 0 = 1`

Equivalent to presolveOps_singletonColRemoval. `bit 1 = 2`

Equivalent to presolveOps_singletonRowRemoval. `bit 2 = 4`

Equivalent to presolveOps_forcingRowRemoval. `bit 3 = 8`

Equivalent to presolveOps_dualReductions. `bit 4 = 16`

Equivalent to presolveOps_redundantRowRemoval. `bit 5 = 32`

Equivalent to presolveOps_duplicateColRemoval. `bit 6 = 64`

Equivalent to presolveOps_duplicateRowRemoval. `bit 7 = 128`

Equivalent to presolveOps_strongDualReductions. `bit 8 = 256`

Equivalent to presolveOps_variableEliminations. `bit 9 = 512`

Equivalent to presolveOps_noIpReductions. `bit 10 = 1024`

Equivalent to presolveOps_noGlobalDomainChange. `bit 11 = 2048`

Equivalent to presolveOps_noAdvIpReductions. `bit 12 = 4096`

Equivalent to presolveOps_noIntVarEliminations. `bit 14 = 16384`

Equivalent to presolveOps_linDependRowRemoval. `bit 15 = 32768`

Equivalent to presolveOps_noIntVarAndSosDetect.

**presolveOps_dualReductions** *(boolean)*: Dual reductions ↵

See also presolveOps.

Default:

`1`

**presolveOps_duplicateColRemoval** *(boolean)*: Duplicate column removal ↵

See also presolveOps.

Default:

`1`

**presolveOps_duplicateRowRemoval** *(boolean)*: Duplicate row removal ↵

See also presolveOps.

Default:

`1`

**presolveOps_forcingRowRemoval** *(boolean)*: Forcing row removal ↵

See also presolveOps.

Default:

`1`

**presolveOps_linDependRowRemoval** *(boolean)*: Linearly dependant row removal ↵

See also presolveOps.

Default:

`0`

**presolveOps_noAdvIpReductions** *(boolean)*: No advanced IP reductions ↵

See also presolveOps.

Default:

`0`

**presolveOps_noGlobalDomainChange** *(boolean)*: No semi-continuous variable detection ↵

See also presolveOps.

Default:

`0`

**presolveOps_noIntVarAndSosDetect** *(boolean)*: No integer variable and SOS detection ↵

See also presolveOps.

Default:

`0`

**presolveOps_noIntVarEliminations** *(boolean)*: No eliminations on integers ↵

See also presolveOps.

Default:

`0`

**presolveOps_noIpReductions** *(boolean)*: No IP reductions ↵

See also presolveOps.

Default:

`0`

**presolveOps_redundantRowRemoval** *(boolean)*: Redundant row removal ↵

See also presolveOps.

Default:

`1`

**presolveOps_singletonColRemoval** *(boolean)*: Singleton column removal ↵

See also presolveOps.

Default:

`1`

**presolveOps_singletonRowRemoval** *(boolean)*: Singleton row removal ↵

See also presolveOps.

Default:

`1`

**presolveOps_strongDualReductions** *(boolean)*: Strong dual reductions ↵

See also presolveOps.

Default:

`1`

**presolveOps_variableEliminations** *(boolean)*: Variable eliminations ↵

See also presolveOps.

Default:

`1`

**presolvePasses** *(integer)*: Number of reduction rounds to be performed in presolve ↵

Range: {

`0`

, ..., ∞}Default:

`1`

**pricingAlg** *(integer)*: Simplex: Determines the primal simplex pricing method ↵

It is used to select which variable enters the basis on each iteration. In general Devex pricing requires more time on each iteration, but may reduce the total number of iterations, whereas partial pricing saves time on each iteration, but may result in more iterations.

Default:

`auto`

value meaning `-1`

Partial pricing. `0`

Determined automatically. `1`

Devex pricing. `2`

Steepest edge. `3`

Steepest edge with unit initial weights.

**primalOps** *(integer)*: Primal simplex: Allows fine tuning the variable selection in the primal simplex solver ↵

If both bits 0 and 1 are both set or unset then the dj scaling strategy is determined automatically.

Default:

`-1`

value meaning `bit 0 = 1`

Use aggressive dj scaling. `bit 1 = 2`

Conventional dj scaling. `bit 2 = 4`

Use reluctant switching back to partial pricing. `bit 3 = 8`

Use dynamic switching between cheap and expensive pricing strategies. `bit 4 = 16`

Keep solving even after potential cycling is detected.

**primalPerturb** *(real)*: Factor by which the problem will be perturbed prior to optimization by primal simplex ↵

A value of 0.0 results in no perturbation prior to optimization. Note the interconnection to the autoPerturb control. If autoPerturb is set to 1, the decision whether to perturb or not is left to the Optimizer. When the problem is automatically perturbed in primal simplex, however, the value of primalPerturb will be used for perturbation.

Range: [-∞, ∞]

Default:

`auto`

**primalUnshift** *(boolean)*: Determines whether primal is allowed to call dual to unshift ↵

Default:

`0`

value meaning `0`

Allow the dual algorithm to be used to unshift. `1`

Don′t allow the dual algorithm to be used to unshift.

**pseudoCost** *(real)*: Branch and Bound: Default pseudo cost used in estimation of the degradation associated with an unexplored node in the tree search ↵

A pseudo cost is associated with each integer decision variable and is an estimate of the amount by which the objective function will be worse if that variable is forced to an integral value.

Range: [

`0`

, ∞]Default:

`0.01`

**qcCuts** *(integer)*: Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation ↵

This control only has an effect for problems with quadratic or second order cone constraints, and only if outer approximation has not been disabled by setting miqcpAlg to 0.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**qcRootAlg** *(integer)*: Determines which algorithm is to be used to solve the root of a mixed integer quadratic constrained or mixed integer second order cone problem, when outer approximation is used ↵

This control only has an effect if miqcpAlg is set to 1.

Default:

`auto`

value meaning `-1`

Determined automatically. `0`

Use the barrier algorithm. `1`

Use the dual simplex on a relaxation of the problem constructed using outer approximation.

**qextractalg** *(integer)*: quadratic extraction algorithm in GAMS interface ↵

Default:

`0`

value meaning `0`

Automatic `1`

ThreePass: Uses a three-pass forward / backward / forward AD technique to compute function / gradient / Hessian values and a hybrid scheme for storage. `2`

DoubleForward: Uses forward-mode AD to compute and store function, gradient, and Hessian values at each node or stack level as required. The gradients and Hessians are stored in linked lists. `3`

Concurrent: Uses ThreePass and DoubleForward in parallel. As soon as one finishes, the other one stops.

**qSimplexOps** *(integer)*: Controls the behavior of the quadratic simplex solvers ↵

Default:

`0`

value meaning `bit 0 = 1`

Force traditional primal first phase. `bit 1 = 2`

Force BigM primal first phase. `bit 2 = 4`

Force traditional dual first phase. `bit 3 = 8`

Force BigM dual first phase. `bit 4 = 16`

Always use artificial bounds in dual. `bit 5 = 32`

Use original problem basis only when warmstarting the KKT. `bit 6 = 64`

Skip the primal bound flips for ranged primals (might cause more trouble than good if the bounds are very large). `bit 7 = 128`

Also do the single pivot crash. `bit 8 = 256`

Do not apply aggressive perturbation in dual.

**quadraticUnshift** *(integer)*: Determines whether an extra solution purification step is called after a solution found by the quadratic simplex (either primal or dual) ↵

Default:

`auto`

value meaning `-1`

Determined automatically. `0`

No purification step. `1`

Always do the purification step.

**randomSeed** *(integer)*: Sets the initial seed to use for the pseudo-random number generator in the Optimizer ↵

The sequence of random numbers is always reset using the seed when starting a new optimization run.

Range: {-∞, ..., ∞}

Default:

`1`

**refineOps** *(integer)*: Specifies when the solution refiner should be executed to reduce solution infeasibilities ↵

The refiner will attempt to satisfy the target tolerances for all original linear constraints before presolve or scaling has been applied.

If neither the 7th nor 8th bit is set, the refiner will use the primal simplex if the primal violations are larger than the dual violations, otherwise it will use the dual simplex. If both the 7th and 8th bit are set then the refiner will split the problem into a primal feasible and dual feasible part, and solve the first with primal simplex and the second with dual simplex.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`19`

value meaning `bit 0 = 1`

Equivalent to refineOps_lpOptimal. `bit 1 = 2`

Equivalent to refineOps_mipSolution. `bit 3 = 8`

Equivalent to refineOps_mipNodeLp. `bit 4 = 16`

Equivalent to refineOps_lpPresolve. `bit 5 = 32`

Equivalent to refineOps_iterativeRefiner. `bit 6 = 64`

Equivalent to refineOps_refinerPrecision. `bit 7 = 128`

Equivalent to refineOps_refinerUsePrimal. `bit 8 = 256`

Equivalent to refineOps_refinerUseDual. `bit 9 = 512`

Equivalent to refineOps_mipFixGlobals. `bit 10 = 1024`

Equivalent to refineOps_mipFixGlobalsTarget.

**refineOps_iterativeRefiner** *(boolean)*: Apply the iterative refiner to refine the solution ↵

See also refineOps.

Default:

`0`

**refineOps_lpOptimal** *(boolean)*: Run the solution refiner on an optimal solution of a continuous problem ↵

See also refineOps.

Default:

`1`

**refineOps_lpPresolve** *(boolean)*: Run the solution refiner on an optimal solution before postsolve on a continuous problem ↵

See also refineOps.

Default:

`1`

**refineOps_mipFixGlobals** *(boolean)*: Refine MIP solutions such that rounding them keeps the problem feasible when reoptimized ↵

See also refineOps.

Default:

`0`

**refineOps_mipFixGlobalsTarget** *(boolean)*: Attempt to refine MIP solutions such that rounding them keeps the problem feasible when reoptimized, but accept integers solutions even if refinement fails ↵

See also refineOps.

Default:

`0`

**refineOps_mipNodeLp** *(boolean)*: Run the solution refiner on each node of the MIP search ↵

See also refineOps.

Default:

`0`

**refineOps_mipSolution** *(boolean)*: Run the solution refiner when a new solution is found during a tree search ↵

The refiner will be applied to the presolved solution before any post-solve operations are applied.

See also refineOps.

Default:

`1`

**refineOps_refinerPrecision** *(boolean)*: Use higher precision in the iterative refinement ↵

See also refineOps.

Default:

`0`

**refineOps_refinerUseDual** *(boolean)*: If set, the iterative refiner will use the dual simplex algorithm ↵

See also refineOps.

Default:

`0`

**refineOps_refinerUsePrimal** *(boolean)*: If set, the iterative refiner will use the primal simplex algorithm ↵

See also refineOps.

Default:

`0`

**reform** *(boolean)*: Substitute out objective var and equ when possible ↵

Default:

`1`

**relaxTreeMemoryLimit** *(real)*: When the memory used by the branch and bound search tree exceeds the target specified by the treeMemoryLimit control, the optimizer will try to reduce this by writing nodes to the tree file ↵

In rare cases, usually where the solve has many millions of very small nodes, the tree structural data (which cannot be written to the tree file) will grow large enough to approach or exceed the tree′s memory target. When this happens, optimizer performance can degrade greatly as the solver makes heavy use of the tree file in preference to memory. To prevent this, the solver will automatically relax the tree memory limit when it detects this case; the relaxTreeMemoryLimit control specifies the proportion of the previous memory limit by which to relax it. Set relaxTreeMemoryLimit to 0.0 to force the Xpress Optimizer to never relax the tree memory limit in this way.

While setting higher values of relaxTreeMemoryLimit can improve performance significantly for a small number of models in low memory situations, the user is advised to use the treeMemoryLimit control to tune the memory usage of the branch and bound tree, according to the solve characteristics of their problem, rather than increasing relaxTreeMemoryLimit.

Range: [

`0`

, ∞]Default:

`0.1`

**relPivotTol** *(real)*: Simplex: Minimum size of pivot element relative to largest element in column ↵

At each iteration a pivot element is chosen within a given column of the matrix. The relative pivot tolerance, relPivotTol, is the size of the element chosen relative to the largest possible pivot element in the same column.

Range: [

`0`

, ∞]Default:

`1e-06`

**repairIndefInitEq** *(boolean)*: Controls if the optimizer should make indefinite quadratic matrices positive definite when it is possible ↵

Default:

`1`

value meaning `0`

Repair if possible. `1`

Do not repair.

**reRun** *(boolean)*: Rerun with primal simplex when not optimal/feasible ↵

Applies only in cases where presolve is turned on and the model is diagnosed as infeasible or unbounded. If rerun is nonzero, we rerun the model using primal simplex with presolve turned off in hopes of getting better diagnostic information. If rerun is zero, no good diagnostic information exists, so we return no solution, only an indication of unboundedness/infeasibility.

Default:

`0`

**reslim** *(real)*: Overrides GAMS reslim option ↵

Sets the resource limit. When the solver has used more than this amount of CPU time (in seconds) the system will stop the search and report the best solution found so far. timeLimit and solTimeLimit overwrite this option.

**resourceStrategy** *(boolean)*: Controls whether the optimizer is allowed to make nondeterministic decisions if memory is running low in an effort to preserve memory and finish the solve ↵

Available memory (or container limits) are automatically detected but can also be changed by maxMemorySoft and maxMemoryHard.

Default:

`0`

value meaning `1`

Allow the optimizer to change the solve path if necessary to preserve memory when getting close to one of the memory limits.

**rootPresolve** *(integer)*: Determines if presolving should be performed on the problem after the tree search has finished with root cutting and heuristics ↵

Default:

`auto`

value meaning `-1`

Let the optimizer decide if the problem should be presolved again. `0`

Disabled. `1`

Always presolve the root problem.

**sbBest** *(integer)*: Number of infeasible MIP entities to initialize pseudo costs for on each node ↵

If sbBest is set to zero, the control historyCosts will also be treated as zero and no past branching or strong branching information will be used in the MIP entity selection.

Default:

`auto`

value meaning `-1`

Determined automatically. `0`

Disable strong branching. `n>0`

Perform strong branching on up to n entities at each node.

**sbEffort** *(real)*: Adjusts the overall amount of effort when using strong branching to select an infeasible MIP entity to branch on ↵

sbEffort is used as a multiplier on other strong branching related controls, and affects the values used for sbBest, sbSelect and sbIterLimit when those are set to automatic.

Range: [

`0`

, ∞]Default:

`1`

**sbEstimate** *(integer)*: Branch and Bound: How to calculate pseudo costs from the local node when selecting an infeasible MIP entity to branch on ↵

These pseudo costs are used in combination with local strong branching and history costs to select the branch candidate.

Default:

`auto`

value meaning `-1`

Automatically determined. `1-6`

Different variants of local pseudo costs.

**sbIterLimit** *(integer)*: Number of dual iterations to perform the strong branching for each entity ↵

This control can be useful to increase or decrease the amount of effort (and thus time) spent performing strong branching at each node. Setting sbIterLimit=0 will disable dual strong branch iterations. Instead, the entity at the head of the candidate list will be selected for branching.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**sbSelect** *(integer)*: Size of the candidate list of MIP entities for strong branching ↵

Before strong branching is applied on a node of the branch and bound tree, a list of candidates is selected among the infeasible MIP entities. These entities are then evaluated based on the local LP solution and prioritized. Strong branching will then be applied to the sbBest candidates. The evaluation is potentially expensive and for some problems it might improve performance if the size of the candidate list is reduced.

Default:

`-2`

value meaning `-2`

Automatic (low effort). `-1`

Automatic (high effort). `n>=0`

Include n entities in the candidate list (but always at least sbBest candidates).

**scaling** *(integer)*: Determines how the Optimizer will rescale a model internally before optimization ↵

If set to 0, no scaling will take place.

Setting scaling to 0 will preserve the current scaling of the problem. Note that the Optimizer might automatically select a different scaling strategy, when the control autoScaling is not disabled. However, if scaling is set to any value by the user, autoScaling will be ignored.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`163`

value meaning `bit 0 = 1`

Equivalent to scaling_rowScaling. `bit 1 = 2`

Equivalent to scaling_colScaling. `bit 2 = 4`

Equivalent to scaling_rowScalingAgain. `bit 3 = 8`

Equivalent to scaling_maximum. `bit 4 = 16`

Equivalent to scaling_curtisReid. `bit 5 = 32`

Equivalent to scaling_byMaxElemNotGeoMean. `bit 6 = 64`

Equivalent to scaling_bigM. `bit 7 = 128`

Equivalent to scaling_simplexObjScaling. `bit 8 = 256`

Equivalent to scaling_ignoreQuadRowPart. `bit 9 = 512`

Equivalent to scaling_beforePresolve. `bit 10 = 1024`

Equivalent to scaling_noScalingRowsUp. `bit 11 = 2048`

Equivalent to scaling_noScalingColsDown. `bit 12 = 4096`

Equivalent to scaling_disableGlobalObjScaling. `bit 13 = 8192`

Equivalent to scaling_rhsScaling. `bit 14 = 16384`

Equivalent to scaling_noAggressiveQScaling. `bit 15 = 32768`

Equivalent to scaling_slackScaling.

**scaling_beforePresolve** *(boolean)*: Scale before presolve ↵

See also scaling.

Default:

`0`

**scaling_bigM** *(boolean)*: Treat big-M rows as normal rows ↵

See also scaling.

Default:

`0`

**scaling_byMaxElemNotGeoMean** *(boolean)*: 0: scale by geometric mean ↵

1: scale by maximum element.

See also scaling.

Default:

`1`

**scaling_colScaling** *(boolean)*: Column scaling ↵

See also scaling.

Default:

`1`

**scaling_curtisReid** *(boolean)*: Curtis-Reid ↵

See also scaling.

Default:

`0`

**scaling_disableGlobalObjScaling** *(boolean)*: Do not apply automatic objective scaling ↵

See also scaling.

Default:

`0`

**scaling_ignoreQuadRowPart** *(boolean)*: Exclude the quadratic part of constraint when calculating scaling factors ↵

See also scaling.

Default:

`0`

**scaling_maximum** *(boolean)*: Maximum ↵

See also scaling.

Default:

`0`

**scaling_noAggressiveQScaling** *(boolean)*: Disable aggressive quadratic scaling ↵

See also scaling.

Default:

`0`

**scaling_noScalingColsDown** *(boolean)*: Do not scale columns down ↵

See also scaling.

Default:

`0`

**scaling_noScalingRowsUp** *(boolean)*: Do not scale rows up ↵

See also scaling.

Default:

`0`

**scaling_rhsScaling** *(boolean)*: RHS scaling ↵

See also scaling.

Default:

`0`

**scaling_rowScaling** *(boolean)*: Row scaling ↵

See also scaling.

Default:

`1`

**scaling_rowScalingAgain** *(boolean)*: Row scaling again ↵

See also scaling.

Default:

`0`

**scaling_simplexObjScaling** *(boolean)*: Scale objective function for the simplex method ↵

See also scaling.

Default:

`1`

**scaling_slackScaling** *(boolean)*: Enable explicit linear slack scaling ↵

See also scaling.

Default:

`0`

**sifting** *(integer)*: Determines whether to enable sifting algorithm with the dual simplex method ↵

Default:

`auto`

value meaning `-1`

Automatically determined. `0`

Disable sifting. `1`

Enable sifting.

**siftPasses** *(integer)*: Determines how quickly we allow to grow the worker problems during the sifting algorithm ↵

Using larger values can increase the number of columns added to the worker problem which often results in increased solve times for the worker problems but the number of necessary sifting iterations may be reduced.

Range: {

`0`

, ..., ∞}Default:

`4`

**siftPresolveOps** *(integer)*: Determines the presolve operations for solving the subproblems during the sifting algorithm ↵

Default:

`-1`

value meaning `-1`

Use the presolveOps setting specified for the original problem. `>=0`

Use the value for the presolveOps parameter for solving the subproblems during the sifting algorithm.

**siftSwitch** *(integer)*: Determines which algorithm to use for solving the subproblems during sifting ↵

Default:

`-1`

value meaning `-1`

Dual simplex. `0`

Barrier. `>0`

Use the barrier algorithm while the number of dual infeasibilities is larger than this value, otherwise use dual simplex.

**solnpool** *(string)*: Solution pool file name ↵

If set, the integer feasible solutions generated during the global search will be saved to a solution pool. A GDX file whose name is given by this option will be created and will contain an index to separate GDX files containing the individual solutions in the solution pool.

Default:

`none`

**solnpoolCapacity** *(integer)*: Limit on number of solutions to store ↵

Range: {

`1`

, ..., ∞}Default:

`999999999`

**solnpoolCullDiversity** *(integer)*: Cull N solutions based on solution diversity ↵

When performing a round of culls due to a full solution pool, this control sets the maximum number to cull based on the diversity of the solutions in the pool.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**solnpoolCullObj** *(integer)*: Cull N solutions based on objective values ↵

When performing a round of culls due to a full solution pool, this control sets the maximum number to cull based on the MIP objective function.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**solnpoolCullRounds** *(integer)*: Terminate solution generation after N culling rounds ↵

Limits the rounds of culls performed due to a full solution pool.

Default:

`999999999`

**solnpoolDupPolicy** *(integer)*: Policy to use when handling storage of duplicate solutions ↵

Default:

`0`

value meaning `0`

Keep all: All solutions are kept including duplicates. `1`

Continuous: All variables are compared with an exact match. Duplicate solutions are discarded. `2`

Discrete and continuous separate: Both the discrete component of a solution pair and the continuous solution variables are compared. The continuous variables are compared with an exact match. Duplicate solutions are discarded. `3`

Discrete only: Only the discrete component of a solution pair is compared. Duplicate solutions are discarded.

**solnpoolmerge** *(string)*: Solution pool file name for merged solutions ↵

Default:

`none`

**solnpoolnumsym** *(integer)*: Maximum number of variable symbols when writing merged solutions ↵

Range: {

`1`

, ..., ∞}Default:

`10`

**solnpoolPop** *(integer)*: Controls method used to populate the solution pool ↵

By default the MIP solution pool merely stores the incumbent solutions that are found during the global search, without changing the behavior of the search itself. In constrast, the MIP solution enumerator makes it possible to enumerate all or many of the feasible solutions for the MIP, instead of searching for the best solution.

Default:

`1`

value meaning `1`

generate solutions using the normal search algorithm `2`

invoke the solution enumerator to generate solutions

**solnpoolPrefix** *(string)*: File name prefix for GDX solution files ↵

Default:

`soln`

**solnpoolVerbosity** *(integer)*: Controls verbosity of solution pool routines ↵

Default:

`0`

value meaning `-1`

no output `0`

output only messages coming from the XPRESS libraries `1`

add some messages logging the effect of solution pool options `2`

debugging mode

**solTimeLimit** *(real)*: Maximum time in seconds that the Optimizer will run a MIP solve before it terminates, given that a solution has been found ↵

As long as no solution has been found, this control will have no effect.

This control has been newly introduced with Xpress Optimizer version 9.0 and should be used instead of the deprecated MAXTIME control. It can be combined with the timeLimit control.

Default:

`1e+20`

value meaning `>0`

If an integer solution has been found, stop MIP search after the given number of seconds, otherwise continue until an integer solution is finally found.

**sosRefTol** *(real)*: Minimum relative gap between the ordering values of elements in a special ordered set ↵

The gap divided by the absolute value of the larger of the two adjacent values must be at least sosRefTol.

This tolerance must not be set lower than 1.0E-06.

Range: [

`0`

, ∞]Default:

`1e-06`

**symmetry** *(integer)*: Adjusts the overall amount of effort for symmetry detection ↵

Default:

`1`

value meaning `0`

No symmetry detection. `1`

Conservative effort. `2`

Intensive symmetry search.

**symSelect** *(integer)*: Adjusts the overall amount of effort for symmetry detection ↵

Default:

`-1`

value meaning `0`

Search the whole matrix (otherwise the 0, 1 and -1 coefficients only). `1`

Search all entities (otherwise binaries only).

**threads** *(integer)*: Default number of threads used during optimization ↵

Controls the number of threads to use. Positive values will be compared to the number of available cores detected and reduced if greater than this amount. Non- positive values are interpreted as the number of cores to leave free so setting threads to 0 uses all available cores while setting threads to -1 leaves one core free for other tasks.

Range: {-∞, ..., ∞}

Default:

`1`

**timeLimit** *(real)*: Maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time ↵

For MIP problems, this is the total time taken to solve all nodes.

This control has been newly introduced with Xpress Optimizer version 9.0 and should be used instead of the deprecated MAXTIME control. Note that the meaning of positive values differs between timeLimit and MAXTIME. When both controls are set, timeLimit takes precedence. The functionality of positive MAXTIME values is covered by solTimeLimit.

Default:

`1e+20`

value meaning `>0`

Stop LP or MIP search after the given number of seconds.

**trace** *(integer)*: Display the infeasibility diagnosis during presolve ↵

If non-zero, an explanation of the logical deductions made by presolve to deduce infeasibility or unboundedness will be displayed on screen or sent to the message callback function.

Presolve is sometimes able to detect infeasibility and unboundedness in problems. The set of deductions made by presolve can allow the user to diagnose the cause of infeasibility or unboundedness in their problem. However, not all infeasibility or unboundedness can be detected and diagnosed in this way.

Range: {

`0`

, ..., ∞}Default:

`0`

**treeCompression** *(integer)*: When writing nodes to the global file, the optimizer can try to use data-compression techniques to reduce the size of the tree file on disk ↵

The treeCompression control determines the strength of the data-compression algorithm used; higher values give superior data- compression at the affect of decreasing performance, while lower values compress quicker but not as effectively. Where treeCompression is set to 0, no data compression will be used on the tree file.

Range: {

`0`

, ..., ∞}Default:

`2`

**treeCoverCuts** *(integer)*: Branch and Bound: Number of rounds of lifted cover inequalities generated at nodes other than the top node in the tree ↵

Compare with the description for coverCuts. A value of -1 indicates the number of rounds is determined automatically.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**treeCutSelect** *(integer)*: Bit vector providing detailed control of the cuts created during the tree search of a MIP solve ↵

Use cutSelect to control cuts on the root node.

The default value is -1 which enables all bits. Any bits not listed in the above table should be left in their default ′on′ state, since the interpretation of such bits might change in future versions of the optimizer.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`-1`

value meaning `bit 5 = 32`

Equivalent to treeCutSelect_clique. `bit 6 = 64`

Equivalent to treeCutSelect_mir. `bit 7 = 128`

Equivalent to treeCutSelect_cover. `bit 8 = 256`

Equivalent to treeCutSelect_mirRowAggregation. `bit 11 = 2048`

Equivalent to treeCutSelect_flowpath. `bit 12 = 4096`

Equivalent to treeCutSelect_implication. `bit 13 = 8192`

Equivalent to treeCutSelect_liftAndProject. `bit 14 = 16384`

Equivalent to treeCutSelect_disableCutRows. `bit 15 = 32768`

Equivalent to treeCutSelect_gubCover. `bit 16 = 65536`

Equivalent to treeCutSelect_zeroHalf. `bit 17 = 131072`

Equivalent to treeCutSelect_indicator. `bit 18 = 262144`

Equivalent to treeCutSelect_gomory. `bit 20 = 1048576`

Equivalent to treeCutSelect_farkas.

**treeCutSelect_clique** *(boolean)*: Clique cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_cover** *(boolean)*: Lifted cover cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_disableCutRows** *(boolean)*: Disable cutting from cut rows ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_farkas** *(boolean)*: Farkas cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_flowpath** *(boolean)*: Flow path cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_gomory** *(boolean)*: Strong Chvatal-Gomory cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_gubCover** *(boolean)*: Lifted GUB cover cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_implication** *(boolean)*: Implication cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_indicator** *(boolean)*: Indicator constraint cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_liftAndProject** *(boolean)*: Turn on automatic Lift and Project cutting strategy ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_mir** *(boolean)*: Mixed Integer Rounding (MIR) cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_mirRowAggregation** *(boolean)*: Turn on row aggregation for MIR cuts ↵

See also treeCutSelect.

Default:

`1`

**treeCutSelect_zeroHalf** *(boolean)*: Zero-half cuts ↵

See also treeCutSelect.

Default:

`1`

**treeGomCuts** *(integer)*: Branch and Bound: Number of rounds of Gomory cuts generated at nodes other than the first node in the tree ↵

Compare with the description for gomCuts. A value of -1 indicates the number of rounds is determined automatically.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**treeMemoryLimit** *(integer)*: Soft limit, in megabytes, for the amount of memory to use in storing the branch and bound search tree ↵

This doesn′t include memory used for presolve, heuristics, solving the LP relaxation, etc. When set to 0 (the default), the optimizer will calculate a limit automatically based on the amount of free physical memory detected in the machine. When the memory used by the branch and bound tree exceeds this limit, the optimizer will try to reduce the memory usage by writing lower-rated sections of the tree to a file called the "tree file". Though the solve can continue if it cannot bring the tree memory usage below the specified limit, performance will be inhibited and a message will be printed to the log.

Range: {

`0`

, ..., ∞}Default:

`auto`

**treeMemorySavingTarget** *(real)*: When the memory used by the branch-and-bound search tree exceeds the limit specified by the treeMemoryLimit control, the optimizer will try to save memory by writing lower-rated sections of the tree to the tree file ↵

The target amount of memory to save will be enough to bring memory usage back below the limit, plus enough extra to give the tree room to grow. The treeMemorySavingTarget control specifies the extra proportion of the tree′s size to try to save; for example, if the tree memory limit is 1000Mb and treeMemorySavingTarget is 0.1, when the tree size exceeds 1000Mb the optimizer will try to reduce the tree size to 900Mb. Reducing the value of treeMemorySavingTarget will cause less extra nodes of the tree to be written to the tree file, but will result in the memory saving routine being triggered more often (as the tree will have less room in which to grow), which can reduce performance. Increasing the value of treeMemorySavingTarget will cause additional, more highly-rated nodes, of the tree to be written to the tree file, which can cause performance issues if these nodes are required later in the solve.

Range: [

`0`

, ∞]Default:

`0.4`

**treeQCCuts** *(integer)*: Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for nodes other than the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation ↵

This control only has an effect for problems with quadratic or second order cone constraints, and only if outer approximation has not been disabled by setting miqcpAlg to 0.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**varSelection** *(integer)*: Branch and Bound: Determines the formula used to calculate the estimate of each integer variable, and thus which integer variable is selected to be branched on at a given node ↵

The variable selected to be branched on is the one with the maximum estimate.

Default:

`auto`

value meaning `-1`

Determined automatically. `1`

The minimum of the ′up′ and ′down′ pseudo costs. `2`

The ′up′ pseudo cost plus the ′down′ pseudo cost. `3`

The maximum of the ′up′ and ′down′ pseudo costs, plus twice the minimum of the ′up′ and ′down′ pseudo costs. `4`

The maximum of the ′up′ and ′down′ pseudo costs. `5`

The ′down′ pseudo cost. `6`

The ′up′ pseudo cost. `7`

A weighted combination of the ′up′ and ′down′ pseudo costs, where the weights depend on how fractional the variable is. `8`

The product of the ′up′ and ′down′ pseudo costs.

**writePrtSol** *(boolean)*: Directs optimizer to output a "printsol" file ↵

Default:

`0`

**xslp_algorithm** *(integer)*: Bit map describing the SLP algorithm(s) to be used ↵

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`166`

value meaning `bit 0 = 1`

Equivalent to xslp_algorithm_noStepBounds. `bit 1 = 2`

Equivalent to xslp_algorithm_stepBoundsAsRequired. `bit 2 = 4`

Equivalent to xslp_algorithm_estimateStepBounds. `bit 3 = 8`

Equivalent to xslp_algorithm_dynamicDamping. `bit 4 = 16`

Equivalent to xslp_algorithm_holdValues. `bit 5 = 32`

Equivalent to xslp_algorithm_retainPreviousValue. `bit 6 = 64`

Equivalent to xslp_algorithm_resetDeltaZ. `bit 7 = 128`

Equivalent to xslp_algorithm_quickConvergenceCheck. `bit 8 = 256`

Equivalent to xslp_algorithm_escalatePenalties. `bit 9 = 512`

Equivalent to xslp_algorithm_switchToPrimal. `bit 11 = 2048`

Equivalent to xslp_algorithm_maxCostOption. `bit 12 = 4096`

Equivalent to xslp_algorithm_residualErrors. `bit 13 = 8192`

Equivalent to xslp_algorithm_noLPPolishing. `bit 14 = 16384`

Equivalent to xslp_algorithm_cascadeBounds. `bit 15 = 32768`

Equivalent to xslp_algorithm_clampExtendedActiveSB. `bit 16 = 65536`

Equivalent to xslp_algorithm_clampExtendedAll.

**xslp_algorithm_cascadeBounds** *(boolean)*: Step bounds are updated to accomodate cascaded values (otherwise cascaded values are pushed to respect step bounds) ↵

Normally, cascading will respect the step bounds of the SLP variable being cascaded. However, allowing the cascaded value to fall outside the step bounds (i.e. expanding the step bounds) can lead to better linearizations, as cascading will set better values for the SLP variables regarding their determining rows; note, that this later strategy might interfere with convergence of the cascaded variables.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_clampExtendedActiveSB** *(boolean)*: Apply clamping when converged on extended criteria only with some variables having active step bounds ↵

When clamping is applied, then in any iteration when the solution would normally be deemed converged on extended criteria only, an extra step bound shrinking step is applied to help imposing strict convergence. In this variant, clamping is only applied on variables that have converged on extended criteria only and have active step bounds.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_clampExtendedAll** *(boolean)*: Apply clamping when converged on extended criteria only ↵

When clamping is applied, then in any iteration when the solution would normally be deemed converged on extended criteria only, an extra step bound shrinking step is applied to help imposing strict convergence. In this variant, clamping is applied on all variables that have converged on extended criteria only.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_dynamicDamping** *(boolean)*: Use dynamic damping ↵

Dynamic damping is sometimes an alternative to step bounding as a means of encouraging convergence, but it does not have the same power to force convergence as do step bounds.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_escalatePenalties** *(boolean)*: Escalate penalties ↵

Constraint penalties are increased after each SLP iteration where penalty vectors are present in the solution. Escalation applies an additional scaling factor to the penalty costs for active errors. This helps to prevent successive solutions becoming "stuck" because of a particular constraint, because its cost will be raised so that other constraints may become more attractive to violate instead and thus open up a new region to explore.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_estimateStepBounds** *(boolean)*: Estimate step bounds from early SLP iterations ↵

If initial step bounds are not being explicitly provided, this gives a good method of calculating reasonable values. Values will tend to be larger rather than smaller, to reduce the risk of infeasibility caused by excessive tightness of the step bounds.

See also xslp_algorithm.

Default:

`1`

**xslp_algorithm_holdValues** *(boolean)*: Do not update values which are converged within strict tolerance ↵

Models which are numerically unstable may benefit from this setting, which does not update values which have effectively hardly changed. If a variable subsequently does move outside its strict convergence tolerance, it will be updated as usual.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_maxCostOption** *(boolean)*: Continue optimizing after penalty cost reaches maximum ↵

Normally if the penalty cost reaches its maximum (by default the value of infinity), the optimization will terminate with an unconverged solution. If the maximum value is set to a smaller value, then it may make sense to continue, using other means to determine when to stop.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_noLPPolishing** *(boolean)*: Skip the solution polishing step if the LP postsolve returns a slightly infeasible, but claimed optimal solution ↵

Due to the nature of the SLP linearizations, and in particular because of the large differences in the objective function (model objective against penalty costs) some dual reductions in the linear presolver might introduce numerically instable reductions that cause slight infeasibilities to appear in postsolve. It is typically more efficient to remove these infeasibilities with an extra call to the linear optimizer; compared to switching these reductions off, which usually has a significant cost in performance. This bit is provided for numerically very hard problems, when the polishing step proves to be too expensive (Xpress SLP will report these if any in the final log summary).

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_noStepBounds** *(boolean)*: Do not apply step bounds ↵

The default algorithm uses step bounds to force convergence. Step bounds may not be appropriate if dynamic damping is used.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_quickConvergenceCheck** *(boolean)*: Quick convergence check ↵

Normally, each variable is checked against all convergence criteria until either a criterion is found which it passes, or it is declared "not converged". Later (extended convergence) criteria are more expensive to test and, once an unconverged variable has been found, the overall convergence status of the solution has been established. The quick convergence check carries out checks on the strict criteria, but omits checks on the extended criteria when an unconverged variable has been found.

See also xslp_algorithm.

Default:

`1`

**xslp_algorithm_resetDeltaZ** *(boolean)*: Reset xslp_delta_z to zero when converged and continue SLP ↵

One of the mechanisms to avoid local optima is to retain small non-zero coefficients between delta vectors and constraints, even when the coefficient should strictly be zero. If this option is set, then a converged solution will be continued with zero coefficients as appropriate.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_residualErrors** *(boolean)*: Accept a solution which has converged even if there are still significant active penalty error vectors ↵

Normally, the optimization will continue if there are active penalty vectors in the solution. However, it may be that there is no feasible solution (and so active penalties will always be present). Setting bit 12 means that, if other convergence criteria are met, then the solution will be accepted as converged and the optimization will stop.

See also xslp_algorithm.

Default:

`0`

**xslp_algorithm_retainPreviousValue** *(boolean)*: Retain previous value when cascading if determining row is zero ↵

If the determining row is zero (that is, all the coefficients interacting with it are either zero or in columns with a zero activity), then it is impossible to calculate a new value for the vector being cascaded. The choice is to use the solution value as it is, or to revert to the assumed value

See also xslp_algorithm.

Default:

`1`

**xslp_algorithm_stepBoundsAsRequired** *(boolean)*: Apply step bounds to SLP delta vectors only when required ↵

Step bounds can be applied to all vectors simultaneously, or applied only when oscillation of the delta vector (change in sign between successive SLP iterations) is detected.

See also xslp_algorithm.

Default:

`1`

**xslp_algorithm_switchToPrimal** *(boolean)*: Use the primal simplex algorithm when all error vectors become inactive ↵

The primal simplex algorithm often performs better than dual during the final stages of SLP optimization when there are relatively few basis changes between successive solutions. As it is impossible to establish in advance when the final stages are being reached, the disappearance of error vectors from the solution is used as a proxy.

See also xslp_algorithm.

Default:

`0`

**xslp_analyze** *(integer)*: Bit map activating additional options supporting model / solution path analyzis ↵

In most cases, the value of this control does not affect the solution process itself. However, bit 3 (extended summary) will cause SLP to do more function evaluations, and the presence of non-deterministic user functions might cause changes in the solution process. These options are off by default due to performance considerations.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`0`

value meaning `bit 3 = 8`

Equivalent to xslp_analyze_extendedFinalSummary. `bit 4 = 16`

Equivalent to xslp_analyze_infeasibleIteration. `bit 6 = 64`

Equivalent to xslp_analyze_saveLinearizations. `bit 7 = 128`

Equivalent to xslp_analyze_saveIterBasis. `bit 8 = 256`

Equivalent to xslp_analyze_saveFile.

**xslp_analyze_extendedFinalSummary** *(boolean)*: Include an extended iteration summary ↵

See also xslp_analyze.

Default:

`0`

**xslp_analyze_infeasibleIteration** *(boolean)*: Run infeasibility analysis on infeasible iterations ↵

See also xslp_analyze.

Default:

`0`

**xslp_analyze_saveFile** *(boolean)*: Create an Xpress SLP save file at every xslp_autosave iterations ↵

See also xslp_analyze.

Default:

`0`

**xslp_analyze_saveIterBasis** *(boolean)*: Write the initial basis of the linearizations to disk at every xslp_autosave iterations ↵

See also xslp_analyze.

Default:

`0`

**xslp_analyze_saveLinearizations** *(boolean)*: Write the linearizations to disk at every xslp_autosave iterations ↵

See also xslp_analyze.

Default:

`0`

**xslp_aTol_a** *(real)*: Absolute delta convergence tolerance ↵

The absolute delta convergence criterion assesses the change in value of a variable (δX) against the absolute delta convergence tolerance. If δX < xslp_aTol_a then the variable has converged on the absolute delta convergence criterion. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_aTol_r** *(real)*: Relative delta convergence tolerance ↵

The relative delta convergence criterion assesses the change in value of a variable (δX) relative to the value of the variable (X), against the relative delta convergence tolerance. If δX < X * xslp_aTol_r then the variable has converged on the relative delta convergence criterion. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_augmentation** *(integer)*: Bit map describing the SLP augmentation method(s) to be used ↵

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`12`

value meaning `bit 0 = 1`

Equivalent to xslp_augmentation_minimum. `bit 1 = 2`

Equivalent to xslp_augmentation_evenHanded. `bit 2 = 4`

Equivalent to xslp_augmentation_equalityErrorVectors. `bit 3 = 8`

Equivalent to xslp_augmentation_allErrorVectors. `bit 4 = 16`

Equivalent to xslp_augmentation_penaltyDeltaVectors. `bit 5 = 32`

Equivalent to xslp_augmentation_aMeanWeight. `bit 6 = 64`

Equivalent to xslp_augmentation_sbFromValues. `bit 7 = 128`

Equivalent to xslp_augmentation_sbFromAbsValues. `bit 8 = 256`

Equivalent to xslp_augmentation_stepBoundRows. `bit 9 = 512`

Equivalent to xslp_augmentation_allRowErrorVectors. `bit 10 = 1024`

Equivalent to xslp_augmentation_noUpdateIfOnlyIV.

**xslp_augmentation_allErrorVectors** *(boolean)*: Penalty error vectors on all non-linear inequality constraints ↵

The linearization of a nonlinear constraint is inevitably an approximation and so may not be feasible except at the point of linearization. Adding penalty error vectors allows the linear approximation to be violated at a cost and so ensures that the linearized constraint is feasible.

See also xslp_augmentation.

Default:

`1`

**xslp_augmentation_allRowErrorVectors** *(boolean)*: Penalty error vectors on all constraints ↵

If the linear portion of the underlying model may actually be infeasible, then applying penalty vectors to all rows may allow identification of the infeasibility and may also allow a useful solution to be found.

See also xslp_augmentation.

Default:

`0`

**xslp_augmentation_aMeanWeight** *(boolean)*: Use arithmetic means to estimate penalty weights ↵

Penalty weights are estimated from the magnitude of the elements in the constraint or interacting rows. Geometric means are normally used, so that a few excessively large or small values do not distort the weights significantly. Arithmetic means will value the coefficients more equally.

See also xslp_augmentation.

Default:

`0`

**xslp_augmentation_equalityErrorVectors** *(boolean)*: Penalty error vectors on all non-linear equality constraints ↵

The linearization of a nonlinear equality constraint is inevitably an approximation and so will not generally be feasible except at the point of linearization. Adding penalty error vectors allows the linear approximation to be violated at a cost and so ensures that the linearized constraint is feasible.

See also xslp_augmentation.

Default:

`1`

**xslp_augmentation_evenHanded** *(boolean)*: Even handed augmentation ↵

Standard augmentation treats variables which appear in non-constant coefficients in a different way from those which contain non-constant coefficients. Even- handed augmentation treats them all in the same way by replacing each non- constant coefficient C in a vector V by a new coefficient C*V in the "equals" column (which has a fixed activity of 1) and creating delta vectors for all types of variable in the same way.

See also xslp_augmentation.

Default:

`0`

**xslp_augmentation_minimum** *(boolean)*: Minimum augmentation ↵

Standard augmentation includes delta vectors for all variables involved in nonlinear terms (in non-constant coefficients or as vectors containing non- constant coefficients). includes delta vectors only for variables in non- constant coefficients. This produces a smaller linearization, but there is less control on convergence, because convergence control (for example, step bounding) cannot be applied to variables without deltas.

See also xslp_augmentation.

Default:

`0`

**xslp_augmentation_noUpdateIfOnlyIV** *(boolean)*: Intial values do not imply an SLP variable ↵

Having an initial value will not cause the augmentation to include the corresponding delta variable; i.e. treat the variable as an SLP variable. Useful to provide initial values necessary in the first linearization in case of a minimal augmentation, or as a convenience option when it′s easiest to set an initial value for all variables for some reason.

See also xslp_augmentation.

Default:

`0`

**xslp_augmentation_penaltyDeltaVectors** *(boolean)*: Penalty vectors to exceed step bounds ↵

Although it has rarely been found necessary or desirable in practice, Xpress-SLP allows step bounds to be violated at a cost. This may help with feasibility but it generally slows down or prevents convergence, so it should be used only if found absolutely necessary.

See also xslp_augmentation.

Default:

`0`

**xslp_augmentation_sbFromAbsValues** *(boolean)*: Estimate step bounds from absolute values of row coefficients ↵

If step bounds are to be imposed from the start, the best approach is to provide explicit values for the bounds. Alternatively, Xpress-SLP can estimate the values from the largest estimated magnitude of the coefficients in the relevant rows.

See also xslp_augmentation.

Default:

`0`

**xslp_augmentation_sbFromValues** *(boolean)*: Estimate step bounds from values of row coefficients ↵

If step bounds are to be imposed from the start, the best approach is to provide explicit values for the bounds. Alternatively, Xpress-SLP can estimate the values from the range of estimated coefficient sizes in the relevant rows.

See also xslp_augmentation.

Default:

`0`

**xslp_augmentation_stepBoundRows** *(boolean)*: Row-based step bounds ↵

Step bounds are normally applied as bounds on the delta variables. Some applications may find that using explicit rows to bound the delta vectors gives better results.

See also xslp_augmentation.

Default:

`0`

**xslp_autosave** *(integer)*: Frequency with which to save the model ↵

A value of zero means that the model will not automatically be saved. A positive value of n will save model information at every nth SLP iteration as requested by xslp_analyze.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_barCrossOverStart** *(integer)*: Default crossover activation behaviour for barrier start ↵

When xslp_barLimit is set, xslp_barCrossOverStart offers an overwrite control on when crossover is applied. A positive value indicates that crossover should be disabled in iterations smaller than xslp_barCrossOverStart and should be enabled afterwards, or when stalling is detected as described in xslp_barStartOps. A value of 0 indicates to respect the value of crossover and only overwrite its value when stalling is detected. A value of -1 indicates to always rely on the value of crossover.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_barLimit** *(integer)*: Number of initial SLP iterations using the barrier method ↵

Particularly for larger models, using the Newton barrier method is faster in the earlier SLP iterations. Later on, when the basis information becomes more useful, a simplex method generally performs better. xslp_barLimit sets the number of SLP iterations which will be performed using the Newton barrier method.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_barStallingLimit** *(integer)*: Number of iterations to allow numerical failures in barrier before switching to dual ↵

On large problems, it may be beneficial to warm start progress by running a number of iterations with the barrier solver as specified by xslp_barLimit. On some numerically difficult problems, the barrier may stop prematurely due to numerical issues. Such solves can sometimes be finished if crossover is applied. After xslp_barStallingLimit such attempts, SLP will automatically switch to use the dual simplex.

Range: {

`0`

, ..., ∞}Default:

`3`

**xslp_barStallingObjLimit** *(integer)*: Number of iterations over which to measure the objective change for barrier iterations with no crossover ↵

On large problems, it may be beneficial to warm start progress by running a number of iterations with the barrier solver without crossover by setting xslp_barLimit to a positive value and setting crossover to 0. A potential drawback is slower convergence due to the interior point provided by the barrier solve keeping a higher number of variables active. This may lead to stalling in progress, negating the benefit of using the barrier. When in the last xslp_barStallingObjLimit iterations no significant progress has been made, crossover is automatically enabled.

Range: {

`0`

, ..., ∞}Default:

`3`

**xslp_barStallingTol** *(real)*: Required change in the objective when progress is measured in barrier iterations without crossover ↵

Minumum objective variability change required in relation to control xslp_barStallingObjLimit for the iterations to be regarded as making progress. The net objective, error cost and error sum are taken into account.

Range: [

`0`

, ∞]Default:

`0.05`

**xslp_barStartOps** *(integer)*: Controls behaviour when the barrier is used to solve the linearizations ↵

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`-1`

value meaning `bit 0 = 1`

Equivalent to xslp_barStartOps_stallingObjective. `bit 1 = 2`

Equivalent to xslp_barStartOps_stallingNumerical. `bit 2 = 4`

Equivalent to xslp_barStartOps_allowInteriorSol.

**xslp_barStartOps_allowInteriorSol** *(boolean)*: If a non-vertex converged solution found by barrier without crossover can be returned as a final solution ↵

See also xslp_barStartOps.

Default:

`1`

**xslp_barStartOps_stallingNumerical** *(boolean)*: Fall back to dual simplex if too many numerical problems are reported by the barrier ↵

See also xslp_barStartOps.

Default:

`1`

**xslp_barStartOps_stallingObjective** *(boolean)*: Check objective progress when no crossover is applied ↵

See also xslp_barStartOps.

Default:

`1`

**xslp_calcThreads** *(integer)*: Number of threads used for formula and derivatives evaluations ↵

When beneficial, SLP can calculate formula values and partial derivative information in parallel.

Range: {

`-1`

, ...,`1`

}Default:

`auto`

**xslp_cdTol_a** *(real)*: Absolute tolerance for deducing constant derivatives ↵

The absolute tolerance test for constant derivatives is used as follows: If the value of the user function at point X0 is Y0 and the values at (X0-δX) and (X0+δX) are Yd and Yu respectively, then the numerical derivatives at X0 are: "down" derivative Dd = (Y0 - Yd) / δX "up" derivative Du = (Yu - Y0) / δX If abs(Dd-Du) ≤ xslp_cdTol_a then the derivative is regarded as constant.

Range: [

`0`

, ∞]Default:

`1e-08`

**xslp_cdTol_r** *(real)*: Relative tolerance for deducing constant derivatives ↵

The relative tolerance test for constant derivatives is used as follows: If the value of the user function at point X0 is Y0 and the values at (X0-δX) and (X0+δX) are Yd and Yu respectively, then the numerical derivatives at X0 are: "down" derivative Dd = (Y0 - Yd) / δX "up" derivative Du = (Yu - Y0) / δX If abs(Dd-Du) ≤ xslp_cdTol_r * abs(Yd+Yu)/2 then the derivative is regarded as constant.

Range: [

`0`

, ∞]Default:

`1e-08`

**xslp_clampShrink** *(real)*: Shrink ratio used to impose strict convergence on variables converged in extended criteria only ↵

If the solution has converged but there are variables converged on extended criteria only, the xslp_clampShrink acts as a shrinking ratio on the step bounds and the problem is optimized (if necessary multiple times), with the purpose of expediting strict convergence on all variables. xslp_algorithm controls if this shrinking is applied at all, and if shrinking is applied to of the variables converged on extended criteria only with active step bounds only, or if on all variables.

Range: [

`0`

,`1`

]Default:

`0.3`

**xslp_clampValidationTol_a** *(real)*: Absolute validation tolerance for applying xslp_clampShrink ↵

If set and the absolute validation value is larger than this value, then control xslp_clampShrink is checked once the solution has converged, but there are variables converged on extended criteria only.

Range: [

`0`

, ∞]Default:

`not set`

**xslp_clampValidationTol_r** *(real)*: Relative validation tolerance for applying xslp_clampShrink ↵

If set and the relative validation value is larger than this value, then control xslp_clampShrink is checked once the solution has converged, but there are variables converged on extended criteria only.

Range: [

`0`

, ∞]Default:

`not set`

**xslp_convergenceOps** *(integer)*: Bit map describing which convergence tests should be carried out ↵

Provides fine tuned control (over setting the related convergence tolerances) of which convergence checks are carried out.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`7167`

value meaning `bit 0 = 1`

Equivalent to xslp_convergenceOps_cTol. `bit 1 = 2`

Equivalent to xslp_convergenceOps_aTol. `bit 2 = 4`

Equivalent to xslp_convergenceOps_mTol. `bit 3 = 8`

Equivalent to xslp_convergenceOps_iTol. `bit 4 = 16`

Equivalent to xslp_convergenceOps_sTol. `bit 5 = 32`

Check for user provided convergence. `bit 6 = 64`

Equivalent to xslp_convergenceOps_vTol. `bit 7 = 128`

Equivalent to xslp_convergenceOps_xTol. `bit 8 = 256`

Equivalent to xslp_convergenceOps_oTol. `bit 9 = 512`

Equivalent to xslp_convergenceOps_wTol. `bit 10 = 1024`

Equivalent to xslp_convergenceOps_extendedScaling. `bit 11 = 2048`

Equivalent to xslp_convergenceOps_validation. `bit 12 = 4096`

Equivalent to xslp_convergenceOps_validationK.

**xslp_convergenceOps_aTol** *(boolean)*: Execute the delta tolerance checks ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_cTol** *(boolean)*: Execute the closure tolerance checks ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_extendedScaling** *(boolean)*: Take scaling of individual variables / rows into account ↵

See also xslp_convergenceOps.

Default:

`0`

**xslp_convergenceOps_iTol** *(boolean)*: Execute the impact tolerance checks ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_mTol** *(boolean)*: Execute the matrix tolerance checks ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_oTol** *(boolean)*: Execute the objective range + active step bound check ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_sTol** *(boolean)*: Execute the slack impact tolerance checks ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_validation** *(boolean)*: Execute the validation target convergence checks ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_validationK** *(boolean)*: Execute the first order optimality target convergence checks ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_vTol** *(boolean)*: Execute the objective range checks ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_wTol** *(boolean)*: Execute the convergence continuation check ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_convergenceOps_xTol** *(boolean)*: Execute the objective range + constraint activity check ↵

See also xslp_convergenceOps.

Default:

`1`

**xslp_cTol** *(real)*: Closure convergence tolerance ↵

The closure convergence criterion measures the change in value of a variable (δX) relative to the value of its initial step bound (B), against the closure convergence tolerance. If δX < B * xslp_cTol then the variable has converged on the closure convergence criterion. If no explicit initial step bound is provided, then the test will not be applied and the variable can never converge on the closure criterion. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_cutStrategy** *(integer)*: Determines whihc cuts to apply in the MISLP search when the default SLP-in-MIP strategy is used ↵

Cuts are derived from the linearizations and are local cuts in that they are valid in the linearization and not necessarily valid for the full problem. The values mirror that of XPRS_CUTSTRATEGY.

Range: {

`-1`

, ...,`3`

}Default:

`0`

**xslp_damp** *(real)*: Damping factor for updating values of variables ↵

The damping factor sets the next assumed value for a variable based on the previous assumed value (X0) and the actual value (X1). The new assumed value is given by X1*xslp_damp + X0*(1-xslp_damp)

Range: [

`0`

,`1`

]Default:

`1`

**xslp_dampExpand** *(real)*: Multiplier to increase damping factor during dynamic damping ↵

If dynamic damping is enabled, the damping factor for a variable will be increased if successive changes are in the same direction. More precisely, if there are xslp_sameDamp successive changes in the same direction for a variable, then the damping factor (D) for the variable will be reset to D*xslp_dampExpand + xslp_dampMax*(1-xslp_dampExpand)

Range: [

`0`

,`1`

]Default:

`1`

**xslp_dampMax** *(real)*: Maximum value for the damping factor of a variable during dynamic damping ↵

If dynamic damping is enabled, the damping factor for a variable will be increased if successive changes are in the same direction. More precisely, if there are xslp_sameDamp successive changes in the same direction for a variable, then the damping factor (D) for the variable will be reset to D*xslp_dampExpand + xslp_dampMax*(1-xslp_dampExpand)

Range: [

`0`

,`1`

]Default:

`1`

**xslp_dampMin** *(real)*: Minimum value for the damping factor of a variable during dynamic damping ↵

If dynamic damping is enabled, the damping factor for a variable will be decreased if successive changes are in the opposite direction. More precisely, the damping factor (D) for the variable will be reset to D*xslp_dampShrink + xslp_dampMin*(1-xslp_dampExpand)

Range: [

`0`

,`1`

]Default:

`1`

**xslp_dampShrink** *(real)*: Multiplier to decrease damping factor during dynamic damping ↵

If dynamic damping is enabled, the damping factor for a variable will be decreased if successive changes are in the opposite direction. More precisely, the damping factor (D) for the variable will be reset to D*xslp_dampShrink + xslp_dampMin*(1-xslp_dampExpand)

Range: [

`0`

,`1`

]Default:

`1`

**xslp_dampStart** *(integer)*: SLP iteration at which damping is activated ↵

If damping is used as part of the SLP algorithm, it can be delayed until a specified SLP iteration. This may be appropriate when damping is used to encourage convergence after an un-damped algorithm has failed to converge.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_defaultStepBound** *(real)*: Minimum initial value for the step bound of an SLP variable if none is explicitly given ↵

If no initial step bound value is given for an SLP variable, this will be used as a minimum value. If the algorithm is estimating step bounds, then the step bound actually used for a variable may be larger than the default. A default initial step bound is ignored when testing for the closure tolerance xslp_cTol: if there is no specific value, then the test will not be applied.

Range: [

`0`

, ∞]Default:

`16`

**xslp_deltaCost** *(real)*: Initial penalty cost multiplier for penalty delta vectors ↵

If penalty delta vectors are used, this parameter sets the initial cost factor. If there are active penalty delta vectors, then the penalty cost may be increased.

Range: [

`0`

, ∞]Default:

`200`

**xslp_deltaCostFactor** *(real)*: Factor for increasing cost multiplier on total penalty delta vectors ↵

If there are active penalty delta vectors, then the penalty cost multiplier will be increased by a factor of xslp_deltaCostFactor up to a maximum of xslp_deltaMaxCost

Range: [

`1`

, ∞]Default:

`1.3`

**xslp_deltaMaxCost** *(real)*: Maximum penalty cost multiplier for penalty delta vectors ↵

If there are active penalty delta vectors, then the penalty cost multiplier will be increased by a factor of xslp_deltaCostFactor up to a maximum of xslp_deltaMaxCost

Range: [

`0`

, ∞]Default:

`1e+20`

**xslp_deltaZLimit** *(integer)*: Number of SLP iterations during which to apply xslp_delta_z ↵

xslp_delta_z is used to retain small derivatives which would otherwise be regarded as zero. This is helpful in avoiding local optima, but may make the linearized problem more difficult to solve because of the number of small nonzero elements in the resulting matrix. xslp_deltaZLimit can be set to a nonzero value, which is then the number of iterations for which xslp_delta_z will be used. After that, small derivatives will be set to zero. A negative value indicates no automatic perturbations to the derivatives in any situation.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_delta_a** *(real)*: Absolute perturbation of values for calculating numerical derivatives ↵

First-order derivatives are calculated by perturbing the value of each variable in turn by a small amount. The amount is determined by the absolute and relative delta factors as follows: xslp_delta_a + abs(X)*xslp_delta_r where (X) is the current value of the variable. If the perturbation takes the variable outside a bound, then the perturbation normally made only in the opposite direction.

Range: [

`0`

, ∞]Default:

`0.001`

**xslp_delta_r** *(real)*: Relative perturbation of values for calculating numerical derivatives ↵

First-order derivatives are calculated by perturbing the value of each variable in turn by a small amount. The amount is determined by the absolute and relative delta factors as follows: xslp_delta_a + abs(X)*xslp_delta_r where (X) is the current value of the variable. If the perturbation takes the variable outside a bound, then the perturbation normally made only in the opposite direction.

Range: [

`0`

, ∞]Default:

`0.001`

**xslp_delta_x** *(real)*: Minimum absolute value of delta coefficients to be retained ↵

If the value of a coefficient in a delta column is less than this value, it will be reset to zero. Larger values of xslp_delta_x will result in matrices with fewer elements, which may be easier to solve. However, there will be increased likelihood of local optima as some of the small relationships between variables and constraints are deleted. There may also be increased difficulties with singular bases resulting from deletion of pivot elements from the matrix.

Range: [

`0`

, ∞]Default:

`1e-06`

**xslp_delta_z** *(real)*: Tolerance used when calculating derivatives ↵

If the absolute value of a variable is less than this value, then a value of xslp_delta_z will be used instead for calculating derivatives. If a nonzero derivative is calculated for a formula which always results in a matrix coefficient less than xslp_delta_z, then a larger value will be substituted so that at least one of the coefficients is xslp_delta_z in magnitude. If xslp_deltaZLimit is set to a positive number, then when that number of iterations have passed, values smaller than xslp_delta_z will be set to zero.

Range: [

`0`

, ∞]Default:

`1e-05`

**xslp_delta_zero** *(real)*: Absolute zero acceptance tolerance used when calculating derivatives ↵

Provides an override value for the xslp_delta_z behavior. Derivatives smaller than xslp_delta_zero will not be substituted by xslp_delta_z, defining a range in which derivatives are deemed nonzero and are affected by xslp_delta_z. A negative value means that this tolerance will not be applied.

Range: [-∞, ∞]

Default:

`-1`

**xslp_derivatives** *(boolean)*: Bitmap describing the method of calculating derivatives ↵

If no bits are set then numerical derivatives are calculated using finite differences. Analytic derivatives cannot be used for formulae involving discontinuous functions. They may not work well with functions which are not smooth (such as MAX), or where the derivative changes very quickly with the value of the variable (such as LOG of small values). Both first and second order analytic derivatives can either be calculated as symbolic formulas, or by the means of auto-differentiation, with the exception that the second order symbolic derivatives require that the first order derivatives are also calculated using the symbolic method.

Default:

`1`

value meaning `bit 0 = 1`

Analytic derivatives where possible `bit 1 = 2`

Avoid embedding numerical derivatives of instantiated functions into analytic derivatives

**xslp_djTol** *(real)*: Tolerance on DJ value for determining if a variable is at its step bound ↵

If a variable is at its step bound and within the absolute delta tolerance xslp_aTol_a or closure tolerance xslp_cTol then the step bounds will not be further reduced. If the DJ is greater in magnitude than xslp_djTol then the step bound may be relaxed if it meets the necessary criteria.

Range: [

`0`

, ∞]Default:

`1e-06`

**xslp_ecfCheck** *(integer)*: Check feasibility at the point of linearization for extended convergence criteria ↵

The extended convergence criteria measure the accuracy of the solution of the linear approximation compared to the solution of the original nonlinear problem. For this to work, the linear approximation needs to be reasonably good at the point of linearization. In particular, it needs to be reasonably close to feasibility. xslp_ecfCheck is used to determine what checking of feasibility is carried out at the point of linearization. If the point of linearization at the start of an SLP iteration is deemed to be infeasible, then the extended convergence criteria are not used to decide convergence at the end of that SLP iteration. If all that is required is to decide that the point of linearization is not feasible, then the search can stop after the first infeasible constraint is found (parameter is set to 1). If the actual number of infeasible constraints is required, then xslp_ecfCheck should be set to 2, and all constraints will be checked. The number of infeasible constraints found at the point of linearization is returned in XSLP_ECFCOUNT.

Default:

`1`

value meaning `0`

No check (extended criteria are always used); `1`

Check until one infeasible constraint is found; `2`

Check all constraints.

**xslp_ecfTol_a** *(real)*: Absolute tolerance on testing feasibility at the point of linearization ↵

The extended convergence criteria test how well the linearization approximates the true problem. They depend on the point of linearization being a reasonable approximation â€” in particular, that it should be reasonably close to feasibility. Each constraint is tested at the point of linearization, and the total positive and negative contributions to the constraint from the columns in the problem are calculated. A feasibility tolerance is calculated as the largest of xslp_ecfTol_a and max(abs(Positive), abs(Negative)) * xslp_ecfTol_r If the calculated infeasibility is greater than the tolerance, the point of linearization is regarded as infeasible and the extended convergence criteria will not be applied. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-1 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_ecfTol_r** *(real)*: Relative tolerance on testing feasibility at the point of linearization ↵

The extended convergence criteria test how well the linearization approximates the true problem. They depend on the point of linearization being a reasonable approximation â€” in particular, that it should be reasonably close to feasibility. Each constraint is tested at the point of linearization, and the total positive and negative contributions to the constraint from the columns in the problem are calculated. A feasibility tolerance is calculated as the largest of xslp_ecfTol_a and max(abs(Positive), abs(Negative)) * xslp_ecfTol_r If the calculated infeasibility is greater than the tolerance, the point of linearization is regarded as infeasible and the extended convergence criteria will not be applied. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-1 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_enforceCostShrink** *(real)*: Factor by which to decrease the current penalty multiplier when enforcing rows ↵

When feasiblity of a row cannot be achieved by increasing the penalty cost on its error variable, removing the variable (fixing it to zero) can force the row to be satisfied, as set by xslp_enforceMaxCost. After the error variables have been removed (which is equivalent to setting to row to be enforced) the penalties on the remaining error variables are rebalanced to allow for a reduction in the size of the penalties in the objective in order to achive better numerical behaviour.

Range: [

`0`

,`1`

]Default:

`1e-05`

**xslp_enforceMaxCost** *(real)*: Maximum penalty cost in the objective before enforcing most violating rows ↵

When feasiblity of a row cannot be achieved by increasing the penalty cost on its error variable, removing the variable (fixing it to zero) can force the row to be satisfied. After the error variables have been removed (which is equivalent to setting to row to be enforced) the penalties on the remaining error variables are rebalanced to allow for a reduction in the size of the penalties in the objective in order to achive better numerical behaviour, controlled by xslp_enforceCostShrink.

Range: [

`0`

, ∞]Default:

`1e+11`

**xslp_errorCost** *(real)*: Initial penalty cost multiplier for penalty error vectors ↵

If penalty error vectors are used, this parameter sets the initial cost factor. If there are active penalty error vectors, then the penalty cost may be increased.

Range: [

`0`

, ∞]Default:

`200`

**xslp_errorCostFactor** *(real)*: Factor for increasing cost multiplier on total penalty error vectors ↵

If there are active penalty error vectors, then the penalty cost multiplier will be increased by a factor of xslp_errorCostFactor up to a maximum of xslp_errorMaxCost

Range: [

`1`

, ∞]Default:

`1.3`

**xslp_errorMaxCost** *(real)*: Maximum penalty cost multiplier for penalty error vectors ↵

If there are active penalty error vectors, then the penalty cost multiplier will be increased by a factor of xslp_errorCostFactor up to a maximum of xslp_errorMaxCost

Range: [

`0`

, ∞]Default:

`1e+20`

**xslp_errorTol_a** *(real)*: Absolute tolerance for error vectors ↵

The solution will be regarded as having no active error vectors if one of the following applies: every penalty error vector and penalty delta vector has an activity less than xslp_errorTol_a; the sum of the cost contributions from all the penalty error and penalty delta vectors is less than xslp_evTol_a; the sum of the cost contributions from all the penalty error and penalty delta vectors is less than xslp_evTol_r * Obj where Obj is the current objective function value.

Range: [

`0`

, ∞]Default:

`1e-05`

**xslp_errorTol_p** *(real)*: Absolute tolerance for printing error vectors ↵

The solution log includes a print of penalty delta and penalty error vectors with an activity greater than xslp_errorTol_p.

Range: [

`0`

, ∞]Default:

`0.0001`

**xslp_escalation** *(real)*: Factor for increasing cost multiplier on individual penalty error vectors ↵

If penalty cost escalation is activated in xslp_algorithm then the penalty cost multiplier will be increased by a factor of xslp_escalation for any active error vector up to a maximum of xslp_maxWeight.

Range: [

`1`

, ∞]Default:

`1.25`

**xslp_eTol_a** *(real)*: Absolute tolerance on penalty vectors ↵

For each penalty error vector, the contribution to its constraint is calculated, together with the total positive and negative contributions to the constraint from other vectors. If its contribution is less than xslp_eTol_a or less than Positive*xslp_eTol_r or less than abs(Negative)*xslp_eTol_r then it will be regarded as insignificant and will not have its penalty increased. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`0.0001`

**xslp_eTol_r** *(real)*: Relative tolerance on penalty vectors ↵

For each penalty error vector, the contribution to its constraint is calculated, together with the total positive and negative contributions to the constraint from other vectors. If its contribution is less than xslp_eTol_a or less than Positive*xslp_eTol_r or less than abs(Negative)*xslp_eTol_r then it will be regarded as insignificant and will not have its penalty increased. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`0.0001`

**xslp_evTol_a** *(real)*: Absolute tolerance on total penalty costs ↵

The solution will be regarded as having no active error vectors if one of the following applies: every penalty error vector and penalty delta vector has an activity less than xslp_errorTol_a; the sum of the cost contributions from all the penalty error and penalty delta vectors is less than xslp_evTol_a; the sum of the cost contributions from all the penalty error and penalty delta vectors is less than xslp_evTol_r * Obj where Obj is the current objective function value. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-2 and 1e-6, but normally a magnitude larger than xslp_eTol_a.

Range: [-∞, ∞]

Default:

`-1`

**xslp_evTol_r** *(real)*: Relative tolerance on total penalty costs ↵

The solution will be regarded as having no active error vectors if one of the following applies: every penalty error vector and penalty delta vector has an activity less than xslp_errorTol_a; the sum of the cost contributions from all the penalty error and penalty delta vectors is less than xslp_evTol_a; the sum of the cost contributions from all the penalty error and penalty delta vectors is less than xslp_evTol_r * Obj where Obj is the current objective function value. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-2 and 1e-6, but normally a magnitude larger than xslp_eTol_r.

Range: [-∞, ∞]

Default:

`-1`

**xslp_expand** *(real)*: Multiplier to increase a step bound ↵

If step bounding is enabled, the step bound for a variable will be increased if successive changes are in the same direction. More precisely, if there are xslp_sameCount successive changes reaching the step bound and in the same direction for a variable, then the step bound (B) for the variable will be reset to B*xslp_expand.

Range: [

`1`

, ∞]Default:

`2`

**xslp_feasTolTarget** *(real)*: When set, this defines a target feasibility tolerance to which the linearizations are solved to ↵

This is a soft version of XPRS_FEASTOL, and will dynamically revert back to XPRS_FEASTOL if the desired accuracy could not be achieved.

Range: [

`0`

, ∞]Default:

`not set`

**xslp_filter** *(integer)*: Bit map for controlling solution updates ↵

Bits 0 determine if XSLPgetslpsol should return the final converged solution, or the solution which had the best value according to the merit function. If bit 1 is set, a cascaded solution which does not improve the merit function will be rejected (Xpress SLP will revert to the solution of the linearization). Bits 2-3 determine the strategy for when the step direction is not improving according to the merit function.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`3`

value meaning `bit 0 = 1`

Equivalent to xslp_filterKeepBest. `bit 1 = 2`

Check cascaded solutions against improvements in the merit function. `bit 2 = 4`

Equivalent to xslp_filterZeroLineSearch. `bit 3 = 8`

Equivalent to xslp_filterZeroLineSearchTR.

**xslp_filterKeepBest** *(boolean)*: Retrain solution best according to the merit function ↵

See also xslp_filter.

Default:

`1`

**xslp_filterZeroLineSearch** *(boolean)*: Force minimum step sizes in line search ↵

See also xslp_filter.

Default:

`0`

**xslp_filterZeroLineSearchTR** *(boolean)*: Accept the trust region step is the line search returns a zero step size ↵

See also xslp_filter.

Default:

`0`

**xslp_findIV** *(integer)*: Option for running a heuristic to find a feasible initial point ↵

The procedure uses bound reduction (and, up to an extent, probing) to obtain a point in the initial bounding box that is feasible for the bound reduction techniques. If an initial point is already specified and is found not to violate bound reduction, then the heuristic is not run and the given point is used as the initial solution.

Default:

`auto`

value meaning `-1`

Automatic (default). `0`

Disable the heuristic. `1`

Enable the heuristic.

**xslp_granularity** *(real)*: Base for calculating penalty costs ↵

If xslp_granularity > 1, then initial penalty costs will be powers of xslp_granularity.

Range: [

`1`

, ∞]Default:

`4`

**xslp_hessian** *(integer)*: Second order differentiation mode when using analytical derivatives ↵

Symbolic mode differentiation for the second order derivatives is only available when xslp_jacobian is also set to symbolic mode.

Default:

`-1`

value meaning `1`

Numerical derivatives (finite difference) `2`

Symbolic differentiation `3`

Automatic differentiation `-1,0`

Automatic selection

**xslp_heurStrategy** *(integer)*: Branch and Bound: MINLP heuristic strategy ↵

On some problems it is worth trying more comprehensive heuristic strategies by setting HEURSTRATEGY to 2 or 3. Note that HEURSTRATEGY is deprecated, use heurEmphasis instead.

Default:

`auto`

value meaning `-1`

Automatic selection of heuristic strategy. `0`

No heuristics. `1`

Basic heuristic strategy. `2`

Enhanced heuristic strategy. `3`

Extensive heuristic strategy. `4`

Run all heuristics without effort limits.

**xslp_infeasLimit** *(integer)*: Maximum number of consecutive infeasible SLP iterations which can occur before Xpress-SLP terminates ↵

An infeasible solution to an SLP iteration means that is likely that Xpress-SLP will create a poor linear approximation for the next SLP iteration. Sometimes, small infeasibilities arise because of numerical difficulties and do not seriously affect the solution process. However, if successive solutions remain infeasible, it is unlikely that Xpress-SLP will be able to find a feasible converged solution. xslp_infeasLimit sets the number of successive SLP iterations which must take place before Xpress-SLP terminates with a status of "infeasible solution".

Range: {

`0`

, ..., ∞}Default:

`3`

**xslp_infinity** *(real)*: Value returned by a divide-by-zero in a formula ↵

Range: [

`0`

, ∞]Default:

`1e+10`

**xslp_iterLimit** *(integer)*: Maximum number of SLP iterations ↵

If Xpress-SLP reaches xslp_iterLimit without finding a converged solution, it will stop. For MISLP, the limit is on the number of SLP iterations at each node.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**xslp_iTol_a** *(real)*: Absolute impact convergence tolerance ↵

The absolute impact convergence criterion assesses the change in the effect of a coefficient in a constraint. The effect of a coefficient is its value multiplied by the activity of the column in which it appears. E = X * C where X is the activity of the matrix column in which the coefficient appears, and C is the value of the coefficient. The linearization approximates the effect of the coefficient as E1 = X * C0 + δX * C′0 where X is as before, C0 is the value of the coefficient C calculated using the assumed values for the variables and C′0 is the value of ∂C ∂X calculated using the assumed values for the variables. If C1 is the value of the coefficient C calculated using the actual values for the variables, then the error in the effect of the coefficient is given by δE = X * C1 - (X * C0 + δX * C′0) If δE < xslp_iTol_a then the variable has passed the absolute impact convergence criterion for this coefficient. If a variable which has not converged on strict (closure or delta) criteria passes the (relative or absolute) impact or matrix criteria for all the coefficients in which it appears, then it is deemed to have converged. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_iTol_r** *(real)*: Relative impact convergence tolerance ↵

The relative impact convergence criterion assesses the change in the effect of a coefficient in a constraint in relation to the magnitude of the constituents of the constraint. The effect of a coefficient is its value multiplied by the activity of the column in which it appears. E = X * C where X is the activity of the matrix column in which the coefficient appears, and C is the value of the coefficient. The linearization approximates the effect of the coefficient as E1 = X * C0 + δX * C′0 where X is as before, C0 is the value of the coefficient C calculated using the assumed values for the variables and C′0 is the value of ∂C ∂X calculated using the assumed values for the variables. If C1 is the value of the coefficient C calculated using the actual values for the variables, then the error in the effect of the coefficient is given by δE = X * C1 - (X * C0 + δX * C′0) All the elements of the constraint are examined, excluding delta and error vectors: for each, the contribution to the constraint is evaluated as the element multiplied by the activity of the vector in which it appears; it is then included in a total positive contribution or total negative contribution depending on the sign of the contribution. If the predicted effect of the coefficient is positive, it is tested against the total positive contribution; if the effect of the coefficient is negative, it is tested against the total negative contribution. If T0 is the total positive or total negative contribution to the constraint (as appropriate) and δE < T0*xslp_iTol_r then the variable has passed the relative impact convergence criterion for this coefficient. If a variable which has not converged on strict (closure or delta) criteria passes the (relative or absolute) impact or matrix criteria for all the coefficients in which it appears, then it is deemed to have converged. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_jacobian** *(integer)*: First order differentiation mode when using analytical derivatives ↵

Symbolic mode differentiation for the second order derivatives is only available when xslp_jacobian is set to symbolic mode.

Default:

`-1`

value meaning `1`

Numerical derivatives (finite difference) `2`

Symbolic differentiation `3`

Automatic differentiation `-1,0`

Automatic selection

**xslp_linQuadBR** *(integer)*: Use linear and quadratic constraints and objective function to further reduce bounds on all variables ↵

While bound reduction is effective when performed on nonlinear, nonquadratic constraints and objective function, it can be useful to obtain tightened bounds from linear and quadratic constraints, as the corresponding variables may appear in other nonlinear constraints. This option then allows for a slightly more expensive bound reduction procedure, at the benefit of further reduction in the problem′s bounds.

Default:

`auto`

value meaning `-1`

Automatic selection `0`

Disable `1`

Enable

**xslp_log** *(integer)*: Level of printing during SLP iterations ↵

Default:

`0`

value meaning `-1`

None `0`

Minimal `1`

Normal: iteration, penalty vectors `2`

Omit from convergence log any variables which have converged `3`

Omit from convergence log any variables which have already converged (except variables on step bounds) `4`

Include all variables in convergence log `5`

Include user function call communications in the log

**xslp_lsIterLimit** *(integer)*: Number of iterations in the line search ↵

The line search attempts to refine the step size suggested by the trust region step bounds. The line search is a local method; the control sets a maximum on the number of model evaluations during the line search.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_lsPatternLimit** *(integer)*: Number of iterations in the pattern search preceding the line search ↵

When positive, defines the number of samples taken along the step size suggested by the trust region step bounds before initiating the line search. Useful for highly non-convex problems.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_lsStart** *(integer)*: Iteration in which to active the line search ↵

Range: {

`0`

, ..., ∞}Default:

`8`

**xslp_lsZeroLimit** *(integer)*: Maximum number of zero length line search steps before line search is deactivated ↵

When the line search repeatedly returns a zero step size, counteracted by bits set on xslp_filter, the effort spent in line search is redundant, and line search will be deactivated after xslp_lsZeroLimit consecutive such iteration.

Range: {

`0`

, ..., ∞}Default:

`5`

**xslp_maxWeight** *(real)*: Maximum penalty weight for delta or error vectors ↵

When penalty vectors are created, or when their weight is increased by escalation, the maximum weight that will be used is given by xslp_maxWeight.

Range: [

`0`

, ∞]Default:

`100`

**xslp_meritLambda** *(real)*: Factor by which the net objective is taken into account in the merit function ↵

The merit function is evaluated in the original, non-augmented / linearized space of the problem. A solution is deemed improved, if either feasibility improved, or if feasibility is not deteriorated but the net objective is improved, or if the combination of the two is improved, where the value of the xslp_meritLambda control is used to combine the two measures. A nonpositive value indicates that the combined effect should not be checked.

Range: [

`0`

, ∞]Default:

`0`

**xslp_minSBFactor** *(real)*: Factor by which step bounds can be decreased beneath xslp_aTol_a ↵

Normally, step bounds are not decreased beneath xslp_aTol_a, as such variables are treated as converged. However, it may be beneficial to decrease step bounds further, as individual variable value changes might affect the convergence of other variables in the model, even if the variablke itself is deemed converged.

Range: [

`0`

, ∞]Default:

`1`

**xslp_minWeight** *(real)*: Minimum penalty weight for delta or error vectors ↵

When penalty vectors are created, the minimum weight that will be used is given by xslp_minWeight.

Range: [

`0`

, ∞]Default:

`0.01`

**xslp_mipAlgorithm** *(integer)*: Bitmap describing the MISLP algorithms to be used ↵

xslp_mipAlgorithm determines the strategy of XSLPnlpoptimize for solving MINLP problems. The recommended approach is to solve the problem first without reference to the discrete variables. This can be handled automatically by setting bit 0 of xslp_mipAlgorithm; if done manually, then optimize using the "l" option to prevent the Optimizer presolve from changing the problem. Some versions of the optimizer re-run the initial node as part of the tree search; it is possible to initiate a new SLP optimization at this point by relaxing or fixing step bounds (use bits 2 and 3). If step bounds are fixed for a class of variable, then the variables in that class will not change their value in any child node. At each node, it is possible to relax or fix step bounds. It is recommended that step bounds are relaxed, so that the new problem can be solved starting from its parent, but without undue restrictions cased by step bounding (use bit 4). Exceptionally, it may be preferable to restrict the freedom of child nodes by relaxing fewer types of step bound or fixing the values of some classes of variable (use bit 5). When the optimal node has been found, it is possible to fix the discrete variables and then re-optimize with SLP. Step bounds can be relaxed or fixed for this optimization as well (use bits 7 and 8). Although it is ultimately necessary to solve the optimal node to convergence, individual nodes can be truncated after xslp_mipIterLimit SLP iterations. Set bit 6 to activate this feature. The normal MISLP algorithm uses SLP at each node. One alternative strategy is to use the MIP optimizer for solving each SLP iteration. Set bit 9 to implement this strategy ("MIP within SLP"). Another strategy is to solve the problem to convergence ignoring the nature of the integer variables. Then, fixing the linearization, use MIP to find the optimal setting of the discrete variables. Then, fixing the discrete variables, but varying the linearization, solve to convergence. Set bit 10 to implement this strategy ("SLP then MIP"). For mode details about MISLP algorithms and strategies, see the separate section.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`17`

value meaning `bit 0 = 1`

Equivalent to xslp_mipAlgorithm_initialSLP. `bit 2 = 4`

Equivalent to xslp_mipAlgorithm_initialRelaxSLP. `bit 3 = 8`

Equivalent to xslp_mipAlgorithm_initialFixSLP. `bit 4 = 16`

Equivalent to xslp_mipAlgorithm_nodeRelaxSLP. `bit 5 = 32`

Equivalent to xslp_mipAlgorithm_nodeFixSLP. `bit 6 = 64`

Equivalent to xslp_mipAlgorithm_nodeLimitSLP. `bit 7 = 128`

Equivalent to xslp_mipAlgorithm_finalRelaxSLP. `bit 8 = 256`

Equivalent to xslp_mipAlgorithm_finalFixSLP. `bit 9 = 512`

Equivalent to xslp_mipAlgorithm_withinSLP. `bit 10 = 1024`

Equivalent to xslp_mipAlgorithm_slpThenMIP.

**xslp_mipAlgorithm_finalFixSLP** *(boolean)*: Fix step bounds according to xslp_mipFixStepBounds after MIP solution is found ↵

See also xslp_mipAlgorithm.

Default:

`0`

**xslp_mipAlgorithm_finalRelaxSLP** *(boolean)*: Relax step bounds according to xslp_mipRelaxStepBounds after MIP solution is found ↵

See also xslp_mipAlgorithm.

Default:

`0`

**xslp_mipAlgorithm_initialFixSLP** *(boolean)*: Fix step bounds according to xslp_mipFixStepBounds after initial node ↵

See also xslp_mipAlgorithm.

Default:

`0`

**xslp_mipAlgorithm_initialRelaxSLP** *(boolean)*: Relax step bounds according to xslp_mipRelaxStepBounds after initial node ↵

See also xslp_mipAlgorithm.

Default:

`0`

**xslp_mipAlgorithm_initialSLP** *(boolean)*: Solve initial SLP to convergence ↵

See also xslp_mipAlgorithm.

Default:

`1`

**xslp_mipAlgorithm_nodeFixSLP** *(boolean)*: Fix step bounds according to xslp_mipFixStepBounds at each node ↵

See also xslp_mipAlgorithm.

Default:

`0`

**xslp_mipAlgorithm_nodeLimitSLP** *(boolean)*: Limit iterations at each node to xslp_mipIterLimit ↵

See also xslp_mipAlgorithm.

Default:

`0`

**xslp_mipAlgorithm_nodeRelaxSLP** *(boolean)*: Relax step bounds according to xslp_mipRelaxStepBounds at each node ↵

See also xslp_mipAlgorithm.

Default:

`1`

**xslp_mipAlgorithm_slpThenMIP** *(boolean)*: Use MIP on converged SLP solution and then SLP on the resulting MIP solution ↵

See also xslp_mipAlgorithm.

Default:

`0`

**xslp_mipAlgorithm_withinSLP** *(boolean)*: Use MIP at each SLP iteration instead of SLP at each node ↵

See also xslp_mipAlgorithm.

Default:

`0`

**xslp_mipCutOffCount** *(integer)*: Number of SLP iterations to check when considering a node for cutting off ↵

If the objective function is worse by a defined amount than the best integer solution obtained so far, then the SLP will be terminated (and the node will be cut off). The node will be cut off at the current SLP iteration if the objective function for the last xslp_mipCutOffCount SLP iterations are all worse than the best obtained so far, and the difference is greater than xslp_mipCutOff_a and OBJ * xslp_mipCutOff_r where OBJ is the best integer solution obtained so far. The test is not applied until at least xslp_mipCutOffLimit SLP iterations have been carried out at the current node.

Range: {

`0`

, ..., ∞}Default:

`5`

**xslp_mipCutOffLimit** *(integer)*: Number of SLP iterations to check when considering a node for cutting off ↵

If the objective function is worse by a defined amount than the best integer solution obtained so far, then the SLP will be terminated (and the node will be cut off). The node will be cut off at the current SLP iteration if the objective function for the last xslp_mipCutOffCount SLP iterations are all worse than the best obtained so far, and the difference is greater than xslp_mipCutOff_a and OBJ * xslp_mipCutOff_r where OBJ is the best integer solution obtained so far. The test is not applied until at least xslp_mipCutOffLimit SLP iterations have been carried out at the current node.

Range: {

`0`

, ..., ∞}Default:

`10`

**xslp_mipCutOff_a** *(real)*: Absolute objective function cutoff for MIP termination ↵

If the objective function is worse by a defined amount than the best integer solution obtained so far, then the SLP will be terminated (and the node will be cut off). The node will be cut off at the current SLP iteration if the objective function for the last xslp_mipCutOffCount SLP iterations are all worse than the best obtained so far, and the difference is greater than xslp_mipCutOff_a and OBJ * xslp_mipCutOff_r where OBJ is the best integer solution obtained so far. The MIP cutoff tests are only applied after xslp_mipCutOffLimit SLP iterations at the current node.

Range: [

`0`

, ∞]Default:

`1e-05`

**xslp_mipCutOff_r** *(real)*: Absolute objective function cutoff for MIP termination ↵

If the objective function is worse by a defined amount than the best integer solution obtained so far, then the SLP will be terminated (and the node will be cut off). The node will be cut off at the current SLP iteration if the objective function for the last xslp_mipCutOffCount SLP iterations are all worse than the best obtained so far, and the difference is greater than xslp_mipCutOff_a and OBJ * xslp_mipCutOff_r where OBJ is the best integer solution obtained so far. The MIP cutoff tests are only applied after xslp_mipCutOffLimit SLP iterations at the current node.

Range: [

`0`

, ∞]Default:

`1e-05`

**xslp_mipDefaultAlgorithm** *(integer)*: Default algorithm to be used during the tree search in MISLP ↵

The default algorithm used within SLP during the MISLP optimization can be set using xslp_mipDefaultAlgorithm. It will not necessarily be the same as the one best suited to the initial SLP optimization.

Range: {

`1`

, ...,`5`

}Default:

`auto`

**xslp_mipErrorTol_a** *(real)*: Absolute penalty error cost tolerance for MIP cut-off ↵

The penalty error cost test is applied at each node where there are active penalties in the solution. If xslp_mipErrorTol_a is nonzero and the absolute value of the penalty costs is greater than xslp_mipErrorTol_a, the node will be declared infeasible. If xslp_mipErrorTol_a is zero then no test is made and the node will not be declared infeasible on this criterion.

Range: [

`0`

, ∞]Default:

`0`

**xslp_mipErrorTol_r** *(real)*: Relative penalty error cost tolerance for MIP cut-off ↵

The penalty error cost test is applied at each node where there are active penalties in the solution. If xslp_mipErrorTol_r is nonzero and the absolute value of the penalty costs is greater than xslp_mipErrorTol_r * abs(Obj) where Obj is the value of the objective function, then the node will be declared infeasible. If xslp_mipErrorTol_r is zero then no test is made and the node will not be declared infeasible on this criterion.

Range: [

`0`

, ∞]Default:

`0`

**xslp_mipFixStepBounds** *(integer)*: Bitmap describing the step-bound fixing strategy during MISLP ↵

At any node (including the initial and optimal nodes) it is possible to fix the step bounds of classes of variables so that the variables themselves will not change. This may help with convergence, but it does increase the chance of a local optimum because of excessive artificial restrictions on the variables.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`0`

value meaning `bit 0 = 1`

Equivalent to xslp_mipFixStepBounds_structNotCoef. `bit 1 = 2`

Equivalent to xslp_mipFixStepBounds_structAll. `bit 2 = 4`

Equivalent to xslp_mipFixStepBounds_coefOnly. `bit 3 = 8`

Equivalent to xslp_mipFixStepBounds_coef.

**xslp_mipFixStepBounds_coef** *(boolean)*: Fix step bounds on SLP variables appearing in coefficients ↵

See also xslp_mipFixStepBounds.

Default:

`0`

**xslp_mipFixStepBounds_coefOnly** *(boolean)*: Fix step bounds on SLP variables appearing only in coefficients ↵

See also xslp_mipFixStepBounds.

Default:

`0`

**xslp_mipFixStepBounds_structAll** *(boolean)*: Fix step bounds on all structural SLP variables ↵

See also xslp_mipFixStepBounds.

Default:

`0`

**xslp_mipFixStepBounds_structNotCoef** *(boolean)*: Fix step bounds on structural SLP variables which are not in coefficients ↵

See also xslp_mipFixStepBounds.

Default:

`0`

**xslp_mipIterLimit** *(integer)*: Maximum number of SLP iterations at each node ↵

If bit 6 of xslp_mipAlgorithm is set, then the number of iterations at each node will be limited to xslp_mipIterLimit.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_mipLog** *(integer)*: Frequency with which MIP status is printed ↵

By default (zero or negative value) the MIP status is printed after syncronization points. If xslp_mipLog is set to a positive integer, then the current MIP status (node number, best value, best bound) is printed every xslp_mipLog nodes.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_mipOCount** *(integer)*: Number of SLP iterations at each node over which to measure objective function variation ↵

The objective function test for MIP termination is applied only when step bounding has been applied (or xslp_sbStart SLP iterations have taken place if step bounding is not being used). The node will be terminated at the current SLP iteration if the range of the objective function values over the last xslp_mipOCount SLP iterations is within xslp_mipOTol_a or within OBJ * xslp_mipOTol_r where OBJ is the average value of the objective function over those iterations.

Range: {

`0`

, ..., ∞}Default:

`5`

**xslp_mipOTol_a** *(real)*: Absolute objective function tolerance for MIP termination ↵

The objective function test for MIP termination is applied only when step bounding has been applied (or xslp_sbStart SLP iterations have taken place if step bounding is not being used). The node will be terminated at the current SLP iteration if the range of the objective function values over the last xslp_mipOCount SLP iterations is within xslp_mipOTol_a or within OBJ * xslp_mipOTol_r where OBJ is the average value of the objective function over those iterations.

Range: [

`0`

, ∞]Default:

`1e-05`

**xslp_mipOTol_r** *(real)*: Relative objective function tolerance for MIP termination ↵

The objective function test for MIP termination is applied only when step bounding has been applied (or xslp_sbStart SLP iterations have taken place if step bounding is not being used). The node will be terminated at the current SLP iteration if the range of the objective function values over the last xslp_mipOCount SLP iterations is within xslp_mipOTol_a or within OBJ * xslp_mipOTol_r where OBJ is the average value of the objective function over those iterations.

Range: [

`0`

, ∞]Default:

`1e-05`

**xslp_mipRelaxStepBounds** *(integer)*: Bitmap describing the step-bound relaxation strategy during MISLP ↵

At any node (including the initial and optimal nodes) it is possible to relax the step bounds of classes of variables so that the variables themselves are completely free to change. This may help with finding a global optimum, but it may also increase the solution time, because more SLP iterations are necessary at each node to obtain a converged solution.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`15`

value meaning `bit 0 = 1`

Equivalent to xslp_mipRelaxStepBounds_structNotCoef. `bit 1 = 2`

Equivalent to xslp_mipRelaxStepBounds_structAll. `bit 2 = 4`

Equivalent to xslp_mipRelaxStepBounds_coefOnly. `bit 3 = 8`

Equivalent to xslp_mipRelaxStepBounds_coef.

**xslp_mipRelaxStepBounds_coef** *(boolean)*: Relax step bounds on SLP variables appearing in coefficients ↵

See also xslp_mipRelaxStepBounds.

Default:

`1`

**xslp_mipRelaxStepBounds_coefOnly** *(boolean)*: Relax step bounds on SLP variables appearing only in coefficients ↵

See also xslp_mipRelaxStepBounds.

Default:

`1`

**xslp_mipRelaxStepBounds_structAll** *(boolean)*: Relax step bounds on all structural SLP variables ↵

See also xslp_mipRelaxStepBounds.

Default:

`1`

**xslp_mipRelaxStepBounds_structNotCoef** *(boolean)*: Relax step bounds on structural SLP variables which are not in coefficients ↵

See also xslp_mipRelaxStepBounds.

Default:

`1`

**xslp_msMaxBoundRange** *(real)*: Defines the maximum range inside which initial points are generated by multistart presets ↵

The is the maximum range in which initial points are generated; the actual range is expected to be smaller as bounds are domains are also considered.

Range: [

`0`

, ∞]Default:

`1000`

**xslp_mTol_a** *(real)*: Absolute effective matrix element convergence tolerance ↵

The absolute effective matrix element convergence criterion assesses the change in the effect of a coefficient in a constraint. The effect of a coefficient is its value multiplied by the activity of the column in which it appears. E = X * C where X is the activity of the matrix column in which the coefficient appears, and C is the value of the coefficient. The linearization approximates the effect of the coefficient as E = X * C0 + δX * C′0 where V is as before, C0 is the value of the coefficient C calculated using the assumed values for the variables and C′0 is the value of ∂C ∂X calculated using the assumed values for the variables. If C1 is the value of the coefficient C calculated using the actual values for the variables, then the error in the effect of the coefficient is given by δE = X * C1 - (X * C0 + δX * C′0) If δE < X * xslp_mTol_a then the variable has passed the absolute effective matrix element convergence criterion for this coefficient. If a variable which has not converged on strict (closure or delta) criteria passes the (relative or absolute) impact or matrix criteria for all the coefficients in which it appears, then it is deemed to have converged. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_mTol_r** *(real)*: Relative effective matrix element convergence tolerance ↵

The relative effective matrix element convergence criterion assesses the change in the effect of a coefficient in a constraint relative to the magnitude of the coefficient. The effect of a coefficient is its value multiplied by the activity of the column in which it appears. E = X * C where X is the activity of the matrix column in which the coefficient appears, and C is the value of the coefficient. The linearization approximates the effect of the coefficient as E1 = X * C0 + δX * C′0 where V is as before, C0 is the value of the coefficient C calculated using the assumed values for the variables and C′0 is the value of ∂C ∂X calculated using the assumed values for the variables. If C1 is the value of the coefficient C calculated using the actual values for the variables, then the error in the effect of the coefficient is given by δE = X * C1 - (X * C0 + δX * C′0) If δE < E1 * xslp_mTol_r then the variable has passed the relative effective matrix element convergence criterion for this coefficient. If a variable which has not converged on strict (closure or delta) criteria passes the (relative or absolute) impact or matrix criteria for all the coefficients in which it appears, then it is deemed to have converged. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_multistartPreset** *(integer)*: Enable multistart ↵

Default:

`0`

value meaning `0`

Disable multistart preset. `1`

Generate xslp_multistart_maxSolves number of random base points. `2`

Generate xslp_multistart_maxSolves number of random base points, filtered by a merit function centred on initial feasibility. `3`

Load the most typical SLP tuning settings. A maximum of xslp_multistart_maxSolves jobs are loaded. `4`

Load a comprehensive set of SLP tuning settings. A maximum of xslp_multistart_maxSolves jobs are loaded.

**xslp_multistart_maxSolves** *(integer)*: Maximum number of jobs to create during the multistart search ↵

This control can be increased on the fly during the mutlistart search: for example, if a job gets refused by a user callback, the callback may increase this limit to account for the rejected job.

Range: {

`-1`

, ..., ∞}Default:

`unlimited`

**xslp_multistart_maxTime** *(integer)*: Maximum total time to be spent in the mutlistart search ↵

XSLP_MAXTIME applies on a per job instance basis. There will be some time spent even after xslp_multistart_maxTime has elapsed, while the running jobs get terminated and their results collected.

Range: {

`0`

, ..., ∞}Default:

`unlimited`

**xslp_multistart_poolsize** *(integer)*: Maximum number of problem objects allowed to pool up before synchronization in the deterministic multistart ↵

Deterministic multistart is ensured by guaranteeing that the multistart solve results are evaluated in the same order every time. Solves that finish too soon can be pooled until all earlier started solves finish, allowing the system to start solving other multistart instances in the meantime on idle threads. Larger pool sizes will provide better speedups, but will require larger amounts of memory. Positive values are interpreted as a multiplier on the maximum number of active threads used, while negative values are interpreted as an absolute limit (and the absolute value is used). A value of zero will mean no result pooling.

Range: {

`0`

, ..., ∞}Default:

`2`

**xslp_multistart_seed** *(integer)*: Random seed used for the automatic generation of initial point when loading multistart presets ↵

Range: {-∞, ..., ∞}

Default:

`0`

**xslp_multistart_threads** *(integer)*: Maximum number of threads to be used in multistart ↵

The current hard upper limit on the number of threads to be sued in multistart is 64.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**xslp_mvTol** *(real)*: Marginal value tolerance for determining if a constraint is slack ↵

If the absolute value of the marginal value of a constraint is less than xslp_mvTol, then (1) the constraint is regarded as not constraining for the purposes of the slack tolerance convergence criteria; (2) the constraint is not regarded as an active constraint when identifying unconverged variables in active constraints. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_objToPenaltyCost** *(real)*: Factor to estimate initial penalty costs from objective function ↵

The setting of initial penalty error costs can affect the path of the optimization and, indeed, whether a solution is achieved at all. If the penalty costs are too low, then unbounded solutions may result although Xpress-SLP will increase the costs in an attempt to recover. If the penalty costs are too high, then the requirement to achieve feasibility of the linearized constraints may be too strong to allow the system to explore the nonlinear feasible region. Low penalty costs can result in many SLP iterations, as feasibility of the nonlinear constraints is not achieved until the penalty costs become high enough; high penalty costs force feasibility of the linearizations, and so tend to find local optima close to an initial feasible point. Xpress-SLP can analyze the problem to estimate the size of penalty costs required to avoid an initial unbounded solution. xslp_objToPenaltyCost can be used in conjunction with this procedure to scale the costs and give an appropriate initial value for balancing the requirements of feasibility and optimality. Not all models are amenable to the Xpress-SLP analysis. As the analysis is initially concerned with establishing a cost level to avoid unboundedness, a model which is sufficiently constrained will never show unboundedness regardless of the cost. Also, as the analysis is done at the start of the optimization to establish a penalty cost, significant changes in the coefficients, or a high degree of nonlinearity, may invalidate the initial analysis. A setting for xslp_objToPenaltyCost of zero disables the analysis. A setting of 3 or 4 has proved successful for many models. If xslp_objToPenaltyCost cannot be used because of the problem structure, its effect can still be emulated by some initial experiments to establish the cost required to avoid unboundedness, and then manually applying a suitable factor. If the problem is initially unbounded, then the penalty cost will be increased until either it reaches its maximum or the problem becomes bounded.

Range: [

`0`

, ∞]Default:

`0`

**xslp_oCount** *(integer)*: Number of SLP iterations over which to measure objective function variation for static objective (2) convergence criterion ↵

The static objective (2) convergence criterion does not measure convergence of individual variables. Instead, it measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables interacting with active constraints (those that have a marginal value of at least xslp_mvTol) have converged. The rationale is that if the remaining unconverged variables are not involved in active constraints and if the objective function is not changing significantly between iterations, then the solution is more-or-less practical. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_oCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_oTol_a then the problem has converged on the absolute static objective (2) convergence criterion. The static objective function (2) test is applied only if xslp_oCount is at least 2.

Range: {

`0`

, ..., ∞}Default:

`5`

**xslp_optimalityTolTarget** *(real)*: When set, this defines a target optimality tolerance to which the linearizations are solved to ↵

This is a soft version of optimalityTol, and will dynamically revert back to optimalityTol if the desired accuracy could not be achieved.

Range: [

`0`

, ∞]Default:

`not set`

**xslp_oTol_a** *(real)*: Absolute static objective (2) convergence tolerance ↵

The static objective (2) convergence criterion does not measure convergence of individual variables. Instead, it measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables interacting with active constraints (those that have a marginal value of at least xslp_mvTol) have converged. The rationale is that if the remaining unconverged variables are not involved in active constraints and if the objective function is not changing significantly between iterations, then the solution is more-or-less practical. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_oCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_oTol_a then the problem has converged on the absolute static objective (2) convergence criterion. The static objective function (2) test is applied only if xslp_oCount is at least 2. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_oTol_r** *(real)*: Relative static objective (2) convergence tolerance ↵

The static objective (2) convergence criterion does not measure convergence of individual variables. Instead, it measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables interacting with active constraints (those that have a marginal value of at least xslp_mvTol) have converged. The rationale is that if the remaining unconverged variables are not involved in active constraints and if the objective function is not changing significantly between iterations, then the solution is more-or-less practical. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_oCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ AVGIter(Obj)*xslp_oTol_r then the problem has converged on the relative static objective (2) convergence criterion. The static objective function (2) test is applied only if xslp_oCount is at least 2. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_penaltyInfoStart** *(integer)*: Iteration from which to record row penalty information ↵

Information about the size (current and total) of active penalties of each row and the number of times a penalty vector has been active is recorded starting at the SLP iteration number given by xslp_penaltyInfoStart.

Range: {

`0`

, ..., ∞}Default:

`3`

**xslp_postsolve** *(integer)*: Determines whether postsolving should be performed automatically ↵

Default:

`-1`

value meaning `-1`

Postsolve if the problem could be solved to optimality/infeasibility. `0`

Do not automatically postsolve. `1`

Postsolve automatically.

**xslp_presolve** *(integer)*: Determines whether presolving should be performed prior to starting the main algorithm ↵

The Xpress NonLinear nonlinear presolve (which is carried out once, before augmentation) is independent of the Optimizer presolve (which is carried out during each SLP iteration).

Default:

`1`

value meaning `0`

Disable SLP presolve. `1`

Activate SLP presolve. `2`

Low memory presolve. Original problem is not restored by postsolve and dual solution may not be completely postsolved.

**xslp_presolveLevel** *(integer)*: Determines the level of changes presolve may carry out on the problem ↵

xslp_presolveOps controls the operations carried out in presolve. xslp_presolveLevel controls how those operations may change the problem.

Default:

`4`

value meaning `1`

Individual rows only presolve, no nonlinear transformations. `2`

Individual rows and bounds only presolve, no nonlinear transformations. `3`

Presolve allowing changing problem dimension, no nonlinear transformations. `4`

Full presolve.

**xslp_presolveOps** *(integer)*: Bitmap indicating the SLP presolve actions to be taken ↵

The Xpress NonLinear nonlinear presolve (which is carried out once, before augmentation) is independent of the Optimizer presolve (which is carried out during each SLP iteration). Linear reductions are performed according to presolveOps if bit 12 is not set.

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`2104`

value meaning `bit 0 = 1`

Equivalent to xslp_presolveOps_general. `bit 1 = 2`

Equivalent to xslp_presolveOps_fixZero. `bit 2 = 4`

Equivalent to xslp_presolveOps_fixAll. `bit 3 = 8`

Equivalent to xslp_presolveOps_setBounds. `bit 4 = 16`

Equivalent to xslp_presolveOps_intBounds. `bit 5 = 32`

Equivalent to xslp_presolveOps_domain. `bit 8 = 256`

Equivalent to xslp_presolveOps_noCoefficients. `bit 9 = 512`

Equivalent to xslp_presolveOps_noDeltas. `bit 10 = 1024`

Equivalent to xslp_presolveOps_noDualSide. `bit 11 = 2048`

Equivalent to xslp_presolveOps_eliminations. `bit 12 = 4096`

Equivalent to xslp_presolveOps_noLinear. `bit 13 = 8192`

Equivalent to xslp_presolveOps_noSimplifier.

**xslp_presolveOps_domain** *(boolean)*: Bound tightening based on function domains ↵

See also xslp_presolveOps.

Default:

`1`

**xslp_presolveOps_eliminations** *(boolean)*: Allow eliminations on determined variables ↵

See also xslp_presolveOps.

Default:

`1`

**xslp_presolveOps_fixAll** *(boolean)*: Explicitly fix all columns identified as fixed ↵

See also xslp_presolveOps.

Default:

`0`

**xslp_presolveOps_fixZero** *(boolean)*: Explicitly fix columns identified as fixed to zero ↵

See also xslp_presolveOps.

Default:

`0`

**xslp_presolveOps_general** *(boolean)*: Generic SLP presolve ↵

See also xslp_presolveOps.

Default:

`0`

**xslp_presolveOps_intBounds** *(boolean)*: MISLP bound tightening ↵

See also xslp_presolveOps.

Default:

`1`

**xslp_presolveOps_noCoefficients** *(boolean)*: Do not presolve coefficients ↵

See also xslp_presolveOps.

Default:

`0`

**xslp_presolveOps_noDeltas** *(boolean)*: Do not remove delta variables ↵

See also xslp_presolveOps.

Default:

`0`

**xslp_presolveOps_noDualSide** *(boolean)*: Avoid reductions that can not be dual postsolved ↵

See also xslp_presolveOps.

Default:

`0`

**xslp_presolveOps_noLinear** *(boolean)*: Avoid performing linear reductions at the nlp level ↵

See also xslp_presolveOps.

Default:

`0`

**xslp_presolveOps_noSimplifier** *(boolean)*: Avoid simplifying nonlinear expressions ↵

See also xslp_presolveOps.

Default:

`0`

**xslp_presolveOps_setBounds** *(boolean)*: SLP bound tightening ↵

See also xslp_presolveOps.

Default:

`1`

**xslp_presolveZero** *(real)*: Minimum absolute value for a variable which is identified as nonzero during SLP presolve ↵

During the SLP (nonlinear)presolve, a variable may be identified as being nonzero (for example, because it is used as a divisor). A bound of plus or minus xslp_presolveZero will be applied to the variable if it is identified as non-negative or non-positive.

Range: [

`0`

, ∞]Default:

`1e-09`

**xslp_primalIntegralRef** *(real)*: Reference solution value to take into account when calculating the primal integral ↵

When a global optimum is known, this can used to calculate a globally valid primal integral. It can also be used to indicate the target objective value still to be taken into account in the integral.

Range: [-∞, ∞]

Default:

`1e+20`

**xslp_probing** *(integer)*: Determines whether probing on a subset of variables should be performed prior to starting the main algorithm ↵

Probing runs multiple times bound reduction in order to further tighten the bounding box.

The Xpress NonLinear nonlinear probing, which is carried out once, is independent of the Optimizer presolve (which is carried out during each SLP iteration). The probing level allows for probing on an expanding set of variables, allowing for probing on all variables (level 5) or only those for which probing is more likely to be useful (binary variables).

Default:

`auto`

value meaning `-1`

Automatic. `0`

Disable SLP probing. `1`

Activate SLP probing only on binary variables. `2`

Activate SLP probing only on binary or unbounded integer variables. `3`

Activate SLP probing only on binary or integer variables. `4`

Activate SLP probing only on binary, integer variables, and unbounded continuous variables. `5`

Activate SLP probing on any variable.

**xslp_sameCount** *(integer)*: Number of steps reaching the step bound in the same direction before step bounds are increased ↵

If step bounding is enabled, the step bound for a variable will be increased if successive changes are in the same direction. More precisely, if there are xslp_sameCount successive changes reaching the step bound and in the same direction for a variable, then the step bound (B) for the variable will be reset to B*xslp_expand.

Range: {

`0`

, ..., ∞}Default:

`3`

**xslp_sameDamp** *(integer)*: Number of steps in same direction before damping factor is increased ↵

If dynamic damping is enabled, the damping factor for a variable will be increased if successive changes are in the same direction. More precisely, if there are xslp_sameDamp successive changes in the same direction for a variable, then the damping factor (D) for the variable will be reset to D*xslp_dampExpand + xslp_dampMax*(1-xslp_dampExpand)

Range: {

`0`

, ..., ∞}Default:

`3`

**xslp_sbStart** *(integer)*: SLP iteration after which step bounds are first applied ↵

If step bounds are used, they can be applied for the whole of the SLP optimization process, or started after a number of SLP iterations. In general, it is better not to apply step bounds from the start unless one of the following applies: (1) the initial estimates are known to be good, and explicit values can be provided for initial step bounds on all variables; or (2) the problem is unbounded unless all variables are step-bounded.

Range: {

`0`

, ..., ∞}Default:

`8`

**xslp_scale** *(integer)*: When to re-scale the SLP problem ↵

During the SLP optimization, matrix entries can change considerably in magnitude, even when the formulae in the coefficients are not very nonlinear. Re-scaling of the matrix can reduce numerical errors, but may increase the time taken to achieve convergence.

Default:

`1`

value meaning `0`

No re-scaling. `1`

Re-scale every SLP iteration up to xslp_scaleCount iterations after the end of barrier optimization. `2`

Re-scale every SLP iteration up to xslp_scaleCount iterations in total. `3`

Re-scale every SLP iteration until primal simplex is automatically invoked. `4`

Re-scale every SLP iteration. `5`

Re-scale every xslp_scaleCount SLP iterations. `6`

Re-scale every xslp_scaleCount SLP iterations after the end of barrier optimization.

**xslp_scaleCount** *(integer)*: Iteration limit used in determining when to re-scale the SLP matrix ↵

If xslp_scale is set to 1 or 2, then xslp_scaleCount determines the number of iterations (after the end of barrier optimization or in total) in which the matrix is automatically re-scaled.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_shrink** *(real)*: Multiplier to reduce a step bound ↵

If step bounding is enabled, the step bound for a variable will be decreased if successive changes are in opposite directions. The step bound (B) for the variable will be reset to B*xslp_shrink. If the step bound is already below the strict (delta or closure) tolerances, it will not be reduced further.

Range: [

`0`

,`1`

]Default:

`0.5`

**xslp_shrinkBias** *(real)*: Defines an overwrite / adjustment of step bounds for improving iterations ↵

Positive values overwrite xslp_shrink only if the objective is improving. A negative value is used to scale all step bounds in improving iterations.

Range: [-∞, ∞]

Default:

`not set`

**xslp_slpLog** *(integer)*: Frequency with which SLP status is printed ↵

If xslp_log is set to zero (minimal logging) then a nonzero value for xslp_slpLog defines the frequency (in SLP iterations) when summary information is printed out.

Range: {

`0`

, ..., ∞}Default:

`1`

**xslp_solver** *(integer)*: Selects the library to use for local solves ↵

The presence of KNITRO is detected automatically. KNITRO can be used to solve any problem loaded into XSLP, independently from how the problem was loaded. xslp_solver is set to automatic, Xpress SLP will be selected if any SLP specific construct has been loaded (these are ignored if KNITRO is selected manually). When solving problems to global optimality, the xslp_solver control is used to decide which local solver to call for reoptimizing NLP- infeasible solutions heuristically.

Default:

`auto`

value meaning `-1`

Automatic selection, based on model characteristics and solver availability `0`

Use Xpress-SLP (always available) `1`

Use Knitro if available `2`

Use Xpress-Optimizer if possible (convex quadratic problems only)

**xslp_sTol_a** *(real)*: Absolute slack convergence tolerance ↵

The slack convergence criterion is identical to the impact convergence criterion, except that the tolerances used are xslp_sTol_a (instead of xslp_iTol_a) and xslp_sTol_r (instead of xslp_iTol_r). See xslp_iTol_a for a description of the test. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_sTol_r** *(real)*: Relative slack convergence tolerance ↵

The slack convergence criterion is identical to the impact convergence criterion, except that the tolerances used are xslp_sTol_a (instead of xslp_iTol_a) and xslp_sTol_r (instead of xslp_iTol_r). See xslp_iTol_r for a description of the test. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_stopOutOfRange** *(boolean)*: Stop optimization and return error code if internal function argument is out of range ↵

If xslp_stopOutOfRange is set to 1, then if an internal function receives an argument which is out of its allowable range (for example, LOG of a negative number), an error code is set and the optimization is terminated.

Default:

`0`

**xslp_threads** *(integer)*: Default number of threads to be used ↵

Overall thread control value, used to determine the number of threads used where parallel calculations are possible.

Range: {

`-1`

, ..., ∞}Default:

`auto`

**xslp_unfinishedLimit** *(integer)*: Number of consecutive SLP iterations that may have an unfinished status before the solve is terminated ↵

If the optimization of the current linear approximation terminates with an "unfinished" status, then first a number of strategies are applied to attempt a successful solve of the same linearization. If this fails, then a new iteration is started to change the linearization itself. This control limits the numner of such repeated attempts.

Range: {

`0`

, ..., ∞}Default:

`3`

**xslp_validationTarget_k** *(real)*: Optimality target tolerance ↵

Primary optimality control for SLP. When the relevant optimality based convergence controls are left at their default values, SLP will adjust their value to match the target. The control defines a target value, that may not necessarily be attainable for problem with no strong constraint qualifications.

Range: [

`0`

, ∞]Default:

`1e-06`

**xslp_validationTarget_r** *(real)*: Feasiblity target tolerance ↵

Primary feasiblity control for SLP. When the relevant feasibility based convergence controls are left at their default values, SLP will adjust their value to match the target. The control defines a target value, that may not necessarily be attainable.

Range: [

`0`

, ∞]Default:

`1e-06`

**xslp_vCount** *(integer)*: Number of SLP iterations over which to measure static objective (3) convergence ↵

The static objective (3) convergence criterion does not measure convergence of individual variables, and in fact does not in any way imply that the solution has converged. However, it is sometimes useful to be able to terminate an optimization once the objective function appears to have stabilized. One example is where a set of possible schedules are being evaluated and initially only a good estimate of the likely objective function value is required, to eliminate the worst candidates. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_vCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_vTol_a then the problem has converged on the absolute static objective function (3) criterion. The static objective function (3) test is applied only if after at least xslp_vLimit + xslp_sbStart SLP iterations have taken place and only if xslp_vCount is at least 2. Where step bounding is being used, this ensures that the test is not applied until after step bounding has been introduced.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_vLimit** *(integer)*: Number of SLP iterations after which static objective (3) convergence testing starts ↵

The static objective (3) convergence criterion does not measure convergence of individual variables, and in fact does not in any way imply that the solution has converged. However, it is sometimes useful to be able to terminate an optimization once the objective function appears to have stabilized. One example is where a set of possible schedules are being evaluated and initially only a good estimate of the likely objective function value is required, to eliminate the worst candidates. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_vCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_vTol_a then the problem has converged on the absolute static objective function (3) criterion. The static objective function (3) test is applied only if after at least xslp_vLimit + xslp_sbStart SLP iterations have taken place and only if xslp_vCount is at least 2. Where step bounding is being used, this ensures that the test is not applied until after step bounding has been introduced.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_vTol_a** *(real)*: Absolute static objective (3) convergence tolerance ↵

The static objective (3) convergence criterion does not measure convergence of individual variables, and in fact does not in any way imply that the solution has converged. However, it is sometimes useful to be able to terminate an optimization once the objective function appears to have stabilized. One example is where a set of possible schedules are being evaluated and initially only a good estimate of the likely objective function value is required, to eliminate the worst candidates. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_vCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_vTol_a then the problem has converged on the absolute static objective function (3) criterion. The static objective function (3) test is applied only if after at least xslp_vLimit + xslp_sbStart SLP iterations have taken place and only if xslp_vCount is at least 2. Where step bounding is being used, this ensures that the test is not applied until after step bounding has been introduced. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_vTol_r** *(real)*: Relative static objective (3) convergence tolerance ↵

The static objective (3) convergence criterion does not measure convergence of individual variables, and in fact does not in any way imply that the solution has converged. However, it is sometimes useful to be able to terminate an optimization once the objective function appears to have stabilized. One example is where a set of possible schedules are being evaluated and initially only a good estimate of the likely objective function value is required, to eliminate the worst candidates. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_vCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ AVGIter(Obj) * xslp_vTol_r then the problem has converged on the absolute static objective function (3) criterion. The static objective function (3) test is applied only if after at least xslp_vLimit

- xslp_sbStart SLP iterations have taken place and only if xslp_vCount is at least 2. Where step bounding is being used, this ensures that the test is not applied until after step bounding has been introduced. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]

Default:

`auto`

**xslp_wCount** *(integer)*: Number of SLP iterations over which to measure the objective for the extended convergence continuation criterion ↵

It may happen that all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. This means that, at least in the linearization, if the variable were to be allowed to move further the objective function would improve. This does not necessarily imply that the same is true of the original problem, but it is still possible that an improved result could be obtained by taking another SLP iteration. The extended convergence continuation criterion is applied after a converged solution has been found where at least one variable has converged on extended criteria and is at its step bound limit. The extended convergence continuation test measures whether any improvement is being achieved when additional SLP iterations are carried out. If not, then the last converged solution will be restored and the optimization will stop. For a maximization problem, the improvement in the objective function at the current iteration compared to the objective function at the last converged solution is given by: δObj = Obj − LastConvergedObj For a minimization problem, the sign is reversed. If δObj > xslp_wTol_a and δObj > ABS(ConvergedObj) * xslp_wTol_r then the solution is deemed to have a significantly better objective function value than the converged solution. When a solution is found which converges on extended criteria and with active step bounds, the solution is saved and SLP optimization continues until one of the following: (1) a new solution is found which converges on some other criterion, in which case the SLP optimization stops with this new solution; (2) a new solution is found which converges on extended criteria and with active step bounds, and which has a significantly better objective function, in which case this is taken as the new saved solution; (3) none of the xslp_wCount most recent SLP iterations has a significantly better objective function than the saved solution, in which case the saved solution is restored and the SLP optimization stops. If xslp_wCount is zero, then the extended convergence continuation criterion is disabled.

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_wTol_a** *(real)*: Absolute extended convergence continuation tolerance ↵

It may happen that all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. This means that, at least in the linearization, if the variable were to be allowed to move further the objective function would improve. This does not necessarily imply that the same is true of the original problem, but it is still possible that an improved result could be obtained by taking another SLP iteration. The extended convergence continuation criterion is applied after a converged solution has been found where at least one variable has converged on extended criteria and is at its step bound limit. The extended convergence continuation test measures whether any improvement is being achieved when additional SLP iterations are carried out. If not, then the last converged solution will be restored and the optimization will stop. For a maximization problem, the improvement in the objective function at the current iteration compared to the objective function at the last converged solution is given by: δObj = Obj − LastConvergedObj For a minimization problem, the sign is reversed. If δObj > xslp_wTol_a and δObj > ABS(ConvergedObj) * xslp_wTol_r then the solution is deemed to have a significantly better objective function value than the converged solution. When a solution is found which converges on extended criteria and with active step bounds, the solution is saved and SLP optimization continues until one of the following: (1) a new solution is found which converges on some other criterion, in which case the SLP optimization stops with this new solution; (2) a new solution is found which converges on extended criteria and with active step bounds, and which has a significantly better objective function, in which case this is taken as the new saved solution; (3) none of the xslp_wCount most recent SLP iterations has a significantly better objective function than the saved solution, in which case the saved solution is restored and the SLP optimization stops. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_wTol_r** *(real)*: Relative extended convergence continuation tolerance ↵

It may happen that all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. This means that, at least in the linearization, if the variable were to be allowed to move further the objective function would improve. This does not necessarily imply that the same is true of the original problem, but it is still possible that an improved result could be obtained by taking another SLP iteration. The extended convergence continuation criterion is applied after a converged solution has been found where at least one variable has converged on extended criteria and is at its step bound limit. The extended convergence continuation test measures whether any improvement is being achieved when additional SLP iterations are carried out. If not, then the last converged solution will be restored and the optimization will stop. For a maximization problem, the improvement in the objective function at the current iteration compared to the objective function at the last converged solution is given by: δObj = Obj − LastConvergedObj For a minimization problem, the sign is reversed. If δObj > xslp_wTol_a and δObj > ABS(ConvergedObj) * xslp_wTol_r then the solution is deemed to have a significantly better objective function value than the converged solution. If xslp_wCount is greater than zero, and a solution is found which converges on extended criteria and with active step bounds, the solution is saved and SLP optimization continues until one of the following: (1) a new solution is found which converges on some other criterion, in which case the SLP optimization stops with this new solution; (2) a new solution is found which converges on extended criteria and with active step bounds, and which has a significantly better objective function, in which case this is taken as the new saved solution; (3) none of the xslp_wCount most recent SLP iterations has a significantly better objective function than the saved solution, in which case the saved solution is restored and the SLP optimization stops. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-4 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_xCount** *(integer)*: Number of SLP iterations over which to measure static objective (1) convergence ↵

It may happen that all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. This means that, at least in the linearization, if the variable were to be allowed to move further the objective function would improve. This does not necessarily imply that the same is true of the original problem, but it is still possible that an improved result could be obtained by taking another SLP iteration. However, if the objective function has already been stable for several SLP iterations, then there is less likelihood of an improved result, and the converged solution can be accepted. The static objective function (1) test measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. Because all the variables have converged, the solution is already converged but the fact that some variables are at their step bound limit suggests that the objective function could be improved by going further. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_xCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_xTol_a then the objective function is deemed to be static according to the absolute static objective function (1) criterion. If ABS(δObj) ≤ AVGIter(Obj) * xslp_xTol_r then the objective function is deemed to be static according to the relative static objective function (1) criterion. The static objective function (1) test is applied only until xslp_xLimit SLP iterations have taken place. After that, if all the variables have converged on strict or extended criteria, the solution is deemed to have converged. If the objective function passes the relative or absolute static objective function (1) test then the solution is deemed to have converged.

Range: {

`0`

, ..., ∞}Default:

`5`

**xslp_xLimit** *(integer)*: Number of SLP iterations up to which static objective (1) convergence testing starts ↵

It may happen that all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. This means that, at least in the linearization, if the variable were to be allowed to move further the objective function would improve. This does not necessarily imply that the same is true of the original problem, but it is still possible that an improved result could be obtained by taking another SLP iteration. However, if the objective function has already been stable for several SLP iterations, then there is less likelihood of an improved result, and the converged solution can be accepted. The static objective function (1) test measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. Because all the variables have converged, the solution is already converged but the fact that some variables are at their step bound limit suggests that the objective function could be improved by going further. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_xCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_xTol_a then the objective function is deemed to be static according to the absolute static objective function (1) criterion. If ABS(δObj) ≤ AVGIter(Obj) * xslp_xTol_r then the objective function is deemed to be static according to the relative static objective function (1) criterion. The static objective function (1) test is applied only until xslp_xLimit SLP iterations have taken place. After that, if all the variables have converged on strict or extended criteria, the solution is deemed to have converged. If the objective function passes the relative or absolute static objective function (1) test then the solution is deemed to have converged.

Range: {

`0`

, ..., ∞}Default:

`100`

**xslp_xTol_a** *(real)*: Absolute static objective function (1) tolerance ↵

It may happen that all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. This means that, at least in the linearization, if the variable were to be allowed to move further the objective function would improve. This does not necessarily imply that the same is true of the original problem, but it is still possible that an improved result could be obtained by taking another SLP iteration. However, if the objective function has already been stable for several SLP iterations, then there is less likelihood of an improved result, and the converged solution can be accepted. The static objective function (1) test measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. Because all the variables have converged, the solution is already converged but the fact that some variables are at their step bound limit suggests that the objective function could be improved by going further. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_xCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_xTol_a then the objective function is deemed to be static according to the absolute static objective function (1) criterion. If ABS(δObj) ≤ AVGIter(Obj) * xslp_xTol_r then the objective function is deemed to be static according to the relative static objective function (1) criterion. The static objective function (1) test is applied only until xslp_xLimit SLP iterations have taken place. After that, if all the variables have converged on strict or extended criteria, the solution is deemed to have converged. If the objective function passes the relative or absolute static objective function (1) test then the solution is deemed to have converged. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_xTol_r** *(real)*: Relative static objective function (1) tolerance ↵

It may happen that all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. This means that, at least in the linearization, if the variable were to be allowed to move further the objective function would improve. This does not necessarily imply that the same is true of the original problem, but it is still possible that an improved result could be obtained by taking another SLP iteration. However, if the objective function has already been stable for several SLP iterations, then there is less likelihood of an improved result, and the converged solution can be accepted. The static objective function (1) test measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables have converged, but some have converged on extended criteria and at least one of these variables is at its step bound. Because all the variables have converged, the solution is already converged but the fact that some variables are at their step bound limit suggests that the objective function could be improved by going further. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_xCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_xTol_a then the objective function is deemed to be static according to the absolute static objective function (1) criterion. If ABS(δObj) ≤ AVGIter(Obj) * xslp_xTol_r then the objective function is deemed to be static according to the relative static objective function (1) criterion. The static objective function (1) test is applied only until xslp_xLimit SLP iterations have taken place. After that, if all the variables have converged on strict or extended criteria, the solution is deemed to have converged. If the objective function passes the relative or absolute static objective function (1) test then the solution is deemed to have converged. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-4 and 1e-6.

Range: [-∞, ∞]

Default:

`auto`

**xslp_zero** *(real)*: Absolute tolerance ↵

If a value is below xslp_zero in magnitude, then it will be regarded as zero in certain formula calculations: an attempt to divide by such a value will give a "divide by zero" error; an exponent of a negative number will produce a "negative number, fractional exponent" error if the exponent differs from an integer by more than xslp_zero.

Range: [

`0`

, ∞]Default:

`1e-15`

**xslp_zeroCriterion** *(integer)*: Bitmap determining the behavior of the placeholder deletion procedure ↵

Setting single boolean options will overwrite the single bits of this bit map option.

Default:

`0`

value meaning `bit 0 = 1`

Equivalent to xslp_zeroCriterion_nbSLPVar. `bit 1 = 2`

Equivalent to xslp_zeroCriterion_nbDelta. `bit 2 = 4`

Equivalent to xslp_zeroCriterion_slpVarNBUpdateRow. `bit 3 = 8`

Equivalent to xslp_zeroCriterion_deltaNBUpdateRow. `bit 4 = 16`

Equivalent to xslp_zeroCriterion_deltaNBDRRow. `bit 5 = 32`

Equivalent to xslp_zeroCriterion_print.

**xslp_zeroCriterionCount** *(integer)*: Number of consecutive times a placeholder entry is zero before being considered for deletion ↵

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_zeroCriterionStart** *(integer)*: SLP iteration at which criteria for deletion of placeholder entries are first activated ↵

Range: {

`0`

, ..., ∞}Default:

`0`

**xslp_zeroCriterion_deltaNBDRRow** *(boolean)*: Remove placeholders in a basic delta variable if the determining row for the corresponding SLP variable is nonbasic ↵

See also xslp_zeroCriterion.

Default:

`0`

**xslp_zeroCriterion_deltaNBUpdateRow** *(boolean)*: Remove placeholders in a basic delta variable if its update row is nonbasic and the corresponding SLP variable is nonbasic ↵

See also xslp_zeroCriterion.

Default:

`0`

**xslp_zeroCriterion_nbDelta** *(boolean)*: Remove placeholders in nonbasic delta variables ↵

See also xslp_zeroCriterion.

Default:

`0`

**xslp_zeroCriterion_nbSLPVar** *(boolean)*: Remove placeholders in nonbasic SLP variables ↵

See also xslp_zeroCriterion.

Default:

`0`

**xslp_zeroCriterion_print** *(boolean)*: Print information about zero placeholders ↵

See also xslp_zeroCriterion.

Default:

`0`

**xslp_zeroCriterion_slpVarNBUpdateRow** *(boolean)*: Remove placeholders in a basic SLP variable if its update row is nonbasic ↵

See also xslp_zeroCriterion.

Default:

`0`

# Helpful Hints

The comments below should help both novice and experienced GAMS users to better understand and make use of GAMS/XPRESS.

**Infeasible and unbounded models**The fact that a model is infeasible/unbounded can be detected at two stages: during the presolve and during the simplex or barrier algorithm. In the first case we cannot recover a solution, nor is any information regarding the infeasible/unbounded constraint or variable provided (at least in a way that can be returned to GAMS). In such a situation, the GAMS link will automatically rerun the model using primal simplex with presolve turned off (this can be avoided by setting the rerun option to 0). It is possible (but very unlikely) that the simplex method will solve a model to optimality while the presolve claims the model is infeasible/unbounded (due to feasibility tolerances in the simplex and barrier algorithms).- The barrier method does not make use of
`iterlim`

. Use`bariterlim`

in an options file instead. The number of barrier iterations is echoed to the log and listing file. If the barrier iteration limit is reached during the barrier algorithm, XPRESS continues with a simplex algorithm, which will obey the iterlim setting. - Semi-integer variables are not implemented in the link, nor are they supported by XPRESS; if present, they trigger an error message.
- SOS1 and SOS2 variables are required by XPRESS to have lower bounds of 0 and nonnegative upper bounds.

# Setting up a GAMS/XPRESS-Link license

To use the GAMS/XPRESS solver with a GAMS/XPRESS-Link license you have to set up the XPRESS portion of the licensing. To do so, copy your XPRESS license `xpauth.xpr`

to the GAMS system directory. As of version 24.2 GAMS already comes with a file `xpauth.xpr`

. You might consider copying this file to `xpauth.xpr.bak`

or similar before overwriting it with your own XPRESS license file.