XPRESS

Table of Contents

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.
  • a global MINLP solver.

The GAMS/XPRESS solver is installed automatically with your GAMS system. There are different license options:

  • GAMS/XPRESS:
    Continuous and discrete linear and convex quadratic models.
  • GAMS/XPRESS-NLP:
    Continuous linear, quadratic and nonlinear models. In general, nonconvex nonlinear models are solved to local optimality only. In order to use GAMS Knitro, a GAMS/KNITRO license must be included.
  • GAMS/XPRESS-MINLP:
    All model types. In general, nonconvex nonlinear models are solved to local optimality only. In order to use GAMS Knitro, a GAMS/KNITRO license must be included.
  • GAMS/XPRESS-GLOBAL:
    All model types. Nonconvex nonlinear models can be solved to global optimality. In order to use GAMS Knitro, a GAMS/KNITRO license must be included.
  • GAMS/XPRESS Link:
    Users must have a separate, licensed XPRESS system. For users who wish to use XPRESS within GAMS and also in other environments. All model types, if XPRESS license enables it. In order to use GAMS Knitro, the user's Xpress license must enable it.
  • demo:
    Like GAMS/XPRESS but with demo limits (small models only).
Attention
The free bare-bone link mode (previously GAMS/OSIXPRESS) that allowed to solve LP and MIP when the user had a separate XPRESS license installed has been removed. If you relied on using this bare-bone link option, then do not hesitate to contact sales@gams.com to arrange for a GAMS/XPRESS Link license.

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. If licensed, XPRESS can solve the models to global optimality (see also xslp_nlpSolver). Otherwise, 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 and Global 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. For XPRESS Global the options optca, optcr, feasTol, xslp_validationTol_a and xslp_validationTol_r can be useful to control optimality and feasibility. More experienced users may want to modify the other XPRESS SLP 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
globalBoundingBox If a nonlinear problem cannot be solved due to appearing unbounded, it can automatically be regularized by the application of a bounding box on the variables 1e+06
inputTol Tolerance on input values elements 0
ioTimeout Maximum number of seconds to wait for an I/O operation before it is cancelled 30
lpIterLimit Maximum number of iterations that will be performed by primal simplex or dual simplex before the optimization process terminates maxint
lpRefineIterLimit Simplex iteration limit the solution refiner can spend in attempting to increase the accuracy of an LP solution auto
maxScaleFactor Determines the maximum scaling factor that can be applied during scaling 64
mpsNameLength Maximum length of MPS names in characters 0
mpsOutputFile Name of MPS output file none
numericalEmphasis How much emphasis to place on numerical stability instead of solve speed auto
outputControls Toggles the printing of all control settings at the beginning of the search 1
outputLog Controls the level of output produced by the Optimizer during optimization 1
outputTol Zero tolerance on print values 1e-05
qextractalg quadratic extraction algorithm in GAMS interface 0
randomSeed Sets the initial seed to use for the pseudo-random number generator in the Optimizer 1
refineOps Specifies when the solution refiner should be executed to reduce solution infeasibilities 19
refineOps_iterativeRefiner Apply the iterative refiner to refine the solution 0
refineOps_lpOptimal Run the solution refiner on an optimal solution of a continuous problem 1
refineOps_lpPresolve Run the solution refiner on an optimal solution before postsolve on a continuous problem 1
refineOps_mipFixGlobals Refine MIP solutions such that rounding them keeps the problem feasible when reoptimized 0
refineOps_mipFixGlobalsTarget Attempt to refine MIP solutions such that rounding them keeps the problem feasible when reoptimized, but accept integers solutions even if refinement fails 0
refineOps_mipNodeLp Run the solution refiner on each node of the MIP search 0
refineOps_mipSolution Run the solution refiner when a new solution is found during a tree search 1
refineOps_refinerPrecision Use higher precision in the iterative refinement 0
refineOps_refinerUseDual If set, the iterative refiner will use the dual simplex algorithm 0
refineOps_refinerUsePrimal If set, the iterative refiner will use the primal simplex algorithm 0
reform Substitute out objective var and equ when possible 1
reRun Rerun with primal simplex when not optimal/feasible 0
reslim Overrides GAMS reslim option
solTimeLimit Maximum time in seconds that the Optimizer will run a MIP solve before it terminates, given that a solution has been found 1e+20
timeLimit Maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time GAMS reslim
trace Display the infeasibility diagnosis during presolve 0
writePrtSol Directs optimizer to output a "printsol" file 0

Hardware Related Options

Option Description Default
backgroundMaxThreads Limit the number of threads to use in background jobs (for example in parallel to the root cut loop) -1
backgroundSelect Select which tasks to run in background jobs (for example in parallel to the root cut loop) -1
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 and hybrid gradient algorithms 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 and hybrid gradient algorithms auto
concurrentThreads Determines the number of threads used by the concurrent solver auto
coresPerCpu Used to override the detected value of the number of cores on a CPU auto
cpuPlatform Newton Barrier: Selects the AMD, Intel x86 or ARM vectorization instruction set that Barrier should run optimized code for -2
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
heurSearchBackgroundSelect Select which large neighborhood searches to run in the background (for example in parallel to the root cut loop) -1
heurThreads Branch and Bound: Number of threads to dedicate to running heuristics during the root solve 0
maxMemoryHard Sets the maximum amount of memory in megabytes the optimizer should allocate unlimited
maxMemorySoft When resourceStrategy is enabled, this control sets the maximum amount of memory in megabytes the optimizer targets to allocate unlimited
mipThreads If set to a positive integer it determines the number of threads implemented to run the parallel MIP code auto
relaxTreeMemoryLimit When the memory used by the branch and bound search tree exceeds the target specified by the treeMemoryLimit control, the optimizer will try to reduce this by writing nodes to the tree file 0.1
resourceStrategy Controls whether the optimizer is allowed to make nondeterministic decisions if memory is running low in an effort to preserve memory and finish the solve 0
threads Default number of threads used during optimization GAMS threads
treeCompression When writing nodes to the global file, the optimizer can try to use data-compression techniques to reduce the size of the tree file on disk 2
treeMemoryLimit Soft limit, in megabytes, for the amount of memory to use in storing the branch and bound search tree auto
treeMemorySavingTarget When the memory used by the branch-and-bound search tree exceeds the limit specified by the treeMemoryLimit control, the optimizer will try to save memory by writing lower-rated sections of the tree to the tree file 0.4

Presolve Options

Option Description Default
barPresolveOps Newton barrier: Controls the Newton-Barrier specific presolve operations 0
barPresolveOps_extra Extra effort is spent in barrier specific presolve 0
barPresolveOps_full Do full matrix eliminations (reduce matrix size) 0
barPresolveOps_standard Use standard presolve 0
dualize For a linear problem or the initial linear relaxation of a MIP, determines whether to form and solve the dual 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 7
elimTol Markowitz tolerance for the elimination phase of the presolve 0.001
indLinBigM During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough 100000
indPreLinBigM During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough 100
lpFolding Simplex and barrier: Whether to fold an LP problem before solving it auto
maxImpliedBound Presolve: When tighter bounds are calculated during MIP preprocessing, only bounds whose absolute value are smaller than maxImpliedBound will be applied to the problem 1e+08
mipPresolve Branch and Bound: Type of integer processing to be performed -1
mipPresolve_allowChangeBounds If node preprocessing is allowed to change bounds on continuous columns 1
mipPresolve_allowTreeRestart [Unused] This bit is no longer used to control restarts 1
mipPresolve_dualReductions Dual reductions will be performed at each node 1
mipPresolve_globalCoefTightening Allow global (non-bound) tightening of the problem during the tree search 1
mipPresolve_logicPreprocessing Primal reductions will be performed at each node 1
mipPresolve_objBasedReductions Objective function will be used to find reductions at each node 1
mipPresolve_reducedCostFixing Reduced cost fixing will be performed at each node 1
mipPresolve_symmetryReductions Allow that symmetry is used to presolve the node problem 1
preAnalyticCenter Determines if analytic centers should be computed and used for variable fixing and the generation of alternative reduced costs (-1: Auto 0: Off, 1: Fixing, 2: Redcost, 3: Both) auto
preBasisRed Determines if a lattice basis reduction algorithm should be attempted as part of presolve 0
preBndRedCone Determines if second order cone constraints should be used for inferring bound reductions on variables when solving a MIP auto
preBndRedQuad Determines if convex quadratic constraints should be used for inferring bound reductions on variables when solving a MIP auto
preCliqueStrategy Determines how much effort to spend on clique covers in presolve -1
preCoefElim Presolve: Specifies whether the optimizer should attempt to recombine constraints in order to reduce the number of non zero coefficients when presolving a mixed integer problem 2
preComponents Presolve: Determines whether small independent components should be detected and solved as individual subproblems during root node processing auto
preComponentsEffort Presolve: Adjusts the overall effort for the independent component presolver 1
preConeDecomp Presolve: Decompose regular and rotated cones with more than two elements and apply Outer Approximation on the resulting components auto
preConfiguration MIP Presolve: Determines whether binary rows with only few repeating coefficients should be reformulated auto
preConvertObjToCons Presolve: Convert a linear or quadratic objective function into an objective transfer constraint auto
preConvertSeparable Presolve: Reformulate problems with a 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_noCliquePresolve No clique presolve 0
presolveOps_noGlobalDomainChange No domain changes for MIP entities (e.g., semi-continuous detection or shifting integers) 0
presolveOps_noImpliedBounds No implied bounds 0
presolveOps_noIntVarAndSosDetect No integer variable and SOS detection 0
presolveOps_noIntVarEliminations No eliminations on integers 0
presolveOps_noIpReductions No IP reductions 0
presolveOps_noMod2Reductions No mod2 presolve 0
presolveOps_noSolutionEnumeration No reductions based on solution enumeration 0
presolveOps_redundantRowRemoval Redundant row removal 1
presolveOps_singletonColRemoval Singleton column removal 1
presolveOps_singletonRowRemoval Singleton row removal 1
presolveOps_strongDualReductions Strong dual reductions 1
presolveOps_variableEliminations Variable eliminations 1
presolvePasses Number of reduction rounds to be performed in presolve 1
rootPresolve Determines if presolving should be performed on the problem after the tree search has finished with root cutting and heuristics auto
siftPresolveOps Determines the presolve operations for solving the subproblems during the sifting algorithm -1

Scaling Options

Option Description Default
autoScaling Whether the Optimizer should automatically select between different scaling algorithms auto
barFreeScale Defines how the barrier algorithm scales free variables 1e-06
barObjScale Defines how the barrier scales the objective auto
barRhsScale Defines how the barrier scales the right hand side auto
objScaleFactor Custom objective scaling factor, expressed as a power of 2 0
scaling Determines how the Optimizer will rescale a model internally before optimization 163
scaling_beforePresolve Scale before presolve 0
scaling_bigM Treat big-M rows as normal rows 0
scaling_byMaxElemNotGeoMean 0: scale by geometric mean 1
scaling_colScaling Column scaling 1
scaling_curtisReid Curtis-Reid 0
scaling_disableGlobalObjScaling Do not apply automatic objective scaling 0
scaling_ignoreQuadRowPart Exclude the quadratic part of constraint when calculating scaling factors 0
scaling_maximum Maximum 0
scaling_noAggressiveQScaling Disable aggressive quadratic scaling 0
scaling_noScalingColsDown Do not scale columns down 0
scaling_noScalingRowsUp Do not scale rows up 0
scaling_rhsScaling RHS scaling 0
scaling_rowScaling Row scaling 1
scaling_rowScalingAgain Row scaling again 0
scaling_simplexObjScaling Scale objective function for the simplex method 1
scaling_slackScaling Enable explicit linear slack scaling 0

LP Options

Option Description Default
algAfterNetwork Algorithm to be used for the clean up step after the network simplex solver auto
autoPerturb Simplex: Indicates whether automatic perturbation is performed auto
bigM Infeasibility penalty used if the "Big M" method is implemented auto
bigMMethod Simplex: Whether to use the "Big M" method, or the standard phase I (achieving feasibility) and phase II (achieving optimality) 1
crash Simplex: Determines the type of crash used when the algorithm begins 2
defaultAlg Selects the algorithm that will be used to solve the LP auto
dualGradient Simplex: Dual simplex pricing method auto
dualPerturb Factor by which the problem will be perturbed prior to optimization by dual simplex auto
dualStrategy Bit-vector control specifies the dual simplex strategy 1
etaTol Tolerance on eta elements 1e-13
feasTol Determines when a solution is treated as feasible 1e-06
feasTolPerturb Determines how much a feasible primal basic solution is allowed to be perturbed when performing basis changes 1e-06
feasTolTarget Target feasibility tolerance for the solution refiner 0
forceParallelDual Dual simplex: Specifies whether the dual simplex solver should always use the parallel simplex algorithm 0
invertFreq Simplex: Frequency with which the basis will be inverted auto
invertMin Simplex: Minimum number of iterations between full inversions of the basis matrix 3
lpFlags Bit-vector control which defines the algorithm for solving an LP problem or the initial LP relaxation of a MIP problem 0
lpFlags_barrier Use the barrier method (or hybrid gradient method if barAlg=4 is set) 0
lpFlags_dual Use the dual simplex method 0
lpFlags_network Use the network simplex method 0
lpFlags_primal Use the primal simplex method 0
lpLog Simplex: Frequency at which the simplex log is printed 100
lpLogDelay Time interval between two LP log lines 1
lpLogStyle Simplex: Style of the simplex log 1
markowitzTol Markowitz tolerance used for the factorization of the basis matrix 0.01
matrixTol Zero tolerance on matrix elements 1e-09
netStallLimit Limit the number of degenerate pivots of the network simplex algorithm, before switching to either primal or dual simplex, depending on algAfterNetwork auto
optimalityTol Simplex: Zero tolerance for reduced costs 1e-06
optimalityTolTarget Target optimality tolerance for the solution refiner 0
penalty Minimum absolute penalty variable coefficient auto
pivotTol Simplex: Zero tolerance for matrix elements 1e-09
ppFactor Partial pricing candidate list sizing parameter 1
pricingAlg Simplex: Determines the primal simplex pricing method auto
primalOps Primal simplex: Allows fine tuning the variable selection in the primal simplex solver -1
primalPerturb Factor by which the problem will be perturbed prior to optimization by primal simplex auto
primalUnshift Determines whether primal is allowed to call dual to unshift 0
relPivotTol Simplex: Minimum size of pivot element relative to largest element in column 1e-06
sifting Determines whether to enable sifting algorithm with the dual simplex method auto
siftPasses Determines how quickly we allow to grow the worker problems during the sifting algorithm 4
siftSwitch Determines which algorithm to use for solving the subproblems during sifting -1

QP Options

Option Description Default
eigenvalueTol Quadratic matrix is considered not to be positive semi-definite, if its smallest eigenvalue is smaller than the negative of this value 1e-06
ifCheckConvexity Determines if the convexity of the problem is checked before optimization 1
qSimplexOps Controls the behavior of the quadratic simplex solvers 0
quadraticUnshift Determines whether an extra solution purification step is called after a solution found by the quadratic simplex (either primal or dual) auto
repairIndefInitEq Controls if the optimizer should make indefinite quadratic matrices positive definite when it is possible 1

Newton-barrier Options

Option Description Default
algAfterCrossover Algorithm to be used for the final clean up step after the crossover auto
barAlg Determines which barrier algorithm is used to solve the problem auto
barCrash Newton barrier and hybrid gradient: Determines the type of crash used for the crossover 4
barDualStop Newton barrier and hybrid gradient: 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 and hybrid gradient: Convergence parameter, representing the tolerance for the relative duality gap auto
barGapTarget Newton barrier: Target tolerance for the relative duality gap auto
barHGExtrapolate Extrapolation parameter for the hybrid gradient algorithm 0.99
barHGMaxRestarts Maximum number of restarts in the hybrid gradient algorithm 500
barHGOps Control options for the hybrid gradient algorithm 8
barHGOps_asymAvg Use an asymmetric average for the primal averaging 0
barHGOps_omegaContract Contract omega towards 1 if the infeasibility is small enough 0
barHGOps_omegaInf Omega is based on the infeasibility 0
barHGOps_sqrtOmega Take the square root of omega 0
barHGOps_startL1 Use the 1-norm of the coefficient matrix in normalizing the initial solution 0
barHGOps_startL2 Use the 2-norm of the coefficient matrix in normalizing the initial solution 0
barHGOps_startLInf Use the infinity norm of the coefficient matrix in normalizing the initial solution 1
barIndefLimit Newton Barrier: Limits the number of consecutive indefinite barrier iterations that will be performed 15
barIterLimit Newton barrier: Maximum number of iterations 500
barKernel Newton barrier: Defines how centrality is weighted in the barrier algorithm 0
barObjPerturb Defines how the barrier perturbs the objective 1e-06
barOrder Newton barrier: Controls the Cholesky factorization in the Newton-Barrier auto
barOutput Newton barrier and hybrid gradient: 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 and hybrid gradient: 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 Controls the computation of the starting point and warm-starting for the Newton barrier and the hybrid gradient algorithms 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 and hybrid gradient: Determines whether the barrier method will cross over to the simplex method when at optimal solution has been found, to provide an end basis and advanced sensitivity analysis information auto
crossoverAccuracyTol Newton barrier: Determines how crossover adjusts the default relative pivot tolerance 1e-06
crossoverIterLimit Newton barrier and hybrid gradient: Maximum number of iterations that will be performed in the crossover procedure before the optimization process terminates 2147483647
crossoverOps Newton barrier and hybrid gradient: 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

Global Solver Options

Option Description Default
globalLSHeurStrategy When integer-feasible (for MINLP, any solution for NLP) but nonlinear-infeasible solutions are encountered within a global solve, the integer variables can be fixed and a local solver can be called on the remaining continuous problem auto
globalNLPCuts Limit on the number of rounds of outer approximation and convexification cuts generated for the root node, when solving an (MI)NLP to global optimality auto
globalNumInitNLPCuts Specifies the maximum number of tangent cuts when setting up the initial relaxation during a global solve auto
globalTreeNLPCuts Limit on the number of rounds of outer approximation and convexification cuts generated for each node in the tree, when solving an (MI)NLP to global optimality auto
heurSearchCopyControls Select how user-set controls should affect local search heuristics auto

MIP Options

Option Description Default
backTrack Branch and Bound: Specifies how to select the next node to work on when a full backtrack is performed 3
backtrackTie Branch and Bound: Specifies how to break ties when selecting the next node to work on when a full backtrack is performed -1
branchChoice Once a MIP entity has been selected for branching, this control determines which of the branches is solved first 0
branchDisj Branch and Bound: Determines whether the optimizer should attempt to branch on general split disjunctions during the branch and bound search auto
branchStructural Branch and Bound: Determines whether the optimizer should search for special structure in the problem to branch on during the branch and bound search auto
breadthFirst Number of nodes to include in the best-first search before switching to the local first search (nodeSelection = 4) 11
deterministic Selects whether to use a deterministic or opportunistic mode when solving a problem using multiple threads 1
feasibilityPump Branch and Bound: Decides if the Feasibility Pump heuristic should be run at the top node auto
fixoptfile name of option file which is read just before solving the fixed problem
genConsAbsTransformation Specifies the reformulation method for absolute value general constraints at the beginning of the search auto
genConsDualReductions Parameter specifies whether dual reductions should be applied to reduce the number of columns and rows added when transforming general constraints to MIP structs 1
historyCosts Branch and Bound: How to update the pseudo cost for a MIP entity when a strong branch or a regular branch is applied auto
loadMipSol Loads a MIP solution (the initial point) 0
localChoice Controls when to perform a local backtrack between the two child nodes during a dive in the branch and bound tree auto
maxLocalBacktrack Branch-and-Bound: How far back up the current dive path the optimizer is allowed to look for a local backtrack candidate node auto
maxMipSol Branch and Bound: Limit on the number of integer solutions to be found by the Optimizer 0
maxMipTasks Branch-and-Bound: The maximum number of tasks to run in parallel during a MIP solve auto
maxNode Branch and Bound: Maximum number of nodes that will be explored maxint
maxStallTime Maximum time in seconds that the Optimizer will continue to search for improving solution after finding a new incumbent 0
mipAbsCutoff Branch and Bound: If the user knows that they are interested only in values of the objective function which are better than some value, this can be assigned to mipAbsCutoff auto
mipAbsStop Branch and Bound: Absolute tolerance determining whether the tree search will continue or not 0
mipAddCutoff Branch and Bound: Amount to add to the objective function of the best integer solution found to give the new CURRMIPCUTOFF 0
mipCleanup Clean up the MIP solution (round-fix-solve) to get duals 1
mipComponents Determines whether disconnected components in a MIP should be solved as separate MIPs auto
mipConcurrentNodes Sets the node limit for when a winning solve is selected when concurrent MIP solves are enabled auto
mipConcurrentSolves Selects the number of concurrent solves to start for a MIP 0
mipDualReductions Branch and Bound: Limits operations that can reduce the MIP solution space 1
mipFracReduce Branch and Bound: Specifies how often the optimizer should run a heuristic to reduce the number of fractional integer variables in the node LP solutions auto
mipKappaFreq Branch and Bound: Specifies how frequently the basis condition number (also known as kappa) should be calculated during the branch-and-bound search 0
mipLog MIP log print control -100
mipRampUp Controls the strategy used by the parallel MIP solver during the ramp-up phase of a branch-and-bound tree search auto
mipRefineIterLimit Defines an effort limit expressed as simplex iterations for the MIP solution refiner auto
mipRelCutoff Branch and Bound: Percentage of the incumbent value to be added to the value of the objective function when an integer solution is found, to give the new value of CURRMIPCUTOFF 0
mipRelStop Branch and Bound: Determines when the branch and bound tree search will terminate 0.0001
mipRestart Branch and Bound: Controls strategy for in-tree restarts auto
mipRestartFactor Branch and Bound: Fine tune initial conditions to trigger an in-tree restart 1
mipRestartGapThreshold Branch and Bound: Initial gap threshold to delay in-tree restart 0.02
mipstopexpr Stopping expression for branch and bound
mipTol Branch and Bound: Tolerance within which a decision variable′s value is considered to be integral 5e-06
mipToltarget Target mipTol value used by the automatic MIP solution refiner as defined by refineOps 0
mipTrace Name of MIP trace file none
mipTraceNode Node interval between MIP trace file entries 100
mipTraceTime Time interval, in seconds, between MIP trace file entries 5
miqcpAlg Determines which algorithm is to be used to solve mixed integer quadratic constrained and mixed integer second order cone problems auto
nodeProbingEffort Adjusts the overall level of node probing 1
nodeSelection Branch and Bound: Determines which nodes will be considered for solution once the current node has been solved auto
objGoodEnough Stop once an objective this good is found none
pseudoCost Branch and Bound: Default pseudo cost used in estimation of the degradation associated with an unexplored node in the tree search 0.01
qcRootAlg Determines which algorithm is to be used to solve the root of a mixed integer quadratic constrained or mixed integer second order cone problem, when outer approximation is used auto
sbBest Number of infeasible MIP entities to initialize pseudo costs for on each node auto
sbEffort Adjusts the overall amount of effort when using strong branching to select an infeasible MIP entity to branch on 1
sbEstimate Branch and Bound: How to calculate pseudo costs from the local node when selecting an infeasible MIP entity to branch on auto
sbIterLimit Number of dual iterations to perform the strong branching for each entity auto
sbSelect Size of the candidate list of MIP entities for strong branching -2
sosRefTol Minimum relative gap between the ordering values of elements in a special ordered set 1e-06
symmetry Adjusts the overall amount of effort for symmetry detection 1
symSelect Adjusts the overall amount of effort for symmetry detection -1
varSelection Branch and Bound: Determines the formula used to calculate the estimate of each integer variable, and thus which integer variable is selected to be branched on at a given node auto

MIP Cuts Options

Option Description Default
autoCutting Automatically decide whether to generate cutting planes at local nodes in the tree auto
conflictCuts Branch and Bound: Specifies how cautious or aggressive the optimizer should be when searching for and applying conflict cuts auto
coverCuts Branch and Bound: Number of rounds of lifted cover inequalities at the top node auto
cutDepth Branch and Bound: Sets the maximum depth in the tree search at which cuts will be generated auto
cutFactor Limit on the number of cuts and cut coefficients the optimizer is allowed to add to the matrix during tree search auto
cutFreq Branch and Bound: Frequency at which cuts are generated in the tree search auto
cutSelect Bit vector providing detailed control of the cuts created for the root node of a MIP solve -1
cutSelect_clique Clique cuts 1
cutSelect_cover Lifted cover cuts 1
cutSelect_disableCutRows Disable cutting from cut rows 1
cutSelect_farkas Farkas cuts 1
cutSelect_flowpath Flow path cuts 1
cutSelect_gomory Strong Chvatal-Gomory cuts 1
cutSelect_gubCover Lifted GUB cover cuts 1
cutSelect_implication Implication cuts 1
cutSelect_indicator Indicator constraint cuts 1
cutSelect_liftAndProject Turn on automatic Lift-and-Project cutting strategy 1
cutSelect_mir Mixed Integer Rounding (MIR) cuts 1
cutSelect_mirRowAggregation Turn on row aggregation for MIR cuts 1
cutSelect_zeroHalf Zero-half cuts 1
cutStrategy Branch and Bound: Cut strategy auto
gomCuts Branch and Bound: Number of rounds of Gomory or lift-and-project cuts at the top node auto
lnpBest Number of infeasible MIP entities to create lift-and-project cuts for during each round of Gomory cuts at the top node (see gomCuts) 50
lnpIterLimit Number of iterations to perform in improving each lift-and-project cut auto
maxCutTime Maximum amount of time allowed for generation of cutting planes and reoptimization 0
mcfCutStrategy Level of Multi-Commodity Flow (MCF) cutting planes separation: This specifies how much aggresively MCF cuts should be separated auto
qcCuts Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation auto
treeCoverCuts Branch and Bound: Number of rounds of lifted cover inequalities generated at nodes other than the top node in the tree auto
treeCutSelect Bit vector providing detailed control of the cuts created during the tree search of a MIP solve -1
treeCutSelect_clique Clique cuts 1
treeCutSelect_cover Lifted cover cuts 1
treeCutSelect_disableCutRows Disable cutting from cut rows 1
treeCutSelect_farkas Farkas cuts 1
treeCutSelect_flowpath Flow path cuts 1
treeCutSelect_gomory Strong Chvatal-Gomory cuts 1
treeCutSelect_gubCover Lifted GUB cover cuts 1
treeCutSelect_implication Implication cuts 1
treeCutSelect_indicator Indicator constraint cuts 1
treeCutSelect_liftAndProject Turn on automatic Lift and Project cutting strategy 1
treeCutSelect_mir Mixed Integer Rounding (MIR) cuts 1
treeCutSelect_mirRowAggregation Turn on row aggregation for MIR cuts 1
treeCutSelect_zeroHalf Zero-half cuts 1
treeGomCuts Branch and Bound: Number of rounds of Gomory cuts generated at nodes other than the first node in the tree auto
treeQCCuts Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for nodes other than the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation auto

MIP Heuristics Options

Option Description Default
feasibilityJump MIP: Decides if the Feasibility Jump heuristic should be run auto
heurBeforeLp Branch and Bound: Determines whether primal heuristics should be run before the initial LP relaxation has been solved auto
heurDiveIterLimit Branch and Bound: Simplex iteration limit for reoptimizing during the diving heuristic auto
heurDiveRandomize Level of randomization to apply in the diving heuristic 0
heurDiveSoftRounding Branch and Bound: Enables a more cautious strategy for the diving heuristic, where it tries to push binaries and integer variables to their bounds using the objective, instead of directly fixing them auto
heurDiveSpeedUp Branch and Bound: Changes the emphasis of the diving heuristic from solution quality to diving speed -1
heurDiveStrategy Branch and Bound: Chooses the strategy for the diving heuristic auto
heurEmphasis Branch and Bound: Specifies an emphasis for the search w.r.t. primal heuristics and other procedures that affect the speed of convergence of the primal-dual gap -1
heurForceSpecialObj Branch and Bound: Whether local search heuristics without objective or with an auxiliary objective should always be used, despite the automatic selection of the Optimizer 0
heurFreq Branch and Bound: Frequency at which heuristics are used in the tree search -1
heurSearchEffort Adjusts the overall level of the local search heuristics 1
heurSearchFreq Branch and Bound: How often the local search heuristic should be run in the tree auto
heurSearchRootCutFreq How frequently to run the local search heuristic during root cutting auto
heurSearchRootSelect Bit vector control for selecting which local search heuristics to apply on the root node of a MIP solve 117
heurSearchTreeSelect Bit vector control for selecting which local search heuristics to apply during the tree search of a MIP solve 17
heurShiftProp Determines whether the Shift-and-propagate primal heuristic should be executed -1

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_filterCascade Check cascaded solutions against improvements in the merit function 1
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_nlpSolver Controls whether to call FICO Xpress Global or one of the local solvers -1
xslp_primalIntegralAlpha Decay term for primal integral computation 0
xslp_primalIntegralRef Reference solution value to take into account when calculating the primal integral 1e+20
xslp_scale When to re-scale the SLP problem 1
xslp_scaleCount Iteration limit used in determining when to re-scale the SLP matrix 0
xslp_solver Selects the library to use for local solves auto
xslp_threads Default number of threads to be used auto
xslp_zero Absolute tolerance 1e-15

NLP Presolve Options

Option Description Default
xslp_boundThreshold Maximum size of a bound that can be introduced by nonlinear presolve 1e+10
xslp_linQuadBR Use linear and quadratic constraints and objective function to further reduce bounds on all variables auto
xslp_postsolve Determines whether postsolving should be performed automatically -1
xslp_presolve Determines whether presolving should be performed prior to starting the main algorithm 1
xslp_presolveLevel Determines the level of changes presolve may carry out on the problem and whether column/row indices may change 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_presolve_elimTol Tolerance for nonlinear eliminations during SLP presolve 0.001
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_slpSkipIVLPHeuristics Avoid running an LP around fixed initial values trying to get feasible 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 1e-06
xslp_clampValidationTol_r Relative validation tolerance for applying xslp_clampShrink 1e-06
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_noQuadCheck Allow convex quadratic problems to converge on extended criteria 0
xslp_convergenceOps_oTol Execute the objective range + active step bound check 1
xslp_convergenceOps_sTol Execute the slack impact tolerance checks 1
xslp_convergenceOps_user Check for user provided convergence 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_validationFactor Minimum improvement in validation targets to continue iterating 0.001
xslp_validationTarget_k Optimality target tolerance 1e-06
xslp_validationTarget_r Feasiblity target tolerance 1e-06
xslp_validationTol_a Absolute tolerance for the XSLPvalidate procedure (may be used by Xpress Global internally) 1e-05
xslp_validationTol_k Relative tolerance for the XSLPvalidatekkt procedure (may be used by Xpress Global internally) 1e-05
xslp_validationTol_r Relative tolerance for the XSLPvalidate procedure (may be used by Xpress Global internally) 1e-05
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_infinity Maximum value for partial derivatives 1e+15
xslp_delta_r Relative perturbation of values for calculating numerical derivatives 0.001
xslp_delta_z Tolerance used when calculating derivatives 1e-05
xslp_delta_zero Absolute zero acceptance tolerance used when calculating derivatives -1
xslp_derivatives Bitmap describing the method of calculating derivatives 1
xslp_hessian Second order differentiation mode when using analytical derivatives -1
xslp_jacobian First order differentiation mode when using analytical derivatives -1

NLP Log Options

Option Description Default
xslp_analyze Bit map activating additional options supporting model / solution path analyzis 0
xslp_analyze_extendedFinalSummary Include an extended iteration summary 0
xslp_analyze_infeasibleIteration Run infeasibility analysis on infeasible iterations 0
xslp_analyze_saveFile Create an Xpress SLP save file at every xslp_autosave iterations 0
xslp_analyze_saveIterBasis Write the initial basis of the linearizations to disk at every xslp_autosave iterations 0
xslp_analyze_saveLinearizations Write the linearizations to disk at every xslp_autosave iterations 0
xslp_autosave Frequency with which to save the model 0
xslp_log Level of printing during SLP iterations 0
xslp_slpLog Frequency with which SLP status is printed 1

MINLP Options

Option Description Default
xslp_cutStrategy Determines whihc cuts to apply in the MISLP search when the default SLP-in-MIP strategy is used 0
xslp_heurStrategy Branch and Bound: MINLP heuristic strategy auto
xslp_mipAlgorithm Bitmap describing the MISLP algorithms to be used 17
xslp_mipAlgorithm_finalFixSLP Fix step bounds according to xslp_mipFixStepBounds after MIP solution is found 0
xslp_mipAlgorithm_finalRelaxSLP Relax step bounds according to xslp_mipRelaxStepBounds after MIP solution is found 0
xslp_mipAlgorithm_initialFixSLP Fix step bounds according to xslp_mipFixStepBounds after initial node 0
xslp_mipAlgorithm_initialRelaxSLP Relax step bounds according to xslp_mipRelaxStepBounds after initial node 0
xslp_mipAlgorithm_initialSLP Solve initial SLP to convergence 1
xslp_mipAlgorithm_nodeFixSLP Fix step bounds according to xslp_mipFixStepBounds at each node 0
xslp_mipAlgorithm_nodeLimitSLP Limit iterations at each node to xslp_mipIterLimit 0
xslp_mipAlgorithm_nodeRelaxSLP Relax step bounds according to xslp_mipRelaxStepBounds at each node 1
xslp_mipAlgorithm_slpThenMIP Use MIP on converged SLP solution and then SLP on the resulting MIP solution 0
xslp_mipAlgorithm_withinSLP Use MIP at each SLP iteration instead of SLP at each node 0
xslp_mipCutOffCount Number of SLP iterations to check when considering a node for cutting off 5
xslp_mipCutOffLimit Number of SLP iterations to check when considering a node for cutting off 10
xslp_mipCutOff_a Absolute objective function cutoff for MIP termination 1e-05
xslp_mipCutOff_r Absolute objective function cutoff for MIP termination 1e-05
xslp_mipDefaultAlgorithm Default algorithm to be used during the tree search in MISLP 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

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

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

Default: auto

value meaning
-1 Automatic.
0 Disabled.
1 Enabled.

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

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

Default: auto

value meaning
0 No perturbation performed.
1 Automatic perturbation is performed.

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

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

Default: auto

value meaning
-1 Automatic.
0 Disabled.
1 Cautious strategy. Non-standard scaling will only be selected if it appears to be clearly superior.
2 Moderate strategy.
3 Aggressive strategy. Standard scaling will only be selected if it appears to be clearly superior.

backgroundMaxThreads (integer): Limit the number of threads to use in background jobs (for example in parallel to the root cut loop) ↵

If this is set to -1 (the default) then Xpress decides automatically how many threads to run. Otherwise this control limits the number of threads that Xpress will use for jobs in the background (for example in parallel to the root cut loop). Set this to 0 (zero) in order to disable jobs in the background. The maxMipTasks does not apply to this control. If you want to have the same solution paths between hardware with different CPU counts or between runs with different thread counts then you should set this control to the same non-negative value in all runs.

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

Default: -1

backgroundSelect (integer): Select which tasks to run in background jobs (for example in parallel to the root cut loop) ↵

If this is set to -1 (the default) then Xpress decides automatically which tasks to run. Otherwise the value is interpreted as a bitset that indicates which heuristics to run. 0 (zero) means not to run any tasks in the background. Background jobs that run large neighborhood search heuristics are controlled by heurSearchBackgroundSelect.

Default: -1

value meaning
bit 0 = 1 Feasibility jump heuristic.
bit 1 = 2 Fast branch-and-bound heuristic.
bit 2 = 4 Same as bit 1 but with some additional heuristics enabled.
bit 3 = 8 Fix-propagate-repair heuristic.

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

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

Default: 3

value meaning
-1 Automatically determined.
1 Unused.
2 Select the node with the best estimated solution.
3 Select the node with the best bound on the solution.
4 Select the deepest node in the search tree (equivalent to depth-first search).
5 Select the highest node in the search tree (equivalent to breadth-first search).
6 Select the earliest node created.
7 Select the latest node created.
8 Select a node randomly.
9 Select the node whose LP relaxation contains the fewest number of infeasible MIP entities.
10 Combination of 2 and 9.
11 Combination of 2 and 4.
12 Combination of 3 and 4.

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

The options are the same as for the backTrack control.

Default: -1

value meaning
-1 Default selection.
1 Unused.
2 Select the node with the best estimated solution.
3 Select the node with the best bound on the solution.
4 Select the deepest node in the search tree (equivalent to depth-first search).
5 Select the highest node in the search tree (equivalent to breadth-first search).
6 Select the earliest node created.
7 Select the latest node created.
8 Select a node randomly.
9 Select the node whose LP relaxation contains the fewest number of infeasible MIP entities.
10 Combination of 2 and 9.
11 Combination of 2 and 4.
12 Combination of 3 and 4.

barAlg (integer): Determines which barrier algorithm is 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. Setting 4, the hybrid gradient algorithm, is suitable for very large or very degenerate problems.

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.
4 Use the hybrid gradient algorithm.

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 and hybrid gradient algorithms ↵

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 and hybrid gradient: 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 and hybrid gradient: 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 and hybrid gradient: 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

barHGExtrapolate (real): Extrapolation parameter for the hybrid gradient algorithm ↵

Although theory suggests that a value of 1 is best, slightly smaller values perform better in general.

Range: [0, ∞]

Default: 0.99

barHGMaxRestarts (integer): Maximum number of restarts in the hybrid gradient algorithm ↵

Restarts play the role of iterations in the hybrid gradient algorithm. A log line is printed at every restart, unless barOutput is set to 0.

Range: {0, ..., ∞}

Default: 500

barHGOps (integer): Control options for the hybrid gradient algorithm ↵

Bits 1, 2 and 3 control which norms of the coefficient matrix are used for solution normalization. The normalization factor is the maximum of the selected norms. By default, or if all three bits are set to 0, the infinity norm is used. The omega parameter referenced in bits 4, 5 and 6 is a measure of the relative magnitudes of the objective and the right-hand side.

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

Default: 8

value meaning
bit 0 = 1 Equivalent to barHGOps_asymAvg.
bit 1 = 2 Equivalent to barHGOps_startL1.
bit 2 = 4 Equivalent to barHGOps_startL2.
bit 3 = 8 Equivalent to barHGOps_startLInf.
bit 4 = 16 Equivalent to barHGOps_sqrtOmega.
bit 5 = 32 Equivalent to barHGOps_omegaContract.
bit 6 = 64 Equivalent to barHGOps_omegaInf.

barHGOps_asymAvg (boolean): Use an asymmetric average for the primal averaging ↵

See also barHGOps.

Default: 0

barHGOps_omegaContract (boolean): Contract omega towards 1 if the infeasibility is small enough ↵

See also barHGOps.

Default: 0

barHGOps_omegaInf (boolean): Omega is based on the infeasibility ↵

See also barHGOps.

Default: 0

barHGOps_sqrtOmega (boolean): Take the square root of omega ↵

See also barHGOps.

Default: 0

barHGOps_startL1 (boolean): Use the 1-norm of the coefficient matrix in normalizing the initial solution ↵

See also barHGOps.

Default: 0

barHGOps_startL2 (boolean): Use the 2-norm of the coefficient matrix in normalizing the initial solution ↵

See also barHGOps.

Default: 0

barHGOps_startLInf (boolean): Use the infinity norm of the coefficient matrix in normalizing the initial solution ↵

See also barHGOps.

Default: 1

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

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

Range: {1, ..., ∞}

Default: 15

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

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

Range: {0, ..., ∞}

Default: 500

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

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

Default: 0

value meaning
>=+1.0 Increases the emphasis on centrality when larger value is set.
<=-1.0 Selects a value adaptively in every iteration from [+1, -barKernel].

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

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

Default: 1e-06

value meaning
0 Turn off objective perturbation.
>0 Let the optimizer decide if the objective is perturbed or not and use the parameter value as the scale of the perturbation.
<0 Always perturb the objective by the absolute value of the parameter.

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

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

Default: auto

value meaning
-1 Let the optimizer decide.
0 Scale by geometric mean.
>=0 Scale such that the largest objective coefficient′s largest element does not exceed this number. In quadratic problems, the quadratic diagonal is used as reference valuses instead of the linear objective.

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

Default: auto

value meaning
0 Choose automatically.
1 Minimum degree method. This selects diagonal elements with the smallest number of nonzeros in their rows or columns.
2 Minimum local fill method. This considers the adjacency graph of nonzeros in the matrix and seeks to eliminate nodes that minimize the creation of new edges.
3 Nested dissection method. This considers the adjacency graph and recursively seeks to separate it into non-adjacent pieces.

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

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

Range: {0, ..., ∞}

Default: auto

barOutput (boolean): Newton barrier and hybrid gradient: Level of solution output provided ↵

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

Default: 1

value meaning
0 No output.
1 At each iteration.

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

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

Range: [0, ∞]

Default: 0

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

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

Default: 0

value meaning
bit 0 = 1 Equivalent to barPresolveOps_standard.
bit 1 = 2 Equivalent to barPresolveOps_extra.
bit 2 = 4 Equivalent to barPresolveOps_full.

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

See also barPresolveOps.

Default: 0

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

See also barPresolveOps.

Default: 0

barPresolveOps_standard (boolean): Use standard presolve ↵

See also barPresolveOps.

Default: 0

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

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

Range: [0, ∞]

Default: auto

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

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

Range: {0, ..., ∞}

Default: 0

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

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

Default: -1

value meaning
bit 0 = 1 Standard regularization is turned on/off.
bit 1 = 2 Reduced regularization is turned on/off. This option reduces the perturbation effect of the standard regularization.
bit 2 = 4 Forces to keep dependent rows in the KKT system.
bit 3 = 8 Forces to preserve degenerate rows in the KKT system.
bit 4 = 16 Restrict regularization to infeasible iterates.
bit 5 = 32 Disable iterative regularizations.
bit 6 = 64 Apply iterative regularization more often.

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

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

Default: auto

value meaning
-1 Let the optimizer decide.
0 Scale by geometric mean.
>=0 Scale such that the largest right hand side coefficient′s largest element does not exceed this number.

barStart (integer): Controls the computation of the starting point and warm-starting for the Newton barrier and the hybrid gradient algorithms ↵

Default: auto

value meaning
-1 Uses the existing solution for warm-start if one is available.
0 Warm-start is disabled; the starting point is determined automatically from the next three options.
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 and hybrid gradient algorithms ↵

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

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

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

Default: auto

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

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

Default: none

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

Range: [0, ∞]

Default: auto

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

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

Default: 1

value meaning
0 For phase I / phase II.
1 If "Big M" method to be used.

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

Default: 0

value meaning
0 Minimum estimate branch first.
1 Maximum estimate branch first.
2 If an incumbent solution exists, solve the branch satisfied by that solution first. Otherwise solve the minimum estimate branch first (option 0).
3 Solve first the branch that forces the value of the branching variable to move farther away from the value it had at the root node. If the branching entity is not a simple variable, solve the minimum estimate branch first (option 0).

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

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

Default: auto

value meaning
-1 Automatic selection of the strategy.
0 Disabled.
1 Cautious strategy. Disjunctive branches will be created only for general integers with a wide range.
2 Moderate strategy.
3 Aggressive strategy. Disjunctive branches will be created for both binaries and integers.

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

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

Default: auto

value meaning
-1 Automatically determined.
0 Disabled.
1 Enabled.

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

Range: {0, ..., ∞}

Default: 11

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

Default: auto

value meaning
bit 0 = 1 Matrix blocking: 0: automatic setting; 1: manual setting.
bit 1 = 2 If manual selection of matrix blocking: 0: multi-pass; 1: single-pass.
bit 2 = 4 Nonseparable QP relaxation: 0: off; 1: on.
bit 3 = 8 Corrector weight: 0: automatic setting; 1: manual setting.
bit 4 = 16 If manual selection of corrector weight: 0: off; 1: on.
bit 5 = 32 Refinement: 0: automatic setting; 1: manual setting.
bit 6 = 64 Preconditioned conjugate gradient method (PCGM): 0: PCGM off; 1: PCGM on.
bit 7 = 128 Preconditioned quasi minimal residual (QMR) to refine solution: 0: QMR off; 1: QMR on.
bit 8 = 256 Perform refinement on the augmented system 0: off; 1: on.
bit 9 = 512 Force highest accuracy in refinement 0: off; 1: on.

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

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

Range: [0, ∞]

Default: 1e-15

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

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

Default: 0

value meaning
-1 Determined automatically.
0 Equivalent to clamping_primal.
1 Equivalent to clamping_dual.
2 Equivalent to clamping_slacks.
3 Equivalent to clamping_rdj.

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

See also clamping.

Default: 0

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

Slacks if provided will be adjusted accordingly.

See also clamping.

Default: 0

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

See also clamping.

Default: 0

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

Reduced costs, if provided, will be adjusted accordingly.

See also clamping.

Default: 0

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

Default: auto

value meaning
-1 Determined automatically
>0 Number of threads to use.

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

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

Default: auto

value meaning
-1 Automatic.
0 Disable conflict cuts.
1 Cautious application of conflict cuts.
2 Medium application of conflict cuts.
3 Aggressive application of conflict cuts.

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

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

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

Default: auto

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

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

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

Default: auto

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

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

Generic code, SSE2 and AVX optimized code will all result in the same solution path, regardless of the operating system. The solution paths of AVX2 runs are also the same, regardless of the operating system. Using AVX2 or NEON might result in a solution path that is different from the AVX path.

Default: -2

value meaning
-2 Highest supported [Generic, SSE2, AVX or AVX2].
-1 Highest supported solve path consistent code [Generic, SSE2 or AVX].
0 Use generic code compatible with all CPUs.
1 Use SSE2 / NEON optimized code.
2 Use AVX optimized code.
3 Use AVX2 optimized code.

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

Default: 0

value meaning
-1 Disable the timer.
0 Use elapsed time.
1 Use process time.

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

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

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

For dual simplex the bit-vector choices are relevant.

Default: 2

value meaning
0 Turns off all crash procedures.
1 For singletons only (one pass).
2 For singletons only (multi pass).
3 Multiple passes through the matrix considering slacks.
4 Multiple (≤ 10) passes through the matrix but only doing slacks at the very end.
bit 0 = 1 Perform standard crash.
bit 1 = 2 Perform additional numerical checks during crash.
bit 2 = 4 Extend the set of column candidates for crash.
bit 3 = 8 Extend the set of row candidates for crash.
bit 4 = 16 Force crash, i.e., consider all suitable columns/rows as candidates for crash.
n>10 As for value 4 but performing at most n - 10 passes.

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

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

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 and hybrid gradient: 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 and hybrid gradient: Bit vector for adjusting the behavior of the crossover procedure ↵

Default: 0

value meaning
bit 0 = 1 Returned solution when the crossover terminates prematurely: 0: Return the last basis from the crossover; 1: Return the barrier solution.
bit 1 = 2 Select the crossover stages to be performed: 0: Perform both crossover stages; 1: Skip second crossover stage.
bit 2 = 4 Set crossover behaviour: 0: Force to perform all pivots; 1: Skip pivots that are numerically less reliable.
bit 3 = 8 Set crossover behaviour: 0: Perform standard crossover; 1: Perform a slower, but numerically more careful crossover.

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

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

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

Default: auto

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

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

Does not affect cutting on the root node.

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

Default: auto

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

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

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

Default: auto

value meaning
-1 Let the optimizer decide on the maximum amount of cuts based on cutStrategy.
>=0 Multiple of number of rows and coefficients to use.

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

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

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

Default: auto

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

Use treeCutSelect to control cuts during the tree search.

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

The separation of Multi-Commodity Flow (MCF) cuts is controlled by mcfCutStrategy.

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

Default: -1

value meaning
bit 5 = 32 Equivalent to cutSelect_clique.
bit 6 = 64 Equivalent to cutSelect_mir.
bit 7 = 128 Equivalent to cutSelect_cover.
bit 8 = 256 Equivalent to cutSelect_mirRowAggregation.
bit 11 = 2048 Equivalent to cutSelect_flowpath.
bit 12 = 4096 Equivalent to cutSelect_implication.
bit 13 = 8192 Equivalent to cutSelect_liftAndProject.
bit 14 = 16384 Equivalent to cutSelect_disableCutRows.
bit 15 = 32768 Equivalent to cutSelect_gubCover.
bit 16 = 65536 Equivalent to cutSelect_zeroHalf.
bit 17 = 131072 Equivalent to cutSelect_indicator.
bit 18 = 262144 Equivalent to cutSelect_gomory.
bit 20 = 1048576 Equivalent to cutSelect_farkas.

cutSelect_clique (boolean): Clique cuts ↵

See also cutSelect.

Default: 1

cutSelect_cover (boolean): Lifted cover cuts ↵

See also cutSelect.

Default: 1

cutSelect_disableCutRows (boolean): Disable cutting from cut rows ↵

See also cutSelect.

Default: 1

cutSelect_farkas (boolean): Farkas cuts ↵

See also cutSelect.

Default: 1

cutSelect_flowpath (boolean): Flow path cuts ↵

See also cutSelect.

Default: 1

cutSelect_gomory (boolean): Strong Chvatal-Gomory cuts ↵

See also cutSelect.

Default: 1

cutSelect_gubCover (boolean): Lifted GUB cover cuts ↵

See also cutSelect.

Default: 1

cutSelect_implication (boolean): Implication cuts ↵

See also cutSelect.

Default: 1

cutSelect_indicator (boolean): Indicator constraint cuts ↵

See also cutSelect.

Default: 1

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

See also cutSelect.

Default: 1

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

See also cutSelect.

Default: 1

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

See also cutSelect.

Default: 1

cutSelect_zeroHalf (boolean): Zero-half cuts ↵

See also cutSelect.

Default: 1

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

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

Default: auto

value meaning
-1 Automatic selection of the cut strategy.
0 No cuts.
1 Conservative cut strategy.
2 Moderate cut strategy.
3 Aggressive cut strategy.

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

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

Default: auto

value meaning
1 Automatically determined.
2 Dual simplex.
3 Primal simplex.
4 Newton barrier (or hybrid gradient, if barAlg=4 is set).

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

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

Range: {0, ..., ∞}

Default: auto

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

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

Default: 1

value meaning
0 Use opportunistic mode.
1 Use deterministic mode.
2 Use deterministic mode, except allow the initial concurrent continuous solve of a MIP to be opportunistic.

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

Default: auto

value meaning
-1 Determined automatically.
0 Devex.
1 Steepest edge.
2 Direct steepest edge.
3 Sparse Devex.

dualize (integer): For a linear problem or the initial linear relaxation of a MIP, determines whether to form and solve the dual problem ↵

Default: auto

value meaning
-1 Determine automatically which version would be faster.
0 Solve the original problem.
1 Solve the dualized 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: 7

elimTol (real): Markowitz tolerance for the elimination phase of the presolve ↵

Range: [0, ∞]

Default: 0.001

etaTol (real): Tolerance on eta elements ↵

During each iteration, the basis inverse is premultiplied by an elementary matrix, which is the identity except for one column - the eta vector. Elements of eta vectors whose absolute value is smaller than etaTol are taken to be zero in this step.

Range: [0, ∞]

Default: 1e-13

feasibilityJump (integer): MIP: Decides if the Feasibility Jump heuristic should be run ↵

The value for this control is either -1 (let Xpress decide), 0 (off) or a value that indicates for which type of models the heuristic should be run.

Default: auto

value meaning
-1 Use automatic settings.
0 Turned off.
1 Run the heuristic on models with all integer variables.
2 Run the heuristic on models in which all non-integer variables have bounds [0,1].
3 Run the heuristic on models in which all non-integer variables have integer bounds.

feasibilityPump (integer): Branch and Bound: Decides if the Feasibility Pump heuristic should be run at the top node ↵

Default: auto

value meaning
-1 Automatic.
0 Turned off.
1 Always try the Feasibility Pump.
2 Try the Feasibility Pump only if other heuristics have failed to find an integer solution.

feasTol (real): Determines when a solution is treated as feasible ↵

If the amount by which a constraint′s activity violates its right-hand side or ranged bound is less in absolute magnitude than feasTol, then the constraint is treated as satisfied. Similarly, if the amount by which a column violates its bounds is less in absolute magnitude than feasTol, those bounds are also treated as satisfied.

Range: [0, ∞]

Default: 1e-06

feasTolPerturb (real): Determines how much a feasible primal basic solution is allowed to be perturbed when performing basis changes ↵

The tolerance feasTol is always considered as an upper limit for the perturbations, but in some cases smaller value can be more desirable.

Range: [0, ∞]

Default: 1e-06

feasTolTarget (real): Target feasibility tolerance for the solution refiner ↵

Zero and negative values are ignored, and the value of feasTol is used.

Use very small values like 1e-100 to state the refinement should continue as long as an improvement is made. Use very large values like 1e+100 to disable only this aspect of the refiner.

Refining solutions to match the feastoltarget can influence and worsen their objective value in case the previous objective could only be achieved through slight infeasibilities.

Range: [-∞, ∞]

Default: 0

fixoptfile (string): name of option file which is read just before solving the fixed problem ↵

forceParallelDual (boolean): Dual simplex: Specifies whether the dual simplex solver should always use the parallel simplex algorithm ↵

By default, when using a single thread, the dual simplex solver will execute a dedicated sequential simplex algorithm.

Default: 0

value meaning
0 Disabled.
1 Enabled. Force the dual simplex solver to use the parallel algorithm.

genConsAbsTransformation (integer): Specifies the reformulation method for absolute value general constraints at the beginning of the search ↵

Default: auto

value meaning
-1 Automatic.
0 Use a formulation based on indicator constraints.
1 Use a formulation based on SOS1-constraints.

genConsDualReductions (boolean): Parameter specifies whether dual reductions should be applied to reduce the number of columns and rows added when transforming general constraints to MIP structs ↵

Default: 1

value meaning
0 Disabled. No dual reductions, add columns and rows.
1 Enabled. Only add neccessary columns and rows, drop those implied by the objective sense.

globalBoundingBox (real): If a nonlinear problem cannot be solved due to appearing unbounded, it can automatically be regularized by the application of a bounding box on the variables ↵

If this control is set to a negative value, in a second solving attempt all original variables will be bounded by the absolute value of this control. If set to a positive value, there will be a third solving attempt afterwards, if necessary, in which also all auxiliary variables are bounded by this value.

Default: 1e+06

value meaning
0 Disabled. Problem will return unbounded.
n<0 Enabled. Apply lower and upper bounds of this magnitude to all original variables if initial LP is unbounded.
n>0 Enabled. Apply lower and upper bounds of this magnitude to all original and auxiliary variables if initial LP and first regularization are unbounded.

globalLSHeurStrategy (integer): When integer-feasible (for MINLP, any solution for NLP) but nonlinear-infeasible solutions are encountered within a global solve, the integer variables can be fixed and a local solver can be called on the remaining continuous problem ↵

This control defines the frequency and effort of such local solves.

Default: auto

value meaning
-1 Automatic selection of the strategy.
0 Never run a local solver on a partially fixed solution.
1 Conservative strategy.
2 Moderate strategy.
3 Aggressive strategy.

globalNLPCuts (integer): Limit on the number of rounds of outer approximation and convexification cuts generated for the root node, when solving an (MI)NLP to global optimality ↵

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

Default: auto

globalNumInitNLPCuts (integer): Specifies the maximum number of tangent cuts when setting up the initial relaxation during a global solve ↵

By default, the algorithm chooses the number of cuts automatically. Adding more cuts tightens the problem, resulting in a smaller branch-and-bound tree, at the cost of slowing down each LP solve.

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

Default: auto

globalTreeNLPCuts (integer): Limit on the number of rounds of outer approximation and convexification cuts generated for each node in the tree, when solving an (MI)NLP to global optimality ↵

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

Default: auto

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.

Default: auto

value meaning
-1 Automatic - let the optimizer decide if heuristics should be run.
0 Disabled.
1 Enabled.

heurDiveIterLimit (real): Branch and Bound: Simplex iteration limit for reoptimizing during the diving heuristic ↵

Default: auto

value meaning
0 No iteration limit.
>=1 Fixed iteration limit.
<0 Automatic selection of the iteration limit based on the problem size. The absolute value is used as a multiplier on the automatic selection.

heurDiveRandomize (real): Level of randomization to apply in the diving heuristic ↵

The diving heuristic uses priority weights on rows and columns to determine the order in which to e.g. round fractional columns, or the direction in which to round them. This control determines by how large a random factor these weights should be changed.

Default: 0

value meaning
0.0-1.0 Amount of randomization (0.0=none, 1.0=full)

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

This can be useful when the default diving heuristics fail to find any feasible solutions.

Default: auto

value meaning
-1 Automatic selection.
0 Do not use soft rounding.
1 Cautious use of the soft rounding strategy.
2 More aggressive use of the soft rounding strategy.

heurDiveSpeedUp (integer): Branch and Bound: Changes the emphasis of the diving heuristic from solution quality to diving speed ↵

Default: -1

value meaning
-2 Automatic selection biased towards quality
-1 Automatic selection biased towards speed.
0-4 Manual emphasis bias from emphasis on quality (0) to emphasis on speed (4).

heurDiveStrategy (integer): Branch and Bound: Chooses the strategy for the diving heuristic ↵

Default: auto

value meaning
-1 Automatic selection of strategy.
0 Disables the diving heuristic.
1-18 Available pre-set strategies for rounding infeasible MIP entities and reoptimizing during the heuristic dive.

heurEmphasis (integer): Branch and Bound: Specifies an emphasis for the search w.r.t. primal heuristics and other procedures that affect the speed of convergence of the primal-dual gap ↵

For problems where the goal is to achieve a small gap but not neccessarily solving them to optimality, it is recommended to set heurEmphasis to 1. This setting triggers many additional heuristic calls, aiming for reducing the gap at the beginning of the search, typically at the expense of an increased time for proving optimality.

Default: -1

value meaning
-1 Optimizer default strategy.
0 Disables all heuristics.
1 Focus on reducing the primal-dual gap in the early part of the search.
2 Extremely aggressive search heuristics.

heurForceSpecialObj (boolean): Branch and Bound: Whether local search heuristics without objective or with an auxiliary objective should always be used, despite the automatic selection of the Optimizer ↵

Deactivated by default.

Default: 0

value meaning
0 Disabled.
1 Enabled. Run special objective heuristics on large problems and even if incumbent exists.

heurFreq (integer): Branch and Bound: Frequency at which heuristics are used in the tree search ↵

Heuristics will only be used at a node if the depth of the node is a multiple of heurFreq.

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

Default: -1

heurSearchBackgroundSelect (integer): Select which large neighborhood searches to run in the background (for example in parallel to the root cut loop) ↵

If this is set to -1 (the default) then Xpress decides automatically which heuristics to run. Otherwise the value is interpreted as a bitset that indices which heuristics to run. 0 (zero) means not to run any large neighborhood search heuristics in the background. Other types of background jobs are controlled by backgroundSelect.

Default: -1

value meaning
bit 1 = 2 Enable L heuristic.

heurSearchCopyControls (integer): Select how user-set controls should affect local search heuristics ↵

If you set any control to prevent an unfavorable behavior, consider also setting heurSearchCopyControls to 2. Termination criteria are not affected by this control.

Default: auto

value meaning
0 Do not copy any user-set controls
1 Automatic - Let the Optimizer decide which user-set controls to copy
2 Copy all user-set controls

heurSearchEffort (real): Adjusts the overall level of the local search heuristics ↵

heurSearchEffort is used as a multiplier on the default amount of work the local search heuristics should do. A higher value means the local search heuristics will be run more often and that they are allowed to search larger neighborhoods.

Range: [0, ∞]

Default: 1

heurSearchFreq (integer): Branch and Bound: How often the local search heuristic should be run in the tree ↵

Default: auto

value meaning
-1 Automatic.
0 Disabled in the tree.
n>0 Number of nodes between each run.

heurSearchRootCutFreq (integer): How frequently to run the local search heuristic during root cutting ↵

This is given as how many cut rounds to perform between runs of the heuristic. Set to zero to avoid applying the heuristic during root cutting. Branch and Bound: This specifies how often the local search heuristic should be run in the tree.

Default: auto

value meaning
-1 Automatic.
0 Disabled heuristic during cutting.
n>0 Number of cutting rounds between each run.

heurSearchRootSelect (integer): Bit vector control for selecting which local search heuristics to apply on the root node of a MIP solve ↵

Use heurSearchTreeSelect to control local search heuristics during the tree search.

Some of the local search heuristics will benefit from having an existing incumbent solution, but it is not required.

Default: 117

value meaning
bit 0 = 1 Local search with a large neighborhood. Potentially slow but is good for finding solutions that differs significantly from the incumbent.
bit 1 = 2 Local search with a small neighborhood centered around a node LP solution.
bit 2 = 4 Local search with a small neighborhood centered around an integer solution. This heuristic will often provide smaller, incremental improvements to an incumbent solution.
bit 3 = 8 Local search with a neighborhood set up through the combination of multiple integer solutions.
bit 4 = 16 Unused
bit 5 = 32 Local search without an objective function. Called seldom and only when no feasible solution is available.
bit 6 = 64 Local search with an auxiliary objective function. Called seldom and only when no feasible solution is available.

heurSearchTreeSelect (integer): Bit vector control for selecting which local search heuristics to apply during the tree search of a MIP solve ↵

Use heurSearchRootSelect to control local search heuristics on the root node.

Some of the local search heuristics will benefit from having an existing incumbent solution, but it is not required.

Default: 17

value meaning
bit 0 = 1 Local search with a large neighborhood. Potentially slow but is good for finding solutions that differs significantly from the incumbent.
bit 1 = 2 Local search with a small neighborhood centered around a node LP solution.
bit 2 = 4 Local search with a small neighborhood centered around an integer solution. This heuristic will often provide smaller, incremental improvements to an incumbent solution.
bit 3 = 8 Local search with a neighborhood set up through the combination of multiple integer solutions.
bit 4 = 16 Unused
bit 5 = 32 Local search without an objective function. Called seldom and only when no feasible solution is available.
bit 6 = 64 Local search with an auxiliary objective function. Called seldom and only when no feasible solution is available.

heurShiftProp (integer): Determines whether the Shift-and-propagate primal heuristic should be executed ↵

If enabled, Shift-and-propagate is an LP-free primal heuristic that is executed immediately after presolve.

Default: -1

value meaning
-1 The solver decides if Shift-and-propagate should be run. This is the default setting.
0 Shift-and-propagate is disabled.
1 Shift-and-propagate is enabled.

heurThreads (integer): Branch and Bound: Number of threads to dedicate to running heuristics during the root solve ↵

When heuristic threads are enabled, the heuristics will be run in parallel with the root cutting.

Default: 0

value meaning
-1 Automatically determined from the threads control.
0 Disabled.
>=1 Number of additional threads to dedicate to parallel heuristics.

historyCosts (integer): Branch and Bound: How to update the pseudo cost for a MIP entity when a strong branch or a regular branch is applied ↵

Default: auto

value meaning
-1 Automatically determined.
0 No update.
1 Update using only regular branches from the root to the current node.
2 Same as 1, but update with strong branching results as well.
3 Update using any regular branching or strong branching information from all nodes solves before the current node.

ifCheckConvexity (boolean): Determines if the convexity of the problem is checked before optimization ↵

Applies to quadratic, mixed integer quadratic and quadratically constrained problems. Checking convexity takes some time, thus for problems that are known to be convex it might be reasonable to switch the checking off.

Default: 1

value meaning
0 Turn off convexity checking.
1 Turn on convexity checking.

indLinBigM (real): During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough ↵

This control defines the largest BigM for which such a linearized version will be added to the problem in addition to the original constraint. If the BigM is even smaller than indPreLinBigM, then the original indicator constraint will additionally be dropped from the problem.

indLinBigM should always be at least as large as indPreLinBigM. For any value less or equal to indPreLinBigM, indicator constraints will never be duplicated and only indPreLinBigM is taken into account for linearization.

Range: [0, ∞]

Default: 100000

indPreLinBigM (real): During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough ↵

This control defines the largest BigM for which the original constraint will be replaced by the linearized version. If the BigM is larger than indPreLinBigM but smaller than indLinBigM, the linearized row will be added but the original indicator constraint is kept as a numerically stable way to check feasibility.

Replacing an indicator constraint with a BigM row has a side effect on tolerances. In the indicator constraint form, the constraint part is satisfied with feasTol tolerance; while after changing it to BigM form, the constraint also includes the binary indicator variable (with a coefficient up to indPreLinBigM and an integrality tolerance of mipTol), therefore the constraint part of the indicator constraint is satisfied with tolerance feasTol+mipTol*indPreLinBigM.

Range: [0, ∞]

Default: 100

inputTol (real): Tolerance on input values elements ↵

If any value is less than or equal to inputTol in absolute value, it is treated as zero. For the internal zero tolerance see matrixTol.

This control needs to be set before inputting the problem, as it has no effect afterwards.

Range: [0, ∞]

Default: 0

invertFreq (integer): Simplex: Frequency with which the basis will be inverted ↵

The basis is maintained in a factorized form and on most simplex iterations it is incrementally updated to reflect the step just taken. This is considerably faster than computing the full inverted matrix at each iteration, although after a number of iterations the basis becomes less well-conditioned and it becomes necessary to compute the full inverted matrix. The value of invertFreq specifies the maximum number of iterations between full inversions.

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

Default: auto

invertMin (integer): Simplex: Minimum number of iterations between full inversions of the basis matrix ↵

See the description of invertFreq for details.

Range: {0, ..., ∞}

Default: 3

ioTimeout (integer): Maximum number of seconds to wait for an I/O operation before it is cancelled ↵

Range: {0, ..., ∞}

Default: 30

knitroOptFile (string): Option file for NLP solver KNITRO ↵

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

Range: {0, ..., ∞}

Default: 50

lnpIterLimit (integer): Number of iterations to perform in improving each lift-and-project cut ↵

By setting the number to zero a Gomory cut will be created instead.

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

Default: auto

loadMipSol (boolean): Loads a MIP solution (the initial point) ↵

If true, the initial point provided by GAMS will be passed to the optimizer to be treated as an integer feasible point. The optimizer uses the values for the discrete variables only: the level values for the continuous variables are ignored and are calculated by fixing the integer variables and reoptimizing. In some cases, loading an initial MIP solution can improve performance. In addition, there will always be a feasible solution to return.

Default: 0

localChoice (integer): Controls when to perform a local backtrack between the two child nodes during a dive in the branch and bound tree ↵

Default: auto

value meaning
1 Never backtrack from the first child, unless it is dropped (infeasible or cut off).
2 Always solve both child nodes before deciding which child to continue with.
3 Automatically determined.

lpFlags (integer): Bit-vector control which defines the algorithm for solving an LP problem or the initial LP relaxation of a MIP problem ↵

When more than one bit is set, then the LP problem will be solved with the concurrent solver. When this control and algorithm is set at the same time, algorithm will overrule the value of this control.

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

Default: 0

value meaning
bit 0 = 1 Equivalent to lpFlags_dual.
bit 1 = 2 Equivalent to lpFlags_primal.
bit 2 = 4 Equivalent to lpFlags_barrier.
bit 3 = 8 Equivalent to lpFlags_network.

lpFlags_barrier (boolean): Use the barrier method (or hybrid gradient method if barAlg=4 is set) ↵

See also lpFlags.

Default: 0

lpFlags_dual (boolean): Use the dual simplex method ↵

See also lpFlags.

Default: 0

lpFlags_network (boolean): Use the network simplex method ↵

See also lpFlags.

Default: 0

lpFlags_primal (boolean): Use the primal simplex method ↵

See also lpFlags.

Default: 0

lpFolding (integer): Simplex and barrier: Whether to fold an LP problem before solving it ↵

Default: auto

value meaning
-1 Automatic.
0 Disable LP folding.
1 Enable LP folding. Attempt to fold all LP problems and MIP initial relaxations.

lpIterLimit (integer): Maximum number of iterations that will be performed by primal simplex or dual simplex before the optimization process terminates ↵

Synonym: iterlim

For MIP problems, this is the maximum total number of iterations over all nodes explored by the Branch and Bound method.

Range: {0, ..., ∞}

Default: maxint

lpLog (integer): Simplex: Frequency at which the simplex log is printed ↵

This control only has an effect if lpLogStyle is set to 0.

Default: 100

value meaning
0 Log displayed at the end of the optimization only.
n<0 Detailed output every - n iterations.
n>0 Summary output every n iterations.

lpLogDelay (real): Time interval between two LP log lines ↵

This control only has an effect if lpLogStyle is set to 1.

Range: [0, ∞]

Default: 1

lpLogStyle (boolean): Simplex: Style of the simplex log ↵

Default: 1

value meaning
0 Simplex log is printed based on simplex iteration count, at a fixed frequency as specified by the lpLog control.
1 Simplex log is printed based on an estimation of elapsed time, determined by an internal deterministic timer.

lpRefineIterLimit (integer): Simplex iteration limit the solution refiner can spend in attempting to increase the accuracy of an LP solution ↵

The solution refiner iteratively attempts to increase the accuracy of the solution until either both feasTolTarget and optimalityTolTarget is satisfied, or accuracy cannot further be increased, or the effort limit determined by lpRefineIterLimit is exhausted.

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

Default: auto

markowitzTol (real): Markowitz tolerance used for the factorization of the basis matrix ↵

Range: [0, ∞]

Default: 0.01

matrixTol (real): Zero tolerance on matrix elements ↵

If the value of a matrix element is less than or equal to matrixTol in absolute value, it is treated as zero. The control applies when solving a problem, for an input tolerance see inputTol.

Range: [0, ∞]

Default: 1e-09

maxCutTime (real): Maximum amount of time allowed for generation of cutting planes and reoptimization ↵

The limit is checked during generation and no further cuts are added once this limit has been exceeded.

Default: 0

value meaning
0 No time limit.
>0 Stop cut generation after the given number of seconds.

maxImpliedBound (real): Presolve: When tighter bounds are calculated during MIP preprocessing, only bounds whose absolute value are smaller than maxImpliedBound will be applied to the problem ↵

For numerically challenging MIP problems, it can sometimes help make the solve more stable by reducing the value of maxImpliedBound to something smaller - e.g. 1.0E+06. It is not recommended to increase this parameter beyond the default of 1.0E+08.

Range: [0, ∞]

Default: 1e+08

maxLocalBacktrack (integer): Branch-and-Bound: How far back up the current dive path the optimizer is allowed to look for a local backtrack candidate node ↵

If this control is set to k, then the candidate set of nodes for a local backtrack will consist of all active nodes in the subtree rooted at height k above the current node. For example, a setting of 1 will result in only sibling nodes of the current node being considered.

Default: auto

value meaning
-1 Automatic.
n>0 Local backtrack limit.

maxMemoryHard (integer): Sets the maximum amount of memory in megabytes the optimizer should allocate ↵

If this limit is exceeded, the solve will terminate. This control is designed to make the optimizer stop in a controlled manner, so that the problem object is valid once termination occurs. The solve state will be set to incomplete. This is different to an out of memory condition in which case the optimizer returns an error. The optimizer may still allocate memory once the limit is exceeded to be able to finsish the operations and stop in a controlled manner. When resourceStrategy is enabled, the control also has the same effect as maxMemorySoft and will cause the optimizer to try preserving memory when possible.

Range: {0, ..., ∞}

Default: unlimited

maxMemorySoft (integer): When resourceStrategy is enabled, this control sets the maximum amount of memory in megabytes the optimizer targets to allocate ↵

This may change the solving path, but will not cause the solve to terminate early. To set a hard version of the same, please set maxMemoryHard.

Range: {0, ..., ∞}

Default: unlimited

maxMipSol (integer): Branch and Bound: Limit on the number of integer solutions to be found by the Optimizer ↵

It is possible that during optimization the Optimizer will find the same objective solution from different nodes. However, maxMipSol refers to the total number of integer solutions found, and not necessarily the number of distinct solutions.

Setting maxMipSol=1 can alter the solution path as this will put the emphasis on finding any feasible solution by triggering additional heuristics.

Range: {0, ..., ∞}

Default: 0

maxMipTasks (integer): Branch-and-Bound: The maximum number of tasks to run in parallel during a MIP solve ↵

The MIP solver will create smaller tasks from individual active nodes or based on local search heuristics. These are tasks that will be executed in parallel by the number of threads set by mipThreads.

If maxMipTasks is set to a fixed, positive value, the branch-and-bound tree nodes will always be solved in the same deterministic way, independent of the actual number of executing threads implied by mipThreads. How a MIP is solved will still depend on the number of threads used for solving the continuous relaxation and therefore on the settings for the controls barThreads, barCores, dualThreads and concurrentThreads). To obtain a MIP solve that is completely independent of the number of threads, it is sufficient to set maxMipTasks, forceParallelDual, barThreads and barCores. The concurrent LP solver should be avoided in this case.

While you can set this control to large value, the implementation will limit the number of tasks for performance reasons. This limit is currently 32 on 32bit platforms and 256 on 64 bit platforms.

Default: auto

value meaning
-1 Task limit determined automatically from mipThreads.
>0 Fixed task limit.

maxNode (integer): Branch and Bound: Maximum number of nodes that will be explored ↵

Range: {0, ..., ∞}

Default: maxint

maxScaleFactor (integer): Determines the maximum scaling factor that can be applied during scaling ↵

The maximum is provided as an exponent of a power of 2.

Default: 64

value meaning
0-64 The maximum is provided an exponent of a power of 2.

maxStallTime (real): Maximum time in seconds that the Optimizer will continue to search for improving solution after finding a new incumbent ↵

Default: 0

value meaning
0 No stall time limit.
>0 If an integer solution has been found, stop MIP search after the given number of seconds without a new incumbent. No effect as long as no solution was found.

mcfCutStrategy (integer): Level of Multi-Commodity Flow (MCF) cutting planes separation: This specifies how much aggresively MCF cuts should be separated ↵

If the separation of MCF cuts is enabled, Xpress will try to detect a MCF network structure in the problem and, if such a structure is identified, it will separate specific cutting planes exploiting the identified network.

Default: auto

value meaning
-1 Automatic - let the Optimizer decide.
0 Separation of MCF cuts disabled.
1 Moderate separation of MCF cuts.
2 Aggressive separation of MCF cuts.

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

This allows the Optimizer to ignore solving any nodes which may yield worse objective values, saving solution time.

Range: [-∞, ∞]

Default: auto

mipAbsStop (real): Branch and Bound: Absolute tolerance determining whether the tree search will continue or not ↵

It will terminate if    | MIPOBJVAL - BESTBOUND| ≤ mipAbsStop where MIPOBJVAL is the value of the best solution′s objective function, and BESTBOUND is the current best solution bound. For example, to stop the tree search when a MIP solution has been found and the Optimizer can guarantee it is within 100 of the optimal solution, set mipAbsStop to 100.

Range: [0, ∞]

Default: 0

mipAddCutoff (real): Branch and Bound: Amount to add to the objective function of the best integer solution found to give the new CURRMIPCUTOFF ↵

Once an integer solution has been found whose objective function is equal to or better than CURRMIPCUTOFF, improvements on this value may not be interesting unless they are better by at least a certain amount. If mipAddCutoff is nonzero, it will be added to CURRMIPCUTOFF each time an integer solution is found which is better than this new value. This cuts off sections of the tree whose solutions would not represent substantial improvements in the objective function, saving processor time. The control mipAbsStop provides a similar function but works in a different way.

Range: [-∞, ∞]

Default: 0

mipCleanup (boolean): Clean up the MIP solution (round-fix-solve) to get duals ↵

If nonzero, clean up the integer solution obtained, i.e. round and fix the discrete variables and re-solve as an LP to get some marginal values for the discrete vars.

Default: 1

mipComponents (integer): Determines whether disconnected components in a MIP should be solved as separate MIPs ↵

There can be significant performence benefits from solving disconnected components individual instead of being part of the main branch-and-bound search.

If there are no constraints linking two variables, either directly or indirectly through other variables, they are said to belong to two separate disconnected components. When a problem contains disconnected components of signficant size, it can be advantageous to solve each component as a separate MIP. When significant disconnected components are detected in the problem, the solver will switch to a different solve mode where each component is solved separately. This switch will happen after the root node processing has completed and when the solve is about to enter the branch-and-bound search.

Solving disconnected components separately is not compatible with many callbacks that can be used for modifying 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.

Concurrent solves are not compatible with many callbacks that can be used for modifying the branch-and-bound search.

Default: 0

value meaning
-1 Enabled. The number of concurrent solves depends on mipThreads.
n>1 Enabled. The number of concurrent solves to start is given by n.
0, 1 Disabled

mipDualReductions (integer): Branch and Bound: Limits operations that can reduce the MIP solution space ↵

The mipDualReductions control, when set to a value different from 1 will adjust the values of other controls in order to prevent MIP solver operations that can result in the removal of dominated solutions. For example, dual reductions during preprocessing attempts to remove dominated solutions based on objective arguments, assuming that all constraints are known to the Optimizer. If a problem is detected to have symmetries, the solver might also remove some symmetrical solutions from the search space. In both cases, the set of feasible MIP solutions might be reduced. With default settings, it is only guaranteed that at least one optimal solution remains.

When attempting to collect the n-best solutions, it is recommended to set mipDualReductions=2. This will ensure that the only solutions missed by the enumeration are those that only differ from an existing solution in the values of the continuous variables.

Default: 1

value meaning
0 Prevent all dual reductions.
1 Allow all dual reductions.
2 Allow dual reductions on continuous variables only.

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

This heuristic is only applicable to problems that are dual degenerate. These are problems that contain multiple solutions with identical objective function value. The more dual degenerate a problem is, the more likely it will be for this heuristic to have an improving effect.

Default: auto

value meaning
-1 Automatic.
0 Disabled.
1 Run before and after cutting on the root node.
2 Run also during root cutting.
3 Run also during the tree search.

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

The condition number is calculated as the norm of the basis matrix multiplied by the norm of its inverse. This uses the Froebenius norm.

A summary will be printed at the end of the solve, summarizing the collected condition numbers collected:

  • Nodes kappa stable: No. of stable sampled nodes (kappa < 10^7)
  • Nodes kappa suspicius: No. of suspicious sampled nodes (10^7 ≤ kappa < 10^10)
  • Nodes kappa unstable: No. of unstable sampled nodes (10^10 ≤ kappa < 10^13)
  • Nodes kappa ill-posed: No. of ill-posed sampled nodes (10^13 ≤ kappa)
  • Largest kappa seen: The largest condition number calculated through all sampled nodes.
  • Kappa attention level: A measure of how ill-posed the problem is (between 0 and 1).

Default: 0

value meaning
0 Do not calculate condition numbers.
1 Calculate conditions numbers on every node, including after each round of root cutting.
n>1 Calculate a condition number once per node of every n′th level of the branch-and-bound tree.

mipLog (integer): MIP log print control ↵

Default: -100

value meaning
0 No printout during MIP tree search.
1 Only print out summary statement at the end.
2 Print out detailed log at all solutions found.
3 Print out detailed log at each node.
-n Print out summary log at each n th node.

mipPresolve (integer): Branch and Bound: Type of integer processing to be performed ↵

If set to 0, no processing will be performed.

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

Default: -1

value meaning
bit 0 = 1 Equivalent to mipPresolve_reducedCostFixing.
bit 1 = 2 Equivalent to mipPresolve_logicPreprocessing.
bit 2 = 4 [Unused] This bit is no longer used to control probing. Refer to the integer control preProbing for setting probing level during presolve.
bit 3 = 8 Equivalent to mipPresolve_allowChangeBounds.
bit 4 = 16 Equivalent to mipPresolve_dualReductions.
bit 5 = 32 Equivalent to mipPresolve_globalCoefTightening.
bit 6 = 64 Equivalent to mipPresolve_objBasedReductions.
bit 7 = 128 Equivalent to mipPresolve_allowTreeRestart.
bit 8 = 256 Equivalent to mipPresolve_symmetryReductions.

mipPresolve_allowChangeBounds (boolean): If node preprocessing is allowed to change bounds on continuous columns ↵

See also mipPresolve.

Default: 1

mipPresolve_allowTreeRestart (boolean): [Unused] This bit is no longer used to control restarts ↵

Refer to the integer control mipRestart for disabling tree restarts.

See also mipPresolve.

Default: 1

mipPresolve_dualReductions (boolean): Dual reductions will be performed at each node ↵

See also mipPresolve.

Default: 1

mipPresolve_globalCoefTightening (boolean): Allow global (non-bound) tightening of the problem during the tree search ↵

See also mipPresolve.

Default: 1

mipPresolve_logicPreprocessing (boolean): Primal reductions will be performed at each node ↵

Uses constraints of the node to tighten the range of variables, often resulting in fixing their values. This greatly simplifies the problem and may even determine optimality or infeasibility of the node.

See also mipPresolve.

Default: 1

mipPresolve_objBasedReductions (boolean): Objective function will be used to find reductions at each node ↵

See also mipPresolve.

Default: 1

mipPresolve_reducedCostFixing (boolean): Reduced cost fixing will be performed at each node ↵

This can simplify the node before it is solved, by deducing that certain variables′ values can be fixed based on additional bounds imposed on other variables at this node.

See also mipPresolve.

Default: 1

mipPresolve_symmetryReductions (boolean): Allow that symmetry is used to presolve the node problem ↵

See also mipPresolve.

Default: 1

mipRampUp (integer): Controls the strategy used by the parallel MIP solver during the ramp-up phase of a branch-and-bound tree search ↵

The branch-and-bound tree search starts from the single root node, and only through branching on this root node and the resulting child nodes, are enough active nodes created to produce sufficient tasks to keep all MIP workers busy. This is referred to as the ramp-up phase of a parallel MIP. In a typical MIP solve, the solutions found during the initial dives will typically provide a significant improvement over the root heuristic solutions. It can therefore be advantageous to let these initial dives run as fast as possible, by limiting resource contention. This can be accomplished by restricting the number of parallel tasks and thereby reducing the memory bus contention. The mipRampUp control can be used to turn this initial task restriction of a parallel MIP solve on or off.

Default: auto

value meaning
-1 Automatically determined.
0 No special treatment during the ramp-up phase. Always run with the maximal number of tasks.
1 Limit the number of tasks until the initial dives have completed.

mipRefineIterLimit (integer): Defines an effort limit expressed as simplex iterations for the MIP solution refiner ↵

The limit is per reoptimizations in the MIP refiner.

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

Default: auto

mipRelCutoff (real): Branch and Bound: Percentage of the incumbent value to be added to the value of the objective function when an integer solution is found, to give the new value of CURRMIPCUTOFF ↵

The effect is to cut off the search in parts of the tree whose best possible objective function would not be substantially better than the current solution. The control mipRelStop provides a similar functionality but works in a different way.

Range: [0, ∞]

Default: 0

mipRelStop (real): Branch and Bound: Determines when the branch and bound tree search will terminate ↵

Branch and bound tree search will stop if:    | MIPOBJVAL - BESTBOUND| ≤ mipRelStop x max(| BESTBOUND|,| MIPOBJVAL|) where MIPOBJVAL is the value of the best solution′s objective function and BESTBOUND is the current best solution bound. For example, to stop the tree search when a MIP solution has been found and the Optimizer can guarantee it is within 5% of the optimal solution, set mipRelStop to 0.05.

This control is a stopping criteria only and different values of the control will not affect the solution path before termination. Unlike other stopping criteria, like time and node count, termination on mipRelStop will cause the final solution to be declared optimal and the problem to be returned to its original state.

Tolerances, such as mipRelCutoff and mipAbsCutoff, determine how much the objective value of a new MIP solution has to differ from the incumbent for it to be accepted. These controls therefore also influence the final gap at the end of a MIP solve.

Range: [0, ∞]

Default: 0.0001

mipRestart (integer): Branch and Bound: Controls strategy for in-tree restarts ↵

Default: auto

value meaning
-1 Determined automatically (XPRS_MIPRESTART_DEFAULT).
0 Disable in-tree restarts (XPRS_MIPRESTART_OFF).
1 Allow in-tree restarts at normal aggressiveness (XPRS_MIPRESTART_MODERATE).
2 Allow in-tree restarts at higher aggressiveness (more likely to trigger a restart) (XPRS_MIPRESTART_AGGRESSIVE).

mipRestartFactor (real): Branch and Bound: Fine tune initial conditions to trigger an in-tree restart ↵

Use a value > 1 to increase the aggressiveness with which the Optimizer restarts. Use a value < 1 to relax the aggressiveness with which the Optimizer restarts. Note that this control does not affect the initial condition on the gap, which must be set separately.

Range: [0, ∞]

Default: 1

mipRestartGapThreshold (real): Branch and Bound: Initial gap threshold to delay in-tree restart ↵

The restart is delayed initially if the gap, given as a fraction between 0 and 1, is below this threshold. The optimizer adjusts the threshold every time a restart is delayed. Note that there are other criteria that can delay or prevent a restart.

Range: [0, 1]

Default: 0.02

mipstopexpr (string): Stopping expression for branch and bound ↵

If the provided logical expression is true, the branch-and-bound is aborted. Supported values are: resusd, nodusd, objest, objval. Supported operators are: +, -, *, /, ^, %, !=, ==, <, <=, >, >=, !, &&, \( \vert \vert \), (, ), abs, ceil, exp, floor, log, log10, pow, sqrt . Example:

nodusd >= 1000 && abs(objest - objval) / abs(objval) < 0.1

mipThreads (integer): If set to a positive integer it determines the number of threads implemented to run the parallel MIP code ↵

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

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

Default: auto

mipTol (real): Branch and Bound: Tolerance within which a decision variable′s value is considered to be integral ↵

Range: [0, ∞]

Default: 5e-06

mipToltarget (real): Target mipTol value used by the automatic MIP solution refiner as defined by refineOps ↵

Negative and zero values are ignored.

Refining solutions to match the miptoltarget can influence and worsen their objective value in case the previous objective could only be achieved through slight infeasibilities.

Range: [-∞, ∞]

Default: 0

mipTrace (string): Name of MIP trace file ↵

A miptrace file with the specified name will be created. This file records the best integer and best bound values every mipTraceNode nodes and at mipTraceTime-second intervals.

Default: none

mipTraceNode (integer): Node interval between MIP trace file entries ↵

Default: 100

mipTraceTime (real): Time interval, in seconds, between MIP trace file entries ↵

Default: 5

miqcpAlg (integer): Determines which algorithm is to be used to solve mixed integer quadratic constrained and mixed integer second order cone problems ↵

Default: auto

value meaning
-1 Determined automatically.
0 Use the barrier algorithm in the branch and bound algorithm.
1 Use outer approximations in the branch and bound algorithm.

mpsNameLength (integer): Maximum length of MPS names in characters ↵

Internally it is rounded up to the smallest multiple of 8. MPS names are right padded with blanks. Maximum value is 64.

Range: {0, ..., ∞}

Default: 0

mpsOutputFile (string): Name of MPS output file ↵

If specified XPRESS-MP will generate an MPS file corresponding to the GAMS model: the argument is the file name to be used. You can prefix the file name with an absolute or relative path.

Default: none

netStallLimit (integer): Limit the number of degenerate pivots of the network simplex algorithm, before switching to either primal or dual simplex, depending on algAfterNetwork ↵

Default: auto

value meaning
-1 Automatically determined limit
0 No limit.
n>0 Limit to n network simplex iterations.

nodeProbingEffort (real): Adjusts the overall level of node probing ↵

nodeProbingEffort is used as a multiplier on the default amount of work node probing should do. Setting the control to zero disables node probing.

Range: [0, ∞]

Default: 1

nodeSelection (integer): Branch and Bound: Determines which nodes will be considered for solution once the current node has been solved ↵

Default: auto

value meaning
1 Local first: Choose between descendant and sibling nodes if available; choose from all outstanding nodes otherwise.
2 Best first: Choose from all outstanding nodes.
3 Local depth first: Choose between descendant and sibling nodes if available; choose from the deepest nodes otherwise.
4 Best first, then local first: Best first is used for the first breadthFirst nodes, after which local first is used.
5 Pure depth first: Choose from the deepest outstanding nodes.

numericalEmphasis (integer): How much emphasis to place on numerical stability instead of solve speed ↵

Default: auto

value meaning
-1 Automatic. The emphasis might be influenced by the setting of other controls.
0 Emphasize speed.
1 Mild emphasis on numerical stability.
2 Medium emphasis on numerical stability.
3 Strong emphasis on numerical stability.

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

Default: none

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

When set, it overwrites the automatic objective scaling factor. A value of 0 means no objective scaling. This control is applied for the full solve, and is independent of any extra scaling that may occur specifically for the barrier or simplex solvers. As it is a power of 2, to scale by 16, set the value of the control to 4.

Range: {0, ..., ∞}

Default: 0

optimalityTol (real): Simplex: Zero tolerance for reduced costs ↵

On each iteration, the simplex method searches for a variable to enter the basis which has a negative reduced cost. The candidates are only those variables which have reduced costs less than the negative value of optimalityTol.

Range: [0, ∞]

Default: 1e-06

optimalityTolTarget (real): Target optimality tolerance for the solution refiner ↵

Zero and negative values are ignored, and the value of optimalityTol is used.

Use very small values like 1e-100 to state the refinement should continue as long as an improvement is made. Use very large values like 1e+100 to disable only this aspect of the refiner.

Refining solutions to match the optimalitytoltarget can influence and increase their infeasibility in case the previous feasibility could only be achieved through slight dual violations.

Range: [-∞, ∞]

Default: 0

outputControls (boolean): Toggles the printing of all control settings at the beginning of the search ↵

This includes the printing of controls that have been explicitly assigned to their default value. All unset controls are omitted as they keep their default value.

Setting outputControls to 0 has no effect on the function XPRSdumpcontrols

Default: 1

value meaning
0 Turn off printing of user-specified control settings.
1 Print controls.

outputLog (integer): Controls the level of output produced by the Optimizer during optimization ↵

Default: 1

value meaning
0 Turn all output off.
1 Print all messages.
3 Print error and warning messages.
4 Print error messages only.

outputTol (real): Zero tolerance on print values ↵

Range: [0, ∞]

Default: 1e-05

penalty (real): Minimum absolute penalty variable coefficient ↵

Range: [0, ∞]

Default: auto

pivotTol (real): Simplex: Zero tolerance for matrix elements ↵

On each iteration, the simplex method seeks a nonzero matrix element to pivot on. Any element with absolute value less than pivotTol is treated as zero for this purpose.

Range: [0, ∞]

Default: 1e-09

ppFactor (real): Partial pricing candidate list sizing parameter ↵

Range: [0, ∞]

Default: 1

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

Default: auto

value meaning
-1 Automatic.
0 Disable analytic center presolving.
1 Use analytic center for variable fixing only.
2 Use analytic center for reduced cost computation only.
3 Use analytic centers for both, variable fixing and reduced cost computation.

preBasisRed (integer): Determines if a lattice basis reduction algorithm should be attempted as part of presolve ↵

Default: 0

value meaning
-1 Automatic.
0 Disable basis reduction.
1 Enable basis reduction.

preBndRedCone (integer): Determines if second order cone constraints should be used for inferring bound reductions on variables when solving a MIP ↵

Default: auto

value meaning
-1 Automatic.
0 Disable bound reductions from second order cone constraints.
1 Enable bound reductions from second order cone constraints.

preBndRedQuad (integer): Determines if convex quadratic 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 quadratic constraints.
1 Enable bound reductions from quadratic constraints.

preCliqueStrategy (integer): Determines how much effort to spend on clique covers in presolve ↵

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

Default: -1

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

Default: 2

value meaning
0 Disabled.
1 Remove as many coefficients as possible.
2 Cautious eliminations. Will not perform a reduction if it might destroy problem structure useful to e.g. heuristics or cutting.

preComponents (integer): Presolve: Determines whether small independent components should be detected and solved as individual subproblems during root node processing ↵

Default: auto

value meaning
-1 Automatically determined.
0 Disable detection of independent components.
1 Enable detection of independent components.

preComponentsEffort (real): Presolve: Adjusts the overall effort for the independent component presolver ↵

This control affects working limits for the subproblem solving as well as thresholds when it is called. Increase to put more emphasis on component presolving.

Range: [0, ∞]

Default: 1

preConeDecomp (integer): Presolve: Decompose regular and rotated cones with more than two elements and apply Outer Approximation on the resulting components ↵

Default: auto

value meaning
-1 Automatically determined.
0 Disable cone decomposition.
1 Enable cone decomposition by replacing large cones with small ones in the presolved problem.
2 Similar to 1, plus decomposition is enabled even if the cone variable is fixed.
3 Cones are decomposed within the Outer Approximation domain only, i.e., the problem maintains the original cones.

preConfiguration (integer): MIP Presolve: Determines whether binary rows with only few repeating coefficients should be reformulated ↵

The reformulation enumerates the extremal feasible configurations of a row and introduces new columns and rows to model the choice between these extremal configurations. This presolve operation can be disabled as part of the (advanced) IP reductions presolveOps.

Default: auto

value meaning
-1 Automatically determined.
0 Disable configuration presolving.

preConvertObjToCons (integer): Presolve: Convert a linear or quadratic objective function into an objective transfer constraint ↵

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 Move only the quadratic part of the objective into a constraint.
2 Move both the linear and quadratic parts of the objective into a constraint.

preConvertSeparable (integer): Presolve: Reformulate problems with a 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 Enable reformulation to diagonal quadratic constraints and reduction to second-order cones.

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 13 = 8192 Equivalent to presolveOps_noSolutionEnumeration.
bit 14 = 16384 Equivalent to presolveOps_linDependRowRemoval.
bit 15 = 32768 Equivalent to presolveOps_noIntVarAndSosDetect.
bit 16 = 65536 Equivalent to presolveOps_noImpliedBounds.
bit 17 = 131072 Equivalent to presolveOps_noCliquePresolve.
bit 18 = 262144 Equivalent to presolveOps_noMod2Reductions.

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_noCliquePresolve (boolean): No clique presolve ↵

See also presolveOps.

Default: 0

presolveOps_noGlobalDomainChange (boolean): No domain changes for MIP entities (e.g., semi-continuous detection or shifting integers) ↵

See also presolveOps.

Default: 0

presolveOps_noImpliedBounds (boolean): No implied bounds ↵

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_noMod2Reductions (boolean): No mod2 presolve ↵

See also presolveOps.

Default: 0

presolveOps_noSolutionEnumeration (boolean): No reductions based on solution enumeration ↵

See also presolveOps.

Default: 0

presolveOps_redundantRowRemoval (boolean): Redundant row removal ↵

See also presolveOps.

Default: 1

presolveOps_singletonColRemoval (boolean): Singleton column removal ↵

See also presolveOps.

Default: 1

presolveOps_singletonRowRemoval (boolean): Singleton row removal ↵

See also presolveOps.

Default: 1

presolveOps_strongDualReductions (boolean): Strong dual reductions ↵

See also presolveOps.

Default: 1

presolveOps_variableEliminations (boolean): Variable eliminations ↵

See also presolveOps.

Default: 1

presolvePasses (integer): Number of reduction rounds to be performed in presolve ↵

Range: {0, ..., ∞}

Default: 1

pricingAlg (integer): Simplex: Determines the primal simplex pricing method ↵

It is used to select which variable enters the basis on each iteration. In general Devex pricing requires more time on each iteration, but may reduce the total number of iterations, whereas partial pricing saves time on each iteration, but may result in more iterations.

Default: auto

value meaning
-1 Partial pricing.
0 Determined automatically.
1 Devex pricing.
2 Steepest edge.
3 Steepest edge with unit initial weights.

primalOps (integer): Primal simplex: Allows fine tuning the variable selection in the primal simplex solver ↵

If both bits 0 and 1 are both set or unset then the dj scaling strategy is determined automatically.

Default: -1

value meaning
bit 0 = 1 Use aggressive dj scaling.
bit 1 = 2 Conventional dj scaling.
bit 2 = 4 Use reluctant switching back to partial pricing.
bit 3 = 8 Use dynamic switching between cheap and expensive pricing strategies.
bit 4 = 16 Keep solving even after potential cycling is detected.

primalPerturb (real): Factor by which the problem will be perturbed prior to optimization by primal simplex ↵

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

Range: [-∞, ∞]

Default: auto

primalUnshift (boolean): Determines whether primal is allowed to call dual to unshift ↵

Default: 0

value meaning
0 Allow the dual algorithm to be used to unshift.
1 Don′t allow the dual algorithm to be used to unshift.

pseudoCost (real): Branch and Bound: Default pseudo cost used in estimation of the degradation associated with an unexplored node in the tree search ↵

A pseudo cost is associated with each integer decision variable and is an estimate of the amount by which the objective function will be worse if that variable is forced to an integral value.

Range: [0, ∞]

Default: 0.01

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

This control only has an effect for problems with quadratic or second order cone constraints, and only if outer approximation has not been disabled by setting miqcpAlg to 0.

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

Default: auto

qcRootAlg (integer): Determines which algorithm is to be used to solve the root of a mixed integer quadratic constrained or mixed integer second order cone problem, when outer approximation is used ↵

This control only has an effect if miqcpAlg is set to 1.

Default: auto

value meaning
-1 Determined automatically.
0 Use the barrier algorithm.
1 Use the dual simplex on a relaxation of the problem constructed using outer approximation.

qextractalg (integer): quadratic extraction algorithm in GAMS interface ↵

Default: 0

value meaning
0 Automatic
1 ThreePass: Uses a three-pass forward / backward / forward AD technique to compute function / gradient / Hessian values and a hybrid scheme for storage.
2 DoubleForward: Uses forward-mode AD to compute and store function, gradient, and Hessian values at each node or stack level as required. The gradients and Hessians are stored in linked lists.
3 Concurrent: Uses ThreePass and DoubleForward in parallel. As soon as one finishes, the other one stops.

qSimplexOps (integer): Controls the behavior of the quadratic simplex solvers ↵

Default: 0

value meaning
bit 0 = 1 Force traditional primal first phase.
bit 1 = 2 Force BigM primal first phase.
bit 2 = 4 Force traditional dual first phase.
bit 3 = 8 Force BigM dual first phase.
bit 4 = 16 Always use artificial bounds in dual.
bit 5 = 32 Use original problem basis only when warmstarting the KKT.
bit 6 = 64 Skip the primal bound flips for ranged primals (might cause more trouble than good if the bounds are very large).
bit 7 = 128 Also do the single pivot crash.
bit 8 = 256 Do not apply aggressive perturbation in dual.
bit 9 = 512 Applies standard scaling to the KKT system.
bit 10 = 1024 Do not fall back to using Barrier in case of numerical difficulties with quadratic simplex during a MIP solve.
bit 11 = 2048 Use primal simplex to solve the phase 1 feasibility problem before applying quadratic primal simplex.
bit 12 = 4096 Use dual simplex to solve the phase 1 feasibility problem before applying quadratic primal simplex.
bit 13 = 8192 Use barrier algorithm to solve the phase 1 feasibility problem before applying quadratic primal simplex.
bit 14 = 16384 Use partial pricing.
bit 15 = 32768 Use full pricing.
bit 16 = 65536 Perform cleanup if a superbasic solution is provided for warm-start.

quadraticUnshift (integer): Determines whether an extra solution purification step is called after a solution found by the quadratic simplex (either primal or dual) ↵

Default: auto

value meaning
-1 Determined automatically.
0 No purification step.
1 Always do the purification step.

randomSeed (integer): Sets the initial seed to use for the pseudo-random number generator in the Optimizer ↵

The sequence of random numbers is always reset using the seed when starting a new optimization run.

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

Default: 1

refineOps (integer): Specifies when the solution refiner should be executed to reduce solution infeasibilities ↵

The refiner will attempt to satisfy the target tolerances for all original linear constraints before presolve or scaling has been applied.

If neither the 7th nor 8th bit is set, the refiner will use the primal simplex if the primal violations are larger than the dual violations, otherwise it will use the dual simplex. If both the 7th and 8th bit are set then the refiner will split the problem into a primal feasible and dual feasible part, and solve the first with primal simplex and the second with dual simplex.

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

Default: 19

value meaning
bit 0 = 1 Equivalent to refineOps_lpOptimal.
bit 1 = 2 Equivalent to refineOps_mipSolution.
bit 3 = 8 Equivalent to refineOps_mipNodeLp.
bit 4 = 16 Equivalent to refineOps_lpPresolve.
bit 5 = 32 Equivalent to refineOps_iterativeRefiner.
bit 6 = 64 Equivalent to refineOps_refinerPrecision.
bit 7 = 128 Equivalent to refineOps_refinerUsePrimal.
bit 8 = 256 Equivalent to refineOps_refinerUseDual.
bit 9 = 512 Equivalent to refineOps_mipFixGlobals.
bit 10 = 1024 Equivalent to refineOps_mipFixGlobalsTarget.

refineOps_iterativeRefiner (boolean): Apply the iterative refiner to refine the solution ↵

See also refineOps.

Default: 0

refineOps_lpOptimal (boolean): Run the solution refiner on an optimal solution of a continuous problem ↵

See also refineOps.

Default: 1

refineOps_lpPresolve (boolean): Run the solution refiner on an optimal solution before postsolve on a continuous problem ↵

See also refineOps.

Default: 1

refineOps_mipFixGlobals (boolean): Refine MIP solutions such that rounding them keeps the problem feasible when reoptimized ↵

See also refineOps.

Default: 0

refineOps_mipFixGlobalsTarget (boolean): Attempt to refine MIP solutions such that rounding them keeps the problem feasible when reoptimized, but accept integers solutions even if refinement fails ↵

See also refineOps.

Default: 0

refineOps_mipNodeLp (boolean): Run the solution refiner on each node of the MIP search ↵

See also refineOps.

Default: 0

refineOps_mipSolution (boolean): Run the solution refiner when a new solution is found during a tree search ↵

The refiner will be applied to the presolved solution before any post-solve operations are applied.

See also refineOps.

Default: 1

refineOps_refinerPrecision (boolean): Use higher precision in the iterative refinement ↵

See also refineOps.

Default: 0

refineOps_refinerUseDual (boolean): If set, the iterative refiner will use the dual simplex algorithm ↵

See also refineOps.

Default: 0

refineOps_refinerUsePrimal (boolean): If set, the iterative refiner will use the primal simplex algorithm ↵

See also refineOps.

Default: 0

reform (boolean): Substitute out objective var and equ when possible ↵

Default: 1

relaxTreeMemoryLimit (real): When the memory used by the branch and bound search tree exceeds the target specified by the treeMemoryLimit control, the optimizer will try to reduce this by writing nodes to the tree file ↵

In rare cases, usually where the solve has many millions of very small nodes, the tree structural data (which cannot be written to the tree file) will grow large enough to approach or exceed the tree′s memory target. When this happens, optimizer performance can degrade greatly as the solver makes heavy use of the tree file in preference to memory. To prevent this, the solver will automatically relax the tree memory limit when it detects this case; the relaxTreeMemoryLimit control specifies the proportion of the previous memory limit by which to relax it. Set relaxTreeMemoryLimit to 0.0 to force the Xpress Optimizer to never relax the tree memory limit in this way.

While setting higher values of relaxTreeMemoryLimit can improve performance significantly for a small number of models in low memory situations, the user is advised to use the treeMemoryLimit control to tune the memory usage of the branch and bound tree, according to the solve characteristics of their problem, rather than increasing relaxTreeMemoryLimit.

Range: [0, ∞]

Default: 0.1

relPivotTol (real): Simplex: Minimum size of pivot element relative to largest element in column ↵

At each iteration a pivot element is chosen within a given column of the matrix. The relative pivot tolerance, relPivotTol, is the size of the element chosen relative to the largest possible pivot element in the same column.

Range: [0, ∞]

Default: 1e-06

repairIndefInitEq (boolean): Controls if the optimizer should make indefinite quadratic matrices positive definite when it is possible ↵

Default: 1

value meaning
0 Repair if possible.
1 Do not repair.

reRun (boolean): Rerun with primal simplex when not optimal/feasible ↵

Applies only in cases where presolve is turned on and the model is diagnosed as infeasible or unbounded. If rerun is nonzero, we rerun the model using primal simplex with presolve turned off in hopes of getting better diagnostic information. If rerun is zero, no good diagnostic information exists, so we return no solution, only an indication of unboundedness/infeasibility.

Default: 0

reslim (real): Overrides GAMS reslim option ↵

Sets the resource limit. When the solver has used more than this amount of CPU time (in seconds) the system will stop the search and report the best solution found so far. timeLimit and solTimeLimit overwrite this option.

resourceStrategy (boolean): Controls whether the optimizer is allowed to make nondeterministic decisions if memory is running low in an effort to preserve memory and finish the solve ↵

Available memory (or container limits) are automatically detected but can also be changed by maxMemorySoft and maxMemoryHard.

Default: 0

value meaning
1 Allow the optimizer to change the solve path if necessary to preserve memory when getting close to one of the memory limits.

rootPresolve (integer): Determines if presolving should be performed on the problem after the tree search has finished with root cutting and heuristics ↵

Default: auto

value meaning
-1 Let the optimizer decide if the problem should be presolved again.
0 Disabled.
1 Always presolve the root problem.

sbBest (integer): Number of infeasible MIP entities to initialize pseudo costs for on each node ↵

If sbBest is set to zero, the control historyCosts will also be treated as zero and no past branching or strong branching information will be used in the MIP entity selection.

Default: auto

value meaning
-1 Determined automatically.
0 Disable strong branching.
n>0 Perform strong branching on up to n entities at each node.

sbEffort (real): Adjusts the overall amount of effort when using strong branching to select an infeasible MIP entity to branch on ↵

sbEffort is used as a multiplier on other strong branching related controls, and affects the values used for sbBest, sbSelect and sbIterLimit when those are set to automatic.

Range: [0, ∞]

Default: 1

sbEstimate (integer): Branch and Bound: How to calculate pseudo costs from the local node when selecting an infeasible MIP entity to branch on ↵

These pseudo costs are used in combination with local strong branching and history costs to select the branch candidate.

Default: auto

value meaning
-1 Automatically determined.
1-6 Different variants of local pseudo costs.

sbIterLimit (integer): Number of dual iterations to perform the strong branching for each entity ↵

This control can be useful to increase or decrease the amount of effort (and thus time) spent performing strong branching at each node. Setting sbIterLimit=0 will disable dual strong branch iterations. Instead, the entity at the head of the candidate list will be selected for branching.

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

Default: auto

sbSelect (integer): Size of the candidate list of MIP entities for strong branching ↵

Before strong branching is applied on a node of the branch and bound tree, a list of candidates is selected among the infeasible MIP entities. These entities are then evaluated based on the local LP solution and prioritized. Strong branching will then be applied to the sbBest candidates. The evaluation is potentially expensive and for some problems it might improve performance if the size of the candidate list is reduced.

Default: -2

value meaning
-2 Automatic (low effort).
-1 Automatic (high effort).
n>=0 Include n entities in the candidate list (but always at least sbBest candidates).

scaling (integer): Determines how the Optimizer will rescale a model internally before optimization ↵

If set to 0, no scaling will take place.

Setting scaling to 0 will preserve the current scaling of the problem. Note that the Optimizer might automatically select a different scaling strategy, when the control autoScaling is not disabled. However, if scaling is set to any value by the user, autoScaling will be ignored. The barrier algorithm uses equilibrium scaling.

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

Default: 163

value meaning
bit 0 = 1 Equivalent to scaling_rowScaling.
bit 1 = 2 Equivalent to scaling_colScaling.
bit 2 = 4 Equivalent to scaling_rowScalingAgain.
bit 3 = 8 Equivalent to scaling_maximum.
bit 4 = 16 Equivalent to scaling_curtisReid.
bit 5 = 32 Equivalent to scaling_byMaxElemNotGeoMean.
bit 6 = 64 Equivalent to scaling_bigM.
bit 7 = 128 Equivalent to scaling_simplexObjScaling.
bit 8 = 256 Equivalent to scaling_ignoreQuadRowPart.
bit 9 = 512 Equivalent to scaling_beforePresolve.
bit 10 = 1024 Equivalent to scaling_noScalingRowsUp.
bit 11 = 2048 Equivalent to scaling_noScalingColsDown.
bit 12 = 4096 Equivalent to scaling_disableGlobalObjScaling.
bit 13 = 8192 Equivalent to scaling_rhsScaling.
bit 14 = 16384 Equivalent to scaling_noAggressiveQScaling.
bit 15 = 32768 Equivalent to scaling_slackScaling.

scaling_beforePresolve (boolean): Scale before presolve ↵

See also scaling.

Default: 0

scaling_bigM (boolean): Treat big-M rows as normal rows ↵

See also scaling.

Default: 0

scaling_byMaxElemNotGeoMean (boolean): 0: scale by geometric mean ↵

1: scale by maximum element.

See also scaling.

Default: 1

scaling_colScaling (boolean): Column scaling ↵

See also scaling.

Default: 1

scaling_curtisReid (boolean): Curtis-Reid ↵

See also scaling.

Default: 0

scaling_disableGlobalObjScaling (boolean): Do not apply automatic objective scaling ↵

See also scaling.

Default: 0

scaling_ignoreQuadRowPart (boolean): Exclude the quadratic part of constraint when calculating scaling factors ↵

See also scaling.

Default: 0

scaling_maximum (boolean): Maximum ↵

See also scaling.

Default: 0

scaling_noAggressiveQScaling (boolean): Disable aggressive quadratic scaling ↵

See also scaling.

Default: 0

scaling_noScalingColsDown (boolean): Do not scale columns down ↵

See also scaling.

Default: 0

scaling_noScalingRowsUp (boolean): Do not scale rows up ↵

See also scaling.

Default: 0

scaling_rhsScaling (boolean): RHS scaling ↵

See also scaling.

Default: 0

scaling_rowScaling (boolean): Row scaling ↵

See also scaling.

Default: 1

scaling_rowScalingAgain (boolean): Row scaling again ↵

See also scaling.

Default: 0

scaling_simplexObjScaling (boolean): Scale objective function for the simplex method ↵

See also scaling.

Default: 1

scaling_slackScaling (boolean): Enable explicit linear slack scaling ↵

See also scaling.

Default: 0

sifting (integer): Determines whether to enable sifting algorithm with the dual simplex method ↵

Default: auto

value meaning
-1 Automatically determined.
0 Disable sifting.
1 Enable sifting.

siftPasses (integer): Determines how quickly we allow to grow the worker problems during the sifting algorithm ↵

Using larger values can increase the number of columns added to the worker problem which often results in increased solve times for the worker problems but the number of necessary sifting iterations may be reduced.

Range: {0, ..., ∞}

Default: 4

siftPresolveOps (integer): Determines the presolve operations for solving the subproblems during the sifting algorithm ↵

Default: -1

value meaning
-1 Use the presolveOps setting specified for the original problem.
>=0 Use the value for the presolveOps parameter for solving the subproblems during the sifting algorithm.

siftSwitch (integer): Determines which algorithm to use for solving the subproblems during sifting ↵

Default: -1

value meaning
-1 Dual simplex.
0 Barrier.
>0 Use the barrier algorithm while the number of dual infeasibilities is larger than this value, otherwise use dual simplex.

solnpool (string): Solution pool file name ↵

If set, the integer feasible solutions generated during the global search will be saved to a solution pool. A GDX file whose name is given by this option will be created and will contain an index to separate GDX files containing the individual solutions in the solution pool.

Default: none

solnpoolCapacity (integer): Limit on number of solutions to store ↵

Range: {1, ..., ∞}

Default: 999999999

solnpoolCullDiversity (integer): Cull N solutions based on solution diversity ↵

When performing a round of culls due to a full solution pool, this control sets the maximum number to cull based on the diversity of the solutions in the pool.

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

Default: -1

solnpoolCullObj (integer): Cull N solutions based on objective values ↵

When performing a round of culls due to a full solution pool, this control sets the maximum number to cull based on the MIP objective function.

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

Default: -1

solnpoolCullRounds (integer): Terminate solution generation after N culling rounds ↵

Limits the rounds of culls performed due to a full solution pool.

Default: 999999999

solnpoolDupPolicy (integer): Policy to use when handling storage of duplicate solutions ↵

Default: 0

value meaning
0 Keep all: All solutions are kept including duplicates.
1 Continuous: All variables are compared with an exact match. Duplicate solutions are discarded.
2 Discrete and continuous separate: Both the discrete component of a solution pair and the continuous solution variables are compared. The continuous variables are compared with an exact match. Duplicate solutions are discarded.
3 Discrete only: Only the discrete component of a solution pair is compared. Duplicate solutions are discarded.

solnpoolmerge (string): Solution pool file name for merged solutions ↵

Default: none

solnpoolnumsym (integer): Maximum number of variable symbols when writing merged solutions ↵

Range: {1, ..., ∞}

Default: 10

solnpoolPop (integer): Controls method used to populate the solution pool ↵

By default the MIP solution pool merely stores the incumbent solutions that are found during the global search, without changing the behavior of the search itself. In constrast, the MIP solution enumerator makes it possible to enumerate all or many of the feasible solutions for the MIP, instead of searching for the best solution.

Default: 1

value meaning
1 generate solutions using the normal search algorithm
2 invoke the solution enumerator to generate solutions

solnpoolPrefix (string): File name prefix for GDX solution files ↵

Default: soln

solnpoolVerbosity (integer): Controls verbosity of solution pool routines ↵

Default: 0

value meaning
-1 no output
0 output only messages coming from the XPRESS libraries
1 add some messages logging the effect of solution pool options
2 debugging mode

solTimeLimit (real): Maximum time in seconds that the Optimizer will run a MIP solve before it terminates, given that a solution has been found ↵

As long as no solution has been found, this control will have no effect.

This control has been newly introduced with Xpress Optimizer version 9.0 and should be used instead of the deprecated MAXTIME control. It can be combined with the timeLimit control.

Default: 1e+20

value meaning
>0 If an integer solution has been found, stop MIP search after the given number of seconds, otherwise continue until an integer solution is finally found.

sosRefTol (real): Minimum relative gap between the ordering values of elements in a special ordered set ↵

The gap divided by the absolute value of the larger of the two adjacent values must be at least sosRefTol.

This tolerance must not be set lower than 1.0E-06.

Range: [0, ∞]

Default: 1e-06

symmetry (integer): Adjusts the overall amount of effort for symmetry detection ↵

Default: 1

value meaning
0 No symmetry detection.
1 Conservative effort.
2 Intensive symmetry search.

symSelect (integer): Adjusts the overall amount of effort for symmetry detection ↵

Default: -1

value meaning
0 Search the whole matrix (otherwise the 0, 1 and -1 coefficients only).
1 Search all entities (otherwise binaries only).

threads (integer): Default number of threads used during optimization ↵

Controls the number of threads to use. Positive values will be compared to the number of available cores detected and reduced if greater than this amount. Non- positive values are interpreted as the number of cores to leave free so setting threads to 0 uses all available cores while setting threads to -1 leaves one core free for other tasks.

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

Default: GAMS threads

timeLimit (real): Maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time ↵

For MIP problems, this is the total time taken to solve all nodes.

This control has been newly introduced with Xpress Optimizer version 9.0 and should be used instead of the deprecated MAXTIME control. Note that the meaning of positive values differs between timeLimit and MAXTIME. When both controls are set, timeLimit takes precedence. The functionality of positive MAXTIME values is covered by solTimeLimit.

Default: GAMS reslim

value meaning
>0 Stop LP or MIP search after the given number of seconds.

trace (integer): Display the infeasibility diagnosis during presolve ↵

If non-zero, an explanation of the logical deductions made by presolve to deduce infeasibility or unboundedness will be displayed on screen or sent to the message callback function.

Presolve is sometimes able to detect infeasibility and unboundedness in problems. The set of deductions made by presolve can allow the user to diagnose the cause of infeasibility or unboundedness in their problem. However, not all infeasibility or unboundedness can be detected and diagnosed in this way.

Range: {0, ..., ∞}

Default: 0

treeCompression (integer): When writing nodes to the global file, the optimizer can try to use data-compression techniques to reduce the size of the tree file on disk ↵

The treeCompression control determines the strength of the data-compression algorithm used; higher values give superior data- compression at the affect of decreasing performance, while lower values compress quicker but not as effectively. Where treeCompression is set to 0, no data compression will be used on the tree file.

Range: {0, ..., ∞}

Default: 2

treeCoverCuts (integer): Branch and Bound: Number of rounds of lifted cover inequalities generated at nodes other than the top node in the tree ↵

Compare with the description for coverCuts. A value of -1 indicates the number of rounds is determined automatically.

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

Default: auto

treeCutSelect (integer): Bit vector providing detailed control of the cuts created during the tree search of a MIP solve ↵

Use cutSelect to control cuts on the root node.

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

The separation of Multi-Commodity Flow (MCF) cuts is controlled by mcfCutStrategy.

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

Default: -1

value meaning
bit 5 = 32 Equivalent to treeCutSelect_clique.
bit 6 = 64 Equivalent to treeCutSelect_mir.
bit 7 = 128 Equivalent to treeCutSelect_cover.
bit 8 = 256 Equivalent to treeCutSelect_mirRowAggregation.
bit 11 = 2048 Equivalent to treeCutSelect_flowpath.
bit 12 = 4096 Equivalent to treeCutSelect_implication.
bit 13 = 8192 Equivalent to treeCutSelect_liftAndProject.
bit 14 = 16384 Equivalent to treeCutSelect_disableCutRows.
bit 15 = 32768 Equivalent to treeCutSelect_gubCover.
bit 16 = 65536 Equivalent to treeCutSelect_zeroHalf.
bit 17 = 131072 Equivalent to treeCutSelect_indicator.
bit 18 = 262144 Equivalent to treeCutSelect_gomory.
bit 20 = 1048576 Equivalent to treeCutSelect_farkas.

treeCutSelect_clique (boolean): Clique cuts ↵

See also treeCutSelect.

Default: 1

treeCutSelect_cover (boolean): Lifted cover cuts ↵

See also treeCutSelect.

Default: 1

treeCutSelect_disableCutRows (boolean): Disable cutting from cut rows ↵

See also treeCutSelect.

Default: 1

treeCutSelect_farkas (boolean): Farkas cuts ↵

See also treeCutSelect.

Default: 1

treeCutSelect_flowpath (boolean): Flow path cuts ↵

See also treeCutSelect.

Default: 1

treeCutSelect_gomory (boolean): Strong Chvatal-Gomory cuts ↵

See also treeCutSelect.

Default: 1

treeCutSelect_gubCover (boolean): Lifted GUB cover cuts ↵

See also treeCutSelect.

Default: 1

treeCutSelect_implication (boolean): Implication cuts ↵

See also treeCutSelect.

Default: 1

treeCutSelect_indicator (boolean): Indicator constraint cuts ↵

See also treeCutSelect.

Default: 1

treeCutSelect_liftAndProject (boolean): Turn on automatic Lift and Project cutting strategy ↵

See also treeCutSelect.

Default: 1

treeCutSelect_mir (boolean): Mixed Integer Rounding (MIR) cuts ↵

See also treeCutSelect.

Default: 1

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

See also treeCutSelect.

Default: 1

treeCutSelect_zeroHalf (boolean): Zero-half cuts ↵

See also treeCutSelect.

Default: 1

treeGomCuts (integer): Branch and Bound: Number of rounds of Gomory cuts generated at nodes other than the first node in the tree ↵

Compare with the description for gomCuts. A value of -1 indicates the number of rounds is determined automatically.

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

Default: auto

treeMemoryLimit (integer): Soft limit, in megabytes, for the amount of memory to use in storing the branch and bound search tree ↵

This doesn′t include memory used for presolve, heuristics, solving the LP relaxation, etc. When set to 0 (the default), the optimizer will calculate a limit automatically based on the amount of free physical memory detected in the machine. When the memory used by the branch and bound tree exceeds this limit, the optimizer will try to reduce the memory usage by writing lower-rated sections of the tree to a file called the "tree file". Though the solve can continue if it cannot bring the tree memory usage below the specified limit, performance will be inhibited and a message will be printed to the log.

Range: {0, ..., ∞}

Default: auto

treeMemorySavingTarget (real): When the memory used by the branch-and-bound search tree exceeds the limit specified by the treeMemoryLimit control, the optimizer will try to save memory by writing lower-rated sections of the tree to the tree file ↵

The target amount of memory to save will be enough to bring memory usage back below the limit, plus enough extra to give the tree room to grow. The treeMemorySavingTarget control specifies the extra proportion of the tree′s size to try to save; for example, if the tree memory limit is 1000Mb and treeMemorySavingTarget is 0.1, when the tree size exceeds 1000Mb the optimizer will try to reduce the tree size to 900Mb. Reducing the value of treeMemorySavingTarget will cause less extra nodes of the tree to be written to the tree file, but will result in the memory saving routine being triggered more often (as the tree will have less room in which to grow), which can reduce performance. Increasing the value of treeMemorySavingTarget will cause additional, more highly-rated nodes, of the tree to be written to the tree file, which can cause performance issues if these nodes are required later in the solve.

Range: [0, ∞]

Default: 0.4

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

This control only has an effect for problems with quadratic or second order cone constraints, and only if outer approximation has not been disabled by setting miqcpAlg to 0.

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

Default: auto

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

The variable selected to be branched on is the one with the maximum estimate.

Default: auto

value meaning
-1 Determined automatically.
1 The minimum of the ′up′ and ′down′ pseudo costs.
2 The ′up′ pseudo cost plus the ′down′ pseudo cost.
3 The maximum of the ′up′ and ′down′ pseudo costs, plus twice the minimum of the ′up′ and ′down′ pseudo costs.
4 The maximum of the ′up′ and ′down′ pseudo costs.
5 The ′down′ pseudo cost.
6 The ′up′ pseudo cost.
7 A weighted combination of the ′up′ and ′down′ pseudo costs, where the weights depend on how fractional the variable is.
8 The product of the ′up′ and ′down′ pseudo costs.

writePrtSol (boolean): Directs optimizer to output a "printsol" file ↵

Default: 0

xslp_algorithm (integer): Bit map describing the SLP algorithm(s) to be used ↵

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

Default: 166

value meaning
bit 0 = 1 Equivalent to xslp_algorithm_noStepBounds.
bit 1 = 2 Equivalent to xslp_algorithm_stepBoundsAsRequired.
bit 2 = 4 Equivalent to xslp_algorithm_estimateStepBounds.
bit 3 = 8 Equivalent to xslp_algorithm_dynamicDamping.
bit 4 = 16 Equivalent to xslp_algorithm_holdValues.
bit 5 = 32 Equivalent to xslp_algorithm_retainPreviousValue.
bit 6 = 64 Equivalent to xslp_algorithm_resetDeltaZ.
bit 7 = 128 Equivalent to xslp_algorithm_quickConvergenceCheck.
bit 8 = 256 Equivalent to xslp_algorithm_escalatePenalties.
bit 9 = 512 Equivalent to xslp_algorithm_switchToPrimal.
bit 11 = 2048 Equivalent to xslp_algorithm_maxCostOption.
bit 12 = 4096 Equivalent to xslp_algorithm_residualErrors.
bit 13 = 8192 Equivalent to xslp_algorithm_noLPPolishing.
bit 14 = 16384 Equivalent to xslp_algorithm_cascadeBounds.
bit 15 = 32768 Equivalent to xslp_algorithm_clampExtendedActiveSB.
bit 16 = 65536 Equivalent to xslp_algorithm_clampExtendedAll.

xslp_algorithm_cascadeBounds (boolean): Step bounds are updated to accomodate cascaded values (otherwise cascaded values are pushed to respect step bounds) ↵

Normally, cascading will respect the step bounds of the SLP variable being cascaded. However, allowing the cascaded value to fall outside the step bounds (i.e. expanding the step bounds) can lead to better linearizations, as cascading will set better values for the SLP variables regarding their determining rows; note, that this later strategy might interfere with convergence of the cascaded variables.

See also xslp_algorithm.

Default: 0

xslp_algorithm_clampExtendedActiveSB (boolean): Apply clamping when converged on extended criteria only with some variables having active step bounds ↵

When clamping is applied, then in any iteration when the solution would normally be deemed converged on extended criteria only, an extra step bound shrinking step is applied to help imposing strict convergence. In this variant, clamping is only applied on variables that have converged on extended criteria only and have active step bounds.

See also xslp_algorithm.

Default: 0

xslp_algorithm_clampExtendedAll (boolean): Apply clamping when converged on extended criteria only ↵

When clamping is applied, then in any iteration when the solution would normally be deemed converged on extended criteria only, an extra step bound shrinking step is applied to help imposing strict convergence. In this variant, clamping is applied on all variables that have converged on extended criteria only.

See also xslp_algorithm.

Default: 0

xslp_algorithm_dynamicDamping (boolean): Use dynamic damping ↵

Dynamic damping is sometimes an alternative to step bounding as a means of encouraging convergence, but it does not have the same power to force convergence as do step bounds.

See also xslp_algorithm.

Default: 0

xslp_algorithm_escalatePenalties (boolean): Escalate penalties ↵

Constraint penalties are increased after each SLP iteration where penalty vectors are present in the solution. Escalation applies an additional scaling factor to the penalty costs for active errors. This helps to prevent successive solutions becoming "stuck" because of a particular constraint, because its cost will be raised so that other constraints may become more attractive to violate instead and thus open up a new region to explore.

See also xslp_algorithm.

Default: 0

xslp_algorithm_estimateStepBounds (boolean): Estimate step bounds from early SLP iterations ↵

If initial step bounds are not being explicitly provided, this gives a good method of calculating reasonable values. Values will tend to be larger rather than smaller, to reduce the risk of infeasibility caused by excessive tightness of the step bounds.

See also xslp_algorithm.

Default: 1

xslp_algorithm_holdValues (boolean): Do not update values which are converged within strict tolerance ↵

Models which are numerically unstable may benefit from this setting, which does not update values which have effectively hardly changed. If a variable subsequently does move outside its strict convergence tolerance, it will be updated as usual.

See also xslp_algorithm.

Default: 0

xslp_algorithm_maxCostOption (boolean): Continue optimizing after penalty cost reaches maximum ↵

Normally if the penalty cost reaches its maximum (by default the value of infinity), the optimization will terminate with an unconverged solution. If the maximum value is set to a smaller value, then it may make sense to continue, using other means to determine when to stop.

See also xslp_algorithm.

Default: 0

xslp_algorithm_noLPPolishing (boolean): Skip the solution polishing step if the LP postsolve returns a slightly infeasible, but claimed optimal solution ↵

Due to the nature of the SLP linearizations, and in particular because of the large differences in the objective function (model objective against penalty costs) some dual reductions in the linear presolver might introduce numerically instable reductions that cause slight infeasibilities to appear in postsolve. It is typically more efficient to remove these infeasibilities with an extra call to the linear optimizer; compared to switching these reductions off, which usually has a significant cost in performance. This bit is provided for numerically very hard problems, when the polishing step proves to be too expensive (Xpress SLP will report these if any in the final log summary).

See also xslp_algorithm.

Default: 0

xslp_algorithm_noStepBounds (boolean): Do not apply step bounds ↵

The default algorithm uses step bounds to force convergence. Step bounds may not be appropriate if dynamic damping is used.

See also xslp_algorithm.

Default: 0

xslp_algorithm_quickConvergenceCheck (boolean): Quick convergence check ↵

Normally, each variable is checked against all convergence criteria until either a criterion is found which it passes, or it is declared "not converged". Later (extended convergence) criteria are more expensive to test and, once an unconverged variable has been found, the overall convergence status of the solution has been established. The quick convergence check carries out checks on the strict criteria, but omits checks on the extended criteria when an unconverged variable has been found.

See also xslp_algorithm.

Default: 1

xslp_algorithm_resetDeltaZ (boolean): Reset xslp_delta_z to zero when converged and continue SLP ↵

One of the mechanisms to avoid local optima is to retain small non-zero coefficients between delta vectors and constraints, even when the coefficient should strictly be zero. If this option is set, then a converged solution will be continued with zero coefficients as appropriate.

See also xslp_algorithm.

Default: 0

xslp_algorithm_residualErrors (boolean): Accept a solution which has converged even if there are still significant active penalty error vectors ↵

Normally, the optimization will continue if there are active penalty vectors in the solution. However, it may be that there is no feasible solution (and so active penalties will always be present). Setting bit 12 means that, if other convergence criteria are met, then the solution will be accepted as converged and the optimization will stop.

See also xslp_algorithm.

Default: 0

xslp_algorithm_retainPreviousValue (boolean): Retain previous value when cascading if determining row is zero ↵

If the determining row is zero (that is, all the coefficients interacting with it are either zero or in columns with a zero activity), then it is impossible to calculate a new value for the vector being cascaded. The choice is to use the solution value as it is, or to revert to the assumed value

See also xslp_algorithm.

Default: 1

xslp_algorithm_stepBoundsAsRequired (boolean): Apply step bounds to SLP delta vectors only when required ↵

Step bounds can be applied to all vectors simultaneously, or applied only when oscillation of the delta vector (change in sign between successive SLP iterations) is detected.

See also xslp_algorithm.

Default: 1

xslp_algorithm_switchToPrimal (boolean): Use the primal simplex algorithm when all error vectors become inactive ↵

The primal simplex algorithm often performs better than dual during the final stages of SLP optimization when there are relatively few basis changes between successive solutions. As it is impossible to establish in advance when the final stages are being reached, the disappearance of error vectors from the solution is used as a proxy.

See also xslp_algorithm.

Default: 0

xslp_analyze (integer): Bit map activating additional options supporting model / solution path analyzis ↵

In most cases, the value of this control does not affect the solution process itself. However, bit 3 (extended summary) will cause SLP to do more function evaluations, and the presence of non-deterministic user functions might cause changes in the solution process. These options are off by default due to performance considerations.

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

Default: 0

value meaning
bit 3 = 8 Equivalent to xslp_analyze_extendedFinalSummary.
bit 4 = 16 Equivalent to xslp_analyze_infeasibleIteration.
bit 6 = 64 Equivalent to xslp_analyze_saveLinearizations.
bit 7 = 128 Equivalent to xslp_analyze_saveIterBasis.
bit 8 = 256 Equivalent to xslp_analyze_saveFile.

xslp_analyze_extendedFinalSummary (boolean): Include an extended iteration summary ↵

See also xslp_analyze.

Default: 0

xslp_analyze_infeasibleIteration (boolean): Run infeasibility analysis on infeasible iterations ↵

See also xslp_analyze.

Default: 0

xslp_analyze_saveFile (boolean): Create an Xpress SLP save file at every xslp_autosave iterations ↵

See also xslp_analyze.

Default: 0

xslp_analyze_saveIterBasis (boolean): Write the initial basis of the linearizations to disk at every xslp_autosave iterations ↵

See also xslp_analyze.

Default: 0

xslp_analyze_saveLinearizations (boolean): Write the linearizations to disk at every xslp_autosave iterations ↵

See also xslp_analyze.

Default: 0

xslp_aTol_a (real): Absolute delta convergence tolerance ↵

The absolute delta convergence criterion assesses the change in value of a variable (δX) against the absolute delta convergence tolerance. If δX < xslp_aTol_a then the variable has converged on the absolute delta convergence criterion. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default: auto

xslp_aTol_r (real): Relative delta convergence tolerance ↵

The relative delta convergence criterion assesses the change in value of a variable (δX) relative to the value of the variable (X), against the relative delta convergence tolerance. If δX < X * xslp_aTol_r then the variable has converged on the relative delta convergence criterion. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default: auto

xslp_augmentation (integer): Bit map describing the SLP augmentation method(s) to be used ↵

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

Default: 12

value meaning
bit 0 = 1 Equivalent to xslp_augmentation_minimum.
bit 1 = 2 Equivalent to xslp_augmentation_evenHanded.
bit 2 = 4 Equivalent to xslp_augmentation_equalityErrorVectors.
bit 3 = 8 Equivalent to xslp_augmentation_allErrorVectors.
bit 4 = 16 Equivalent to xslp_augmentation_penaltyDeltaVectors.
bit 5 = 32 Equivalent to xslp_augmentation_aMeanWeight.
bit 6 = 64 Equivalent to xslp_augmentation_sbFromValues.
bit 7 = 128 Equivalent to xslp_augmentation_sbFromAbsValues.
bit 8 = 256 Equivalent to xslp_augmentation_stepBoundRows.
bit 9 = 512 Equivalent to xslp_augmentation_allRowErrorVectors.
bit 10 = 1024 Equivalent to xslp_augmentation_noUpdateIfOnlyIV.
bit 12 = 4096 Equivalent to xslp_augmentation_slpSkipIVLPHeuristics.

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_slpSkipIVLPHeuristics (boolean): Avoid running an LP around fixed initial values trying to get feasible ↵

Unless this bit is set, if almost all variables have initial values, an LP can be solved with all variables with initial values fixed to those, to try to extend the partial initial solution to a feasible solution.

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_boundThreshold (real): Maximum size of a bound that can be introduced by nonlinear presolve ↵

Range: [0, ∞]

Default: 1e+10

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: 1e-06

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: 1e-06

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 Equivalent to xslp_convergenceOps_user.
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.
bit 13 = 8192 Equivalent to xslp_convergenceOps_noQuadCheck.

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_noQuadCheck (boolean): Allow convex quadratic problems to converge on extended criteria ↵

See also xslp_convergenceOps.

Default: 0

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_user (boolean): Check for user provided convergence ↵

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_infinity (real): Maximum value for partial derivatives ↵

Range: [0, ∞]

Default: 1e+15

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 Equivalent to xslp_filterCascade.
bit 2 = 4 Equivalent to xslp_filterZeroLineSearch.
bit 3 = 8 Equivalent to xslp_filterZeroLineSearchTR.

xslp_filterCascade (boolean): Check cascaded solutions against improvements in the merit function ↵

See also xslp_filter.

Default: 1

xslp_filterKeepBest (boolean): Retrain solution best according to the merit function ↵

See also xslp_filter.

Default: 1

xslp_filterZeroLineSearch (boolean): Force minimum step sizes in line search ↵

See also xslp_filter.

Default: 0

xslp_filterZeroLineSearchTR (boolean): Accept the trust region step is the line search returns a zero step size ↵

See also xslp_filter.

Default: 0

xslp_findIV (integer): Option for running a heuristic to find a feasible initial point ↵

The procedure uses bound reduction (and, up to an extent, probing) to obtain a point in the initial bounding box that is feasible for the bound reduction techniques. If an initial point is already specified and is found not to violate bound reduction, then the heuristic is not run and the given point is used as the initial solution.

Default: auto

value meaning
-1 Automatic (default).
0 Disable the heuristic.
1 Enable the heuristic.

xslp_granularity (real): Base for calculating penalty costs ↵

If xslp_granularity > 1, then initial penalty costs will be powers of xslp_granularity.

Range: [1, ∞]

Default: 4

xslp_hessian (integer): Second order differentiation mode when using analytical derivatives ↵

Symbolic mode differentiation for the second order derivatives is only available when xslp_jacobian is also set to symbolic mode.

Default: -1

value meaning
1 Numerical derivatives (finite difference)
2 Symbolic differentiation
3 Automatic differentiation
-1,0 Automatic selection

xslp_heurStrategy (integer): Branch and Bound: MINLP heuristic strategy ↵

On some problems it is worth trying more comprehensive heuristic strategies by setting HEURSTRATEGY to 2 or 3. Note that HEURSTRATEGY is deprecated, use heurEmphasis instead.

Default: auto

value meaning
-1 Automatic selection of heuristic strategy.
0 No heuristics.
1 Basic heuristic strategy.
2 Enhanced heuristic strategy.
3 Extensive heuristic strategy.
4 Run all heuristics without effort limits.

xslp_infeasLimit (integer): Maximum number of consecutive infeasible SLP iterations which can occur before Xpress-SLP terminates ↵

An infeasible solution to an SLP iteration means that is likely that Xpress-SLP will create a poor linear approximation for the next SLP iteration. Sometimes, small infeasibilities arise because of numerical difficulties and do not seriously affect the solution process. However, if successive solutions remain infeasible, it is unlikely that Xpress-SLP will be able to find a feasible converged solution. xslp_infeasLimit sets the number of successive SLP iterations which must take place before Xpress-SLP terminates with a status of "infeasible solution".

Range: {0, ..., ∞}

Default: 3

xslp_infinity (real): Value returned by a divide-by-zero in a formula ↵

Range: [0, ∞]

Default: 1e+10

xslp_iterLimit (integer): Maximum number of SLP iterations ↵

If Xpress-SLP reaches xslp_iterLimit without finding a converged solution, it will stop. For MISLP, the limit is on the number of SLP iterations at each node.

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

Default: 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 XSLPnlpoptimize for solving MINLP problems. The recommended approach is to solve the problem first without reference to the discrete variables. This can be handled automatically by setting bit 0 of xslp_mipAlgorithm; if done manually, then optimize using the "l" option to prevent the Optimizer presolve from changing the problem. Some versions of the optimizer re-run the initial node as part of the tree search; it is possible to initiate a new SLP optimization at this point by relaxing or fixing step bounds (use bits 2 and 3). If step bounds are fixed for a class of variable, then the variables in that class will not change their value in any child node. At each node, it is possible to relax or fix step bounds. It is recommended that step bounds are relaxed, so that the new problem can be solved starting from its parent, but without undue restrictions cased by step bounding (use bit 4). Exceptionally, it may be preferable to restrict the freedom of child nodes by relaxing fewer types of step bound or fixing the values of some classes of variable (use bit 5). When the optimal node has been found, it is possible to fix the discrete variables and then re-optimize with SLP. Step bounds can be relaxed or fixed for this optimization as well (use bits 7 and 8). Although it is ultimately necessary to solve the optimal node to convergence, individual nodes can be truncated after xslp_mipIterLimit SLP iterations. Set bit 6 to activate this feature. The normal MISLP algorithm uses SLP at each node. One alternative strategy is to use the MIP optimizer for solving each SLP iteration. Set bit 9 to implement this strategy ("MIP within SLP"). Another strategy is to solve the problem to convergence ignoring the nature of the integer variables. Then, fixing the linearization, use MIP to find the optimal setting of the discrete variables. Then, fixing the discrete variables, but varying the linearization, solve to convergence. Set bit 10 to implement this strategy ("SLP then MIP"). For mode details about MISLP algorithms and strategies, see the separate section.

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

Default: 17

value meaning
bit 0 = 1 Equivalent to xslp_mipAlgorithm_initialSLP.
bit 2 = 4 Equivalent to xslp_mipAlgorithm_initialRelaxSLP.
bit 3 = 8 Equivalent to xslp_mipAlgorithm_initialFixSLP.
bit 4 = 16 Equivalent to xslp_mipAlgorithm_nodeRelaxSLP.
bit 5 = 32 Equivalent to xslp_mipAlgorithm_nodeFixSLP.
bit 6 = 64 Equivalent to xslp_mipAlgorithm_nodeLimitSLP.
bit 7 = 128 Equivalent to xslp_mipAlgorithm_finalRelaxSLP.
bit 8 = 256 Equivalent to xslp_mipAlgorithm_finalFixSLP.
bit 9 = 512 Equivalent to xslp_mipAlgorithm_withinSLP.
bit 10 = 1024 Equivalent to xslp_mipAlgorithm_slpThenMIP.

xslp_mipAlgorithm_finalFixSLP (boolean): Fix step bounds according to xslp_mipFixStepBounds after MIP solution is found ↵

See also xslp_mipAlgorithm.

Default: 0

xslp_mipAlgorithm_finalRelaxSLP (boolean): Relax step bounds according to xslp_mipRelaxStepBounds after MIP solution is found ↵

See also xslp_mipAlgorithm.

Default: 0

xslp_mipAlgorithm_initialFixSLP (boolean): Fix step bounds according to xslp_mipFixStepBounds after initial node ↵

See also xslp_mipAlgorithm.

Default: 0

xslp_mipAlgorithm_initialRelaxSLP (boolean): Relax step bounds according to xslp_mipRelaxStepBounds after initial node ↵

See also xslp_mipAlgorithm.

Default: 0

xslp_mipAlgorithm_initialSLP (boolean): Solve initial SLP to convergence ↵

See also xslp_mipAlgorithm.

Default: 1

xslp_mipAlgorithm_nodeFixSLP (boolean): Fix step bounds according to xslp_mipFixStepBounds at each node ↵

See also xslp_mipAlgorithm.

Default: 0

xslp_mipAlgorithm_nodeLimitSLP (boolean): Limit iterations at each node to xslp_mipIterLimit ↵

See also xslp_mipAlgorithm.

Default: 0

xslp_mipAlgorithm_nodeRelaxSLP (boolean): Relax step bounds according to xslp_mipRelaxStepBounds at each node ↵

See also xslp_mipAlgorithm.

Default: 1

xslp_mipAlgorithm_slpThenMIP (boolean): Use MIP on converged SLP solution and then SLP on the resulting MIP solution ↵

See also xslp_mipAlgorithm.

Default: 0

xslp_mipAlgorithm_withinSLP (boolean): Use MIP at each SLP iteration instead of SLP at each node ↵

See also xslp_mipAlgorithm.

Default: 0

xslp_mipCutOffCount (integer): Number of SLP iterations to check when considering a node for cutting off ↵

If the objective function is worse by a defined amount than the best integer solution obtained so far, then the SLP will be terminated (and the node will be cut off). The node will be cut off at the current SLP iteration if the objective function for the last xslp_mipCutOffCount SLP iterations are all worse than the best obtained so far, and the difference is greater than xslp_mipCutOff_a and OBJ * xslp_mipCutOff_r where OBJ is the best integer solution obtained so far. The test is not applied until at least xslp_mipCutOffLimit SLP iterations have been carried out at the current node.

Range: {0, ..., ∞}

Default: 5

xslp_mipCutOffLimit (integer): Number of SLP iterations to check when considering a node for cutting off ↵

If the objective function is worse by a defined amount than the best integer solution obtained so far, then the SLP will be terminated (and the node will be cut off). The node will be cut off at the current SLP iteration if the objective function for the last xslp_mipCutOffCount SLP iterations are all worse than the best obtained so far, and the difference is greater than xslp_mipCutOff_a and OBJ * xslp_mipCutOff_r where OBJ is the best integer solution obtained so far. The test is not applied until at least xslp_mipCutOffLimit SLP iterations have been carried out at the current node.

Range: {0, ..., ∞}

Default: 10

xslp_mipCutOff_a (real): Absolute objective function cutoff for MIP termination ↵

If the objective function is worse by a defined amount than the best integer solution obtained so far, then the SLP will be terminated (and the node will be cut off). The node will be cut off at the current SLP iteration if the objective function for the last xslp_mipCutOffCount SLP iterations are all worse than the best obtained so far, and the difference is greater than xslp_mipCutOff_a and OBJ * xslp_mipCutOff_r where OBJ is the best integer solution obtained so far. The MIP cutoff tests are only applied after xslp_mipCutOffLimit SLP iterations at the current node.

Range: [0, ∞]

Default: 1e-05

xslp_mipCutOff_r (real): Absolute objective function cutoff for MIP termination ↵

If the objective function is worse by a defined amount than the best integer solution obtained so far, then the SLP will be terminated (and the node will be cut off). The node will be cut off at the current SLP iteration if the objective function for the last xslp_mipCutOffCount SLP iterations are all worse than the best obtained so far, and the difference is greater than xslp_mipCutOff_a and OBJ * xslp_mipCutOff_r where OBJ is the best integer solution obtained so far. The MIP cutoff tests are only applied after xslp_mipCutOffLimit SLP iterations at the current node.

Range: [0, ∞]

Default: 1e-05

xslp_mipDefaultAlgorithm (integer): Default algorithm to be used during the tree search in MISLP ↵

The default algorithm used within SLP during the MISLP optimization can be set using xslp_mipDefaultAlgorithm. It will not necessarily be the same as the one best suited to the initial SLP optimization.

Range: {1, ..., 5}

Default: 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 used 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_nlpSolver (integer): Controls whether to call FICO Xpress Global or one of the local solvers ↵

Default: -1

value meaning
-1 If the license allows and there are no user functions or multistart jobs, FICO Xpress Global will be called, otherwise a local solver.
1 The algorithm selected by xslp_solver will be used to find a locally optimal solution
2 FICO Xpress Global will be used to find a globally optimal solution

xslp_objToPenaltyCost (real): Factor to estimate initial penalty costs from objective function ↵

The setting of initial penalty error costs can affect the path of the optimization and, indeed, whether a solution is achieved at all. If the penalty costs are too low, then unbounded solutions may result although Xpress-SLP will increase the costs in an attempt to recover. If the penalty costs are too high, then the requirement to achieve feasibility of the linearized constraints may be too strong to allow the system to explore the nonlinear feasible region. Low penalty costs can result in many SLP iterations, as feasibility of the nonlinear constraints is not achieved until the penalty costs become high enough; high penalty costs force feasibility of the linearizations, and so tend to find local optima close to an initial feasible point. Xpress-SLP can analyze the problem to estimate the size of penalty costs required to avoid an initial unbounded solution. xslp_objToPenaltyCost can be used in conjunction with this procedure to scale the costs and give an appropriate initial value for balancing the requirements of feasibility and optimality. Not all models are amenable to the Xpress-SLP analysis. As the analysis is initially concerned with establishing a cost level to avoid unboundedness, a model which is sufficiently constrained will never show unboundedness regardless of the cost. Also, as the analysis is done at the start of the optimization to establish a penalty cost, significant changes in the coefficients, or a high degree of nonlinearity, may invalidate the initial analysis. A setting for xslp_objToPenaltyCost of zero disables the analysis. A setting of 3 or 4 has proved successful for many models. If xslp_objToPenaltyCost cannot be used because of the problem structure, its effect can still be emulated by some initial experiments to establish the cost required to avoid unboundedness, and then manually applying a suitable factor. If the problem is initially unbounded, then the penalty cost will be increased until either it reaches its maximum or the problem becomes bounded.

Range: [0, ∞]

Default: 0

xslp_oCount (integer): Number of SLP iterations over which to measure objective function variation for static objective (2) convergence criterion ↵

The static objective (2) convergence criterion does not measure convergence of individual variables. Instead, it measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables interacting with active constraints (those that have a marginal value of at least xslp_mvTol) have converged. The rationale is that if the remaining unconverged variables are not involved in active constraints and if the objective function is not changing significantly between iterations, then the solution is more-or-less practical. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_oCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_oTol_a then the problem has converged on the absolute static objective (2) convergence criterion. The static objective function (2) test is applied only if xslp_oCount is at least 2.

Range: {0, ..., ∞}

Default: 5

xslp_optimalityTolTarget (real): When set, this defines a target optimality tolerance to which the linearizations are solved to ↵

This is a soft version of optimalityTol, and will dynamically revert back to optimalityTol if the desired accuracy could not be achieved.

Range: [0, ∞]

Default: not set

xslp_oTol_a (real): Absolute static objective (2) convergence tolerance ↵

The static objective (2) convergence criterion does not measure convergence of individual variables. Instead, it measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables interacting with active constraints (those that have a marginal value of at least xslp_mvTol) have converged. The rationale is that if the remaining unconverged variables are not involved in active constraints and if the objective function is not changing significantly between iterations, then the solution is more-or-less practical. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_oCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ xslp_oTol_a then the problem has converged on the absolute static objective (2) convergence criterion. The static objective function (2) test is applied only if xslp_oCount is at least 2. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default: auto

xslp_oTol_r (real): Relative static objective (2) convergence tolerance ↵

The static objective (2) convergence criterion does not measure convergence of individual variables. Instead, it measures the significance of the changes in the objective function over recent SLP iterations. It is applied when all the variables interacting with active constraints (those that have a marginal value of at least xslp_mvTol) have converged. The rationale is that if the remaining unconverged variables are not involved in active constraints and if the objective function is not changing significantly between iterations, then the solution is more-or-less practical. The variation in the objective function is defined as δObj = MAXIter(Obj) - MINIter(Obj) where Iter is the xslp_oCount most recent SLP iterations and Obj is the corresponding objective function value. If ABS(δObj) ≤ AVGIter(Obj)*xslp_oTol_r then the problem has converged on the relative static objective (2) convergence criterion. The static objective function (2) test is applied only if xslp_oCount is at least 2. When the value is set to be negative, the value is adjusted automatically by SLP, based on the optimality target xslp_validationTarget_k. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default: auto

xslp_penaltyInfoStart (integer): Iteration from which to record row penalty information ↵

Information about the size (current and total) of active penalties of each row and the number of times a penalty vector has been active is recorded starting at the SLP iteration number given by xslp_penaltyInfoStart.

Range: {0, ..., ∞}

Default: 3

xslp_postsolve (integer): Determines whether postsolving should be performed automatically ↵

Default: -1

value meaning
-1 Postsolve if the problem could be solved to optimality/infeasibility.
0 Do not automatically postsolve.
1 Postsolve automatically.

xslp_presolve (integer): Determines whether presolving should be performed prior to starting the main algorithm ↵

The Xpress NonLinear nonlinear presolve (which is carried out once, before augmentation) is independent of the Optimizer presolve (which is carried out during each SLP iteration).

Default: 1

value meaning
0 Disable SLP presolve.
1 Activate SLP presolve.
2 Low memory presolve. Original problem is not restored by postsolve and dual solution may not be completely postsolved.

xslp_presolveLevel (integer): Determines the level of changes presolve may carry out on the problem and whether column/row indices may change ↵

xslp_presolveOps controls the operations carried out in presolve. xslp_presolveLevel controls how those operations may change the problem. xslp_presolve controls whether presolve is performed at all.

Default: 4

value meaning
1 Individual rows only presolve, no dropped columns/rows or index changes, no nonlinear transformations (XSLP_PRESOLVELEVEL_LOCALIZED).
2 All linear presolve that does not drop columns/rows, no index changes, no nonlinear transformations (XSLP_PRESOLVELEVEL_BASIC).
3 Full linear presolve including dropping columns/rows and index changes, no nonlinear transformations (XSLP_PRESOLVELEVEL_LINEAR).
4 Full presolve (XSLP_PRESOLVELEVEL_FULL).

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_presolve_elimTol (real): Tolerance for nonlinear eliminations during SLP presolve ↵

Any eliminations on smaller coefficients will be rejected.

Range: [0, ∞]

Default: 0.001

xslp_primalIntegralAlpha (real): Decay term for primal integral computation ↵

This control represents the exponential decay term for computing the primal integral. The smaller it is, the more emphasis is put on the early part of the search. A value of 0 corresponds to computing a regular primal integral without exponential decay. For details see Berthold and Csizmadia: The confined primal integral, Mathematical Programming volume 188(2), pp. 523–537, 2021.

Range: [0, ∞]

Default: 0

xslp_primalIntegralRef (real): Reference solution value to take into account when calculating the primal integral ↵

When a global optimum is known, this can used to calculate a globally valid primal integral. It can also be used to indicate the target objective value still to be taken into account in the integral.

Range: [-∞, ∞]

Default: 1e+20

xslp_probing (integer): Determines whether probing on a subset of variables should be performed prior to starting the main algorithm ↵

Probing runs multiple times bound reduction in order to further tighten the bounding box.

The Xpress NonLinear nonlinear probing, which is carried out once, is independent of the Optimizer presolve (which is carried out during each SLP iteration). The probing level allows for probing on an expanding set of variables, allowing for probing on all variables (level 5) or only those for which probing is more likely to be useful (binary variables).

Default: auto

value meaning
-1 Automatic.
0 Disable SLP probing.
1 Activate SLP probing only on binary variables.
2 Activate SLP probing only on binary or unbounded integer variables.
3 Activate SLP probing only on binary or integer variables.
4 Activate SLP probing only on binary, integer variables, and unbounded continuous variables.
5 Activate SLP probing on any variable.

xslp_sameCount (integer): Number of steps reaching the step bound in the same direction before step bounds are increased ↵

If step bounding is enabled, the step bound for a variable will be increased if successive changes are in the same direction. More precisely, if there are xslp_sameCount successive changes reaching the step bound and in the same direction for a variable, then the step bound (B) for the variable will be reset to B*xslp_expand.

Range: {0, ..., ∞}

Default: 3

xslp_sameDamp (integer): Number of steps in same direction before damping factor is increased ↵

If dynamic damping is enabled, the damping factor for a variable will be increased if successive changes are in the same direction. More precisely, if there are xslp_sameDamp successive changes in the same direction for a variable, then the damping factor (D) for the variable will be reset to D*xslp_dampExpand + xslp_dampMax*(1-xslp_dampExpand)

Range: {0, ..., ∞}

Default: 3

xslp_sbStart (integer): SLP iteration after which step bounds are first applied ↵

If step bounds are used, they can be applied for the whole of the SLP optimization process, or started after a number of SLP iterations. In general, it is better not to apply step bounds from the start unless one of the following applies: (1) the initial estimates are known to be good, and explicit values can be provided for initial step bounds on all variables; or (2) the problem is unbounded unless all variables are step-bounded.

Range: {0, ..., ∞}

Default: 8

xslp_scale (integer): When to re-scale the SLP problem ↵

During the SLP optimization, matrix entries can change considerably in magnitude, even when the formulae in the coefficients are not very nonlinear. Re-scaling of the matrix can reduce numerical errors, but may increase the time taken to achieve convergence.

Default: 1

value meaning
0 No re-scaling.
1 Re-scale every SLP iteration up to xslp_scaleCount iterations after the end of barrier optimization.
2 Re-scale every SLP iteration up to xslp_scaleCount iterations in total.
3 Re-scale every SLP iteration until primal simplex is automatically invoked.
4 Re-scale every SLP iteration.
5 Re-scale every xslp_scaleCount SLP iterations.
6 Re-scale every xslp_scaleCount SLP iterations after the end of barrier optimization.

xslp_scaleCount (integer): Iteration limit used in determining when to re-scale the SLP matrix ↵

If xslp_scale is set to 1 or 2, then xslp_scaleCount determines the number of iterations (after the end of barrier optimization or in total) in which the matrix is automatically re-scaled.

Range: {0, ..., ∞}

Default: 0

xslp_shrink (real): Multiplier to reduce a step bound ↵

If step bounding is enabled, the step bound for a variable will be decreased if successive changes are in opposite directions. The step bound (B) for the variable will be reset to B*xslp_shrink. If the step bound is already below the strict (delta or closure) tolerances, it will not be reduced further.

Range: [0, 1]

Default: 0.5

xslp_shrinkBias (real): Defines an overwrite / adjustment of step bounds for improving iterations ↵

Positive values overwrite xslp_shrink only if the objective is improving. A negative value is used to scale all step bounds in improving iterations.

Range: [-∞, ∞]

Default: not set

xslp_slpLog (integer): Frequency with which SLP status is printed ↵

If xslp_log is set to zero (minimal logging) then a nonzero value for xslp_slpLog defines the frequency (in SLP iterations) when summary information is printed out.

Range: {0, ..., ∞}

Default: 1

xslp_solver (integer): Selects the library to use for local solves ↵

The presence of KNITRO is detected automatically. KNITRO can be used to solve any problem loaded into XSLP, independently from how the problem was loaded. xslp_solver is set to automatic, Xpress SLP will be selected if any SLP specific construct has been loaded (these are ignored if KNITRO is selected manually). When solving problems to global optimality, the xslp_solver control is used to decide which local solver to call for reoptimizing NLP- infeasible solutions heuristically.

Default: auto

value meaning
-1 Automatic selection, based on model characteristics and solver availability
0 Use Xpress-SLP (always available)
1 Use Knitro if available
2 Use Xpress-Optimizer if possible (convex quadratic problems only)

xslp_sTol_a (real): Absolute slack convergence tolerance ↵

The slack convergence criterion is identical to the impact convergence criterion, except that the tolerances used are xslp_sTol_a (instead of xslp_iTol_a) and xslp_sTol_r (instead of xslp_iTol_r). See xslp_iTol_a for a description of the test. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default: auto

xslp_sTol_r (real): Relative slack convergence tolerance ↵

The slack convergence criterion is identical to the impact convergence criterion, except that the tolerances used are xslp_sTol_a (instead of xslp_iTol_a) and xslp_sTol_r (instead of xslp_iTol_r). See xslp_iTol_r for a description of the test. When the value is set to be negative, the value is adjusted automatically by SLP, based on the feasibility target xslp_validationTarget_r. Good values for the control are usually fall between 1e-3 and 1e-6.

Range: [-∞, ∞]

Default: auto

xslp_stopOutOfRange (boolean): Stop optimization and return error code if internal function argument is out of range ↵

If xslp_stopOutOfRange is set to 1, then if an internal function receives an argument which is out of its allowable range (for example, LOG of a negative number), an error code is set and the optimization is terminated.

Default: 0

xslp_threads (integer): Default number of threads to be used ↵

Overall thread control value, used to determine the number of threads used where parallel calculations are possible.

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

Default: auto

xslp_unfinishedLimit (integer): Number of consecutive SLP iterations that may have an unfinished status before the solve is terminated ↵

If the optimization of the current linear approximation terminates with an "unfinished" status, then first a number of strategies are applied to attempt a successful solve of the same linearization. If this fails, then a new iteration is started to change the linearization itself. This control limits the numner of such repeated attempts.

Range: {0, ..., ∞}

Default: 3

xslp_validationFactor (real): Minimum improvement in validation targets to continue iterating ↵

Range: [0, ∞]

Default: 0.001

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_validationTol_a (real): Absolute tolerance for the XSLPvalidate procedure (may be used by Xpress Global internally) ↵

Range: [0, ∞]

Default: 1e-05

xslp_validationTol_k (real): Relative tolerance for the XSLPvalidatekkt procedure (may be used by Xpress Global internally) ↵

Range: [0, ∞]

Default: 1e-05

xslp_validationTol_r (real): Relative tolerance for the XSLPvalidate procedure (may be used by Xpress Global internally) ↵

Range: [0, ∞]

Default: 1e-05

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. Users with a floating XPRESS license will have to construct the xpauth.xpr themselves with content use_server name="<servername>". Here, <servername> is the name of the license server machine.

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