XPRESS

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:

  1. iterlim (on the cumulative pivot count) or reslim (in seconds of CPU time),
  2. optca & optcr (stopping criteria based on gap between best integer solution found and best possible) or
  3. 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:

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
extraPresolve No longer has any effect and will be removed from future releases 0
inputTol Tolerance on input values elements 0
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
maxTime Maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time 0
mpsNameLength Maximum length of MPS names in characters 0
mpsOutputFile Name of MPS output file none
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 non-global problem 1
refineOps_lpPresolve Run the solution refiner on an optimal solution before postsolve on a non-global 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 global 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
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
cacheSize Newton Barrier: L2 or L3 (see notes) cache size in kB (kilobytes) of the CPU 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 or Intel x86 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
l1Cache Newton barrier: L1 cache size in kB (kilo bytes) of the CPU auto
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 global 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 global 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 global file 0.4

Presolve Options

Option Description Default
barPresolveOps Newton barrier: Controls the Newton-Barrier specific presolve operations 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 Indicator constraints can be internally converted to regular rows (i.e. linearized) using a BigM coefficient whenever the BigM coefficient is smaller or equal to this value 100000
indPreLinBigM During presolve, indicator constraints can be internally replaced with regular rows (i.e. linearized) using a BigM coefficient whenever the BigM coefficient is smaller or equal to this value 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 Allow the branch-and-bound tree search to be restarted if it appears to be advantageous 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
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
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 global search has finished with root cutting and heuristics auto

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 global 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 global 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 (only relevant when no advanced basis is available) 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
lpThreads Parameter is deprecated and will be removed in a future release -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
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
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 (see XPRSobjsa, XPRSrhssa, XPRSbndsa) 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 global 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 Branch and Bound: Specifies whether the parallel MIP search should be deterministic 1
feasibilityPump Branch and Bound: Decides if the Feasibility Pump heuristic should be run at the top node auto
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 global 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
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 global 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 -1e-05
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 Global 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.0001
mipRelStop Branch and Bound: Determines when the global 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 global 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 global entity to branch on 1
sbEstimate Branch and Bound: How to calculate pseudo costs from the local node when selecting an infeasible global 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 global entities for strong branching -2
sleepOnThreadWait Determines if the threads should be put into a wait state when waiting for work auto
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
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 global 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 global solve -1
cutSelect_clique Clique cuts 1
cutSelect_cover Lifted cover cuts 1
cutSelect_disableCutRows Disable cutting from cut rows 1
cutSelect_flowpath Flow path 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 global 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 global solve -257
treeCutSelect_clique Clique cuts 1
treeCutSelect_cover Lifted cover cuts 1
treeCutSelect_disableCutRows Disable cutting from cut rows 1
treeCutSelect_flowpath Flow path 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 0
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
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 global solve 117
heurSearchTreeSelect Bit vector control for selecting which local search heuristics to apply during the tree search of a global 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 First order differentiation mode when using analytical derivatives 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 0
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 1000
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 global search in MISLP 3
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

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

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

Default: 0

value meaning
0 Use standard presolve.
1 Extra effort is spent in barrier specific presolve.
2 Do full matrix eliminations (reduce matrix size).

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.

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

cacheSize (integer): Newton Barrier: L2 or L3 (see notes) cache size in kB (kilobytes) of the CPU

On Intel (or compatible) platforms a value of -1 may be used to determine the cache size automatically. If the CPU model is new then the cache size may not be correctly detected by an older release of the software.

  1. Specifying the correct cache size can give a significant performance advantage with the Newton barrier algorithm. If the size is unknown, it is better to specify a smaller size. 2. If the size cannot be determined automatically, a default size of 128kB is assumed. 3. Where present, the L3 cache size should be chosen rather than the L2 cache size. 4. For multi-core CPUs, the cache is shared between a subset of the cores. The Optimizer will divide the cacheSize value by the number of cores sharing the cache if >1 Barrier threads are running. 5. Where the CPU is described as having multiple caches ie. 2x6M then the correct cache size to use is 6M not 12M. 6. Examples: Intel Core 2 Duo E6400 (2M Cache, 2.13GHz) cacheSize=2048 Intel Xeon x5570 (8M Cache, 2.93GHz) cacheSize=8192 Intel Core 2 QX6700 (2x4M Cache, 2.93 GHz) cacheSize=4096 7. If in doubt, please contact Xpress Support for advice.

Range: {-1, ..., ∞}

Default: auto

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 or Intel x86 vectorization instruction set that Barrier should run optimized code for

Generic code, SSE2 and AVX optimized code will all result in the same solution path. Using AVX2 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 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 (only relevant when no advanced basis is available)

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.

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.
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 (see XPRSobjsa, XPRSrhssa, XPRSbndsa)

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

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_flowpath (boolean): Flow path 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): Branch and Bound: Specifies whether the parallel MIP search should be deterministic

Default: 1

value meaning
0 Use non-deterministic parallel MIP.
1 Use deterministic parallel MIP.
2 Use deterministic parallel MIP, but allow the concurrent root LP solve 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

extraPresolve (integer): No longer has any effect and will be removed from future releases

Use presolveMaxGrow to limit the number of non-zero coefficients in the presolved problem.

Range: {0, ..., ∞}

Default: 0

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

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.

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 global 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 global 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 global 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 global entity when a strong branch or a regular branch is applied

Default: auto

value meaning
-1 Automatically determined.
0 No update.
1 Initialize using only regular branches from the root to the current node.
2 Same as 1, but initialize with strong branching results as well.
3 Initialize 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): Indicator constraints can be internally converted to regular rows (i.e. linearized) using a BigM coefficient whenever the BigM coefficient is smaller or equal to this value

Range: [0, ∞]

Default: 100000

indPreLinBigM (real): During presolve, indicator constraints can be internally replaced with regular rows (i.e. linearized) using a BigM coefficient whenever the BigM coefficient is smaller or equal to this value

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 than or equal to inputTol in absolute value, it is treated as zero. The control applies to input functions. For the internal zero tolerance see matrixTol.

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

knitroOptFile (string): Option file for NLP solver KNITRO

l1Cache (integer): Newton barrier: L1 cache size in kB (kilo bytes) of the CPU

On Intel (or compatible) platforms a value of -1 may be used to determine the cache size automatically.

Specifying the correct L1 cache size can give a significant performance advantage with the Newton barrier algorithm. If the size is unknown, it is better to specify a smaller size. If the size cannot be determined automatically on Intel (or compatible) platforms, a default size of 8 kB is assumed.

Range: {-1, ..., ∞}

Default: auto

lnpBest (integer): Number of infeasible global 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

lpThreads (integer): Parameter is deprecated and will be removed in a future release

This control is provided for compatibility purposes. Please use concurrentThreads instead.

The value of this control is mirrored by the concurrentThreads control.

Range: {-1, ..., ∞}

Default: -1

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 (integer): 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.
n>0 Stop cut generation after n 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, dualThreads and concurrentThreads). To obtain a MIP solve that is completely independent of the number of threads, it is sufficient to set maxMipTasks, forceParallelDual and barThreads. The concurrent LP solver should be avoided in this case.

The number of MIP tasks that can be defined for a 32-bit system is limited to 32 for performance reasons.

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.

maxTime (integer): 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 the nodes.

Default: 0

value meaning
0 No time limit.
n<0 Stop in LP or MIP search after n seconds.
n>0 If an integer solution has been found, stop MIP search after n seconds, otherwise continue until an integer solution is finally 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 global 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 global 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: -1e-05

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): Global print control

Default: -100

value meaning
0 No printout in global.
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): Allow the branch-and-bound tree search to be restarted if it appears to be advantageous

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

mipRelStop (real): Branch and Bound: Determines when the global search will terminate

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

objGoodEnough (real): Stop once an objective this good is found

Default: none

objScaleFactor (integer): Custom global objective scaling factor, expressed as a power of 2

When set, it overwrites the automatic global 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.

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.

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.

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.

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 non-global problem

See also refineOps.

Default: 1

refineOps_lpPresolve (boolean): Run the solution refiner on an optimal solution before postsolve on a non-global 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 global 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 global 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 global 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 global 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. maxTime overwrites 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 global 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 global entities to initialize pseudo costs for on each node

By default, strong branching will be performed only for infeasible global entities whose pseudo costs have not otherwise been initialized (see historyCosts). 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 global 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 global 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 global 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 global 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 global 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 global 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

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.

sleepOnThreadWait (integer): Determines if the threads should be put into a wait state when waiting for work

Default: auto

value meaning
-1 Automatically determined depending on the CPU the Optimizer is running on.
0 Keep the threads busy when waiting for work.
1 Put the threads into a wait state when waiting for work.

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

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

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 global 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 global 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 global solve

Use cutSelect to control cuts on the root node.

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

Default: -257

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.

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_flowpath (boolean): Flow path 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: 0

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 "global 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 global 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 global 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 global 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: {0, ..., ∞}

Default: 1000

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 XSLPglobal for solving MINLP problems. The recommended approach is to solve the problem first without reference to the global 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 global 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 global 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 global variables. Then, fixing the linearization, use MIP to find the optimal setting of the global variables. Then, fixing the global 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 global 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: 3

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 (boolean): Determines whether postsolving should be performed automatically

Default: 0

value meaning
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): First order differentiation mode when using analytical derivatives

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

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

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.