Table of Contents
- Introduction
- Usage
-
Summary of XPRESS Options
- General LP / MIP / QP Options
- Hardware Related Options
- Presolve Options
- Scaling Options
- LP Options
- QP Options
- Newton-barrier Options
- Global Solver Options
- MIP Options
- MIP Cuts Options
- MIP Heuristics Options
- MIP Solution Pool Options
- General NLP / MINLP Options
- NLP Presolve Options
- NLP Augmentation and Linearization Options
- NLP Barrier Options
- NLP Penalty Options
- NLP Step Bounds Options
- NLP Variable Update Options
- NLP Termination Options
- NLP Multistart Options
- NLP Derivative Options
- NLP Log Options
- MINLP Options
- KNITRO Options
- Primal Dual Hybrid Gradient Options
- Tuner Options
- IIS Options
- Detailed Descriptions of XPRESS Options
- Helpful Hints
- Setting up a GAMS/XPRESS-Link license
Introduction
The GAMS/XPRESS solver is based on the XPRESS Optimization Subroutine Library, and runs only in conjunction with the GAMS modeling system. GAMS/XPRESS (also simply referred to as XPRESS) is a versatile, high-performance optimization system. The system integrates:
- a powerful simplex-based LP solver.
- a MIP module with cut generation for integer programming problems.
- a barrier module implementing a state-of-the-art interior point algorithm for very large LP problems.
- a sequential linear programming solver (SLP) for (mixed-integer) nonlinear programs NLP, CNS and MINLP.
- a global MINLP solver.
The GAMS/XPRESS solver is installed automatically with your GAMS system. There are different license options:
- GAMS/XPRESS-MIP:
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 defaultalg 3 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, reRun, and reslim control the behavior of the GAMS/XPRESS link. The options crash, lpIterlimit, presolve, scalingMethod, threads, and trace set XPRESS library control variables, and can be used to fine-tune XPRESS. See section General LP / MIP / QP Options for more details of XPRESS general options.
LP
See section LP Options for more details of XPRESS library control variables which can be used to fine-tune the XPRESS LP solver.
MIP
In some cases, the branch-and-bound MIP algorithm will stop with a proven optimal solution or when unboundedness or (integer) infeasibility is detected. In most cases, however, the global search is stopped through one of the generic GAMS options:
- iterlim (on the cumulative pivot count) or reslim (in seconds of CPU time),
- optca & optcr (stopping criteria based on gap between best integer solution found and best possible) or
- nodlim (on the total number of nodes allowed in the B&B tree).
It is also possible to set the maxNode and maxMipSol options to stop the global search: see section MIP Options for XPRESS control variables for MIP. The options loadMipSol, mipCleanup, mipTrace, mipTraceNode, and mipTraceTime control the behavior of the GAMS/XPRESS link on MIP models. The other options in section MIP Options set XPRESS library control variables, and can be used to fine-tune the XPRESS MIP solver.
MIP Solution Pool
Typically, XPRESS collects multiple solutions in its solution pool during MIP solves, global solves, and SLP-in-MIP solves, but only the final solution is returned to GAMS. The additional solutions can be exported for later processing with the options solnpool (a GDX index file with one GDX file per solution, named by solnpoolPrefix) and solnpoolmerge (all solutions in one GDX file).
The number of collected solutions is limited by poolLimit (default 10, -1 collects all solutions found). The options poolAbsGap and poolRelGap limit the absolute and relative gap between the objective values of the best and the worst solution in the pool.
By default, only the solutions found by the normal branch-and-bound search are collected. With poolEnumStrategy set to 1 or 2, the branch-and-bound search is extended to enumerate additional solutions. The enumeration is restricted to MIP entities (binary, integer, semi-continuous, and semi-integer variables), and poolDuplicateCheck determines which of them are compared when checking whether two solutions are duplicates. When solution enumeration is enabled, the relative and absolute gap of the stopping criteria (optcr and optca) refer to the gap between the best bound on any solution that can still be found and the worst solution that can still be added to the pool. For example, the \(N\)-best solutions are found with poolEnumStrategy 2 and poolLimit \(N\), and all solutions within a gap of the optimal objective value are found with poolEnumStrategy 2, poolLimit -1, and poolAbsGap or poolRelGap.
See Accessing the Solution Pool for the GDX index-file format and an example of reading the exported solutions. Use the export options for this solver rather than the CPLEX options shown there.
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
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:
- Strict convergence: Describes the numerical behaviour of convergence in the formal, mathematical sense. User options: xslp_cTol, xslp_aTol_a, xslp_aTol_r.
- Extended convergence: Measures the quality of the linearization, including the effect of changes to the nonlinear terms that contribute to a variable in the linearization: User options: xslp_mTol_a, xslp_mTol_r, xslp_iTol_a, xslp_iTol_r, xslp_sTol_a, xslp_sTol_r.
When each variable has converged in one of the above cases, XPRESS SLP terminates based on the following stopping criteria:
- Baseline static objective convergence measure that compares changes in the objective over a given number of iterations relative to the average objective value. User options: xslp_vCount, xslp_vLimit, xslp_vTol_a, xslp_vTol_r.
- Static objective convergence measure that is applied when there are no unconverged variables in active constraints. User options: xslp_oCount, xslp_oTol_a, xslp_oTol_r.
- Static objective convergence measure that is applied when a practical 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 xslp_convergenceOps 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. For supported XPRESS Knitro options, see Knitro Options.
For more information about this nonlinear programming solver, see also the GAMS/Knitro documentation.
Summary of XPRESS Options
General LP / MIP / QP Options
| Option | Description | Default |
|---|---|---|
| advBasis | Use advanced basis provided by GAMS | 1 |
| basisOut | Directs optimizer to output an MPS basis file | |
| clamping | Bit-vector control allows for the adjustment of returned solution values such that they are always within bounds | 0 |
| clamping_dual | Adjust dual solution to always be within the dual bounds implied by the slacks | 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 primal slack values to always be within constraint bounds | 0 |
| cpiAlpha | Decay term for confined primal integral computation | 0 |
| cpuTime | How time should be measured when timings are reported in the log and when checking against time limits | 0 |
| deterministicLog | Suppress non-deterministic log information in the standard MIP log | 0 |
| escapeNames | If characters illegal to an mps or lp file should be escaped to guarantee readability, and whether escaped characters should be transformed back when reading such a file | 1 |
| freegamsmodel | Preserves memory by dumping the GAMS model instance representation temporarily to disk | 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 | Zero tolerance for input values | 0 |
| ioTimeout | Maximum number of seconds to wait for an I/O operation before it is cancelled | 30 |
| lpIterLimit | Simplex: 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 | -1 |
| maxPageLines | Number of lines between page breaks in printable output | 23 |
| maxScaleFactor | Determines the maximum scaling factor that can be applied during scaling | 64 |
| maxTotalTreeFilesize | Maximum amount of disk space, in megabytes (MB), that can be used for storing tree data for a single problem | 2147483647 |
| mipStopStage | Allows stopping a MIP solve in an early stage of the solution process | 0 |
| mps18Compatible | Provides compatibility of MPS file output for older MPS readers | 0 |
| mpsNameLength | Maximum length of MPS names in characters | 0 |
| mpsOutputFile | Name of MPS output file | |
| multiObjLog | Log level for multi-objective optimization | 2 |
| multiObjOps | Modifies the behaviour of the Optimizer when solving multi-objective problems | 7 |
| multiObjOps_enabled | Multi-objective enabled | 1 |
| multiObjOps_noSolveAttribs | If this bit is set, the Optimizer will not save the problem attributes after each objective is solved, which reduces memory usage | 0 |
| multiObjOps_presolve | Apply multi-objective modifications during presolve | 1 |
| multiObjOps_rcFixing | Reduced cost fixing | 1 |
| multobj | Controls the hierarchical optimization of multiple objectives | 0 |
| numericalEmphasis | How much emphasis to place on numerical stability instead of solve speed | -1 |
| objnabstol | Allowable absolute degradation for objective | |
| objnreltol | Allowable relative degradation for objective | |
| 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 |
| qextractdenseswitchfactor | Sparse/dense factor for quadratic extraction algorithm in GAMS interface | 0.008 |
| qextractdenseswitchlog | Enables additional information about sparse/dense factor choice in 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 |
| 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 |
| workLimit | Maximum work (measured in work units) that the Optimizer will run before it terminates | 1e+20 |
| writePrtSol | Directs optimizer to output a "printsol" file | 0 |
Hardware Related Options
| Option | Description | Default |
|---|---|---|
| backgroundMaxThreads | Limits the number of threads to use in background jobs (for example in parallel to the root cut loop) | -1 |
| backgroundSelect | Bit-vector control to select which tasks to run in background jobs (for example in parallel to the root cut loop) | -1 |
| barCores | Determines the number of physical CPU cores assumed to be present in the system by the barrier and hybrid gradient algorithms | -1 |
| 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 | 0 |
| barThreads | Determines the number of threads implemented to run the Newton-barrier and hybrid gradient algorithms | -1 |
| concurrentThreads | Determines the number of threads used by the concurrent solver | -1 |
| coresPerCpu | Used to override the number of cores assumed to be present on a CPU | -1 |
| 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 | -1 |
| dualThreads | Determines the maximum number of threads that dual simplex is allowed to use | -1 |
| gpuCUDADevice | Controls which CUDA device should be used when GPU execution is enabled and there are multiple CUDA devices installed in a system | -1 |
| gpuPlatform | Controls what kind of GPU support is enabled overall in Xpress | 1 |
| heurSearchBackgroundSelect | Bit-vector control to 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 MB (megabytes) the Optimizer should allocate | 0 |
| maxMemorySoft | When resourceStrategy is enabled, this control sets the maximum amount of memory in megabytes (MB) the Optimizer targets to allocate | 0 |
| mipThreads | If set to a positive integer it determines the number of threads implemented to run the parallel MIP code | -1 |
| 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 tree 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 MB (megabytes), for the amount of memory to use in storing the branch and bound search tree | 0 |
| 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: Bit-vector 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 | -1 |
| 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 | -1 |
| maxImpliedBound | Presolve: When tighter bounds are calculated during MIP or nonlinear 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 at nodes | -1 |
| mipPresolve_globalCoefTightening | Allow global (non-bound) tightening of the problem during the tree search | 1 |
| mipPresolve_objBasedReductions | Objective function will be used to find reductions at each node | 1 |
| mipPresolve_symmetryReductions | Allow that symmetry is used to presolve the node problem | 1 |
| nodeAppliedBounds | Determines whether the solver is allowed to apply primal reductions at each node | -1 |
| nodeDualReductions | Determines whether the solver is allowed to apply dual reductions at each node | -1 |
| nodePresolve | Determines whether some form of presolving should be performed at Branch and Bound nodes | -1 |
| nodeRedCostTighten | Determines whether reduced cost tightening is applied during Branch and Bound | -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) | -1 |
| 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 | -1 |
| preBndRedQuad | Determines if convex quadratic constraints should be used for inferring bound reductions on variables when solving a MIP | -1 |
| preCliqueLifting | Presolve: Determines whether to do clique lifting | -1 |
| 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 | -1 |
| 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 | -1 |
| preConfiguration | MIP Presolve: Determines whether binary rows with only few repeating coefficients should be reformulated | -1 |
| preConvertObjToCons | Presolve: Convert a linear or quadratic objective function into an objective transfer constraint | -1 |
| preConvertSeparable | Presolve: Reformulate problems with a non-diagonal quadratic objective and/or constraints as diagonal quadratic or second-order conic constraints | -1 |
| preDomCol | Presolve: Determines the level of dominated column removal reductions to perform when presolving a mixed integer problem | -1 |
| preDomRow | Presolve: Determines the level of dominated row removal reductions to perform when presolving a problem | -1 |
| preDualReductions | Determines whether the solver is allowed to apply dual reductions during presolve | -1 |
| preDupRow | Presolve: Determines the type of duplicate rows to look for and eliminate when presolving a problem | -1 |
| preEliminations | Presolve: Determines whether to perform variable eliminations | -1 |
| preElimQuad | Presolve: Allows for elimination of quadratic variables via doubleton rows | -1 |
| preFolding | Presolve: Determines if a folding procedure should be used to aggregate continuous columns in an equitable partition | -1 |
| preImplications | Presolve: Determines whether to use implication structures to remove redundant rows | -1 |
| preLinDep | Presolve: Determines whether to check for and remove linearly dependent equality constraints when presolving a problem | -1 |
| preMIPEntDetect | Presolve: Determines whether to do integer variable and SOS detection | -1 |
| preMIPReductions | Presolve: Determines whether to do integrality based reductions | -1 |
| 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 |
| prePermute | Bit-vector control specifies whether to randomly permute rows, columns and MIP entities when starting the presolve | 0 |
| prePermuteSeed | Specifies the seed for the pseudo-random number generator for permuting the problem when starting the presolve | 1 |
| prePermute_cols | Permute columns | 0 |
| prePermute_mip | Permute MIP entities | 0 |
| prePermute_rows | Permute rows | 0 |
| preProbing | Presolve: Amount of probing to perform on binary variables during presolve | -1 |
| 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 | Bit-vector control specifies the operations which are performed during the presolve | 511 |
| presolveOps_duplicateColRemoval | Duplicate column removal | 1 |
| presolveOps_duplicateRowRemoval | Duplicate row removal | 1 |
| presolveOps_forcingRowRemoval | Forcing row removal | 1 |
| presolveOps_noGlobalDomainChange | No domain changes for MIP entities (e.g., semi-continuous detection or shifting integers) | 0 |
| presolveOps_noImpliedBounds | No implied bounds | 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 |
| presolvePasses | Number of reduction rounds to be performed in presolve | 1 |
| preSort | Bit-vector control specifies whether to sort rows, columns and MIP entities by their names when starting the presolve | 0 |
| preSort_cols | Sort columns | 0 |
| preSort_mip | Sort MIP entities | 0 |
| preSort_rows | Sort rows | 0 |
| rootPresolve | Determines if presolving should be performed on the problem after the tree search has finished with root cutting and heuristics | -1 |
| siftPresolveOps | Determines the presolve operations for solving the subproblems during the sifting algorithm | -1 |
Scaling Options
| Option | Description | Default |
|---|---|---|
| barFreeScale | Defines how the barrier algorithm scales free variables | 1e-06 |
| barObjScale | Defines how the barrier scales the objective | -1 |
| barRhsScale | Defines how the barrier scales the right hand side | -1 |
| objScaleFactor | Custom objective scaling factor, expressed as a power of 2 | 0 |
| scalingBigM | Whether to apply special handling of big-M rows during scaling | -1 |
| scalingMethod | Which scaling method to use | -1 |
| scalingOps | Bit-vector control allows finer-grained control of the scaling process | 3 |
| scalingOps_colScaling | Column scaling | 1 |
| scalingOps_disableGlobalObjScaling | Do not apply automatic objective scaling | 0 |
| scalingOps_ignoreQuadRowPart | Exclude the quadratic part of constraint when calculating scaling factors | 0 |
| scalingOps_noAggressiveQScaling | Disable aggressive quadratic scaling | 0 |
| scalingOps_noScalingColsDown | Do not scale columns down | 0 |
| scalingOps_noScalingRowsUp | Do not scale rows up | 0 |
| scalingOps_rhsScaling | RHS scaling | 0 |
| scalingOps_rowScaling | Row scaling | 1 |
| scalingOps_rowScalingAgain | Row scaling again | 0 |
| scalingOps_slackScaling | Enable explicit linear slack scaling | 0 |
| scalingOrder | When scaling is applied relative to presolve | -1 |
LP Options
| Option | Description | Default |
|---|---|---|
| algAfterNetwork | Algorithm to be used for the clean up step after the network simplex solver | -1 |
| autoPerturb | Simplex: Indicates whether automatic perturbation is performed | 1 |
| bigM | Infeasibility penalty used if the "Big M" method is implemented | 1024 |
| 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 | 1 |
| dualGradient | Simplex: Dual simplex pricing method | -1 |
| dualPerturb | Factor by which the problem will be perturbed prior to optimization by dual simplex | -1 |
| dualStrategy | Bit-vector control specifies the dual simplex strategy | 1 |
| etaTol | Zero tolerance for eta vector 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 | -1 |
| invertMin | Minimum number of Simplex iterations between full inversions of the basis matrix | 3 |
| lpBackgroundThreads | Maximum number of threads to use for background work (typically heuristics) in parallel to the root LP relaxation of a MIP | -1 |
| 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 or barAlg=5 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 for 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 | -1 |
| optimalityTol | Simplex: Zero tolerance for reduced costs | 1e-06 |
| optimalityTolTarget | Target optimality tolerance for the solution refiner | 0 |
| penalty | Minimum absolute penalty variable coefficient | 0 |
| pivotTol | Simplex: Zero tolerance for pivot elements | 1e-09 |
| ppFactor | Partial pricing candidate list sizing parameter | 1 |
| pricingAlg | Simplex: Determines the primal simplex pricing method | 0 |
| 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 | -1 |
| 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 | -1 |
| 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 via a bit-vector | 0 |
| quadraticUnshift | Determines whether an extra solution purification step is called after a solution found by the quadratic simplex (either primal or dual) | -1 |
| repairIndefInitEq | Controls if the Optimizer should make indefinite quadratic matrices over binary columns 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 | 1 |
| barAlg | Determines which barrier algorithm is used to solve the problem | -1 |
| 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 | 0 |
| barFailIterLimit | Newton barrier: Maximum number of consecutive iterations that fail to improve the solution in the barrier algorithm | 0 |
| barGapStop | Newton barrier and hybrid gradient: Convergence parameter, representing the tolerance for the relative duality gap | 0 |
| barGapTarget | Newton barrier: Target tolerance for the relative duality gap | 0 |
| barIndefLimit | Newton Barrier: Limits the number of consecutive indefinite barrier iterations that will be performed | 15 |
| barIterative | Maximum number of barrier iterations in which an iterative solver is used instead of the Cholesky decomposition | -2 |
| barIterLimit | Newton barrier: Maximum number of iterations | 500 |
| barKernel | Newton barrier: Defines how centrality is weighted in the barrier algorithm | 0 |
| barLargeBound | Threshold for the barrier to handle large bounds | 0 |
| barObjPerturb | Defines how the barrier perturbs the objective | 1e-06 |
| barOrder | Newton barrier: Controls the Cholesky factorization in the Newton-Barrier | 0 |
| 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 | 0 |
| barRefIter | Newton barrier: After terminating the barrier algorithm, further refinement steps can be performed | 0 |
| barRegularize | Bit-vector control 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 | 0 |
| barStartWeight | Newton barrier: Sets the weight for the warm-start point when warm-start is set for the barrier algorithm | 0.85 |
| barStepStop | Newton barrier: Convergence parameter, representing the minimal step size | 1e-16 |
| choleskyAlg | Newton barrier: Type of Cholesky factorization used; bit-vector-control | -1 |
| 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 | -1 |
| 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 | 0 |
Global Solver Options
| Option | Description | Default |
|---|---|---|
| globalConvCutMaxRounds | Number of rounds of outer approximation and convexification cuts separated at the root node of the branch-and-bound tree search, when solving an (MI)NLP to global optimality | -1 |
| globalConvCutMaxTreeRounds | Number of rounds of outer approximation and convexification cuts separated at a node of the branch-and-bound tree search other than the root node, when solving an (MI)NLP to global optimality | -1 |
| globalInitCutStrategy | Strategy for the initial tangent/secant convexification cuts added per nonlinear operator when setting up the initial LP relaxation during a global solve | -1 |
| 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 | -1 |
| globalMISLPHeurStrategy | Controls how aggressively a set of MISLP-based root heuristics are run at the root node when solving an (MI)NLP to global optimality | -1 |
| globalPresolveOBBT | Controls the amount of work performed by Optimization-Based Bound Tightening (OBBT) | -1 |
| globalSpatialBranchCuttingEffort | Limits the effort that is spent on creating cuts during spatial branching | -1 |
| globalSpatialBranchIfPreferOrig | Whether spatial branchings on original variables should be preferred over branching on auxiliary variables that were introduced by the reformulation of the global solver | -1 |
| globalSpatialBranchPropagationEffort | Limits the effort that is spent on propagation during spatial branching | -1 |
| heurSearchCopyControls | Select how user-set controls should affect the subproblems solved by large neighborhood search (LNS) heuristics | 1 |
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 | -1 |
| 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 | -1 |
| 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 root node | -1 |
| 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 | -1 |
| 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 | -1 |
| 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 | 3 |
| maxLocalBacktrack | Branch-and-Bound: How far back up the current dive path the Optimizer is allowed to look for a local backtrack candidate node | -1 |
| maxMipSol | Branch and Bound: Specifies a 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 | -1 |
| 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 |
| maxTreeFileSize | Maximum size, in megabytes (MB), to which a single tree file may grow | 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 | 0 |
| 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 | max(-mipabsstop,-1E-05) |
| mipCleanup | Clean up the MIP solution (round-fix-solve) to get duals | 0 |
| mipComponents | Determines whether disconnected components in a MIP should be solved as separate MIPs | -1 |
| mipConcurrentNodes | Sets the node limit for when a winning solve is selected when concurrent MIP solves are enabled | -1 |
| 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 | -1 |
| 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 | -1 |
| mipRefineIterLimit | Defines an effort limit expressed as simplex iterations for the MIP solution refiner | -1 |
| 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 | min(miprelstop,1E-04) |
| 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 | -1 |
| 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 | |
| mipstopexprnodestep | Node interval that triggers stop expression evaluation | 100 |
| mipstopexprsolutiontol | Solution improvement that triggers stop expression evaluation | 1e-6 |
| mipstopexprtimestep | Time interval that triggers stop expression evaluation | 1 |
| mipstopexprverbosity | Verbosity level of stop expression | 0 |
| 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 | |
| mipTraceIncumbent | Minimal absolute improvement in primal bound, between MIP trace file I entries | 1e-6 |
| mipTraceNode | Node interval between MIP trace file N entries | 100 |
| mipTraceTime | Time interval, in seconds, between MIP trace file T entries | 5 |
| miqcpAlg | Determines which algorithm is to be used to solve mixed integer quadratic constrained and mixed integer second order cone problems | -1 |
| 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 | 4 |
| 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 | -1 |
| refactor | Indicates whether the optimization should restart using the current representation of the factorization in memory | -1 |
| sbBest | Number of infeasible MIP entities to initialize pseudo costs for on each node | -1 |
| 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 | -1 |
| sbIterLimit | Number of dual iterations to perform during strong branching for each MIP entity | -1 |
| 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 |
| treeDiagnostics | Bit-vector providing control over how various tree-management-related messages get printed in the tree log file during the branch-and-bound search | 7 |
| treeDiagnostics_memorySavedReports | Output messages whenever tree data is being written to tree file | 1 |
| treeDiagnostics_memorySavedReportsInterval | Output progress messages while tree data is being written to the tree file, at an interval controlled by the treeFileLogInterval control | 1 |
| treeDiagnostics_memoryUsageSummaries | Output regular summaries of current tree memory usage | 1 |
| treeFileLogInterval | Sets the interval between progress messages output while writing tree data to the tree file, in seconds | 60 |
| 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 | -1 |
MIP Cuts Options
| Option | Description | Default |
|---|---|---|
| alternativeLPSols | Controls the collection of alternative LP solutions for cut separation and heuristics | -1 |
| autoCutting | Automatically decide whether to generate cutting planes at local nodes in the tree | -1 |
| conflictCuts | Branch and Bound: Specifies how cautious or aggressive the Optimizer should be when searching for and applying conflict cuts | -1 |
| cutAggRows | Strategy for row aggregation used when separating Mixed Integer Rounding (MIR) cuts, lifted cover cuts and Strong Chvatal-Gomory (CG) cuts | -1 |
| cutDepth | Branch and Bound: Sets the maximum depth in the tree search at which cuts will be generated | -1 |
| cutFactor | Limit on the number of cuts and cut coefficients the Optimizer is allowed to add to the matrix during tree search | -1 |
| cutFreq | Branch and Bound: Frequency at which cuts are generated in the tree search | -1 |
| cutFromCutRows | Strategy to decide whether cutting planes already added to the matrix may themselves be used as base rows for separating new Mixed Integer Rounding (MIR) cuts, lifted cover cuts and Strong Chvatal-Gomory (CG) cuts | -1 |
| cutGomMaxRounds | Number of rounds of Gomory cuts or lift-and-project cuts separated at the root node of the branch-and-bound tree search | -1 |
| cutGomMaxTreeRounds | Number of rounds of Gomory cuts or lift-and-project cuts separated at a node of the branch-and-bound tree search other than the root node | -1 |
| cutMaxRounds | Number of rounds of cuts separated at the root node of the branch-and-bound tree search, for all MIP cut separators except Gomory cuts | -1 |
| cutMaxTreeRounds | Number of rounds of cuts separated at a node of the branch-and-bound tree search other than the root node, for all MIP cut separators except Gomory cuts | -1 |
| cutOAMaxRounds | Number of rounds of Outer Approximation (OA) cuts for convex quadratic problems and for Second Order Cone Programs (SOCPs) separated at the root node of the branch-and-bound tree search | -1 |
| cutOAMaxTreeRounds | Number of rounds of Outer Approximation (OA) cuts for convex quadratic problems and for Second Order Cone Programs (SOCPs) separated at a node of the branch-and-bound tree search other than the root node | -1 |
| cutSepCliqueStrategy | Strategy for separation of clique cuts | -1 |
| cutSepCoverStrategy | Strategy for separation of lifted cover cuts | -1 |
| cutSepFarkasStrategy | Strategy for separation of Farkas cuts | -1 |
| cutSepFlowPathStrategy | Strategy for separation of flow path cuts | -1 |
| cutSepGomoryStrategy | Strategy for separation of Gomory cuts | -1 |
| cutSepGUBCoverStrategy | Strategy for separation of lifted GUB cover cuts | -1 |
| cutSepImplBoundStrategy | Strategy for separation of implication cuts | -1 |
| cutSepMCFStrategy | Strategy for separation of Multi-Commodity Flow (MCF) cuts | -1 |
| cutSepMIRStrategy | Strategy for separation of Mixed Integer Rounding (MIR) cuts | -1 |
| cutSepPathMixStrategy | Strategy for separation of path mixing cuts | -1 |
| cutSepRLTStrategy | Strategy for separation of Reformulation-Linearization Technique (RLT) cuts | -1 |
| cutSepSDPStrategy | Strategy for separation of semidefinite programming (SDP) cuts | -1 |
| cutSepStrategy | Meta control specifying the cut separation strategy for every individual CUTSEP*STRATEGY control left at its default value of -1 (automatic) | -1 |
| cutSepStrongCGStrategy | Strategy for separation of Strong Chvatal-Gomory (CG) cuts | -1 |
| cutSepZeroHalfStrategy | Strategy for separation of zero-half cuts | -1 |
| cutStrategy | Branch and Bound: General cut strategy in terms of limits on the number of cuts and of non-zero cut elements that can be added to the problem | -1 |
| lnpBest | Maximum number of infeasible MIP entities to create lift-and-project cuts for during each round of Gomory cuts at the root node (see GOMCUTS) | 50 |
| lnpIterLimit | Number of iterations to perform in improving each lift-and-project cut | -1 |
| maxCutTime | Maximum amount of time allowed for generation of cutting planes and reoptimization | 0 |
MIP Heuristics Options
| Option | Description | Default |
|---|---|---|
| feasibilityJump | MIP: Decides if the Feasibility Jump heuristic should be run | -1 |
| heurBeforeLp | Branch and Bound: Determines whether primal heuristics should be run before the initial LP relaxation has been solved | -1 |
| heurBeforeLPGPUEffort | Effort dial to control the effort spent inside the selected GPU heuristic method | -1 |
| heurBeforeLPGPUMethod | Enables a GPU-accelerated heuristic of the specified type | -1 |
| heurDiveIterLimit | Branch and Bound: Simplex iteration limit for reoptimizing during the diving heuristic | -1 |
| 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 | -1 |
| 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 | -1 |
| 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 large neighborhood search (LNS) 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 |
| heurSearchAnalyticStrategy | Strategy control for the Analytic Center (A) large neighborhood search heuristic, an LNS heuristic with an auxiliary objective function | -1 |
| heurSearchCombineStrategy | Strategy control for the Combine (C) large neighborhood search heuristic, which uses a neighborhood set up through the combination of multiple integer solutions | -1 |
| heurSearchEffort | Adjusts the overall level of the large neighborhood search (LNS) heuristics | 1 |
| heurSearchFreq | Branch and Bound: How often the large neighborhood search (LNS) heuristic should be run in the tree | -1 |
| heurSearchLPFirstStrategy | Strategy control for the LP first (L) large neighborhood search heuristic, an LNS heuristic with a small neighborhood centered around a node LP solution | -1 |
| heurSearchMIPFirstStrategy | Strategy control for the MIP first (M) large neighborhood search heuristic, an LNS heuristic with a small neighborhood centered around an integer solution | -1 |
| heurSearchRINSStrategy | Strategy control for the RINS (R) large neighborhood search heuristic, an LNS heuristic that is potentially expensive but good for finding solutions that differ significantly from the incumbent | -1 |
| heurSearchRootCutFreq | How frequently to run the large neighborhood search (LNS) heuristics during root cutting | -1 |
| heurSearchStrategy | Meta strategy control for large neighborhood search (LNS) heuristics | -1 |
| heurSearchZeroObjStrategy | Strategy control for the Zero Objective (Z) large neighborhood search heuristic, an LNS heuristic without an objective function | -1 |
| heurShiftProp | Determines whether the Shift-and-propagate primal heuristic should be executed | -1 |
| preRootEffort | Dial for the work spent during the Pre-root parallel heuristic phase | -1 |
| preRootThreads | Specifies an explicit number of threads that should be used for the Pre-root parallel heuristic phase | -1 |
| preRootWorklimit | Set an explicit work limit in work units for the Pre-root parallel heuristic phase | -1 |
| userSolHeuristic | Determines how much effort to put into running a large neighborhood search heuristic to find a feasible integer solution from a partial or infeasible user solution | -1 |
MIP Solution Pool Options
| Option | Description | Default |
|---|---|---|
| poolAbsGap | Limit on the absolute gap between the objective function values of the best and worst solutions in the pool | 0 |
| poolDuplicateCheck | Determines which MIP column entities to consider when checking whether two enumerated solutions are duplicates | 1 |
| poolEnumStrategy | Enables extended branch-and-bound search strategies to identify and capture additional solutions into the solution pool | 0 |
| poolLimit | Determines the maximum number of solutions to be collected during a solve | 10 |
| poolRelGap | Limit on the relative gap between the objective function values of the best and worst solutions in the pool | 0 |
| solnpool | Solution pool file name | |
| solnpoolmerge | Solution pool file name for merged solutions | |
| solnpoolnumsym | Maximum number of variable symbols when writing merged solutions | 10 |
| solnpoolPrefix | File name prefix for GDX solution files | soln |
General NLP / MINLP Options
| Option | Description | Default |
|---|---|---|
| xslp_algorithm | Bit map describing the SLP algorithm(s) to be used | 166 |
| xslp_algorithm_cascadeBounds | Step bounds are updated to accommodate 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_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_switchToPrimal | Use the primal simplex algorithm when all error vectors become inactive | 0 |
| xslp_calcThreads | Number of threads used for formula and derivatives evaluations | -1 |
| xslp_cascade | Bit map describing the cascading to be used | 257 |
| xslp_cascadeNLimit | Maximum number of iterations for cascading with non-linear determining rows | 10 |
| xslp_cascadeTol_PA | Absolute cascading print tolerance | 0.01 |
| xslp_cascadeTol_PR | Relative cascading print tolerance | 0.01 |
| xslp_cascade_all | Apply cascading to all variables with determining rows | 1 |
| xslp_cascade_allCoefVar | Apply cascading to all SLP variables which appear in coefficients | 0 |
| xslp_cascade_allStructVar | Apply cascading to all SLP variables which are structural | 0 |
| xslp_cascade_autoApply | Automatically determine whether to apply cascading | 1 |
| xslp_cascade_coefVar | Apply cascading to SLP variables which appear in coefficients and which would change by more than feasTol | 0 |
| xslp_cascade_dRColPreviousValue | In cases where the determining column is below xslp_dRColTol, fix at the previous rather than current value | 0 |
| xslp_cascade_dRColPVRange | In cases where the determining column is below xslp_dRColTol, fix within a range xslp_dRFixRange of previous value | 0 |
| xslp_cascade_secondaryGroups | Create secondary order groupping DR rows with instantiated user functions together in the order | 0 |
| xslp_cascade_structVar | Apply cascading to SLP variables which are structural and which would change by more than feasTol | 0 |
| xslp_defaultIV | Default initial value for an SLP variable if none is explicitly given | 100 |
| xslp_delayUpdateRows | Number of SLP iterations before update rows are fully activated | 2 |
| xslp_deterministic | Determines if the parallel features of SLP should be guaranteed to be deterministic | 1 |
| xslp_dRColDJTol | Reduced cost tolerance on the delta variable when fixing due to the determining column being below xslp_dRColTol | 0 |
| xslp_dRColTol | Minimum absolute magnitude of a determining column, for which the determined variable is still regarded as well defined | 1e-06 |
| xslp_dRFixRange | Range around the previous value where variables are fixed in cascading if the determining column is below xslp_dRColTol | 0.1 |
| xslp_filter | Bit map for controlling solution updates | 3 |
| xslp_filter_cascade | Check cascaded solutions against improvements in the merit function | 1 |
| xslp_filter_zeroLineSearch | Force minimum step sizes in line search | 0 |
| xslp_filter_zeroLineSearchTR | 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 | -1 |
| xslp_gridHeurSelect | Bit map selecting which heuristics to run if the problem has a variable with an integer delta | 6 |
| xslp_gridHeurSelect_all | Enumeration: Try all combinations | 0 |
| xslp_gridHeurSelect_simAnneal | Simulated annealing | 1 |
| xslp_gridHeurSelect_simple | Simple search heuristics | 1 |
| xslp_infinity | Value returned by a divide-by-zero in a formula | 1e+10 |
| xslp_iterFallbackOps | Alternative LP level control values for numerically challenging problems | |
| xslp_memoryFactor | Factor for expanding size of dynamic arrays in memory | 1.6 |
| xslp_nlpSolver | Controls whether to call FICO Xpress Global or one of the local solvers | -1 |
| xslp_objThreshold | Assumed maximum value of the objective function in absolute value | 1e+15 |
| 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_returnSolution | Selects whether to return the final converged iterate or the best merit-function iterate | -1 |
| 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 | -1 |
| xslp_stepBounding | Selects the step bounding strategy used by SLP | -1 |
| xslp_threads | Default number of threads to be used | -1 |
| 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 | -1 |
| xslp_postsolve | Determines whether postsolving should be performed automatically | -1 |
| xslp_presolve | Determines whether presolving should be performed on the nonlinear problem 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 | -1 |
| xslp_reformulate | Controls the problem reformulations carried out before augmentation | 511 |
| xslp_reformulate_abs | Convert ABS functions to MIP constraints if the full problem can be made not nonlinear | 1 |
| xslp_reformulate_allAbs | Always convert ABS expressions | 0 |
| xslp_reformulate_allMinMax | Always convert MIN and MAX expressions | 0 |
| xslp_reformulate_minMax | Convert MIN and MAX functions to MIP expressions if the full problem can be made not nonlinear | 1 |
| xslp_reformulate_pwl | Convert piecewise linear functions to MIP constructs | 1 |
| xslp_reformulate_qcqp2slp | Convert non-convex QCQP constraints to SLP constructs | 1 |
| xslp_reformulate_qp2slp | Convert non-convex quadratic objectives to SLP constructs | 1 |
| xslp_reformulate_qpsolve | Convexity of a quadratic only problem may be checked by calling the optimizer to solve the instance | 1 |
| xslp_reformulate_slp2qcqp | Solve convex quadratic constraints using the XPRS library | 1 |
| xslp_reformulate_slp2qp | Solve convex quadratic objectives using the XPRS library | 1 |
| xslp_reformulate_socp2slp | Keep second order cones in the XPRS problem to keep them in the linearizations | 1 |
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 | Initial 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 | 0 |
| xslp_matrixTol | Nonzero tolerance for dropping coefficients from the linearization | 0 |
| xslp_optimalityTolTarget | When set, this defines a target optimality tolerance to which the linearizations are solved to | 0 |
| 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 | -1 |
| 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 | 0 |
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 | -1 |
| xslp_aTol_r | Relative delta convergence tolerance | -1 |
| xslp_convergenceOps | Bit map describing which convergence tests should be carried out | 39935 |
| 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_requireOTolR | Do not declare converged if still sufficient improvement in objective | 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 | -1 |
| 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 | -1 |
| xslp_ecfTol_r | Relative tolerance on testing feasibility at the point of linearization | -1 |
| xslp_infeasLimit | Maximum number of consecutive infeasible or unbounded 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 | -1 |
| xslp_iTol_r | Relative impact convergence tolerance | -1 |
| xslp_maxTime | Maximum time in seconds that the SLP optimization will run before it terminates | 0 |
| xslp_mTol_a | Absolute effective matrix element convergence tolerance | -1 |
| xslp_mTol_r | Relative effective matrix element convergence tolerance | -1 |
| xslp_mvTol | Marginal value tolerance for determining if a constraint is slack | -1 |
| 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 | -1 |
| xslp_oTol_r | Relative static objective (2) convergence tolerance | -1 |
| xslp_sTol_a | Absolute slack convergence tolerance | -1 |
| xslp_sTol_r | Relative slack convergence tolerance | -1 |
| 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 | Feasibility 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 | -1 |
| xslp_vTol_r | Relative static objective (3) convergence tolerance | -1 |
| 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 | -1 |
| xslp_wTol_r | Relative extended convergence continuation tolerance | -1 |
| 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 is performed | 100 |
| xslp_xTol_a | Absolute static objective function (1) tolerance | -1 |
| xslp_xTol_r | Relative static objective function (1) tolerance | -1 |
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 | -1 |
| xslp_multistart_maxTime | Maximum total time to be spent in the multistart search | 0 |
| 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 | -1 |
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 analysis | 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_multistart_log | Level of logging during the multistart run | 0 |
| xslp_slpLog | Frequency with which SLP status is printed | 1 |
MINLP Options
| Option | Description | Default |
|---|---|---|
| xslp_cutStrategy | Determines which 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 | -1 |
| 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_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 | Relative 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 |
| xslp_mislpAlgorithm | Selects the MISLP strategy used to combine SLP with the branch-and-bound search | -1 |
KNITRO Options
| Option | Description | Default |
|---|---|---|
| knitro_bar_directinterval | Controls the maximum number of consecutive conjugate gradient (CG) steps before KNITRO will try to enforce that a step is taken using direct linear algebra. | 10 |
| knitro_bar_feasible | Specifies whether special emphasis is placed on getting and staying feasible in the interior-point algorithms. | 0 |
| knitro_bar_feasmodetol | Tolerance used in the feasibility condition that determines whether KNITRO will force subsequent iterates to remain feasible. | 0.0001 |
| knitro_bar_initmu | Specifies the initial value for the barrier parameter \(\mu\) used with the barrier algorithms. | 0.1 |
| knitro_bar_initpt | Indicates initial point strategy for x, slacks and multipliers when using a barrier algorithm. | 0 |
| knitro_bar_maxbacktrack | Indicates the maximum allowable number of trial points during the linesearch of the Interior/Direct or SQP algorithm before treating the linesearch step as a failure and generating a new step. | 3 |
| knitro_bar_maxcrossit | Specifies the maximum number of crossover iterations before termination. | 0 |
| knitro_bar_maxrefactor | Indicates the maximum number of refactorizations of the KKT system per iteration of the Interior/Direct algorithm before reverting to a CG step. | -1 |
| knitro_bar_murule | Indicates which strategy to use for modifying the barrier parameter \(\mu\) in the barrier algorithms. | 0 |
| knitro_bar_pencons | Indicates whether a penalty approach is applied to the constraints. | 0 |
| knitro_bar_penrule | Indicates which penalty parameter strategy to use for determining whether or not to accept a trial iterate. | 0 |
| knitro_bar_switchrule | Indicates whether or not the barrier algorithms will allow switching from an optimality phase to a pure feasibility phase. | 0 |
| knitro_blasoption | Specifies the BLAS/LAPACK function library to use for basic vector and matrix computations. | 1 |
| knitro_delta | Specifies the initial trust region radius scaling factor used to determine the initial trust region size. | 1 |
| knitro_feastol | Specifies the final relative stopping tolerance for the feasibility error. | 1e-06 |
| knitro_feastolabs | Specifies the final absolute stopping tolerance for the feasibility error. | -1 |
| knitro_gradopt | Specifies how to compute the gradients of the objective and constraint functions. | 1 |
| knitro_hessopt | Specifies how to compute the (approximate) Hessian of the Lagrangian. | 0 |
| knitro_honorbnds | Indicates whether or not to enforce satisfaction of simple variable bounds throughout the optimization. | 2 |
| knitro_infeastol | Specifies the (relative) tolerance used for declaring infeasibility of a model. | 1e-08 |
| knitro_linsolver | Indicates which linear solver to use to solve linear systems arising in KNITRO algorithms. | 0 |
| knitro_lmsize | Specifies the number of limited memory pairs stored when approximating the Hessian using the limited-memory quasi-Newton BFGS option. | 10 |
| knitro_maxcgit | Determines the maximum allowable number of inner conjugate gradient (CG) iterations per KNITRO minor iteration. | 0 |
| knitro_maxit | Specifies the maximum number of iterations before termination. | 0 |
| knitro_mip_branchrule | Specifies which branching rule to use for MIP branch and bound procedure. | 0 |
| knitro_mip_gub_branch | Specifies whether or not to branch on generalized upper bounds (GUBs). | 0 |
| knitro_mip_heuristic | Which MIP heuristic to apply for an initial integer feasible point. | 0 |
| knitro_mip_heur_maxit | Maximum number of iterations to allow for MIP heuristic. | 100 |
| knitro_mip_implicatns | Whether to add logical implications deduced from branching decisions at a MIP node. | 1 |
| knitro_mip_intgapabs | The absolute optimality gap stop tolerance for MIP. | 1e-06 |
| knitro_mip_intgaprel | The relative optimality gap stop tolerance for MIP. | 1e-06 |
| knitro_mip_knapsack | Specifies rules for adding MIP knapsack cuts. | 1 |
| knitro_mip_maxnodes | Specifies the maximum number of nodes explored (0 means no limit). | 100000 |
| knitro_mip_method | Specifies which MIP method to use. | 0 |
| knitro_mip_outinterval | Specifies node printing interval for mip_outlevel when mip_outlevel > 0. | 10 |
| knitro_mip_outlevel | Specifies how much MIP information to print. | 1 |
| knitro_mip_pseudoinit | Specifies the method used to initialize pseudo-costs corresponding to variables that have not yet been branched on in the MIP method. | 0 |
| knitro_mip_root_nlpalg | Specifies which algorithm to use for root node NLP solves in MIP (same options as nlp_algorithm user option). | 0 |
| knitro_mip_rounding | Specifies the MIP rounding rule to apply. | 0 |
| knitro_mip_selectrule | Specifies the MIP select rule for choosing the next node in the branch-and-bound tree. | 0 |
| knitro_mip_strong_candlim | Specifies the maximum number of candidates to explore for MIP strong branching. | 10 |
| knitro_mip_strong_level | Specifies the maximum number of tree levels on which to perform MIP strong branching. | 10 |
| knitro_mip_strong_maxit | Specifies the maximum number of iterations to allow for MIP strong branching solves. | 1000 |
| knitro_nlp_algorithm | Indicates which algorithm to use to solve nonlinear problems (e.g. NLPs, QPs, QCQPs) | 0 |
| knitro_objrange | Specifies the extreme limits of the objective function for purposes of determining unboundedness. | 1e+20 |
| knitro_opttol | Specifies the final relative stopping tolerance for the KKT (optimality) error. | 1e-06 |
| knitro_opttolabs | Specifies the final absolute stopping tolerance for the KKT (optimality) error. | 0 |
| knitro_outlev | Controls the level of output produced by KNITRO. | 2 |
| knitro_par_numthreads | Number of threads to use for parallel computing features. | 1 |
| knitro_presolve | Determine whether or not to use the KNITRO presolver to try to simplify the model by removing variables or constraints. | 1 |
| knitro_presolve_tol | Determines the tolerance used by the KNITRO presolver to remove variables and constraints from the model. | 1e-06 |
| knitro_scale | Specifies whether to perform problem scaling of the objective function, constraint functions, or possibly variables. | 1 |
| knitro_soc | Specifies whether or not to try second order corrections (SOC). | 1 |
| knitro_xtol | Tolerance for convergence criterion based on relative change between successive solution points. | 1e-15 |
Primal Dual Hybrid Gradient Options
| Option | Description | Default |
|---|---|---|
| barHGExtrapolate | Extrapolation parameter for the hybrid gradient algorithm | 0.15 |
| barHGGPU | Whether to use a GPU for the hybrid gradient algorithm | 0 |
| barHGGPUAlg | Defines the GPU algorithm choice | 0 |
| barHGGPUBlockSize | Size of CUDA blocks to use for the GPU calculations | 256 |
| barHGHalpern | Defines the balance between the regular and the Halpern updates during the iterations | 0.6 |
| barHGMaxRestarts | Maximum number of restarts in the hybrid gradient algorithm | -5000000 |
| barHGMinorIterationLimit | Minor iterations are faster but simplified steps in the algorithm | 0 |
| barHGOps | Bit-vector control options for the hybrid gradient algorithm | 0 |
| barHGOps_asymAvg | Use an asymmetric average for the primal averaging | 0 |
| barHGOps_noHalpern | Turn off Halpern updates | 0 |
| barHGOps_objScale | Normalize the objective | 0 |
| barHGOps_omegaContract | Contract omega towards 1 if the infeasibility is small enough | 0 |
| barHGOps_omegaInf | Omega is based on the infeasibility | 0 |
| barHGOps_restartL2 | Use L2 norm to measure solution quality | 0 |
| barHGOps_rhsScale | Normalize the RHS | 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 | 0 |
| barHGPrecision | Whether to use single or double precision floating-point arithmetic in the hybrid gradient algorithm | -1 |
| barHGRelTol | Relative feasibility tolerance for the hybrid gradient algorithm | 0 |
Tuner Options
| Option | Description | Default |
|---|---|---|
| Tuner | Enables tuner | 0 |
| tunerHistory | Tuner: Whether to reuse and append to previous tuner results of the same problem | 2 |
| tunerMaxTime | Tuner: Maximum time in seconds that the tuner will run before it terminates | 0 |
| tunerMethod | Tuner: Selects a factory tuner method | -1 |
| tunerMethodFile | Tuner: Defines a file from which the tuner can read user-defined tuner method | |
| tunerOutput | Tuner: Whether to output tuner results and logs to the file system | 1 |
| tunerOutputPath | Tuner: Defines a root path to which the tuner writes the result file and logs | tuneroutput |
| tunerPermute | Tuner: Defines the number of permutations to solve for each control setting | 0 |
| tunerSessionName | Tuner: Defines a session name for the tuner | |
| tunerTarget | Tuner: Defines the tuner target – what should be evaluated when comparing two runs with different control settings | -1 |
| tunerThreads | Tuner: Number of threads used by the tuner | 1 |
| tunerVerbose | Tuner: Whether the tuner should prints detailed information for each run | 1 |
IIS Options
| Option | Description | Default |
|---|---|---|
| iis | Run the Irreducible Infeasible Subsystem (IIS) finder if the problem is infeasible | 0 |
| iisLog | Selects how much information should be printed during the IIS procedure | 1 |
| iisOps | Selects which part of the restrictions (bounds, constraints, entities) should always be kept in an IIS | 0 |
| iisOps_binary | Keep binary integralities | 0 |
| iisOps_bound | Keep all variable bounds | 0 |
| iisOps_constraint | Keep all constraints | 0 |
| iisOps_equality | Keep all equality constraints | 0 |
| iisOps_fixedVar | Keep fixed variables | 0 |
| iisOps_genIntegrality | Keep all general integer entities, except binaries | 0 |
| iisOps_indicator | Keep all indicator constraints | 0 |
| iisOps_set | Keep all specially ordered set (SOS) constraints | 0 |
| iisOps_zeroLower | Keep the 0 lower bounds of variables | 0 |
Detailed Descriptions of XPRESS Options
advBasis (integer): Use advanced basis provided by GAMS ↵
Default:
1
value meaning 0Do not load basis 1Load basis if suitable (decided by solver link) 2Force loading basis
algAfterCrossover (integer): Algorithm to be used for the final clean up step after the crossover ↵
Default:
1
value meaning 1Automatically determined. 2Dual simplex. 3Primal simplex. 4Concurrent.
algAfterNetwork (integer): Algorithm to be used for the clean up step after the network simplex solver ↵
Default:
-1
value meaning -1Automatically determined. 2Dual simplex. 3Primal simplex.
alternativeLPSols (integer): Controls the collection of alternative LP solutions for cut separation and heuristics ↵
Default:
-1
value meaning -1The solver decides if collecting alternative LP solutions is beneficial or not. This is the default setting. 0Searching for alternative LP solutions is disabled. 1Searching for alternative LP solutions is enabled.
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:
-1
value meaning -1Automatic. 0Disabled. 1Enabled.
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:
1
value meaning 0No perturbation performed. 1Automatic perturbation is performed.
backgroundMaxThreads (integer): Limits 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.
In case of a GAMS license with core limit, the link may overwrite
backgroundMaxThreadsto enforce the limit.Default:
-1
value meaning -1The number of background threads is decided automatically. >=0The number of background threads.
backgroundSelect (integer): Bit-vector control to 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 tasks 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 = 1Feasibility jump heuristic. bit 1 = 2Fast branch-and-bound heuristic. bit 2 = 4Same as bit 1 but with some additional heuristics enabled. bit 3 = 8Fix-propagate-repair heuristic. bit 4 = 16Auxiliary parallel root cutloop. bit 7 = 128Zero-objective heuristic (called only when no feasible solution is available).
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 -1Automatically determined. 2Select the node with the best estimated solution. 3Select the node with the best bound on the solution. 4Select the deepest node in the search tree (equivalent to depth-first search). 5Select the highest node in the search tree (equivalent to breadth-first search). 6Select the earliest node created. 7Select the latest node created. 8Select a node randomly. 9Select the node whose LP relaxation contains the fewest number of infeasible MIP entities. 10Combination of 2 and 9. 11Combination of 2 and 4. 12Combination 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 -1Automatically determined. 2Select the node with the best estimated solution. 3Select the node with the best bound on the solution. 4Select the deepest node in the search tree (equivalent to depth-first search). 5Select the highest node in the search tree (equivalent to breadth-first search). 6Select the earliest node created. 7Select the latest node created. 8Select a node randomly. 9Select the node whose LP relaxation contains the fewest number of infeasible MIP entities. 10Combination of 2 and 9. 11Combination of 2 and 4. 12Combination of 3 and 4.
barAlg (integer): Determines which barrier algorithm is used to solve the problem ↵
Notably, this is also the control to enable the primal-dual hybrid gradient algorithm.
The automatic setting uses 1 for LP and QP problems and 3 for QCQP problems. The detection of primal or dual infeasibility is usually 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 or 5, the hybrid gradient algorithm, is suitable for very large or very degenerate problems, with 5 being faster and more robust in general, and should be the preferred choice.
Default:
-1
value meaning -1Determined automatically. 0Unused. 1Use the infeasible-start barrier algorithm. 2Use the homogeneous self-dual barrier algorithm. 3Start with 2 and optionally switch to 1 during the execution. 4Use the hybrid gradient algorithm. 5Use an alternative version of the hybrid gradient algorithm.
barCores (integer): Determines the number of physical CPU cores assumed to be present in the system by the barrier and hybrid gradient algorithms ↵
The control is provided for cross-hardware reproducibility purposes. The count does not include logical cores created by Hyper-Threading.
In case of a GAMS license with core limit, the link may overwrite
barCoresto enforce the limit.Default:
-1
value meaning -1Xpress will automatically detect the number of cores. >=1The number of physical CPU cores assumed.
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 0Turns off all crash procedures. 1..6Available 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.
The default value is determined automatically based on the problem size, structure and algorithm choice.
Range: [
0, ∞]Default:
0
barFailIterLimit (integer): Newton barrier: Maximum number of consecutive iterations that fail to improve the solution in the barrier algorithm ↵
Default:
0
value meaning 0Determined automatically >0Maximum 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.
Default:
1e-06
value meaning [0,1]Defines how aggressively free variables are scaled.
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.
The default value is determined automatically based on the problem size, structure and algorithm choice.
Range: [
0, ∞]Default:
0
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, setting barGapTarget to a small positive 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 10-10 and 10-18.
The default value is determined automatically based on the problem size, structure and algorithm choice.
Range: [
0, ∞]Default:
0
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.
Default:
0.15
value meaning [0,1]Defines the extrapolation parameter for the hybrid gradient algorithm.
barHGGPU (boolean): Whether to use a GPU for the hybrid gradient algorithm ↵
Even though the GPU implementation of the hybrid gradient algorithm is identical in operation and functionality to the CPU implementation, the returned solutions can differ between the two versions due to the different architecture of the GPU. GPU support is not available in the deterministic concurrent LP algorithm.
Default:
0
value meaning 0Do not use a GPU. 1Use the GPU, if available.
barHGGPUAlg (integer): Defines the GPU algorithm choice ↵
The Nvidia linear algebra libraries offer various ways to calculate matrix- vector products. Some of these require more memory, but offer deterministic execution. On the other hand, there is a limited memory option, but with nondeterministic execution.
Default:
0
value meaning 0The selected algorithm ensures deterministic runs on GPU. 1Use a faster GPU implementation that may result in nondeterministic runs. 2Use a reduced memory version on GPU, which may result in nondeterministic runs. 3Use a faster and reduced memory implementation on GPU, which may result in nondeterministic runs.
barHGGPUBlockSize (integer): Size of CUDA blocks to use for the GPU calculations ↵
Range: {
0, ..., ∞}Default:
256
barHGHalpern (real): Defines the balance between the regular and the Halpern updates during the iterations ↵
Increasing this parameter increases the Halpern reduction.
The recommended range is [0,1].
Default:
0.6
value meaning [0,2]Controls the contribution of the Halpern update for the hybrid gradient algorithm.
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.
Default:
-5000000
value meaning >=0The maximum number of restarts in the hybrid gradient algorithm. <0Use the absolute value as a limit on the total number of iterations.
barHGMinorIterationLimit (integer): Minor iterations are faster but simplified steps in the algorithm ↵
This control determines how many minor iterations can be performed before performing a full step.
Default:
0
value meaning 0Automatic choice of iteration limit. >0Use the given minor iteration limit.
barHGOps (integer): Bit-vector 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 L2 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. Additional scaling is controlled by bits 8-9. If no bit is set at all then a the default value is determined automatically based on the algorithm choice.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
0
value meaning bit 0 = 1Equivalent to barHGOps_asymAvg. bit 1 = 2Equivalent to barHGOps_startL1. bit 2 = 4Equivalent to barHGOps_startL2. bit 3 = 8Equivalent to barHGOps_startLInf. bit 4 = 16Equivalent to barHGOps_restartL2. bit 5 = 32Equivalent to barHGOps_omegaContract. bit 6 = 64Equivalent to barHGOps_omegaInf. bit 7 = 128Equivalent to barHGOps_noHalpern. bit 8 = 256Equivalent to barHGOps_objScale. bit 9 = 512Equivalent to barHGOps_rhsScale.
barHGOps_asymAvg (boolean): Use an asymmetric average for the primal averaging ↵
See also barHGOps.
Default:
0
barHGOps_noHalpern (boolean): Turn off Halpern updates ↵
See also barHGOps.
Default:
0
barHGOps_objScale (boolean): Normalize the objective ↵
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_restartL2 (boolean): Use L2 norm to measure solution quality ↵
See also barHGOps.
Default:
0
barHGOps_rhsScale (boolean): Normalize the RHS ↵
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:
0
barHGPrecision (integer): Whether to use single or double precision floating-point arithmetic in the hybrid gradient algorithm ↵
The single precision implementation uses less memory and is, in general, faster than the double precision implementation. This control applies to both the CPU and the GPU implementation of the algorithm. The performance difference is greater for the GPU version.
Default:
-1
value meaning -1Automatically selected based on the value of barHGGPU 0Use single precision arithmetic on both CPU and GPU platforms. 1Use double precision arithmetic on both CPU and GPU platforms.
barHGRelTol (real): Relative feasibility tolerance for the hybrid gradient algorithm ↵
Range: [
0, ∞]Default:
0
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.
Default:
15
value meaning >=0The maximum number of consecutive indefinite barrier iterations.
barIterative (integer): Maximum number of barrier iterations in which an iterative solver is used instead of the Cholesky decomposition ↵
Default:
-2
value meaning -2Automatically determined. -1Turn iterative solver off. 0Use iterative solver for the starting point computation. >0Specifies the maximum number of barrier iterations to apply the iterative solver.
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.
Default:
500
value meaning >=0The maximum number of barrier iterations.
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 0The parameter is not taken into account. >=+1.0Increases the emphasis on centrality when larger value is set. <=-1.0Selects a value adaptively in every iteration from [+1, -barKernel].
barLargeBound (real): Threshold for the barrier to handle large bounds ↵
Default:
0
value meaning 0The handling of large bounds is turned off. >0.0Bounds larger than or equal to this value are considered being large for the barrier.
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 0Turn off objective perturbation. (0,1]Let the Optimizer decide if the objective is perturbed or not and use the parameter value as the scale of the perturbation. [-1,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:
-1
value meaning -1Let the Optimizer decide. 0Scale by geometric mean. >=0Scale 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:
0
value meaning 0Choose automatically. 1Minimum degree method. This selects diagonal elements with the smallest number of nonzeros in their rows or columns. 2Minimum 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. 3Nested 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.
In case of a GAMS license with core limit, the link may overwrite
barOrderThreadsto enforce the limit.Range: {
0, ..., ∞}Default:
0
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 0No output. 1At 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 controls 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: Bit-vector 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 = 1Equivalent to barPresolveOps_standard. bit 1 = 2Equivalent to barPresolveOps_extra. bit 2 = 4Equivalent 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.
The default value is determined automatically based on the problem size, structure and algorithm choice.
Range: [
0, ∞]Default:
0
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.
Default:
0
value meaning >=0The maximum number of refinement iterations after barrier termination.
barRegularize (integer): Bit-vector control determines how the barrier algorithm applies regularization on the KKT system ↵
If the value of the control is set to -1 (default) then the solver will automatically select the bits it deems most useful.
Default:
-1
value meaning bit 0 = 1Standard regularization is turned on/off. bit 1 = 2Reduced regularization is turned on/off. This option reduces the perturbation effect of the standard regularization. bit 2 = 4Forces to keep dependent rows in the KKT system. bit 3 = 8Forces to preserve degenerate rows in the KKT system. bit 4 = 16Restrict regularization to infeasible iterates. bit 5 = 32Disable iterative regularizations. bit 6 = 64Apply 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:
-1
value meaning -1Let the Optimizer decide. 0Scale by geometric mean. >=0Scale 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:
0
value meaning -1Uses the existing solution for warm-start if one is available. 0Warm-start is disabled; the starting point is determined automatically from the next three options. 1Uses simple heuristics to compute the starting point based on the magnitudes of the matrix entries. 2Uses 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. 3Uses the unit starting point for the homogeneous self-dual barrier algorithm.
barStartWeight (real): Newton barrier: Sets the weight for the warm-start point when warm-start is set for the barrier algorithm ↵
Using larger weight gives more emphasis for the supplied starting point.
Default:
0.85
value meaning [0,1]The weight for the barrier warm-start point.
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.
Default:
1e-16
value meaning 0The default value is determined automatically based on the problem size, structure and algorithm choice. >0The minimal step size for the Newton barrier.
barThreads (integer): Determines the number of threads implemented to run the Newton-barrier and hybrid gradient algorithms ↵
There is a practical upper limit of 50 on the number of parallel threads the Optimizer will create.
In case of a GAMS license with core limit, the link may overwrite
barThreadsto enforce the limit.Default:
-1
value meaning -1The threads control will determine the number of threads used. >0The number of threads to use.
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.
bigM (real): Infeasibility penalty used if the "Big M" method is implemented ↵
Range: [
0, ∞]Default:
1024
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 0For phase I / phase II. 1If "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 0Minimum estimate branch first. 1Maximum estimate branch first. 2If an incumbent solution exists, solve the branch satisfied by that solution first. Otherwise solve the minimum estimate branch first (option 0). 3Solve 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:
-1
value meaning -1Automatic selection of the strategy. 0Disabled. 1Cautious strategy. Disjunctive branches will be created only for general integers with a wide range. 2Moderate strategy. 3Aggressive 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:
-1
value meaning -1Automatically determined. 0Disabled. 1Enabled.
breadthFirst (integer): Number of nodes to include in the best-first search before switching to the local first search (nodeSelection = 4) ↵
Default:
11
value meaning >=0The number of nodes to include in the best-first search before switching to the local first search.
choleskyAlg (integer): Newton barrier: Type of Cholesky factorization used; bit-vector-control ↵
If the value of the control is set to -1 (default) then the solver will automatically select the bits it deems most useful.
Default:
-1
value meaning bit 0 = 1Matrix blocking: 0: automatic setting; 1: manual setting. bit 1 = 2If manual selection of matrix blocking: 0: multi-pass; 1: single-pass. bit 2 = 4Nonseparable QP relaxation: 0: off; 1: on. bit 3 = 8Corrector weight: 0: automatic setting; 1: manual setting. bit 4 = 16If manual selection of corrector weight: 0: off; 1: on. bit 5 = 32Refinement: 0: automatic setting; 1: manual setting. bit 6 = 64Preconditioned conjugate gradient method (PCGM): 0: PCGM off; 1: PCGM on. bit 7 = 128Preconditioned quasi minimal residual (QMR) to refine solution: 0: QMR off; 1: QMR on. bit 8 = 256Perform refinement on the augmented system 0: off; 1: on. bit 9 = 512Force 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 ↵
Default:
1e-15
value meaning >0If the absolute value of the pivot element is less than or equal than this value, it merits special treatment in the Cholesky decomposition process.
clamping (integer): Bit-vector control 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 bit 0 = 1Equivalent to clamping_primal. bit 1 = 2Equivalent to clamping_dual. bit 2 = 4Equivalent to clamping_slacks. bit 3 = 8Equivalent to clamping_rdj.
clamping_dual (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
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 primal slack values to always be within constraint bounds ↵
See also clamping.
Default:
0
concurrentThreads (integer): Determines the number of threads used by the concurrent solver ↵
Default:
-1
value meaning -1Determined automatically >0Number 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:
-1
value meaning -1Automatic. 0Disable conflict cuts. 1Cautious application of conflict cuts. 2Medium application of conflict cuts. 3Aggressive application of conflict cuts.
coresPerCpu (integer): Used to override the number of cores assumed to be present 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.
Default:
-1
value meaning -1The number of cores is detected automatically. >0The number of cores per CPU.
cpiAlpha (real): Decay term for confined primal integral computation ↵
This control represents the exponential decay term for computing the OBSERVEDPRIMALINTEGRAL. The smaller it is, the more emphasis is put on the early part of the search.
Default:
0
value meaning [0.0,1.0)Exponential decay for computing the OBSERVEDPRIMALINTEGRAL. A value of 0 corresponds to computing a regular primal integral without exponential decay.
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 -2Highest supported [Generic, SSE2, AVX or AVX2], that is, using AVX2 instructions if supported by the CPU. -1Highest supported solve path consistent code [Generic, SSE2 or AVX]. 0Use generic code compatible with all CPUs. 1Use SSE2 / NEON optimized code. 2Use AVX optimized code. 3Use 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 -1Disable the timer. 0Use elapsed time. 1Use 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.
Default:
2
value meaning 0Turns off all crash procedures. 1For singletons only (one pass). 2For singletons only (multi pass). 3Multiple passes through the matrix considering slacks. 4Multiple (≤ 10) passes through the matrix but only doing slacks at the very end. bit 0 = 1Perform standard crash. bit 1 = 2Perform additional numerical checks during crash. bit 2 = 4Extend the set of column candidates for crash. bit 3 = 8Extend the set of row candidates for crash. bit 4 = 16Force crash, i.e., consider all suitable columns/rows as candidates for crash. >10As for value 4 but performing at most n - 10 passes, where n is the specified control value.
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:
-1
value meaning -1Determined automatically. 0No crossover. 1Primal crossover first. 2Dual 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 ↵
Default:
2147483647
value meaning >=0The maximum number of crossover iterations.
crossoverOps (integer): Newton barrier and hybrid gradient: Bit-vector for adjusting the behavior of the crossover procedure ↵
Default:
0
value meaning bit 0 = 1Returned solution when the crossover terminates prematurely: 0: Return the last basis from the crossover; 1: Return the barrier solution. bit 1 = 2Select the crossover stages to be performed: 0: Perform both crossover stages; 1: Skip second crossover stage. bit 2 = 4Set crossover behaviour: 0: Force to perform all pivots; 1: Skip pivots that are numerically less reliable. bit 3 = 8Set 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 ↵
In case of a GAMS license with core limit, the link may overwrite
crossoverThreadsto enforce the limit.Default:
-1
value meaning -1The barThreads control will determine the number of crossover threads. >0The maximum number of crossover threads.
cutAggRows (integer): Strategy for row aggregation used when separating Mixed Integer Rounding (MIR) cuts, lifted cover cuts and Strong Chvatal-Gomory (CG) cuts ↵
Row aggregation combines several rows of the problem into a single row from which a cut is then derived. A more aggressive strategy will try more and more complex row aggregations, which can uncover cuts that would otherwise be missed, at the cost of extra computational effort and, in some cases, at the cost of separating denser cutting planes that could slow down the node throughput.
Default:
-1
value meaning -1Automatic selection of the row aggregation strategy. 0Off. No row aggregation. 1Conservative row aggregation strategy. 2Moderate row aggregation strategy. 3Aggressive row aggregation strategy. 4Very aggressive row aggregation strategy.
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.
Does not affect cutting at the root node.
Default:
-1
value meaning -1The maximum depth is determined automatically. 0No cuts will be generated in the tree search. >0The maximum tree depth to generate cuts.
cutFactor (real): Limit on the number of cuts and cut coefficients the Optimizer is allowed to add to the matrix during tree search ↵
The number of 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:
-1
value meaning -1Let the Optimizer decide on the maximum amount of cuts based on cutStrategy. >=0Multiple 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.
Default:
-1
value meaning -1The frequency is determined automatically. >=0The frequency at which cuts are generated in the tree.
cutFromCutRows (integer): Strategy to decide whether cutting planes already added to the matrix may themselves be used as base rows for separating new Mixed Integer Rounding (MIR) cuts, lifted cover cuts and Strong Chvatal-Gomory (CG) cuts ↵
A more aggressive strategy allows cutting from cut rows more often, which can uncover additional cuts, at the cost of extra computational effort and, in some cases, at the cost of separating denser cutting planes that could slow down the node throughput.
Default:
-1
value meaning -1Automatic selection. 0Off. Only original constraints are used as base rows. 1Conservative strategy. 2Moderate strategy. 3Aggressive strategy.
cutGomMaxRounds (integer): Number of rounds of Gomory cuts or lift-and-project cuts separated at the root node of the branch-and-bound tree search ↵
Does not affect the number of rounds of other MIP cut separators, which is controlled separately by cutMaxRounds.
Default:
-1
value meaning -1Number of rounds determined automatically. 0No Gomory cut separation at the root node. >0Target number of Gomory cut rounds at the root node.
cutGomMaxTreeRounds (integer): Number of rounds of Gomory cuts or lift-and-project cuts separated at a node of the branch-and-bound tree search other than the root node ↵
Does not affect the number of rounds of other MIP cut separators, which is controlled separately by cutMaxTreeRounds.
Default:
-1
value meaning -1Number of rounds determined automatically. 0No Gomory cut separation at tree nodes. >0Target number of Gomory cut rounds at tree nodes.
cutMaxRounds (integer): Number of rounds of cuts separated at the root node of the branch-and-bound tree search, for all MIP cut separators except Gomory cuts ↵
Does not affect the number of rounds of Gomory cuts, which is controlled separately by cutGomMaxRounds.
Default:
-1
value meaning -1Number of rounds determined automatically. 0No cut separation at the root node. >0Target number of cut rounds at the root node.
cutMaxTreeRounds (integer): Number of rounds of cuts separated at a node of the branch-and-bound tree search other than the root node, for all MIP cut separators except Gomory cuts ↵
Does not affect the number of rounds of Gomory cuts, which is controlled separately by cutGomMaxTreeRounds.
Default:
-1
value meaning -1Number of rounds determined automatically. 0No cut separation at tree nodes. >0Target number of cut rounds at tree nodes.
cutOAMaxRounds (integer): Number of rounds of Outer Approximation (OA) cuts for convex quadratic problems and for Second Order Cone Programs (SOCPs) separated at the root node of the branch-and-bound tree search ↵
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.
Default:
-1
value meaning -1Number of rounds determined automatically. 0No OA cut separation at the root node. >0Target number of OA cut rounds at the root node.
cutOAMaxTreeRounds (integer): Number of rounds of Outer Approximation (OA) cuts for convex quadratic problems and for Second Order Cone Programs (SOCPs) separated at a node of the branch-and-bound tree search other than the root node ↵
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.
Default:
-1
value meaning -1Number of rounds determined automatically. 0No OA cut separation at tree nodes. >0Target number of OA cut rounds at tree nodes.
cutSepCliqueStrategy (integer): Strategy for separation of clique cuts ↵
A more aggressive strategy will increase the effort spent in clique cut separation and the frequency at which clique cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then clique cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepCliqueStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for clique cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of clique cuts. 1Conservative cut separation strategy. Clique cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepCoverStrategy (integer): Strategy for separation of lifted cover cuts ↵
A more aggressive strategy will increase the effort spent in lifted cover cut separation and the frequency at which lifted cover cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then lifted cover cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepCoverStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for lifted cover cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of lifted cover cuts. 1Conservative cut separation strategy. Lifted cover cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepFarkasStrategy (integer): Strategy for separation of Farkas cuts ↵
A more aggressive strategy will increase the effort spent in Farkas cut separation and the frequency at which Farkas cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then Farkas cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepFarkasStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for Farkas cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of Farkas cuts. 1Conservative cut separation strategy. Farkas cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepFlowPathStrategy (integer): Strategy for separation of flow path cuts ↵
A more aggressive strategy will increase the effort spent in flow path cut separation and the frequency at which flow path cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then flow path cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepFlowPathStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for flow path cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of flow path cuts. 1Conservative cut separation strategy. Flow path cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepGomoryStrategy (integer): Strategy for separation of Gomory cuts ↵
A more aggressive strategy will increase the effort spent in Gomory cut separation and the frequency at which Gomory cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then Gomory cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepGomoryStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for Gomory cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of Gomory cuts. 1Conservative cut separation strategy. Gomory cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepGUBCoverStrategy (integer): Strategy for separation of lifted GUB cover cuts ↵
A more aggressive strategy will increase the effort spent in lifted GUB cover cut separation and the frequency at which lifted GUB cover cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then lifted GUB cover cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepGUBCoverStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for lifted GUB cover cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of lifted GUB cover cuts. 1Conservative cut separation strategy. Lifted GUB cover cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepImplBoundStrategy (integer): Strategy for separation of implication cuts ↵
A more aggressive strategy will increase the effort spent in implication cut separation and the frequency at which implication cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then implication cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepImplBoundStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for implication cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of implication cuts. 1Conservative cut separation strategy. Implication cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepMCFStrategy (integer): Strategy for separation of Multi-Commodity Flow (MCF) cuts ↵
A more aggressive strategy will increase the effort spent in MCF cut separation and the frequency at which MCF cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then MCF cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepMCFStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for MCF cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of MCF cuts. 1Conservative cut separation strategy. MCF cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepMIRStrategy (integer): Strategy for separation of Mixed Integer Rounding (MIR) cuts ↵
A more aggressive strategy will increase the effort spent in MIR cut separation and the frequency at which MIR cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then MIR cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepMIRStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for MIR cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of MIR cuts. 1Conservative cut separation strategy. MIR cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepPathMixStrategy (integer): Strategy for separation of path mixing cuts ↵
A more aggressive strategy will increase the effort spent in path mixing cut separation and the frequency at which path mixing cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then path mixing cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepPathMixStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for path mixing cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of path mixing cuts. 1Conservative cut separation strategy. Path mixing cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepRLTStrategy (integer): Strategy for separation of Reformulation-Linearization Technique (RLT) cuts ↵
A more aggressive strategy will increase the effort spent in RLT cut separation and the frequency at which RLT cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then RLT cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepRLTStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for RLT cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of RLT cuts. 1Conservative cut separation strategy. RLT cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepSDPStrategy (integer): Strategy for separation of semidefinite programming (SDP) cuts ↵
A more aggressive strategy will increase the effort spent in SDP cut separation and the frequency at which SDP cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then SDP cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepSDPStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for SDP cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of SDP cuts. 1Conservative cut separation strategy. SDP cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepStrategy (integer): Meta control specifying the cut separation strategy for every individual CUTSEP*STRATEGY control left at its default value of -1 (automatic) ↵
Setting cutSepStrategy to a value other than -1 overrides the automatic decision for each cut separator whose own control is left to value -1 (automatic). An individual control (e.g. cutSepCliqueStrategy) that is set to a value other than -1 always takes precedence over this meta control.
Each individual CUTSEP*STRATEGY control has a special value -2, which can be set to ignore the value of this meta control and force the default behavior for the cut separator.
Default:
-1
value meaning -1Automatic cut separation strategy. 0Off. Disable all cut separators set to automatic. 1Conservative cut separation strategy applied to all cuts separators set to automatic. 2Moderate cut separation strategy applied to all cuts separators set to automatic. 3Aggressive cut separation strategy applied to all cuts separators set to automatic.
cutSepStrongCGStrategy (integer): Strategy for separation of Strong Chvatal-Gomory (CG) cuts ↵
A more aggressive strategy will increase the effort spent in Strong CG cut separation and the frequency at which Strong CG cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then Strong CG cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepStrongCGStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for Strong CG cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of Strong CG cuts. 1Conservative cut separation strategy. Strong CG cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutSepZeroHalfStrategy (integer): Strategy for separation of zero-half cuts ↵
A more aggressive strategy will increase the effort spent in zero-half cut separation and the frequency at which zero-half cuts are separated during the branch-and-bound tree search. If a conservative strategy is selected (i.e., value 1), then zero-half cuts will be separated only at the root node of the branch-and-bound tree.
Setting the control to value -2 behaves like automatic selection (value -1), but, unlike -1, the value -2 is not overridden by the meta control cutSepStrategy. For instance, setting cutSepStrategy = 0 cutSepZeroHalfStrategy = -2 will disable all other cut separators, but enforce an automatic separation strategy for zero-half cuts.
Default:
-1
value meaning -2Automatic selection of cut separation strategy, enforced regardless of the value of the meta control cutSepStrategy. -1Automatic selection of cut separation strategy. 0Off. No separation of zero-half cuts. 1Conservative cut separation strategy. Zero-half cuts separated only at the root node. 2Moderate cut separation strategy. 3Aggressive cut separation strategy.
cutStrategy (integer): Branch and Bound: General cut strategy in terms of limits on the number of cuts and of non-zero cut elements that can be added to the problem ↵
A more aggressive cut strategy, allowing a greater number of cuts and non-zero cut elements in the subproblems, will typically result in fewer nodes to be explored, but at the cost of a slowdown in the node throughput (i.e., the more cuts are added, the harder it becomes to solve the LP relaxation of each node subproblem). On the other hand, a more conservative cut strategy will typically improve the node throughput, but at the cost of more nodes to be explored for solving the problem.
Default:
-1
value meaning -1Automatic selection of the cut strategy. 0No cuts. 1Conservative cut strategy. 2Moderate cut strategy. 3Aggressive 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:
1
value meaning 1Automatically determined. 2Dual simplex. 3Primal simplex. 4Newton barrier (or hybrid gradient, if barAlg=4 or barAlg=5 is set). 5Network simplex.
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.
Default:
0
value meaning 0The limit is determined automatically. >0Every column with more than this number of elements is considered dense by the Newton barrier.
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. GPU support for the hybrid gradient algorithm is not available in the concurrent LP solver in deterministic mode.
Default:
1
value meaning 0Use opportunistic mode. 1Use deterministic mode. 2Use deterministic mode, except allow the initial concurrent continuous solve of a MIP to be opportunistic.
deterministicLog (boolean): Suppress non-deterministic log information in the standard MIP log ↵
In particular, wall clock time stamps are replaced by (deterministic) work units.
By default, all solution routines of the Optimizer are deterministic - multiple invocations on the same data yield a reproducible algorithmic path. However, some of the log information produced may differ between two runs. In particular, wall clock time stamps in seconds may slightly vary between runs. Setting deterministicLog=1 suppresses all nondeterministic log information. All time stamps are reported as deterministic work units. Setting deterministicLog=1 also suppresses memory usage information. The degree of determinism of the Optimizer is governed by the user control deterministic. The correct function of time limit controls such as timeLimit is not affected by this control. This control does not guarantee a deterministic log for nonstandard values of the mipLog control.
Default:
0
value meaning 0Report wall clock time stamps and other non-deterministic log information (the default) 1Suppress non-deterministic log information. In particular, report deterministic work units instead of time.
dualGradient (integer): Simplex: Dual simplex pricing method ↵
Default:
-1
value meaning -1Determined automatically. 0Devex. 1Steepest edge. 2Direct steepest edge. 3Sparse 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:
-1
value meaning -1Determine automatically which version would be faster. 0Solve the original problem. 1Solve the dualized problem.
dualizeOps (boolean): Bit-vector control for adjusting the behavior when a problem is dualized ↵
Default:
1
value meaning bit 0 = 1Swap 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 ↵
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.
Default:
-1
value meaning -1The perturbation factor is determined automatically. 0No perturbation prior to optimization. >0The perturbation factor.
dualStrategy (integer): Bit-vector control specifies the dual simplex strategy ↵
Default:
1
value meaning bit 0 = 1Switch to primal when re-optimization goes dual infeasible and numerically unstable. bit 1 = 2When dual intend to switch to primal, stop the solve instead of switching to primal. bit 2 = 4Use more aggressive cut-off in MIP search. bit 3 = 8Use dual simplex to remove cost perturbations. bit 4 = 16Enable more aggressive dual pivoting strategy. bit 5 = 32Keep using dual simplex even when it′s numerically unstable.
dualThreads (integer): Determines the maximum number of threads that dual simplex is allowed to use ↵
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.
In case of a GAMS license with core limit, the link may overwrite
dualThreadsto enforce the limit.Default:
-1
value meaning -1The threads are determined by the threads control. >0The maximum number of dual simplex threads.
eigenvalueTol (real): Quadratic matrix is considered not to be positive semi-definite, if its smallest eigenvalue is smaller than the negative of this value ↵
Default:
1e-06
value meaning >=0The eigenvalue tolerance.
elimFillin (integer): Amount of fill-in allowed when performing an elimination in presolve ↵
Default:
7
value meaning 0No fill-in is allowed. >0Amount of fill-in allowed for a single elimination in presolve.
elimTol (real): Markowitz tolerance for the elimination phase of the presolve ↵
Default:
0.001
value meaning (0,1]Markowitz tolerance to use.
escapeNames (boolean): If characters illegal to an mps or lp file should be escaped to guarantee readability, and whether escaped characters should be transformed back when reading such a file ↵
Default:
1
value meaning 0Illegal characters are not escaped. 1Illegal characters are escaped.
etaTol (real): Zero tolerance for eta vector 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.
Default:
1e-13
value meaning >0The zero tolerance for eta vector elements.
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:
-1
value meaning -1Use automatic settings. 0Turned off. 1Run the heuristic on models with all integer variables. 2Run the heuristic on models in which all non-integer variables have bounds [0,1]. 3Run 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 root node ↵
Default:
-1
value meaning -1Automatic. 0Turned off. 1Always try the Feasibility Pump. 2Try 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.
Default:
1e-06
value meaning >0The feasibility tolerance.
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.
Default:
1e-06
value meaning >0The upper limit for basic solution perturbations.
feasTolTarget (real): Target feasibility tolerance for the solution refiner ↵
Use very small positive 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.
Default:
0
value meaning 0The value of feasTol is used. >0The target feasibility tolerance for the solution refiner.
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 0Disabled. 1Enabled. Force the dual simplex solver to use the parallel algorithm.
freegamsmodel (boolean): Preserves memory by dumping the GAMS model instance representation temporarily to disk ↵
Default:
0
genConsAbsTransformation (integer): Specifies the reformulation method for absolute value general constraints at the beginning of the search ↵
Default:
-1
value meaning -1Automatic. 0Use a formulation based on indicator constraints. 1Use 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 0Disabled. No dual reductions, add columns and rows. 1Enabled. 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 0Disabled. Problem will return unbounded. >0Enabled. Apply lower and upper bounds of this magnitude to all nonlinear original and auxiliary variables if initial LP and first regularization are unbounded. <0Enabled. Apply lower and upper bounds of this magnitude to all nonlinear original variables if initial LP is unbounded.
globalConvCutMaxRounds (integer): Number of rounds of outer approximation and convexification cuts separated at the root node of the branch-and-bound tree search, when solving an (MI)NLP to global optimality ↵
Default:
-1
value meaning -1Number of rounds determined automatically. 0No outer approximation or convexification cuts at the root node. >0Target number of rounds of outer approximation and convexification cuts at the root node.
globalConvCutMaxTreeRounds (integer): Number of rounds of outer approximation and convexification cuts separated at a node of the branch-and-bound tree search other than the root node, when solving an (MI)NLP to global optimality ↵
Default:
-1
value meaning -1Number of rounds determined automatically. 0No outer approximation or convexification cuts at tree nodes. >0Target number of rounds of outer approximation and convexification cuts at tree nodes.
globalInitCutStrategy (integer): Strategy for the initial tangent/secant convexification cuts added per nonlinear operator when setting up the initial LP relaxation during a global solve ↵
Adding more cuts tightens the problem, resulting in a smaller branch-and-bound tree, at the cost of slowing down each LP solve.
Default:
-1
value meaning -1Automatic selection of the strategy. 0Off. No initial convexification cuts are added. 1Conservative strategy. 2Moderate strategy. 3Aggressive strategy.
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:
-1
value meaning -1Automatic selection of the strategy. 0Never run a local solver on a partially fixed solution. 1Conservative strategy. 2Moderate strategy. 3Aggressive strategy.
globalMISLPHeurStrategy (integer): Controls how aggressively a set of MISLP-based root heuristics are run at the root node when solving an (MI)NLP to global optimality ↵
Default:
-1
value meaning -1Automatic. The solver decides which heuristics to run and how aggressively, based on heurEmphasis. 0Off. No root heuristics of this kind are run. 1Conservative. A small set of cheap root heuristics is run with tight effort limits. 2Moderate. A larger set of root heuristics is run with moderate effort limits. 3Aggressive. The full set of root heuristics is run with generous effort limits.
globalPresolveOBBT (integer): Controls the amount of work performed by Optimization-Based Bound Tightening (OBBT) ↵
Default:
-1
value meaning -1Automatic. The solver decides how much effort goes into OBBT. 0Disabled. No OBBT will be performed. 1OBBT is run for a small subset of the variables, approximately equal to the square root of the number of total variables used in the solve, i.e., original and auxiliary. 2OBBT is run on a larger portion of the variables while keeping the computational effort limited w.r.t. the whole global solve. 3OBBT is run on all variables. This is most computationally taxing as a large number of LPs will be solved.
globalSpatialBranchCuttingEffort (real): Limits the effort that is spent on creating cuts during spatial branching ↵
Default:
-1
value meaning -1The algorithm chooses the effort limit automatically (default). 0Disables cuts on branching entities. (0,1]Relative effort to spend on cutting on branching entities. Higher values lead to more cuts.
globalSpatialBranchIfPreferOrig (integer): Whether spatial branchings on original variables should be preferred over branching on auxiliary variables that were introduced by the reformulation of the global solver ↵
Default:
-1
value meaning -1Automatically determined. 0Always consider both original and auxiliary variables. 1Always prefer branching on original variables over auxiliaries. 2Always prefer branching on auxiliary variables over originals.
globalSpatialBranchPropagationEffort (real): Limits the effort that is spent on propagation during spatial branching ↵
Default:
-1
value meaning -1The algorithm chooses the effort limit automatically (default). 0Disables propagation on branching entities. >0Relative effort to spend on propagating on branching entities. Higher values lead to more propagation.
gpuCUDADevice (integer): Controls which CUDA device should be used when GPU execution is enabled and there are multiple CUDA devices installed in a system ↵
The first CUDA device number is 0. If the selected CUDA device is invalid or is not found, then an error is returned.
Default:
-1
value meaning -1Use the default device for the current thread (typically 0). >=0Select the CUDA device to use.
gpuPlatform (boolean): Controls what kind of GPU support is enabled overall in Xpress ↵
Individual solver components may disable GPU support.
Enabling GPU support will almost certainly lead to a different solution path and potentially a slightly different solution.
Default:
1
value meaning 0Do not use any GPU support. 1Use GPU support based on CUDA (if available).
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:
-1
value meaning -1Automatic - let the Optimizer decide if heuristics should be run. 0Disabled. 1Enabled.
heurBeforeLPGPUEffort (real): Effort dial to control the effort spent inside the selected GPU heuristic method ↵
If a GPU-accelerated heuristic method has been selected, this control can be used to increase or decrease the overall effort spent by the heuristic. For the heuristic enabled by setting heurBeforeLPGPUMethod to 1, the effort parameter controls the iterations spent inside the primal-dual hybrid gradient algorithm.
For the feasibility pump heuristic, the effort is mainly limited by an iteration limit for the primal-dual hybrid gradient algorithm. The automatic setting -1.0 is equivalent to the value 1.0 unless the user specified a value for barHGMaxRestarts, which is then used as iteration limit for each LP solved by the heuristic.
Default:
-1
value meaning -2Run with (almost) no effort limit. This can be useful for evaluating whether the heuristic can find a solution without practical working limits -1Automatic choice of effort. 0Disable GPU heuristics. (0,100]Dial the effort for the GPU heuristic by setting a value > 1.0, limit the search effort by setting a value < 1.0.
heurBeforeLPGPUMethod (integer): Enables a GPU-accelerated heuristic of the specified type ↵
If enabled, this heuristic is called as a BEFORELP heuristic for multiple rounds. The control value 1 enables a GPU accelerated version of feasibility pump. In each round, the LP relaxation is approximately solved using the Primal Dual Hybrid Gradient algorithm on the GPU, The fractional solution is then rounded, and a heuristic is called to minimize the remaining violations. The effort spent on this final polishing step can be controlled by the user.
For the feasibility pump heuristic, all controls affecting the Primal-dual hybrid gradient algorithm also affect this heuristic, in particular the barHGPrecision to control the precision of the arithmetic on the GPU, and barHGRelTol to specify the feasibility tolerance. If those values are left to their defaults, the heuristic may choose a sensibly loose tolerance value to speed up the convergence of the PDHG algorithm. The feasibility of solutions returned by the GPU heuristic is unaffected by the selected value for barHGRelTol, as the rounding and polishing steps are performed respecting the main tolerances of the Optimizer, namely mipTol and feasTol.
Default:
-1
value meaning -1Leave the decision to the solver. 0Disable any GPU heuristic. 1Enable the feasibility pump GPU Heuristic. Use the limit controls as well as the controls of the primal-dual hybrid gradient algorithm to fine-tune the behavior.
heurDiveIterLimit (real): Branch and Bound: Simplex iteration limit for reoptimizing during the diving heuristic ↵
Default:
-1
value meaning 0No iteration limit. >0Fixed iteration limit. <0Automatic 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:
-1
value meaning -1Automatic selection. 0Do not use soft rounding. 1Cautious use of the soft rounding strategy. 2More 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 -2Automatic selection biased towards quality -1Automatic selection biased towards speed. 0..4Manual 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:
-1
value meaning -1Automatic selection of strategy. 0Disables the diving heuristic. 1..18Available 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.
A setting of this control to 2 will enable the Pre-root parallel heuristic phase for a limited, problem-dependent amount of work. This phase can be explicitly disabled by setting preRootEffort to 0.
Default:
-1
value meaning -1Optimizer default strategy. 0Disables all heuristics. 1Focus on reducing the primal-dual gap in the early part of the search. 2Extremely aggressive search heuristics.
heurForceSpecialObj (boolean): Branch and Bound: Whether large neighborhood search (LNS) 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 0Disabled. 1Enabled. 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.
Default:
-1
value meaning -1Automatic. >=0The frequency at which heuristics are used in the tree search.
heurSearchAnalyticStrategy (integer): Strategy control for the Analytic Center (A) large neighborhood search heuristic, an LNS heuristic with an auxiliary objective function ↵
Called seldom and only when no feasible solution is available.
At a moderate strategy, the LNS heuristics obey any user-specified value for heurSearchRootCutFreq and/or heurSearchFreq exactly. However, setting an LNS heuristic to a conservative (aggressive) strategy will lead to a less (more) frequent execution during the root cut loop and/or during the tree search than mandated by the frequency controls. Note that the effective frequency and effort applied by the chosen strategy are also influenced by heurEmphasis. The control value -2 behaves like automatic selection (value −1), but, unlike -1, the value -2 is not overridden by the meta control heurSearchStrategy. For instance, setting heurSearchStrategy = 0 heurSearchAnalyticStrategy = -2 will disable all other LNS heuristics, but enforce the default behavior of the A heuristic.
Default:
-1
value meaning -2Automatic enforced. The Optimizer determines the frequency and effort of this heuristic, ignoring the value of heurSearchStrategy. -1Automatic. The Optimizer determines the frequency and effort of this heuristic. 0Disabled. 1Conservative strategy; the heuristic is run less frequently than the default. 2Moderate strategy; default level of frequency and effort. 3Aggressive strategy; the heuristic is run more frequently than the default.
heurSearchBackgroundSelect (integer): Bit-vector control to 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 indicates 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 = 2Enable L heuristic.
heurSearchCombineStrategy (integer): Strategy control for the Combine (C) large neighborhood search heuristic, which uses a neighborhood set up through the combination of multiple integer solutions ↵
At a moderate strategy, the LNS heuristics obey any user-specified value for heurSearchRootCutFreq and/or heurSearchFreq exactly. However, setting an LNS heuristic to a conservative (aggressive) strategy will lead to a less (more) frequent execution during the root cut loop and/or during the tree search than mandated by the frequency controls. Note that the effective frequency and effort applied by the chosen strategy are also influenced by heurEmphasis. The control value -2 behaves like automatic selection (value −1), but, unlike -1, the value -2 is not overridden by the meta control heurSearchStrategy. For instance, setting heurSearchStrategy = 0 heurSearchCombineStrategy = -2 will disable all other LNS heuristics, but enforce the default behavior of the C heuristic.
Default:
-1
value meaning -2Automatic enforced. The Optimizer determines the frequency and effort of this heuristic, ignoring the value of heurSearchStrategy. -1Automatic. The Optimizer determines the frequency and effort of this heuristic. 0Disabled. 1Conservative strategy; the heuristic is run less frequently than the default. 2Moderate strategy; default level of frequency and effort. 3Aggressive strategy; the heuristic is run more frequently than the default.
heurSearchCopyControls (integer): Select how user-set controls should affect the subproblems solved by large neighborhood search (LNS) 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:
1
value meaning 0Do not copy any user-set controls into the subproblems. 1Automatic - Let the Optimizer decide which user-set controls to copy. 2Copy all user-set controls.
heurSearchEffort (real): Adjusts the overall level of the large neighborhood search (LNS) heuristics ↵
Default:
1
value meaning 0Disables all LNS heuristics. >0Multiplier on the default amount of work the large neighborhood search heuristics should do. A higher value means that all active LNS heuristics are allowed to search larger neighborhoods.
heurSearchFreq (integer): Branch and Bound: How often the large neighborhood search (LNS) heuristic should be run in the tree ↵
Default:
-1
value meaning -1Automatic. 0Disabled in the tree. >0Number of nodes between each run.
heurSearchLPFirstStrategy (integer): Strategy control for the LP first (L) large neighborhood search heuristic, an LNS heuristic with a small neighborhood centered around a node LP solution ↵
At a moderate strategy, the LNS heuristics obey any user-specified value for heurSearchRootCutFreq and/or heurSearchFreq exactly. However, setting an LNS heuristic to a conservative (aggressive) strategy will lead to a less (more) frequent execution during the root cut loop and/or during the tree search than mandated by the frequency controls. Note that the effective frequency and effort applied by the chosen strategy are also influenced by heurEmphasis. The control value -2 behaves like automatic selection (value −1), but, unlike -1, the value -2 is not overridden by the meta control heurSearchStrategy. For instance, setting heurSearchStrategy = 0 heurSearchLPFirstStrategy = -2 will disable all other LNS heuristics, but enforce the default behavior of the L heuristic.
Default:
-1
value meaning -2Automatic enforced. The Optimizer determines the frequency and effort of this heuristic, ignoring the value of heurSearchStrategy. -1Automatic. The Optimizer determines the frequency and effort of this heuristic. 0Disabled. 1Conservative strategy; the heuristic is run less frequently than the default. 2Moderate strategy; default level of frequency and effort. 3Aggressive strategy; the heuristic is run more frequently than the default.
heurSearchMIPFirstStrategy (integer): Strategy control for the MIP first (M) large neighborhood search heuristic, an LNS heuristic with a small neighborhood centered around an integer solution ↵
This heuristic will often provide smaller, incremental improvements to an incumbent solution.
At a moderate strategy, the LNS heuristics obey any user-specified value for heurSearchRootCutFreq and/or heurSearchFreq exactly. However, setting an LNS heuristic to a conservative (aggressive) strategy will lead to a less (more) frequent execution during the root cut loop and/or during the tree search than mandated by the frequency controls. Note that the effective frequency and effort applied by the chosen strategy are also influenced by heurEmphasis. The control value -2 behaves like automatic selection (value −1), but, unlike -1, the value -2 is not overridden by the meta control heurSearchStrategy. For instance, setting heurSearchStrategy = 0 heurSearchMIPFirstStrategy = -2 will disable all other LNS heuristics, but enforce the default behavior of the M heuristic.
Default:
-1
value meaning -2Automatic enforced. The Optimizer determines the frequency and effort of this heuristic, ignoring the value of heurSearchStrategy. -1Automatic. The Optimizer determines the frequency and effort of this heuristic. 0Disabled. 1Conservative strategy; the heuristic is run less frequently than the default. 2Moderate strategy; default level of frequency and effort. 3Aggressive strategy; the heuristic is run more frequently than the default.
heurSearchRINSStrategy (integer): Strategy control for the RINS (R) large neighborhood search heuristic, an LNS heuristic that is potentially expensive but good for finding solutions that differ significantly from the incumbent ↵
At a moderate strategy, the LNS heuristics obey any user-specified value for heurSearchRootCutFreq and/or heurSearchFreq exactly. However, setting an LNS heuristic to a conservative (aggressive) strategy will lead to a less (more) frequent execution during the root cut loop and/or during the tree search than mandated by the frequency controls. Note that the effective frequency and effort applied by the chosen strategy are also influenced by heurEmphasis. The control value -2 behaves like automatic selection (value −1), but, unlike -1, the value -2 is not overridden by the meta control heurSearchStrategy. For instance, setting heurSearchStrategy = 0 heurSearchRINSStrategy = -2 will disable all other LNS heuristics, but enforce the default behavior of the R heuristic.
Default:
-1
value meaning -2Automatic enforced. The Optimizer determines the frequency and effort of this heuristic, ignoring the value of heurSearchStrategy. -1Automatic. The Optimizer determines the frequency and effort of this heuristic. 0Disabled. 1Conservative strategy; the heuristic is run less frequently than the default. 2Moderate strategy; default level of frequency and effort. 3Aggressive strategy; the heuristic is run more frequently than the default.
heurSearchRootCutFreq (integer): How frequently to run the large neighborhood search (LNS) heuristics during root cutting ↵
This is given as how many cut rounds to perform between runs of the heuristics. Set to zero to disable all LNS heuristics during root cutting.
Default:
-1
value meaning -1Automatic. 0Disables LNS heuristics during cutting. >0Number of cutting rounds between each run.
heurSearchStrategy (integer): Meta strategy control for large neighborhood search (LNS) heuristics ↵
When set to a value other than automatic, it determines the frequency and effort of all LNS heuristics whose individual strategy control is set to automatic. Individual heuristic strategy controls take precedence over this setting.
Each individual LNS heuristic control has a special value -2, which can be set to ignore the value of this meta control and force the default behavior for the heuristic. At a moderate strategy, the LNS heuristics obey any user-specified value for heurSearchRootCutFreq and/or heurSearchFreq exactly. However, setting an LNS heuristic to a conservative (aggressive) strategy will lead to a less (more) frequent execution during the root cut loop and/or during the tree search than mandated by the frequency controls.
Default:
-1
value meaning -1Each LNS heuristic uses its own default strategy. 0All LNS heuristics set to automatic are disabled. 1Conservative strategy applied to all LNS heuristics set to automatic. 2Moderate strategy applied to all LNS heuristics set to automatic. 3Aggressive strategy applied to all LNS heuristics set to automatic.
heurSearchZeroObjStrategy (integer): Strategy control for the Zero Objective (Z) large neighborhood search heuristic, an LNS heuristic without an objective function ↵
Called seldom and only when no feasible solution is available.
At a moderate strategy, the LNS heuristics obey any user-specified value for heurSearchRootCutFreq and/or heurSearchFreq exactly. However, setting an LNS heuristic to a conservative (aggressive) strategy will lead to a less (more) frequent execution during the root cut loop and/or during the tree search than mandated by the frequency controls. Note that the effective frequency and effort applied by the chosen strategy are also influenced by heurEmphasis. The control value -2 behaves like automatic selection (value −1), but, unlike -1, the value -2 is not overridden by the meta control heurSearchStrategy. For instance, setting heurSearchStrategy = 0 heurSearchZeroObjStrategy = -2 will disable all other LNS heuristics, but enforce the default behavior of the Z heuristic.
Default:
-1
value meaning -2Automatic enforced. The Optimizer determines the frequency and effort of this heuristic, ignoring the value of heurSearchStrategy. -1Automatic. The Optimizer determines the frequency and effort of this heuristic. 0Disabled. 1Conservative strategy; the heuristic is run less frequently than the default. 2Moderate strategy; default level of frequency and effort. 3Aggressive strategy; the heuristic is run more frequently than the default.
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 -1The solver decides if Shift-and-propagate should be run. This is the default setting. 0Shift-and-propagate is disabled. 1Shift-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.
In case of a GAMS license with core limit, the link may overwrite
heurThreadsto enforce the limit.Default:
0
value meaning -1Automatically determined from the threads control. 0Disabled. >=1Number 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:
-1
value meaning -1Automatically determined. 0No update. 1Update using only regular branches from the root to the current node. 2Same as 1, but update with strong branching results as well. 3Update 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 0Turn off convexity checking. 1Turn on convexity checking.
iis (integer): Run the Irreducible Infeasible Subsystem (IIS) finder if the problem is infeasible ↵
Default:
0
value meaning 0No IIS computation 1Compute IIS after solve if the problem is infeasible 2Compute IIS without previous solve
iisLog (integer): Selects how much information should be printed during the IIS procedure ↵
Default:
1
value meaning 0The IIS procedure does not produce any output. 1Prints general information and a progress log of the deletion filter, including bounds on the size of the IIS and timing information. 2Complete logging, including the full progress log of all the subproblem solves in the deletion filter. This setting is recommended only for debugging as it may produce a lot of output.
iisOps (integer): Selects which part of the restrictions (bounds, constraints, entities) should always be kept in an IIS ↵
This is useful if certain types of restrictions cannot be violated, thus they are known not to be the cause of infeasibility. The IIS obtained this way is irreducible only for the non-protected restrictions. This bit-vector control has an effect only on the deletion filter of the IIS procedure.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
0
value meaning bit 0 = 1Equivalent to iisOps_binary. bit 1 = 2Equivalent to iisOps_zeroLower. bit 2 = 4Equivalent to iisOps_fixedVar. bit 3 = 8Equivalent to iisOps_bound. bit 4 = 16Equivalent to iisOps_genIntegrality. bit 5 = 32Equivalent to iisOps_equality. bit 6 = 64Keep all general constraints. bit 7 = 128Keep all piecewise linear constraints. bit 8 = 256Equivalent to iisOps_set. bit 9 = 512Equivalent to iisOps_indicator. bit 10 = 1024Keep all delayed rows. bit 11 = 2048Equivalent to iisOps_constraint.
iisOps_binary (boolean): Keep binary integralities ↵
See also iisOps.
Default:
0
iisOps_bound (boolean): Keep all variable bounds ↵
See also iisOps.
Default:
0
iisOps_constraint (boolean): Keep all constraints ↵
See also iisOps.
Default:
0
iisOps_equality (boolean): Keep all equality constraints ↵
See also iisOps.
Default:
0
iisOps_fixedVar (boolean): Keep fixed variables ↵
See also iisOps.
Default:
0
iisOps_genIntegrality (boolean): Keep all general integer entities, except binaries ↵
See also iisOps.
Default:
0
iisOps_indicator (boolean): Keep all indicator constraints ↵
See also iisOps.
Default:
0
iisOps_set (boolean): Keep all specially ordered set (SOS) constraints ↵
See also iisOps.
Default:
0
iisOps_zeroLower (boolean): Keep the 0 lower bounds of variables ↵
See also iisOps.
Default:
0
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.
Default:
100000
value meaning >=0Largest Big-M for which linearizations of indicator constraints are added.
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.
Default:
100
value meaning >=0Largest Big-M for which indicator constraints are replaced by their linearization.
inputTol (real): Zero tolerance for input values ↵
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.
Default:
0
value meaning >=0The zero tolerance for input values.
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.
Default:
-1
value meaning -1The frequency is determined automatically. >=0The frequency with which the basis will be inverted.
invertMin (integer): Minimum number of Simplex iterations between full inversions of the basis matrix ↵
See the description of invertFreq for details.
Default:
3
value meaning -1The frequency is determined automatically. >=0The minimum number of Simplex iterations between full inversions of the basis matrix.
ioTimeout (integer): Maximum number of seconds to wait for an I/O operation before it is cancelled ↵
Default:
30
value meaning >=1The maximum number of seconds to wait for I/O operations.
knitro_bar_directinterval (integer): Controls the maximum number of consecutive conjugate gradient (CG) steps before KNITRO will try to enforce that a step is taken using direct linear algebra. ↵
Range: {
-1, ..., ∞}Default:
10
knitro_bar_feasible (integer): Specifies whether special emphasis is placed on getting and staying feasible in the interior-point algorithms. ↵
Range: {
0, ...,3}Default:
0
knitro_bar_feasmodetol (real): Tolerance used in the feasibility condition that determines whether KNITRO will force subsequent iterates to remain feasible. ↵
Range: [
0, ∞]Default:
0.0001
knitro_bar_initmu (real): Specifies the initial value for the barrier parameter \(\mu\) used with the barrier algorithms. ↵
Range: [-∞, ∞]
Default:
0.1
knitro_bar_initpt (integer): Indicates initial point strategy for x, slacks and multipliers when using a barrier algorithm. ↵
Range: {
0, ...,3}Default:
0
knitro_bar_maxbacktrack (integer): Indicates the maximum allowable number of trial points during the linesearch of the Interior/Direct or SQP algorithm before treating the linesearch step as a failure and generating a new step. ↵
Range: {
0, ..., ∞}Default:
3
knitro_bar_maxcrossit (integer): Specifies the maximum number of crossover iterations before termination. ↵
Range: {
0, ..., ∞}Default:
0
knitro_bar_maxrefactor (integer): Indicates the maximum number of refactorizations of the KKT system per iteration of the Interior/Direct algorithm before reverting to a CG step. ↵
Range: {
-1, ..., ∞}Default:
-1
knitro_bar_murule (integer): Indicates which strategy to use for modifying the barrier parameter \(\mu\) in the barrier algorithms. ↵
Range: {
0, ...,6}Default:
0
knitro_bar_pencons (integer): Indicates whether a penalty approach is applied to the constraints. ↵
Range: {
-1, ...,3}Default:
0
knitro_bar_penrule (integer): Indicates which penalty parameter strategy to use for determining whether or not to accept a trial iterate. ↵
Range: {
0, ...,2}Default:
0
knitro_bar_switchrule (integer): Indicates whether or not the barrier algorithms will allow switching from an optimality phase to a pure feasibility phase. ↵
Range: {
-1, ...,3}Default:
0
knitro_blasoption (integer): Specifies the BLAS/LAPACK function library to use for basic vector and matrix computations. ↵
Range: {
-1, ...,4}Default:
1
knitro_delta (real): Specifies the initial trust region radius scaling factor used to determine the initial trust region size. ↵
Range: [
1e-14, ∞]Default:
1
knitro_feastol (real): Specifies the final relative stopping tolerance for the feasibility error. ↵
A value of -1 means that KNITRO chooses this automatically.
Range: [
-1, ∞]Default:
1e-06
knitro_feastolabs (real): Specifies the final absolute stopping tolerance for the feasibility error. ↵
Range: [
-1, ∞]Default:
-1
knitro_gradopt (integer): Specifies how to compute the gradients of the objective and constraint functions. ↵
Range: {
1, ...,5}Default:
1
knitro_hessopt (integer): Specifies how to compute the (approximate) Hessian of the Lagrangian. ↵
Range: {
0, ...,7}Default:
0
knitro_honorbnds (integer): Indicates whether or not to enforce satisfaction of simple variable bounds throughout the optimization. ↵
Range: {
-1, ...,2}Default:
2
knitro_infeastol (real): Specifies the (relative) tolerance used for declaring infeasibility of a model. ↵
Range: [
0, ∞]Default:
1e-08
knitro_linsolver (integer): Indicates which linear solver to use to solve linear systems arising in KNITRO algorithms. ↵
Range: {
0, ...,9}Default:
0
knitro_lmsize (integer): Specifies the number of limited memory pairs stored when approximating the Hessian using the limited-memory quasi-Newton BFGS option. ↵
Range: {
1, ...,100}Default:
10
knitro_maxcgit (integer): Determines the maximum allowable number of inner conjugate gradient (CG) iterations per KNITRO minor iteration. ↵
Range: {
-1, ..., ∞}Default:
0
knitro_maxit (integer): Specifies the maximum number of iterations before termination. ↵
Range: {
0, ..., ∞}Default:
0
knitro_mip_branchrule (integer): Specifies which branching rule to use for MIP branch and bound procedure. ↵
Range: {
0, ...,3}Default:
0
knitro_mip_gub_branch (integer): Specifies whether or not to branch on generalized upper bounds (GUBs). ↵
Range: {
0, ...,1}Default:
0
knitro_mip_heuristic (integer): Which MIP heuristic to apply for an initial integer feasible point. ↵
Range: {-∞, ..., ∞}
Default:
0
knitro_mip_heur_maxit (integer): Maximum number of iterations to allow for MIP heuristic. ↵
Range: {
0, ..., ∞}Default:
100
knitro_mip_implicatns (integer): Whether to add logical implications deduced from branching decisions at a MIP node. ↵
Range: {
0, ...,1}Default:
1
knitro_mip_intgapabs (real): The absolute optimality gap stop tolerance for MIP. ↵
Range: [
-1, ∞]Default:
1e-06
knitro_mip_intgaprel (real): The relative optimality gap stop tolerance for MIP. ↵
Range: [
-1, ∞]Default:
1e-06
knitro_mip_knapsack (integer): Specifies rules for adding MIP knapsack cuts. ↵
Range: {
-1, ...,2}Default:
1
knitro_mip_maxnodes (integer): Specifies the maximum number of nodes explored (0 means no limit). ↵
Range: {
0, ..., ∞}Default:
100000
knitro_mip_method (integer): Specifies which MIP method to use. ↵
Range: {
0, ...,3}Default:
0
knitro_mip_outinterval (integer): Specifies node printing interval for mip_outlevel when mip_outlevel > 0. ↵
Range: {
0, ..., ∞}Default:
10
knitro_mip_outlevel (integer): Specifies how much MIP information to print. ↵
Range: {
0, ...,3}Default:
1
knitro_mip_pseudoinit (integer): Specifies the method used to initialize pseudo-costs corresponding to variables that have not yet been branched on in the MIP method. ↵
Range: {
0, ...,2}Default:
0
knitro_mip_root_nlpalg (integer): Specifies which algorithm to use for root node NLP solves in MIP (same options as nlp_algorithm user option). ↵
Range: {
0, ...,6}Default:
0
knitro_mip_rounding (integer): Specifies the MIP rounding rule to apply. ↵
Range: {
-1, ...,4}Default:
0
knitro_mip_selectrule (integer): Specifies the MIP select rule for choosing the next node in the branch-and-bound tree. ↵
Range: {
0, ...,3}Default:
0
knitro_mip_strong_candlim (integer): Specifies the maximum number of candidates to explore for MIP strong branching. ↵
Range: {
0, ..., ∞}Default:
10
knitro_mip_strong_level (integer): Specifies the maximum number of tree levels on which to perform MIP strong branching. ↵
Range: {
0, ..., ∞}Default:
10
knitro_mip_strong_maxit (integer): Specifies the maximum number of iterations to allow for MIP strong branching solves. ↵
Range: {
0, ..., ∞}Default:
1000
knitro_nlp_algorithm (integer): Indicates which algorithm to use to solve nonlinear problems (e.g. NLPs, QPs, QCQPs) ↵
Range: {
0, ...,6}Default:
0
knitro_objrange (real): Specifies the extreme limits of the objective function for purposes of determining unboundedness. ↵
Range: [
0, ∞]Default:
1e+20
knitro_opttol (real): Specifies the final relative stopping tolerance for the KKT (optimality) error. ↵
A value of -1 means that KNITRO chooses this automatically.
Range: [
-1, ∞]Default:
1e-06
knitro_opttolabs (real): Specifies the final absolute stopping tolerance for the KKT (optimality) error. ↵
Range: [
-1, ∞]Default:
0
knitro_outlev (integer): Controls the level of output produced by KNITRO. ↵
Range: {
0, ...,6}Default:
2
knitro_par_numthreads (integer): Number of threads to use for parallel computing features. ↵
Range: {-∞, ..., ∞}
Default:
1
knitro_presolve (integer): Determine whether or not to use the KNITRO presolver to try to simplify the model by removing variables or constraints. ↵
Range: {
0, ...,1}Default:
1
knitro_presolve_tol (real): Determines the tolerance used by the KNITRO presolver to remove variables and constraints from the model. ↵
Range: [
0, ∞]Default:
1e-06
knitro_scale (integer): Specifies whether to perform problem scaling of the objective function, constraint functions, or possibly variables. ↵
Range: {
0, ...,3}Default:
1
knitro_soc (integer): Specifies whether or not to try second order corrections (SOC). ↵
Range: {
0, ...,2}Default:
1
knitro_xtol (real): Tolerance for convergence criterion based on relative change between successive solution points. ↵
Range: [
0, ∞]Default:
1e-15
lnpBest (integer): Maximum number of infeasible MIP entities to create lift-and-project cuts for during each round of Gomory cuts at the root node (see GOMCUTS) ↵
Default:
50
value meaning >=0The maximum number of infeasible MIP entities to create lift-and-project cuts for.
lnpIterLimit (integer): Number of iterations to perform in improving each lift-and-project cut ↵
Default:
-1
value meaning -1The number of iterations is determined automatically. 0A Gomory cut is created. >0The number of improving iterations.
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:
3
value meaning 1Never backtrack from the first child, unless it is dropped (infeasible or cut off). 2Always solve both child nodes before deciding which child to continue with. 3Automatically determined.
lpBackgroundThreads (integer): Maximum number of threads to use for background work (typically heuristics) in parallel to the root LP relaxation of a MIP ↵
This control can help finding feasible MIP solutions fast for models with difficult root LP relaxation. The algorithm employed is similar to the one used during pre-root parallel heuristics.
This control can be used to enable, disable, and tune the share of work dedicated to heuristics during the LP root relaxation. A specific choice of LP background threads has a direct consequence on the number of threads that the Optimizer uses for the LP relaxation. Users should avoid to manually specify more threads than physical cores are available on the host computer. The default behavior of this control is subject to the choice of heurEmphasis. If heurEmphasis=1 or higher, some of the available threads (typically 25%) are used for LP background work. The heuristic algorithm employed is similar to the algorithm used inside pre-root parallel heuristics. Every LP background thread increases the memory consumption of the search during the initial root relaxation. Use this control to limit or disable LP background work, if you encounter memory errors during the root relaxation.
Default:
-1
value meaning -1Automatic selection of LP background threads depending on the choice of heurEmphasis. 0Disable LP background threads >0Enabled. Specifies the number of threads reserved for LP background work.
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
algorithmis set at the same time,algorithmwill 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 = 1Equivalent to lpFlags_dual. bit 1 = 2Equivalent to lpFlags_primal. bit 2 = 4Equivalent to lpFlags_barrier. bit 3 = 8Equivalent to lpFlags_network.
lpFlags_barrier (boolean): Use the barrier method (or hybrid gradient method if barAlg=4 or barAlg=5 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:
-1
value meaning -1Automatic. 0Disable LP folding. 1Enable LP folding. Attempt to fold all LP problems and MIP initial relaxations.
lpIterLimit (integer): Simplex: 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.
When an lpIterLimit of 0 is set, the solver will stop at the beginning of the simplex solve (i.e., after presolving).
Default:
maxint
value meaning >=0The overall maximum number of Simplex iterations.
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 0Log displayed at the end of the optimization only. >0Specifies the frequency of the summary output by the number of Simplex iterations. <0Specifies the frequency of a detailed output by the number of Simplex 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 0Simplex log is printed based on simplex iteration count, at a fixed frequency as specified by the lpLog control. 1Simplex 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.
Default:
-1
value meaning -1The number of iterations is determined automatically. >=0The maximum number of refiner simplex iterations.
markowitzTol (real): Markowitz tolerance used for the factorization of the basis matrix ↵
Default:
0.01
value meaning (0,1]Defines the Markowitz tolerance.
matrixTol (real): Zero tolerance for 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.
Default:
1e-09
value meaning >0The zero tolerance for matrix elements.
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 0No time limit. >0Stop cut generation after the given number of seconds.
maxImpliedBound (real): Presolve: When tighter bounds are calculated during MIP or nonlinear 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.
This control does not apply to nonlinear probing, as that is designed to work on large bounds.
Default:
1e+08
value meaning >=0The maximum size of implied bounds during MIP presolve and nonlinear presolve.
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:
-1
value meaning -1Automatic. >=1Specifies local backtrack limit.
maxMemoryHard (integer): Sets the maximum amount of memory in MB (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.
Default:
0
value meaning 0No limit. >0The maximum amount of memory in MB.
maxMemorySoft (integer): When resourceStrategy is enabled, this control sets the maximum amount of memory in megabytes (MB) 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.
Default:
0
value meaning 0No limit. >0The maximum amount of target memory in MB.
maxMipSol (integer): Branch and Bound: Specifies a limit on the number of integer solutions to be found by the Optimizer ↵
The solve terminates once this limit is reached. 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 solution values.
Setting maxMipSol=1 can alter the solution path as this will put the emphasis on finding any feasible solution by triggering additional heuristics.
Default:
0
value meaning 0No limit. >0The maximum number of integer solutions to be found by the Optimizer.
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. 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 32-bit platforms and 256 on 64-bit platforms.
Default:
-1
value meaning -1Task limit determined automatically from mipThreads. >0Fixed task limit.
maxNode (integer): Branch and Bound: Maximum number of nodes that will be explored ↵
When maxNode is set to 0, the solver will stop after the root node.
Default:
maxint
value meaning >=0The maximum number of Branch and Bound nodes that will be explored.
maxPageLines (integer): Number of lines between page breaks in printable output ↵
Default:
23
value meaning >=0The number of lines between page breaks in printable output.
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..64The 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 0No stall time limit. >0If 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.
maxTotalTreeFilesize (integer): Maximum amount of disk space, in megabytes (MB), that can be used for storing tree data for a single problem ↵
If more than this is required by the solve, it will terminate with an error.
Where maxTreeFileSize has been set to enable tree data to be split across multiple files, maxTotalTreeFilesize will limit the sum of the sizes of all tree files.
Default:
2147483647
value meaning 0Do not allow any tree data to be written to disk. >=1The maximum size in MB of the tree file(s) on disk.
maxTreeFileSize (integer): Maximum size, in megabytes (MB), to which a single tree file may grow ↵
When the tree file reaches this limit, a second tree file will be created. Useful if you are using a filesystem that puts a maximum limit on the size of a file.
Default:
0
value meaning 0No limit for the size of the tree file. >=1The maximum size in MB of a tree file.
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:
0
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.
When solution enumeration is enabled (poolEnumStrategy> 0), mipAbsStop is compared against the upper and lower bounds on any undiscovered solution that can be added to the pool.
Default:
0
value meaning >=0The absolute MIP gap tolerance to terminate.
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:
max(-mipabsstop,-1E-05)
mipCleanup (boolean): Clean up the MIP solution (round-fix-solve) to get duals ↵
If nonzero, clean up the integer solution obtained, i.e. round and fix the discrete variables and re-solve as an LP to get some marginal values for the discrete vars.
Default:
0
mipComponents (integer): Determines whether disconnected components in a MIP should be solved as separate MIPs ↵
There can be significant performence benefits from solving disconnected components individual instead of being part of the main branch-and-bound search.
If there are no constraints linking two variables, either directly or indirectly through other variables, they are said to belong to two separate disconnected components. When a problem contains disconnected components of signficant size, it can be advantageous to solve each component as a separate MIP. When significant disconnected components are detected in the problem, the solver will switch to a different solve mode where each component is solved separately. This switch will happen after the root node processing has completed and when the solve is about to enter the branch-and-bound search. Solving disconnected components separately is not compatible with concurrent MIP solves. If concurrent MIP solves has been turned off, disconnected components will be solved as part of the standard branch-and-bound search in each concurrent solve. Disabling MIP dual reductions through mipDualReductions will also disable the separate solve of disconnected components.
Default:
-1
value meaning -1Automatic - let the solver decide. 0Disable solving disconnected components separately. 1Solve 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:
-1
value meaning -1Automatic - let the solver decide on a node limit. >=0Number of nodes each concurrent solve should complete before a winner is selected.
mipConcurrentSolves (integer): Selects the number of concurrent solves to start for a MIP ↵
Each solve will use a unique random seed for its random number generator, but will otherwise apply the same user controls. The first concurrent solve to complete will have solved the MIP and all the concurrent solves will be terminated at this point. Using concurrent solves can be advantageous when a MIP displays a high level of performance variability.
A node limit is imposed on each concurrent solve, through mipConcurrentNodes. When a concurrent solve reaches this node limit, it will be suspended until all concurrent solves have reached the limit. At this point a winner will be declared, based on which solve made the most progress towards optimality and only the winning solve will continue, using all threading resources. If a concurrent solve completes its MIP search before reaching the node limit, all solves will be stopped.
Default:
0
value meaning -1Enabled. The number of concurrent solves depends on mipThreads. 0..1Disabled >1Enabled. Specifies the number of concurrent solves to start.
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. Setting mipDualReductions=0 disables all dual reductions. This is recommended for advanced use cases such as optimization under external constraints applied dynamically to the problem using callbacks. In this case, mipDualReductions=0 guarantees that any solution to the original problem that satisfies all of the user′s external constraints maps to a feasible solution in the presolved space.
Default:
1
value meaning 0Prevent all dual reductions. 1Allow all dual reductions. 2Allow dual reductions on non MIP entities 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:
-1
value meaning -1Automatic. 0Disabled. 1Run before and after cutting on the root node. 2Run also during root cutting. 3Run 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 0Do not calculate condition numbers. 1Calculate conditions numbers on every node, including after each round of root cutting. >1Calculate a condition number once per node of every n′th level of the branch-and-bound tree, where n is the specified control value.
mipLog (integer): MIP log print control ↵
Default:
-100
value meaning 0No printout during MIP tree search. 1Only print out summary statement at the end. 2Print out detailed log at all solutions found. 3Print out detailed log at each node. <0Print out summary log at each n th node.
mipPresolve (integer): Branch and Bound: Type of integer processing to be performed at nodes ↵
If set to 0, no processing will be performed. This is a bit-vector control.
A value of -1 enables all individual bits.
You can control whether node presolve is applied, and at which level, with the control nodePresolve. The most common node presolve reductions also have a dedicated control, like nodeRedCostTighten. This bit-vector control allows you a more fine-grained control on which (less common) reductions are enabled or not.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
-1
value meaning bit 0 = 1Reduced cost fixing will be performed at each node. This bit is deprecated, use nodeRedCostTighten instead. bit 1 = 2Primal reductions will be performed at each node. This bit is deprecated, use nodeAppliedBounds instead. bit 3 = 8If node preprocessing is allowed to change bounds on non MIP entities (e.g., continuous) columns. This bit is deprecated, use nodeAppliedBounds instead. bit 4 = 16Dual reductions will be performed at each node. This bit is deprecated, use nodeDualReductions instead. bit 5 = 32Equivalent to mipPresolve_globalCoefTightening. bit 6 = 64Equivalent to mipPresolve_objBasedReductions. bit 7 = 128[Unused] This bit is no longer used to control restarts. Refer to the integer control mipRestart for disabling tree restarts. bit 8 = 256Equivalent to mipPresolve_symmetryReductions.
mipPresolve_globalCoefTightening (boolean): Allow global (non-bound) tightening of the problem during the tree search ↵
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_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:
-1
value meaning -1Automatically determined. 0No special treatment during the ramp-up phase. Always run with the maximal number of tasks. 1Limit 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.
Default:
-1
value meaning -1The effort limit is determined automatically. >=0The effort limit in terms of the number of simplex iterations.
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:
min(miprelstop,1E-04)
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 * 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 criterion 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. When solution enumeration is enabled (poolEnumStrategy> 0), mipRelStop is compared against the upper and lower bounds on any undiscovered solution that can be added to the pool.
Default:
0.0001
value meaning >=0The relative MIP gap tolerance to terminate.
mipRestart (integer): Branch and Bound: Controls strategy for in-tree restarts ↵
Default:
-1
value meaning -1Determined automatically. 0Disable in-tree restarts. 1Allow in-tree restarts at normal aggressiveness. 2Allow in-tree restarts at higher aggressiveness (more likely to trigger a restart).
mipRestartFactor (real): Branch and Bound: Fine tune initial conditions to trigger an in-tree restart ↵
Note that this control does not affect the initial condition on the gap, which must be set separately.
Default:
1
value meaning >0Aggressiveness with which the Optimizer restarts. Use a value > 1 to increase the aggressiveness with which the Optimizer restarts and a value < 1 to relax the aggressiveness with which the Optimizer restarts.
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.
Default:
0.02
value meaning [0.0,1.0]Initial relative MIP gap to delay in-tree restart.
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,
is_feasible.Supported opertators are: +, -, *, /, ^, %, !=, ==, <, <=, >, >=, !, &&, ||, (, ), abs, ceil, exp, floor, log, log10, pow, sqrt.
Example:
nodusd >= 1000 && is_feasible && abs(objest - objval) / abs(objval) < 0.1If multiple stop expressions are given in an option file, the algorithm stops if any of them is true (|| concatenation).
It is also possible to use historical values of these variables by appending a time-based look-back suffix, e.g.,
objval_10srefers to the best objective value from 10 seconds ago. This allows creating conditions based on progress over time, for example,objval - objval_60s < 0.01to stop if the objective has not improved by at least 0.01 in the last 60 seconds.To avoid performance degradation from evaluating the expression too frequently, the evaluation is skipped if progress in terms of time, nodes, and solution quality is below configurable thresholds. See also mipstopexprnodestep, mipstopexprtimestep, mipstopexprsolutiontol and mipstopexprverbosity.
mipstopexprnodestep (integer): Node interval that triggers stop expression evaluation ↵
Range: {
0, ..., ∞}Default:
100
mipstopexprsolutiontol (real): Solution improvement that triggers stop expression evaluation ↵
Range: [
0, ∞]Default:
1e-6
mipstopexprtimestep (real): Time interval that triggers stop expression evaluation ↵
Range: [
0, ∞]Default:
1
mipstopexprverbosity (integer): Verbosity level of stop expression ↵
Range: {
0, ...,2}Default:
0
mipStopStage (integer): Allows stopping a MIP solve in an early stage of the solution process ↵
If the control is set to a stage that is already completed then the next optimization will stop immediately.
Default:
0
value meaning 0Do not stop at an early stage of the solve. 1Stop after presolve. 2Stop after heuristics run before the initial relaxation. 3Stop after solving the initial relaxation. 4Stop at the end of the root node.
mipThreads (integer): If set to a positive integer it determines the number of threads implemented to run the parallel MIP code ↵
In case of a GAMS license with core limit, the link may overwrite
mipThreadsto enforce the limit.Default:
-1
value meaning -1The threads control will determine the number of threads used. >0The number of threads to run the parallel MIP code
mipTol (real): Branch and Bound: Tolerance within which a decision variable′s value is considered to be integral ↵
Default:
5e-06
value meaning >0The integrality tolerance for decision variables.
mipToltarget (real): Target mipTol value used by the automatic MIP solution refiner as defined by refineOps ↵
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.
Default:
0
value meaning 0The value of mipTol is used. >0Target mipTol value used by the automatic MIP solution refiner.
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.
mipTraceIncumbent (real): Minimal absolute improvement in primal bound, between MIP trace file I entries ↵
Range: [
0, ∞]Default:
1e-6
mipTraceNode (integer): Node interval between MIP trace file N entries ↵
Range: {
0, ..., ∞}Default:
100
mipTraceTime (real): Time interval, in seconds, between MIP trace file T entries ↵
Range: [
0, ∞]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:
-1
value meaning -1Determined automatically. 0Use the barrier algorithm in the branch and bound algorithm. 1Use outer approximations in the branch and bound algorithm.
mps18Compatible (integer): Provides compatibility of MPS file output for older MPS readers ↵
Default:
0
value meaning bit 0 = 1Do not write objective sense (OBJSENSE section). bit 1 = 2Fixed binaries are written as fixed only (unless used as a base variable for an indicator constraint).
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.
multiObjLog (integer): Log level for multi-objective optimization ↵
Default:
2
value meaning 0No logging. 1Print a summary of each problem that is solved as part of the multi-objective optimization. 2In addition to summaries, print messages produced by each solve at the level determined by outputLog.
multiObjOps (integer): Modifies the behaviour of the Optimizer when solving multi-objective problems ↵
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
7
value meaning bit 0 = 1Equivalent to multiObjOps_enabled. bit 1 = 2Equivalent to multiObjOps_presolve. bit 2 = 4Equivalent to multiObjOps_rcFixing. bit 3 = 8Equivalent to multiObjOps_noSolveAttribs.
multiObjOps_enabled (boolean): Multi-objective enabled ↵
If this bit is not set, multi-objective problems will treated as single- objective problems, and only objective 0 will be optimized.
See also multiObjOps.
Default:
1
multiObjOps_noSolveAttribs (boolean): If this bit is set, the Optimizer will not save the problem attributes after each objective is solved, which reduces memory usage ↵
See also multiObjOps.
Default:
0
multiObjOps_presolve (boolean): Apply multi-objective modifications during presolve ↵
If this bit is not set, the original problem will be modified when solving each subsequent objective, and these modifications will remain in the problem after the solve has completed.
See also multiObjOps.
Default:
1
multiObjOps_rcFixing (boolean): Reduced cost fixing ↵
If this bit is set, optimality of earlier objectives will be preserved by fixing all non-basic variables with non-zero reduced costs to their bounds. If not set, optimality of earlier objectives will be preserved by adding constraints to the problem.
See also multiObjOps.
Default:
1
multobj (boolean): Controls the hierarchical optimization of multiple objectives ↵
Default:
0
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:
-1
value meaning -1Automatically determined limit 0No limit. >0Limits the number of degenerate pivots of the network simplex algorithm.
nodeAppliedBounds (integer): Determines whether the solver is allowed to apply primal reductions at each node ↵
The solver will use the constraints of the node to tighten the range of variables, often resulting in fixing their values. This can greatly simplify the problem and may even determine optimality or infeasibility of the node before the simplex method commences.
Default:
-1
value meaning -1Automatic: the solver decides if and when to apply primal reductions at nodes. 0Disabled. 1Only apply primal reductions to MIP entities. 2Apply primal reductions to all variables.
nodeDualReductions (integer): Determines whether the solver is allowed to apply dual reductions at each node ↵
Default:
-1
value meaning -1Automatic: the solver decides if and when to apply dual reductions at nodes. 0Disabled. 1Apply dual reductions to all variables. 2Only apply dual reductions to non MIP entities.
nodePresolve (integer): Determines whether some form of presolving should be performed at Branch and Bound nodes ↵
Node presolve attempts to simplify the problem by detecting and removing redundant constraints, tightening variable bounds, etc.
The user can control which presolve operations are performed at nodes with the dedicated controls nodeRedCostTighten, nodeAppliedBounds, nodeDualReductions, nodeProbingEffort and the bits in mipPresolve. Note however that if node presolve is disabled by nodePresolve, then those will have no effect.
Default:
-1
value meaning -1Automatic: the solver decides which reductions to apply, and to which extent. 0Disabled. 1Minimal node presolve is applied. 2Standard node presolve is applied.
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.
Default:
1
value meaning >=0Level of the node probing effort.
nodeRedCostTighten (integer): Determines whether reduced cost tightening is applied during Branch and Bound ↵
Default:
-1
value meaning -1Automatic: the solver decides if and when to apply reduced cost tightening. 0Disabled. 1Enabled. 2Aggressive: the solver will search for alternative reduced costs to potentially increase the amount of tightening.
nodeSelection (integer): Branch and Bound: Determines which nodes will be considered for solution once the current node has been solved ↵
Default:
4
value meaning 1Local first: Choose between descendant and sibling nodes if available; choose from all outstanding nodes otherwise. 2Best first: Choose from all outstanding nodes. 3Local depth first: Choose between descendant and sibling nodes if available; choose from the deepest nodes otherwise. 4Best first, then local first: Best first is used for the first breadthFirst nodes, after which local first is used. 5Pure depth first: Choose from the deepest outstanding nodes.
numericalEmphasis (integer): How much emphasis to place on numerical stability instead of solve speed ↵
Default:
-1
value meaning -1Automatic. The emphasis might be influenced by the setting of other controls. 0Emphasize speed. 1Mild emphasis on numerical stability. 2Medium emphasis on numerical stability. 3Strong emphasis on numerical stability.
objnabstol (string): Allowable absolute degradation for objective ↵
objnreltol (string): Allowable relative degradation for objective ↵
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.
This control does not apply to problems solved with the global solver or to problems with multiple objectives.
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.
Default:
1e-06
value meaning >0The zero tolerance for reduced costs.
optimalityTolTarget (real): Target optimality tolerance for the solution refiner ↵
Use very small positive 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.
Default:
0
value meaning 0The value of optimalityTol is used. >0The target optimality tolerance for the solution refiner.
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 0Turn off printing of user-specified control settings. 1Print controls.
outputLog (integer): Controls the level of output produced by the Optimizer during optimization ↵
Default:
1
value meaning 0Turn all output off. 1Print all messages. 3Print error and warning messages. 4Print error messages only.
outputTol (real): Zero tolerance on print values ↵
Default:
1e-05
value meaning >=0The zero tolerance on print values.
penalty (real): Minimum absolute penalty variable coefficient ↵
Range: [
0, ∞]Default:
0
pivotTol (real): Simplex: Zero tolerance for pivot 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.
Default:
1e-09
value meaning >0The zero tolerance for Simplex pivot elements.
poolAbsGap (real): Limit on the absolute gap between the objective function values of the best and worst solutions in the pool ↵
The absolute difference between the objective values of the best solution in the pool and any other solution in the pool must be smaller than poolAbsGap. If a new best solution is discovered, any existing solutions that would violate this restriction are purged from the pool. This restriction is in addition to any other restrictions on the collected solutions.
Default:
0
value meaning 0No absolute gap restriction. >0The absolute gap limit to satisfy.
poolDuplicateCheck (integer): Determines which MIP column entities to consider when checking whether two enumerated solutions are duplicates ↵
If two solutions are discovered with the same discrete values for the MIP column entities, only the solution with the better objective value is kept.
The comparison between solutions is performed against the user′s provided problem. It does not include any MIP column entities introduced through problem transformations or presolve.
A MIP column entity is a binary, integer, semi-continuous, or semi-integer variable. For a semi-continuous variable, the comparison check will only distinguish between whether the solution value is zero or above the semi- continuous lower bound.
Default:
1
value meaning 1Solutions that agree in MIP columns specified using XPRSloadbranchdirs are considered duplicates. If no directives are given, then behaves the same as option 2. 2Solutions must agree in all MIP column entity values to be considered duplicates.
poolEnumStrategy (integer): Enables extended branch-and-bound search strategies to identify and capture additional solutions into the solution pool ↵
The built-in solution pool will collect solutions encountered during a branch- and-bound search, subject to the limitations imposed by controls such as poolLimit, poolRelGap and poolAbsGap. With the default setting of poolEnumStrategy=0 the collection will not affect the branch-and-bound search itself. When poolEnumStrategy > 0, more of the branch-and-bound tree will be explored and additional nodes will be searched based on whether they admit additional solutions that can be added to the solution pool.
Enumeration is only available for MIP column entities. This is either a binary, integer, semi-continuous, or semi-integer variable. It is not available for continuous variables or non-column MIP entities such as special ordered sets, piece-wise linear functions or general constraints.
A typical case when looking for alternative solutions is to find the n-best MIP solutions that differ in the MIP column entities. To do this, set poolLimit = n to collect n solutions and set poolEnumStrategy=2 to guarantee that all integer solutions are reachable through the branch-and-bound search.
Default:
0
value meaning 0Collect solutions that are found through a standard branch-and-bound search. 1Extend the branch-and-bound search to include solutions reachable through fractional branching. 2Extend the branch-and-bound search to include solutions reachable through both fraction and non-fractional branching on MIP column entities.
poolLimit (integer): Determines the maximum number of solutions to be collected during a solve ↵
Multiple solutions can be collected from a MIP solve, a Global solve or an MISLP solve.
The best solution to the problem will always be available through the pool as index 0. Setting poolLimit=0 or 1 is therefore equivalent to a standard solve without collecting additional solutions. No additional memory will be used by the pool in this case.
Default:
10
value meaning -1Collect all solutions found. 0Do not collect multiple solutions. 1Do not collect multiple solutions. >1Limit collection to the given number of solutions.
poolRelGap (real): Limit on the relative gap between the objective function values of the best and worst solutions in the pool ↵
The absolute difference between the objective values of the best solution in the pool and any other solution in the pool must be smaller than poolRelGap times the absolute objective value of the best solution. If a new best solution is discovered, any existing solutions that would violate this restriction are purged from the pool. This restriction is in addition to any other restrictions on the collected solutions.
Default:
0
value meaning 0No relative gap restriction. >0The relative gap limit to satisfy.
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:
-1
value meaning -1Automatic. 0Disable analytic center presolving. 1Use analytic center for variable fixing only. 2Use analytic center for reduced cost computation only. 3Use 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 -1Automatic. 0Disable basis reduction. 1Enable basis reduction.
preBndRedCone (integer): Determines if second order cone constraints should be used for inferring bound reductions on variables when solving a MIP ↵
Default:
-1
value meaning -1Automatic. 0Disable bound reductions from second order cone constraints. 1Enable 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:
-1
value meaning -1Automatic. 0Disable bound reductions from quadratic constraints. 1Enable bound reductions from quadratic constraints.
preCliqueLifting (integer): Presolve: Determines whether to do clique lifting ↵
Default:
-1
value meaning -1Automatically determined. 0Disabled. 1Enabled.
preCliqueStrategy (integer): Determines how much effort to spend on clique covers in presolve ↵
Default:
-1
value meaning -1Determined automatically. 0Disabled. >0Enabled.
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 0Disabled. 1Remove as many coefficients as possible. 2Cautious 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:
-1
value meaning -1Automatically determined. 0Disable the detection of independent components. 1Detect and solve independent components after presolving. 2Detect and solve independent components after solving the initial LP relaxation.
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.
Default:
1
value meaning >=0Effort of the independent component presolver.
preConeDecomp (integer): Presolve: Decompose regular and rotated cones with more than two elements and apply Outer Approximation on the resulting components ↵
Default:
-1
value meaning -1Automatically determined. 0Disable cone decomposition. 1Enable cone decomposition by replacing large cones with small ones in the presolved problem. 2Similar to 1, plus decomposition is enabled even if the cone variable is fixed. 3Cones 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:
-1
value meaning -1Automatically determined. 0Disable 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:
-1
value meaning -1Automatically determined. 0Disable reformulation. 1Move only the quadratic part of the objective into a constraint. 2Move 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:
-1
value meaning -1Automatically determined. 0Disable reformulation. 1Enable reformulation to diagonal quadratic constraints. 2Enable 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:
-1
value meaning -1Automatically determined. 0Disabled. 1Cautious strategy, limited effort looking for special structure. 2Same as 1 but checking all candidates. 3Includes 2 but also looks for more general column domination.
preDomRow (integer): Presolve: Determines the level of dominated row removal reductions to perform when presolving a problem ↵
Default:
-1
value meaning -1Automatically determined. 0Disabled. 1Cautious strategy. 2Medium strategy. 3Aggressive strategy. All candidate row combinations will be considered.
preDualReductions (integer): Determines whether the solver is allowed to apply dual reductions during presolve ↵
Default:
-1
value meaning -1Automatic: the solver decides if and when to apply dual reductions during presolve. 0Disabled. 1Apply dual reductions to all variables. 2Only apply dual reductions to non MIP entities.
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:
-1
value meaning -1Automatically determined. 0Do not eliminate duplicate rows. 1Eliminate only rows that are identical in all variables. 2Same as option 1 plus eliminate duplicate rows with simple penalty variable expressions. (MIP only). 3Same as option 2 plus eliminate duplicate rows with more complex penalty variable expressions. (MIP only).
preEliminations (integer): Presolve: Determines whether to perform variable eliminations ↵
Default:
-1
value meaning -1Automatically determined. 0Disabled. 1Only eliminations on non MIP entities. 2All types of eliminations allowed.
preElimQuad (integer): Presolve: Allows for elimination of quadratic variables via doubleton rows ↵
Default:
-1
value meaning -1Automatically determined. 0Do not eliminate duplicate rows. 1Eliminate 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:
-1
value meaning -1Automatically determined. 0Disabled. 1Enabled.
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:
-1
value meaning -1Automatically determined. 0Do not use implications for sparsification. 1Use implications to remove reduandant rows.
preLinDep (integer): Presolve: Determines whether to check for and remove linearly dependent equality constraints when presolving a problem ↵
Default:
-1
value meaning -1Automatically determined. 0Do not check for linearly dependent equality constraints. 1Check for and remove linearly dependent equality constraints.
preMIPEntDetect (integer): Presolve: Determines whether to do integer variable and SOS detection ↵
Default:
-1
value meaning -1Automatically determined. 0Disabled. 1Enabled.
preMIPReductions (integer): Presolve: Determines whether to do integrality based reductions ↵
Default:
-1
value meaning -1Automatically determined. 0Disabled. 1Only simple reductions are enabled. 2All reductions, including advanced ones, are enabled.
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 0Disable check and reductions. 1Enable check and reductions.
prePermute (integer): Bit-vector control specifies whether to randomly permute rows, columns and MIP entities when starting the presolve ↵
With the default value 0, no permutation will take place.
Random permutations enable trying out different solution paths when solving a problem. The random seed for the permutations can be set using prePermuteSeed. When both preSort and prePermute are enabled, it will sort and then permute the problem.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
0
value meaning bit 0 = 1Equivalent to prePermute_rows. bit 1 = 2Equivalent to prePermute_cols. bit 2 = 4Equivalent to prePermute_mip.
prePermuteSeed (integer): Specifies the seed for the pseudo-random number generator for permuting the problem when starting the presolve ↵
This control only has effects when prePermute is enabled.
Default:
1
value meaning >=1The seed for the pseudo-random number generator for permuting the problem when starting the presolve.
prePermute_cols (boolean): Permute columns ↵
See also prePermute.
Default:
0
prePermute_mip (boolean): Permute MIP entities ↵
This bit only affects MIP problems.
See also prePermute.
Default:
0
prePermute_rows (boolean): Permute rows ↵
See also prePermute.
Default:
0
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:
-1
value meaning -1Let the Optimizer decide on the amount of probing. 0Disabled. 1Light probing — only few implications will be examined. 2Full probing — all implications for all binaries will be examined. 3Full probing and repeat as long as the problem is significantly reduced.
preRootEffort (real): Dial for the work spent during the Pre-root parallel heuristic phase ↵
A positive value sets a suitable work limit that is dependent on problem- characteristics. Changing the value up/or down dials the work spent in this phase up or down. This control also enables/disables Pre-root parallel heuristics.
The special value of -2 does not use a phase-specific work limit at all. Make sure to use other limits to stop the Pre-root parallel phase eventually. If a workLimit on the overall solution process has been set, it also applies during the pre-root parallel phase. This control always sets a work limit that depends on the characteristics of the presolved problem. If you prefer to set an absolute work limit instead, consider the control preRootWorklimit.
Default:
-1
value meaning -2Enable Pre-root parallel heuristics without a specific work limit for this phase. The phase will terminate if a different limit is hit, or if it runs out of heuristic work to do. -1Enablement of Pre-root parallel heuristics is subject to heurEmphasis. 0Disable Pre-root parallel heuristics. >0Enable Pre-root parallel heuristics with a work limit dependent on problem characteristics, using the control value as a factor to dial this work limit up or down.
preRootThreads (integer): Specifies an explicit number of threads that should be used for the Pre-root parallel heuristic phase ↵
By default, this phase will use all threads available to the solver (as governed by the control threads).
Setting an explicit number of threads does not enable Pre-root parallel heuristics if they are otherwise disabled. To enable this phase, consider the controls heurEmphasis, preRootEffort, or preRootWorklimit. This control is useful to limit the peak memory usage during Pre-root parallel heuristics, by limiting the amount of problem copies necessary to conduct this phase.
In case of a GAMS license with core limit, the link may overwrite
preRootThreadsto enforce the limit.Default:
-1
value meaning -1Use all available threads. 0Disable pre-root parallel heuristics. >0Use the specified number of threads, superseding the value of threads
preRootWorklimit (real): Set an explicit work limit in work units for the Pre-root parallel heuristic phase ↵
Any positive value also enables this phase and runs it until the preRootWorklimit units of work are hit.
A workLimit on the overall solution process also applies during pre-root parallel phase. It may happen that even if this control is set, Pre-root parallel heuristics terminate before this work limit is reached. This may happen due to stalling or if the heuristics employed are not applicable to the current problem
Default:
-1
value meaning -1No explicit work limit for the Pre-root parallel heuristic phase. If enabled, the work limit for this phase is controlled via preRootEffort. 0Disable Pre-root parallel heuristics. >0Enable Pre-root parallel heuristics with the given explicit limit of work units. If set, this work limit has precedence over any work limit set by preRootEffort.
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 -1Presolve 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. 0Presolve not applied. 1Presolve applied. 2Presolve applied, but redundant bounds are not removed. This can sometimes increase the efficiency of the barrier algorithm. 3Presolve 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 ↵
Default:
0.1
value meaning >=0Ratio of the number of non-zero coefficients by which its number is allowed to grow during presolve.
presolveOps (integer): Bit-vector control 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 = 1Equivalent to presolveOps_singletonColRemoval. bit 1 = 2Equivalent to presolveOps_singletonRowRemoval. bit 2 = 4Equivalent to presolveOps_forcingRowRemoval. bit 3 = 8Dual reductions. This bit is deprecated, use preDualReductions instead. bit 4 = 16Equivalent to presolveOps_redundantRowRemoval. bit 5 = 32Equivalent to presolveOps_duplicateColRemoval. bit 6 = 64Equivalent to presolveOps_duplicateRowRemoval. bit 7 = 128Equivalent to presolveOps_strongDualReductions. bit 8 = 256Variable eliminations. This bit is deprecated, use preEliminations instead. bit 9 = 512No IP reductions. This bit is deprecated, use preMIPReductions instead. bit 10 = 1024Equivalent to presolveOps_noGlobalDomainChange. bit 11 = 2048No advanced IP reductions. This bit is deprecated, use preMIPReductions instead. bit 12 = 4096No eliminations on integers. This bit is deprecated, use preEliminations instead. bit 13 = 8192Equivalent to presolveOps_noSolutionEnumeration. bit 14 = 16384Linearly dependant row removal. bit 15 = 32768No integer variable and SOS detection. This bit is deprecated, use preMIPEntDetect instead. bit 16 = 65536Equivalent to presolveOps_noImpliedBounds. bit 17 = 131072No clique presolve. This bit is deprecated, use preCliqueLifting instead. bit 18 = 262144Equivalent to presolveOps_noMod2Reductions. bit 29 = 536870912No dual reductions on global entities. This bit is deprecated, use preDualReductions instead.
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_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_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
presolvePasses (integer): Number of reduction rounds to be performed in presolve ↵
Default:
1
value meaning >=1The number of reduction rounds in presolve.
preSort (integer): Bit-vector control specifies whether to sort rows, columns and MIP entities by their names when starting the presolve ↵
With the default value 0, no sorting will take place.
Sorting a problem by names can help obtain the same solution path when the rows, columns or MIP entities of the problem is rearranged. It is recommended to enable all three bits when sorting a problem. When both preSort and prePermute are enabled, it will sort and then permute the problem.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
0
value meaning bit 0 = 1Equivalent to preSort_rows. bit 1 = 2Equivalent to preSort_cols. bit 2 = 4Equivalent to preSort_mip.
preSort_cols (boolean): Sort columns ↵
See also preSort.
Default:
0
preSort_mip (boolean): Sort MIP entities ↵
This bit only affects MIP problems.
See also preSort.
Default:
0
preSort_rows (boolean): Sort rows ↵
See also preSort.
Default:
0
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:
0
value meaning -1Partial pricing. 0Determined automatically. 1Devex pricing. 2Steepest edge. 3Steepest edge with unit initial weights.
primalOps (integer): Primal simplex: Allows fine tuning the variable selection in the primal simplex solver ↵
A value of -1 enables all individual bits. If bits 0 and 1 are both set or unset then the dj scaling strategy is determined automatically.
Default:
-1
value meaning bit 0 = 1Use aggressive dj scaling. bit 1 = 2Conventional dj scaling. bit 2 = 4Use reluctant switching back to partial pricing. bit 3 = 8Use dynamic switching between cheap and expensive pricing strategies. bit 5 = 32Keep solving even after potential cycling is detected.
primalPerturb (real): Factor by which the problem will be perturbed prior to optimization by primal simplex ↵
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.
Default:
-1
value meaning -1The perturbation factor is determined automatically. 0No perturbation prior to optimization. >0The perturbation factor.
primalUnshift (boolean): Determines whether primal is allowed to call dual to unshift ↵
Default:
0
value meaning 0Allow the dual algorithm to be used to unshift. 1Don′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.
Default:
0.01
value meaning >=0Default pseudo cost used in estimation of the degradation associated with an unexplored node in the tree search.
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:
-1
value meaning -1Determined automatically. 0Use the barrier algorithm. 1Use 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 0Automatic 1ThreePass: Uses a three-pass forward / backward / forward AD technique to compute function / gradient / Hessian values and a hybrid scheme for storage. 2DoubleForward: 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. 3Concurrent: Uses ThreePass and DoubleForward in parallel. As soon as one finishes, the other one stops.
qextractdenseswitchfactor (real): Sparse/dense factor for quadratic extraction algorithm in GAMS interface ↵
Range: [
0, ∞]Default:
0.008
qextractdenseswitchlog (boolean): Enables additional information about sparse/dense factor choice in quadratic extraction algorithm in GAMS interface ↵
Default:
0
qSimplexOps (integer): Controls the behavior of the quadratic simplex solvers via a bit-vector ↵
Default:
0
value meaning bit 0 = 1Force traditional primal first phase. bit 1 = 2Force BigM primal first phase. bit 2 = 4Force traditional dual first phase. bit 3 = 8Force BigM dual first phase. bit 4 = 16Always use artificial bounds in dual. bit 5 = 32Use original problem basis only when warmstarting the KKT. bit 6 = 64Skip the primal bound flips for ranged primals (might cause more trouble than good if the bounds are very large). bit 7 = 128Also do the single pivot crash. bit 8 = 256Do not apply aggressive perturbation in dual. bit 9 = 512Applies standard scaling to the KKT system. bit 10 = 1024Do not fall back to using Barrier in case of numerical difficulties with quadratic simplex during a MIP solve. bit 11 = 2048Use primal simplex to solve the phase 1 feasibility problem before applying quadratic primal simplex. bit 12 = 4096Use dual simplex to solve the phase 1 feasibility problem before applying quadratic primal simplex. bit 13 = 8192Use barrier algorithm to solve the phase 1 feasibility problem before applying quadratic primal simplex. bit 14 = 16384Use partial pricing. bit 15 = 32768Use full pricing. bit 16 = 65536Perform 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:
-1
value meaning -1Determined automatically. 0No purification step. 1Always 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.
Default:
1
value meaning >=1Initial seed to use for the pseudo-random number generator.
refactor (integer): Indicates whether the optimization should restart using the current representation of the factorization in memory ↵
In the tree search, the optimal bases at the nodes are not refactorized by default, but the optimal basis for an LP problem will be refactorized. If you are repeatedly solving LPs with few changes then it is more efficient to set refactor to 0.
Default:
-1
value meaning -1Automatic. 0Do not refactor on reoptimizing. 1Refactor on reoptimizing.
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.
This is a bit-vector control. 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 = 1Equivalent to refineOps_lpOptimal. bit 1 = 2Equivalent to refineOps_mipSolution. bit 3 = 8Equivalent to refineOps_mipNodeLp. bit 4 = 16Equivalent to refineOps_lpPresolve. bit 5 = 32Equivalent to refineOps_iterativeRefiner. bit 6 = 64Equivalent to refineOps_refinerPrecision. bit 7 = 128Equivalent to refineOps_refinerUsePrimal. bit 8 = 256Equivalent to refineOps_refinerUseDual. bit 9 = 512Equivalent to refineOps_mipFixGlobals. bit 10 = 1024Equivalent 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
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.
Default:
0.1
value meaning [0.0,1.0]Amount of tree memory limit relaxed as a proportion of treeMemoryLimit.
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.
Default:
1e-06
value meaning >0The relative Simplex pivot tolerance.
repairIndefInitEq (integer): Controls if the Optimizer should make indefinite quadratic matrices over binary columns positive definite when it is possible ↵
This is achieved by making the matrix diagonally dominant and it enables solving nonconvex quadratic problems with binary columns without relying on linearization or resorting to the Xpress Global Solver.
Default:
-1
value meaning -1Use problem data to decide whether to repair the matrix or not. 0Do not repair. 1Repair if possible.
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 0Do not allow the Optimizer to change the solve path only to preserve memory. 1Allow 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:
-1
value meaning -1Let the Optimizer decide if the problem should be presolved again. 0Disabled. 1Always 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:
-1
value meaning -1Determined automatically. 0Disable strong branching. >0Perform strong branching on up to the specified number of 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.
Default:
1
value meaning >=0The strong branching effort.
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:
-1
value meaning -1Automatically determined. 1..6Different variants of local pseudo costs.
sbIterLimit (integer): Number of dual iterations to perform during strong branching for each MIP entity ↵
This control can be useful to increase or decrease the amount of effort (and thus time) spent performing strong branching at each node.
Default:
-1
value meaning -1The number of dual iterations is determined automatically. 0Disables strong branching. Instead, the entity at the head of the candidate list will be selected for branching. >0The number of dual iterations for strong branching per MIP entity.
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 -2Automatic (low effort). -1Automatic (high effort). >=0Include the given number of entities in the candidate list (but always at least sbBest candidates).
scalingBigM (integer): Whether to apply special handling of big-M rows during scaling ↵
If scalingMethod is also explicitly set to a value that disables scaling entirely (0), it takes precedence over scalingBigM.
Default:
-1
value meaning -1The big-M handling is determined automatically. 0Disable special handling of big-M rows; they are treated as normal rows during scaling. 1Enable special handling of big-M rows.
scalingMethod (integer): Which scaling method to use ↵
Other than 0 (which disables scaling), scalingMethod only selects the underlying scaling method; Other aspects of scaling can be controled using scalingOrder, scalingBigM and scalingOps.
Default:
-1
value meaning -1The scaling method is determined automatically. 0Disable scaling. 1Use maximum element scaling (also called equilibrium scaling). 2Use geometric mean scaling. 3Use Curtis-Reid scaling. 4Use maximum element plus Curtis-Reid scaling.
scalingOps (integer): Bit-vector control allows finer-grained control of the scaling process ↵
In most circumstances it should not be necessary to change it from it′s default value.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
3
value meaning bit 0 = 1Equivalent to scalingOps_rowScaling. bit 1 = 2Equivalent to scalingOps_colScaling. bit 2 = 4Equivalent to scalingOps_rowScalingAgain. bit 8 = 256Equivalent to scalingOps_ignoreQuadRowPart. bit 10 = 1024Equivalent to scalingOps_noScalingRowsUp. bit 11 = 2048Equivalent to scalingOps_noScalingColsDown. bit 12 = 4096Equivalent to scalingOps_disableGlobalObjScaling. bit 13 = 8192Equivalent to scalingOps_rhsScaling. bit 14 = 16384Equivalent to scalingOps_noAggressiveQScaling. bit 15 = 32768Equivalent to scalingOps_slackScaling.
scalingOps_colScaling (boolean): Column scaling ↵
See also scalingOps.
Default:
1
scalingOps_disableGlobalObjScaling (boolean): Do not apply automatic objective scaling ↵
See also scalingOps.
Default:
0
scalingOps_ignoreQuadRowPart (boolean): Exclude the quadratic part of constraint when calculating scaling factors ↵
See also scalingOps.
Default:
0
scalingOps_noAggressiveQScaling (boolean): Disable aggressive quadratic scaling ↵
See also scalingOps.
Default:
0
scalingOps_noScalingColsDown (boolean): Do not scale columns down ↵
See also scalingOps.
Default:
0
scalingOps_noScalingRowsUp (boolean): Do not scale rows up ↵
See also scalingOps.
Default:
0
scalingOps_rhsScaling (boolean): RHS scaling ↵
See also scalingOps.
Default:
0
scalingOps_rowScaling (boolean): Row scaling ↵
See also scalingOps.
Default:
1
scalingOps_rowScalingAgain (boolean): Row scaling again ↵
See also scalingOps.
Default:
0
scalingOps_slackScaling (boolean): Enable explicit linear slack scaling ↵
See also scalingOps.
Default:
0
scalingOrder (integer): When scaling is applied relative to presolve ↵
Default:
-1
value meaning -1The scaling order is determined automatically, typically after presolve only. 1Scale after presolve. 2Scale before presolve. 3Scale both before and after presolve.
sifting (integer): Determines whether to enable sifting algorithm with the dual simplex method ↵
Default:
-1
value meaning -1Automatically determined. 0Disable sifting. 1Enable 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 -1Use the presolveOps setting specified for the original problem. >=0Use 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 -1Dual simplex. 0Barrier. >0Use 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.
solnpoolmerge (string): Solution pool file name for merged solutions ↵
solnpoolnumsym (integer): Maximum number of variable symbols when writing merged solutions ↵
Range: {
1, ..., ∞}Default:
10
solnpoolPrefix (string): File name prefix for GDX solution files ↵
Default:
soln
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. A solTimeLimit of 0 has no effect.
Default:
1e+20
value meaning 0The value is ignored. >0If 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 ↵
Within the same set, two ordering values must not be the same and for any two values the gap divided by the absolute value of the larger of the two values must be at least sosRefTol.
This tolerance must not be set lower than 1.0E-06.
Default:
1e-06
value meaning >0The minimum relative gap between the ordering values of elements in a special ordered set.
symmetry (integer): Adjusts the overall amount of effort for symmetry detection ↵
Note that setting symmetry=2 causes symmetry detection to run without limits, and can thus be very expensive.
Default:
1
value meaning 0No symmetry detection. 1Conservative effort. 2Intensive symmetry search.
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.
In case of a GAMS license with core limit, the link may overwrite
threadsto enforce the limit.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 a timeLimit of 0 is set, the solver will stop immediately.
Default:
GAMS reslim
value meaning >=0Stop 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.
Default:
0
value meaning 0Explanation is not displayed. >0Explanation is displayed. <0Explanation is displayed.
treeCompression (integer): When writing nodes to the tree 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 effect 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.
Default:
2
value meaning 0No data compression will be used on the tree file. 1..9The strength of the data-compression algorithm used.
treeDiagnostics (integer): Bit-vector providing control over how various tree-management-related messages get printed in the tree log file during the branch-and-bound search ↵
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
7
value meaning bit 0 = 1Equivalent to treeDiagnostics_memoryUsageSummaries. bit 1 = 2Equivalent to treeDiagnostics_memorySavedReports. bit 2 = 4Equivalent to treeDiagnostics_memorySavedReportsInterval.
treeDiagnostics_memorySavedReports (boolean): Output messages whenever tree data is being written to tree file ↵
See also treeDiagnostics.
Default:
1
treeDiagnostics_memorySavedReportsInterval (boolean): Output progress messages while tree data is being written to the tree file, at an interval controlled by the treeFileLogInterval control ↵
See also treeDiagnostics.
Default:
1
treeDiagnostics_memoryUsageSummaries (boolean): Output regular summaries of current tree memory usage ↵
See also treeDiagnostics.
Default:
1
treeFileLogInterval (integer): Sets the interval between progress messages output while writing tree data to the tree file, in seconds ↵
The solve is slowed greatly while data is being written to the tree file and this output allows the user to see how much progress is being made.
Default:
60
value meaning >=1The interval between progress messages output in seconds.
treeMemoryLimit (integer): Soft limit, in MB (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 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.
Default:
0
value meaning 0The tree memory limit is calculated automatically based on the amount of free physical memory detected in the machine. >0The tree memory limit in MB.
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.
Default:
0.4
value meaning [0.01,1.0]Extra amount of tree memory saved as a proportion of treeMemoryLimit.
Tuner (boolean): Enables tuner ↵
Default:
0
tunerHistory (integer): Tuner: Whether to reuse and append to previous tuner results of the same problem ↵
This control only has an effect on the tuner. This control cannot be tuned.
Default:
2
value meaning 0Discard any previous tuner results. 1Append new results to the previous tuner results, but do not reuse them. 2Reuse the previous results and append new results to it.
tunerMaxTime (real): Tuner: Maximum time in seconds that the tuner will run before it terminates ↵
This control only has an effect on the tuner.
Default:
0
value meaning 0No time limit. >0Stop the tuner after the given number of seconds.
tunerMethod (integer): Tuner: Selects a factory tuner method ↵
A tuner method consists of a list of controls with different settings that the tuner will evaluate and try to combine.
This control only has an effect on the tuner. This control cannot be tuned.
Default:
-1
value meaning -1Automatically determined. The tuner will select the default method based on the problem type. 0Select the default LP tuner method. 1Select the default MIP tuner method. 2Select a more comprehensive MIP tuner method. 3Select a root-focus MIP tuner method. 4Select a tree-focus MIP tuner method. 5Select a simple MIP tuner method. 6Select the default SLP tuner method. 7Select the default MISLP tuner method. 8Select a MIP tuner method focussed on primal heuristics. 9Select the default Xpress Global tuner method.
tunerMethodFile (string): Tuner: Defines a file from which the tuner can read user-defined tuner method ↵
This option allows to define a custom tuner method rather than using one of the existing tuner methods defined by tunerMethod. The tuner method file has the following format:
Example:
FIXED-CONTROLSMAXTIME = 100\ref XPRESSthreads "threads" = 1TUNABLE-CONTROLS\ref XPRESSsbEffort "sbEffort" = 0.25, 4\ref XPRESSheurSearchEffort "heurSearchEffort" = 0.5, 2\ref XPRESScutFactor "cutFactor" = 0.5, 1, 5\ref XPRESSscalingMethod "scalingMethod" = 0\ref XPRESSpresolve "presolve" = 0\ref XPRESSvarSelection "varSelection" = 2, 7\ref XPRESScutFreq "cutFreq" = 2\ref XPRESSsymmetry "symmetry" = 0, 1, 2\ref XPRESScutMaxRounds "cutMaxRounds" = 0, 2\ref XPRESScutGomMaxRounds "cutGomMaxRounds" = 0, 2, 10\ref XPRESScutMaxTreeRounds "cutMaxTreeRounds" = 0\ref XPRESScutGomMaxTreeRounds "cutGomMaxTreeRounds" = 0\ref XPRESSheurEmphasis "heurEmphasis" = 0,1\ref XPRESSsbEstimate "sbEstimate" = 1, 2, 3, 4, 5, 6\ref XPRESSrootPresolve "rootPresolve" = 1\ref XPRESSpreProbing "preProbing" = 3\ref XPRESSbranchDisj "branchDisj" = 0The fixed controls section starts with
FIXED-CONTROLS, followed by control setting lines in assignment form. Each control in this section can only be assigned to one value. If the same control appears several times in this section, its first appearance will be used. This section can be empty.The tunable controls section starts with
TUNABLE-CONTROLS, followed by control setting lines in assignment form. Each control in this section can be assigned to one value, or multiple values seperated by commas. A control may appear multiple times in this section.For bit-vector controls, such as presolveOps or scalingOps, it is possible to either specify concrete assignments to the control or to specify individual bits that should be used for tuning. In the latter case, one has to use a colon instead of an equals sign. For example, "\ref XPRESSscalingOps "scalingOps" = 3, 259" will tune using the two given concrete values 3 and 259, while "\ref XPRESSscalingOps "scalingOps" : 0, 1, 8" will individually toggle bits 0, 1, and 8 of the default value for scalingOps and potentially also try combinations of those later during tuning.
This section can be empty. When both the fixed and the tunable secitons are empty, the tuner will then use a pre-defined factory tuner method.
tunerOutput (boolean): Tuner: Whether to output tuner results and logs to the file system ↵
This control only has an effect on the tuner. This control cannot be tuned.
Default:
1
value meaning 0Don′t output to the file system. 1Output results and logs to the file system.
tunerOutputPath (string): Tuner: Defines a root path to which the tuner writes the result file and logs ↵
This control only defines the root path for the tuner output. For each problem, the tuner result will be output to a subfolder underneath this path. For example, by default, the tuner result for a problem called prob will be located at tuneroutput/prob/ This control only has an effect on the tuner. This control cannot be tuned.
Default:
tuneroutput
tunerPermute (integer): Tuner: Defines the number of permutations to solve for each control setting ↵
This control only has an effect on the tuner. This control cannot be tuned.
Default:
0
value meaning 0Solve the original problem only for each setting. >0Solve the original problem and the given number of permuted problems for each setting.
tunerSessionName (string): Tuner: Defines a session name for the tuner ↵
When defined, the session name will override the problem name within the tuner. For example, if this control is set to session, then the tuner result for a problem will be located at tuneroutput/session/ This control can be useful when the problem name is randomly generated. This control only has an effect on the tuner. This control cannot be tuned.
tunerTarget (integer): Tuner: Defines the tuner target – what should be evaluated when comparing two runs with different control settings ↵
This control only has an effect on the tuner. This control cannot be tuned. When tuning for deterministic work (tunerTarget=11), it is advised not to use a timeLimit. Use a workLimit instead.
Default:
-1
value meaning -1Automatically determined. The tuner will choose the default target based on problem type. 0Solution time then gap. (MIP/MISLP default) 1Solution time then best bound. 2Solution time then best integer solution. 3The primal dual integral. 4Time only. (LP/SLP default) 5SLP objective only. (SLP/MISLP choice) 6SLP validation number only. (SLP/MISLP choice) 7Gap only. 8Best bound only. 9Best integer solution only. 10Best primal integral. (Only for individual instances, not for problem sets) 11Least deterministic work consumed. Compares runs by the amount of algorithmic work (in work units) used to reach the final solution.
tunerThreads (integer): Tuner: Number of threads used by the tuner ↵
Setting this control will not affect number of threads used by each individual run. It is recommended to have the product of tunerThreads and threads less or equal to the number of system threads. When setting tunerThreads=-1, the tuner will automatically use as many threads as the number of logical processors detected. This control only has an effect on the tuner. This control cannot be tuned.
In case of a GAMS license with core limit, the link may overwrite
tunerThreadsto enforce the limit.Default:
1
value meaning -1Choose automaticlly. 1The tuner will run in sequential. >1The tuner will run in parallel with the given number of threads.
tunerVerbose (boolean): Tuner: Whether the tuner should prints detailed information for each run ↵
This control only has an effect on the tuner. This control cannot be tuned.
Default:
1
value meaning 0Print less information. 1Print extra information.
userSolHeuristic (integer): Determines how much effort to put into running a large neighborhood search heuristic to find a feasible integer solution from a partial or infeasible user solution ↵
When a partial or infeasible MIP start is loaded, a large neighborhood search heuristic will be applied to the problem in an attempt to find a feasible, integer solution that either completes the partial solution or is close to the infeasible solution. Whether to run such a heuristic, or how much effort to put into the heuristic can be controlled by this userSolHeuristic parameter.
Default:
-1
value meaning -1Automatically determined. 0Search heuristic disabled. 1Light effort. 2Moderate effort. 3High effort.
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:
-1
value meaning -1Determined automatically. 1The minimum of the ′up′ and ′down′ pseudo costs. 2The ′up′ pseudo cost plus the ′down′ pseudo cost. 3The maximum of the ′up′ and ′down′ pseudo costs, plus twice the minimum of the ′up′ and ′down′ pseudo costs. 4The maximum of the ′up′ and ′down′ pseudo costs. 5The ′down′ pseudo cost. 6The ′up′ pseudo cost. 7A weighted combination of the ′up′ and ′down′ pseudo costs, where the weights depend on how fractional the variable is. 8The product of the ′up′ and ′down′ pseudo costs.
workLimit (real): Maximum work (measured in work units) that the Optimizer will run before it terminates ↵
WORK is accumulated during the search and ever increasing. In contrast to TIME, WORK is independent of the hardware and platform on which the search is conducted. The workLimit serves as a deterministic stopping criterion. When it is reached, it leaves the Optimizer in a reproducible state.
The reproducibility of a search conducted under a workLimit depends on the chosen determinism of the search, see the control deterministic for more information. The speed at which work is accumulated depends on the hardware, the algorithms involved, and the problem being solved. When a workLimit of 0 is set, the solver will stop immediately.
Default:
1e+20
value meaning >=0Stop LP or MIP search when the given number of work units is reached.
writePrtSol (boolean): Directs optimizer to output a "printsol" file ↵
Default:
0
xslp_algorithm (integer): Bit map describing the SLP algorithm(s) to be used ↵
Bit 0: Superseded by xslp_stepBounding, which if left at its default of -1 continues to respect this bit. 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. Bit 1: Superseded by xslp_stepBounding, which if left at its default of -1 continues to respect this bit. 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. In addition to the default bits 1, 2, 5, and 7, bits 8 and 9 can often be helpful.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
166
value meaning bit 0 = 1Do not apply step bounds. bit 1 = 2Apply step bounds to SLP delta vectors only when required. bit 2 = 4Equivalent to xslp_algorithm_estimateStepBounds. bit 3 = 8Equivalent to xslp_algorithm_dynamicDamping. bit 4 = 16Equivalent to xslp_algorithm_holdValues. bit 5 = 32Equivalent to xslp_algorithm_retainPreviousValue. bit 6 = 64Equivalent to xslp_algorithm_resetDeltaZ. bit 7 = 128Equivalent to xslp_algorithm_quickConvergenceCheck. bit 8 = 256Equivalent to xslp_algorithm_escalatePenalties. bit 9 = 512Equivalent to xslp_algorithm_switchToPrimal. bit 11 = 2048Equivalent to xslp_algorithm_maxCostOption. bit 12 = 4096Equivalent to xslp_algorithm_residualErrors. bit 13 = 8192Equivalent to xslp_algorithm_noLPPolishing. bit 14 = 16384Equivalent to xslp_algorithm_cascadeBounds. bit 15 = 32768Equivalent to xslp_algorithm_clampExtendedActiveSB. bit 16 = 65536Equivalent to xslp_algorithm_clampExtendedAll.
xslp_algorithm_cascadeBounds (boolean): Step bounds are updated to accommodate 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 PLUSINFINITY), 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_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_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 analysis ↵
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 = 8Equivalent to xslp_analyze_extendedFinalSummary. bit 4 = 16Equivalent to xslp_analyze_infeasibleIteration. bit 6 = 64Equivalent to xslp_analyze_saveLinearizations. bit 7 = 128Equivalent to xslp_analyze_saveIterBasis. bit 8 = 256Equivalent 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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 = 1Equivalent to xslp_augmentation_minimum. bit 1 = 2Equivalent to xslp_augmentation_evenHanded. bit 2 = 4Equivalent to xslp_augmentation_equalityErrorVectors. bit 3 = 8Equivalent to xslp_augmentation_allErrorVectors. bit 4 = 16Equivalent to xslp_augmentation_penaltyDeltaVectors. bit 5 = 32Equivalent to xslp_augmentation_aMeanWeight. bit 6 = 64Equivalent to xslp_augmentation_sbFromValues. bit 7 = 128Equivalent to xslp_augmentation_sbFromAbsValues. bit 8 = 256Equivalent to xslp_augmentation_stepBoundRows. bit 9 = 512Equivalent to xslp_augmentation_allRowErrorVectors. bit 10 = 1024Equivalent to xslp_augmentation_noUpdateIfOnlyIV. bit 12 = 4096Equivalent 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): Initial 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 ↵
Minimum 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 = 1Equivalent to xslp_barStartOps_stallingObjective. bit 1 = 2Equivalent to xslp_barStartOps_stallingNumerical. bit 2 = 4Equivalent 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:
-1
xslp_cascade (integer): Bit map describing the cascading to be used ↵
Normal cascading (bit 0) uses determining rows to recalculate the values of variables to be consistent with values already available or already recalculated. Other bit settings are normally required only in quadratic programming where some of the SLP variables are in the objective function. The values of such variables may need to be corrected if the corresponding update row is slightly infeasible.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
257
value meaning bit 0 = 1Equivalent to xslp_cascade_all. bit 1 = 2Equivalent to xslp_cascade_coefVar. bit 2 = 4Equivalent to xslp_cascade_allCoefVar. bit 3 = 8Equivalent to xslp_cascade_structVar. bit 4 = 16Equivalent to xslp_cascade_allStructVar. bit 5 = 32Equivalent to xslp_cascade_secondaryGroups. bit 6 = 64Equivalent to xslp_cascade_dRColPreviousValue. bit 7 = 128Equivalent to xslp_cascade_dRColPVRange. bit 8 = 256Equivalent to xslp_cascade_autoApply.
xslp_cascadeNLimit (integer): Maximum number of iterations for cascading with non-linear determining rows ↵
Re-calculation of the value of a variable uses a modification of the Newton- Raphson method. The maximum number of steps in the method is set by xslp_cascadeNLimit. If the maximum number of steps is taken without reaching a converged value, the best value found will be used.
Range: {
0, ..., ∞}Default:
10
xslp_cascadeTol_PA (real): Absolute cascading print tolerance ↵
The change to the value of a variable as a result of cascading is only printed if the change is deemed significant. The change is tested against: absolute and relative convergence tolerance and absolute and relative cascading print tolerance. The change is printed only if all tests fail. The absolute cascading print criterion measures the change in value of a variable (δX) against the absolute cascading print tolerance. If δX < xslp_cascadeTol_PA then the change is within the absolute cascading print tolerance and will not be printed. xslp_log must be at least 5 for this control to have an effect.
Range: [
0, ∞]Default:
0.01
xslp_cascadeTol_PR (real): Relative cascading print tolerance ↵
The change to the value of a variable as a result of cascading is only printed if the change is deemed significant. The change is tested against: absolute and relative convergence tolerance and absolute and relative cascading print tolerance. The change is printed only if all tests fail. The relative cascading print criterion measures the change in value of a variable (δX) relative to the value of the variable (X), against the relative cascading print tolerance. If δX < X * xslp_cascadeTol_PR then the change is within the relative cascading print tolerance and will not be printed. xslp_log must be at least 5 for this control to have an effect.
Range: [
0, ∞]Default:
0.01
xslp_cascade_all (boolean): Apply cascading to all variables with determining rows ↵
See also xslp_cascade.
Default:
1
xslp_cascade_allCoefVar (boolean): Apply cascading to all SLP variables which appear in coefficients ↵
See also xslp_cascade.
Default:
0
xslp_cascade_allStructVar (boolean): Apply cascading to all SLP variables which are structural ↵
See also xslp_cascade.
Default:
0
xslp_cascade_autoApply (boolean): Automatically determine whether to apply cascading ↵
See also xslp_cascade.
Default:
1
xslp_cascade_coefVar (boolean): Apply cascading to SLP variables which appear in coefficients and which would change by more than feasTol ↵
See also xslp_cascade.
Default:
0
xslp_cascade_dRColPreviousValue (boolean): In cases where the determining column is below xslp_dRColTol, fix at the previous rather than current value ↵
See also xslp_cascade.
Default:
0
xslp_cascade_dRColPVRange (boolean): In cases where the determining column is below xslp_dRColTol, fix within a range xslp_dRFixRange of previous value ↵
See also xslp_cascade.
Default:
0
xslp_cascade_secondaryGroups (boolean): Create secondary order groupping DR rows with instantiated user functions together in the order ↵
See also xslp_cascade.
Default:
0
xslp_cascade_structVar (boolean): Apply cascading to SLP variables which are structural and which would change by more than feasTol ↵
See also xslp_cascade.
Default:
0
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:
39935
value meaning bit 0 = 1Equivalent to xslp_convergenceOps_cTol. bit 1 = 2Equivalent to xslp_convergenceOps_aTol. bit 2 = 4Equivalent to xslp_convergenceOps_mTol. bit 3 = 8Equivalent to xslp_convergenceOps_iTol. bit 4 = 16Equivalent to xslp_convergenceOps_sTol. bit 5 = 32Equivalent to xslp_convergenceOps_user. bit 6 = 64Equivalent to xslp_convergenceOps_vTol. bit 7 = 128Equivalent to xslp_convergenceOps_xTol. bit 8 = 256Equivalent to xslp_convergenceOps_oTol. bit 9 = 512Equivalent to xslp_convergenceOps_wTol. bit 10 = 1024Equivalent to xslp_convergenceOps_extendedScaling. bit 11 = 2048Equivalent to xslp_convergenceOps_validation. bit 12 = 4096Equivalent to xslp_convergenceOps_validationK. bit 13 = 8192Equivalent to xslp_convergenceOps_noQuadCheck. bit 15 = 32768Equivalent to xslp_convergenceOps_requireOTolR.
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_requireOTolR (boolean): Do not declare converged if still sufficient improvement in objective ↵
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
xslp_cutStrategy (integer): Determines which 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 the Optimizer′s cutStrategy control.
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_defaultIV (real): Default initial value for an SLP variable if none is explicitly given ↵
If no initial value is given for an SLP variable, then the initial value provided for the "equals column" will be used. If no such value has been provided, then xslp_defaultIV will be used. If this is above the upper bound for the variable, then the upper bound will be used; if it is below the lower bound for the variable, then the lower bound will be used.
Range: [
0, ∞]Default:
100
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_delayUpdateRows (integer): Number of SLP iterations before update rows are fully activated ↵
During augmentation, one or more delta vectors are created for each SLP variable. The values of these are linked to that of the variable through an update row which is created as part of the augmentation procedure.
Range: {
0, ..., ∞}Default:
2
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 is 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 is 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 LOG10 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 = 1Analytic derivatives where possible bit 1 = 2Avoid embedding numerical derivatives of instantiated functions into analytic derivatives
xslp_deterministic (boolean): Determines if the parallel features of SLP should be guaranteed to be deterministic ↵
Determinism can only be guaranteed if no callbacks are used, or if in the presence of callbacks the effect of the callbacks only depend on local information provided by SLP.
Default:
1
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_dRColDJTol (real): Reduced cost tolerance on the delta variable when fixing due to the determining column being below xslp_dRColTol ↵
Range: [
0, ∞]Default:
0
xslp_dRColTol (real): Minimum absolute magnitude of a determining column, for which the determined variable is still regarded as well defined ↵
Range: [
0, ∞]Default:
1e-06
xslp_dRFixRange (real): Range around the previous value where variables are fixed in cascading if the determining column is below xslp_dRColTol ↵
Range: [
0, ∞]Default:
0.1
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 SLPECFCOUNT.
Default:
1
value meaning 0No check (extended criteria are always used); 1Check until one infeasible constraint is found; 2Check 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 usually fall between 1e-1 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 usually fall between 1e-1 and 1e-6.
Range: [-∞, ∞]
Default:
-1
xslp_enforceCostShrink (real): Factor by which to decrease the current penalty multiplier when enforcing rows ↵
When feasibility 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 the 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 achieve better numerical behaviour.
Range: [
0,1]Default:
1e-05
xslp_enforceMaxCost (real): Maximum penalty cost in the objective before enforcing most violating rows ↵
When feasibility 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 the 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 achieve 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
Default:
-1
value meaning -1Let the solver decide. >=0Maximum penalty cost multiplier.
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 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 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 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 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 feasTol, and will dynamically revert back to feasTol if the desired accuracy could not be achieved.
Range: [
0, ∞]Default:
0
xslp_filter (integer): Bit map for controlling solution updates ↵
Bit 0 is superseded by xslp_returnSolution, which if left at its default of -1 continues to respect this bit. Bit 0 determines whether Xpress SLP should return the final converged solution (if the bit is off), or the solution which had the best value according to the merit function (if the bit is on, which is the default). 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 = 1Retain best solution according to the merit function. bit 1 = 2Equivalent to xslp_filter_cascade. bit 2 = 4Equivalent to xslp_filter_zeroLineSearch. bit 3 = 8Equivalent to xslp_filter_zeroLineSearchTR.
xslp_filter_cascade (boolean): Check cascaded solutions against improvements in the merit function ↵
See also xslp_filter.
Default:
1
xslp_filter_zeroLineSearch (boolean): Force minimum step sizes in line search ↵
See also xslp_filter.
Default:
0
xslp_filter_zeroLineSearchTR (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 bounds, then the heuristic is not run and the given point is used as the initial solution.
Default:
-1
value meaning -1Automatic (default). 0Disable the heuristic. 1Enable 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_gridHeurSelect (integer): Bit map selecting which heuristics to run if the problem has a variable with an integer delta ↵
A value of 0 indicates that integer deltas are only taken into consideration during the SLP iterations.
The enumeration option can be useful for cases where the number of possible values of the variables with an integer delta is small.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
6
value meaning bit 0 = 1Equivalent to xslp_gridHeurSelect_all. bit 1 = 2Equivalent to xslp_gridHeurSelect_simple. bit 2 = 4Equivalent to xslp_gridHeurSelect_simAnneal.
xslp_gridHeurSelect_all (boolean): Enumeration: Try all combinations ↵
See also xslp_gridHeurSelect.
Default:
0
xslp_gridHeurSelect_simAnneal (boolean): Simulated annealing ↵
See also xslp_gridHeurSelect.
Default:
1
xslp_gridHeurSelect_simple (boolean): Simple search heuristics ↵
See also xslp_gridHeurSelect.
Default:
1
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 1Numerical derivatives (finite difference) 2Symbolic differentiation 3Automatic differentiation -1,0Automatic 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:
-1
value meaning -1Automatic selection of heuristic strategy (depending on heurEmphasis). 0No heuristics. 1Basic heuristic strategy. 2Enhanced heuristic strategy. 3Extensive heuristic strategy. 4Run all heuristics without effort limits.
xslp_infeasLimit (integer): Maximum number of consecutive infeasible or unbounded 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_iterFallbackOps (string): Alternative LP level control values for numerically challenging problems ↵
When set, this control provides alternative ways of solving a linearization called adaptive iteration solves. This can be useful for numerically challenging problems that either solve to a non-satisfactory accuracy (relative to xslp_feasTolTarget) with the default solves, or that can incorrectly report infeasibility or unboundedness. In such cases, the solve will try the controls listed by xslp_iterFallbackOps until a satisfactory solution is found or all options are exhausted. The individual controls for each solve are separated by a comma (′,′), while the set of controls for an attempt by a colon (′:′) . Example: ′defaultAlg=3 : barOrder = 2, presolve = 0′ will try primal in one solve, and the homogenous barrier with presolve turned off in another. Optimizer flags are not inherited by the solve, so use defaultAlg for selecting an LP solver to use. The resulting LP solves are carried out in a parallel manner, using xslp_multistart_threads number of threads. The result of the adaptive solves are always deterministic. Once a satisfactory solution is found, remaining solves are progressed only as far as necessary to guarantee determinism, so it is beneficial to list more promising control sets first.
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 1Numerical derivatives (finite difference) 2Symbolic differentiation 3Automatic differentiation -1,0Automatic 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:
-1
value meaning -1Automatic selection 0Disable 1Enable
xslp_log (integer): Level of printing during SLP iterations ↵
Default:
0
value meaning -1None 0Minimal 1Normal: iteration, penalty vectors 2Omit from convergence log any variables which have converged 3Omit from convergence log any variables which have already converged (except variables on step bounds) 4Include all variables in convergence log 5Include 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_matrixTol (real): Nonzero tolerance for dropping coefficients from the linearization ↵
Any value smaller than xslp_matrixTol in magnitude will not be loaded into the linearization. This only applies to the matrix coefficients; bounds, right hand sides and objectives are not affected.
Range: [
0, ∞]Default:
0
xslp_maxTime (integer): Maximum time in seconds that the SLP optimization will run before it terminates ↵
The (elapsed) time is measured from the beginning of the first SLP optimization. If xslp_maxTime is negative, Xpress NonLinear will terminate after (-xslp_maxTime) seconds. If it is positive, Xpress NonLinear will terminate in MISLP after xslp_maxTime seconds or as soon as an integer solution has been found thereafter. It is recommended to use the Optimizer′s timeLimit control in preference to xslp_maxTime to limit the overall solution time, since timeLimit applies uniformly across LP, MIP and SLP solves and offers finer control over how the time limit is enforced.
Range: {-∞, ..., ∞}
Default:
0
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_memoryFactor (real): Factor for expanding size of dynamic arrays in memory ↵
When a dynamic array has to be increased in size, the new space allocated will be xslp_memoryFactor times as big as the previous size. A larger value may result in improved performance because arrays need to be re-sized and moved less frequently; however, more memory may be required under such circumstances because not all of the previous memory area can be re- used efficiently.
Range: [
1, ∞]Default:
1.6
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 variable 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 XPRSoptimize or XPRSnlpoptimize 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 caused 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. Bits 9 and 10 are superseded by xslp_mislpAlgorithm, which if left at its default of −1 continues to respect these bits. 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").
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
17
value meaning bit 0 = 1Equivalent to xslp_mipAlgorithm_initialSLP. bit 2 = 4Equivalent to xslp_mipAlgorithm_initialRelaxSLP. bit 3 = 8Equivalent to xslp_mipAlgorithm_initialFixSLP. bit 4 = 16Equivalent to xslp_mipAlgorithm_nodeRelaxSLP. bit 5 = 32Equivalent to xslp_mipAlgorithm_nodeFixSLP. bit 6 = 64Equivalent to xslp_mipAlgorithm_nodeLimitSLP. bit 7 = 128Equivalent to xslp_mipAlgorithm_finalRelaxSLP. bit 8 = 256Equivalent to xslp_mipAlgorithm_finalFixSLP. bit 9 = 512Use MIP at each SLP iteration instead of SLP at each node. bit 10 = 1024Use MIP on converged SLP solution and then SLP on the resulting MIP solution.
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_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): Relative 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 = 1Equivalent to xslp_mipFixStepBounds_structNotCoef. bit 1 = 2Equivalent to xslp_mipFixStepBounds_structAll. bit 2 = 4Equivalent to xslp_mipFixStepBounds_coefOnly. bit 3 = 8Equivalent 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 = 1Equivalent to xslp_mipRelaxStepBounds_structNotCoef. bit 1 = 2Equivalent to xslp_mipRelaxStepBounds_structAll. bit 2 = 4Equivalent to xslp_mipRelaxStepBounds_coefOnly. bit 3 = 8Equivalent 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_mislpAlgorithm (integer): Selects the MISLP strategy used to combine SLP with the branch-and-bound search ↵
SLP-MIP-SLP is generally the fastest algorithm since it only requires two SLP- and one MILP-solve compared to number-of-nodes-many SLP solves for SLP-in-MIP and number-of-SLP-iterations-many MIP solves in MIP-in-SLP. On the other hand it usually produces worse local optima and has the highest likelihood of running into local infeasibility.
This control replaces bits 9 and 10 of xslp_mipAlgorithm (SLPMIPWITHINSLP and SLPSLPTHENMIP), which are now deprecated. While xslp_mislpAlgorithm is left at its default of -1, those bits continue to determine the MISLP strategy exactly as before; setting xslp_mislpAlgorithm to any other value overrides them.
Default:
-1
value meaning -1Fall back to bits 9 and 10 of xslp_mipAlgorithm. By default neither bit is set, which is equivalent to 0. 0Use SLP at each node of the branch and bound search. 1Solve the linearization in each SLP iteration as an MILP. 2Solve the continuous relaxation, solve an MILP on the final linearization and then fix all integers and solve with SLP again.
xslp_msMaxBoundRange (real): Defines the maximum range inside which initial points are generated by multistart presets ↵
This is the maximum range in which initial points are generated; the actual range is expected to be smaller as bounds and 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 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 < 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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 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 < 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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
xslp_multistartPreset (integer): Enable multistart ↵
Default:
0
value meaning 0Disable multistart preset. 1Generate xslp_multistart_maxSolves number of random base points. 2Generate xslp_multistart_maxSolves number of random base points, filtered by a merit function centred on initial feasibility. 3Load the most typical SLP tuning settings. A maximum of xslp_multistart_maxSolves jobs are loaded. 4Load a comprehensive set of SLP tuning settings. A maximum of xslp_multistart_maxSolves jobs are loaded.
xslp_multistart_log (integer): Level of logging during the multistart run ↵
Range: {
0, ..., ∞}Default:
0
xslp_multistart_maxSolves (integer): Maximum number of jobs to create during the multistart search ↵
This control can be increased on the fly during the multistart 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:
-1
xslp_multistart_maxTime (integer): Maximum total time to be spent in the multistart 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:
0
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.
In case of a GAMS license with core limit, the link may overwrite
xslp_multistart_threadsto enforce the limit.Range: {
-1, ..., ∞}Default:
-1
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
xslp_nlpSolver (integer): Controls whether to call FICO Xpress Global or one of the local solvers ↵
Default:
-1
value meaning -1If the license allows and there are no user functions or multistart jobs, FICO Xpress Global will be called, otherwise a local solver. 1The algorithm selected by xslp_solver will be used to find a locally optimal solution 2FICO Xpress Global will be used to find a globally optimal solution
xslp_objThreshold (real): Assumed maximum value of the objective function in absolute value ↵
Range: [-∞, ∞]
Default:
1e+15
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:
0
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 -1Postsolve if the problem could be solved to optimality/infeasibility. 0Do not automatically postsolve. 1Postsolve automatically.
xslp_presolve (integer): Determines whether presolving should be performed on the nonlinear problem prior to starting the main algorithm ↵
The Xpress NonLinear nonlinear presolve (which is carried out once, before augmentation in SLP or introducing auxiliaries in global) is independent of the Optimizer presolve (which is carried out during each SLP iteration or after introducing auxiliaries for a global solve).
Default:
-1
value meaning -1Disable nonlinear presolve if and only if Optimizer presolve is disabled. 0Disable nonlinear presolve. 1Activate nonlinear presolve. 2Low 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 and xslp_reformulate control 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 1Individual rows only presolve, no dropped columns/rows or index changes, no nonlinear transformations. 2All linear presolve that does not drop columns/rows, no index changes, no nonlinear transformations. 3Full linear presolve including dropping columns/rows and index changes, no nonlinear transformations. 4Full presolve.
xslp_presolveOps (integer): Bitmap indicating the SLP presolve actions to be taken ↵
The Xpress NonLinear nonlinear presolve (which is carried out once, before augmentation) is independent of the Optimizer presolve (which is carried out during each SLP iteration). Linear reductions are performed according to presolveOps if bit 12 is not set.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
2104
value meaning bit 0 = 1Equivalent to xslp_presolveOps_general. bit 1 = 2Equivalent to xslp_presolveOps_fixZero. bit 2 = 4Equivalent to xslp_presolveOps_fixAll. bit 3 = 8Equivalent to xslp_presolveOps_setBounds. bit 4 = 16Equivalent to xslp_presolveOps_intBounds. bit 5 = 32Equivalent to xslp_presolveOps_domain. bit 8 = 256Equivalent to xslp_presolveOps_noCoefficients. bit 9 = 512Equivalent to xslp_presolveOps_noDeltas. bit 10 = 1024Equivalent to xslp_presolveOps_noDualSide. bit 11 = 2048Equivalent to xslp_presolveOps_eliminations. bit 12 = 4096Equivalent to xslp_presolveOps_noLinear. bit 13 = 8192Equivalent 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 bound reduction multiple times 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:
-1
value meaning -1Automatic. 0Disable SLP probing. 1Activate SLP probing only on binary variables. 2Activate SLP probing only on binary or unbounded integer variables. 3Activate SLP probing only on binary or integer variables. 4Activate SLP probing only on binary, integer variables, and unbounded continuous variables. 5Activate SLP probing on any variable.
xslp_reformulate (integer): Controls the problem reformulations carried out before augmentation ↵
This allows SLP to take advantage of dedicated algorithms for special problem classes.
The reformulation is part of Xpress SLP presolve, and is only carried out if xslp_presolve is nonzero.
Setting single boolean options will overwrite the single bits of this bit map option.
Default:
511
value meaning bit 0 = 1Equivalent to xslp_reformulate_slp2qp. bit 1 = 2Equivalent to xslp_reformulate_qp2slp. bit 2 = 4Equivalent to xslp_reformulate_slp2qcqp. bit 3 = 8Equivalent to xslp_reformulate_qcqp2slp. bit 4 = 16Equivalent to xslp_reformulate_socp2slp. bit 5 = 32Equivalent to xslp_reformulate_qpsolve. bit 6 = 64Equivalent to xslp_reformulate_pwl. bit 7 = 128Equivalent to xslp_reformulate_abs. bit 8 = 256Equivalent to xslp_reformulate_minMax. bit 9 = 512Equivalent to xslp_reformulate_allAbs. bit 10 = 1024Equivalent to xslp_reformulate_allMinMax.
xslp_reformulate_abs (boolean): Convert ABS functions to MIP constraints if the full problem can be made not nonlinear ↵
See also xslp_reformulate.
Default:
1
xslp_reformulate_allAbs (boolean): Always convert ABS expressions ↵
See also xslp_reformulate.
Default:
0
xslp_reformulate_allMinMax (boolean): Always convert MIN and MAX expressions ↵
See also xslp_reformulate.
Default:
0
xslp_reformulate_minMax (boolean): Convert MIN and MAX functions to MIP expressions if the full problem can be made not nonlinear ↵
See also xslp_reformulate.
Default:
1
xslp_reformulate_pwl (boolean): Convert piecewise linear functions to MIP constructs ↵
See also xslp_reformulate.
Default:
1
xslp_reformulate_qcqp2slp (boolean): Convert non-convex QCQP constraints to SLP constructs ↵
See also xslp_reformulate.
Default:
1
xslp_reformulate_qp2slp (boolean): Convert non-convex quadratic objectives to SLP constructs ↵
See also xslp_reformulate.
Default:
1
xslp_reformulate_qpsolve (boolean): Convexity of a quadratic only problem may be checked by calling the optimizer to solve the instance ↵
See also xslp_reformulate.
Default:
1
xslp_reformulate_slp2qcqp (boolean): Solve convex quadratic constraints using the XPRS library ↵
See also xslp_reformulate.
Default:
1
xslp_reformulate_slp2qp (boolean): Solve convex quadratic objectives using the XPRS library ↵
See also xslp_reformulate.
Default:
1
xslp_reformulate_socp2slp (boolean): Keep second order cones in the XPRS problem to keep them in the linearizations ↵
See also xslp_reformulate.
Default:
1
xslp_returnSolution (integer): Selects whether to return the final converged iterate or the best merit-function iterate ↵
This control replaces bit 0 of xslp_filter, which is now deprecated. While xslp_returnSolution is left at its default of -1, that bit continues to determine which solution is returned exactly as before; setting xslp_returnSolution to 1 or 2 overrides it.
Default:
-1
value meaning -1Fall back to bit 0 of xslp_filter: return the best merit-function iterate if the bit is set (the default), or the final converged iterate if it is not. 1Return the solution which had the best value according to the merit function. 2Return the final converged iterate.
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 0No re-scaling. 1Re-scale every SLP iteration up to xslp_scaleCount iterations after the end of barrier optimization. 2Re-scale every SLP iteration up to xslp_scaleCount iterations in total. 3Re-scale every SLP iteration until primal simplex is automatically invoked. 4Re-scale every SLP iteration. 5Re-scale every xslp_scaleCount SLP iterations. 6Re-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:
0
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:
-1
value meaning -1Automatic selection, based on model characteristics and solver availability 0Use Xpress-SLP (always available) 1Use Knitro if available 2Use Xpress-Optimizer if possible (convex quadratic problems only)
xslp_stepBounding (integer): Selects the step bounding strategy used by SLP ↵
This control replaces bits 0 and 1 of xslp_algorithm (SLPNOSTEPBOUNDS and SLPSTEPBOUNDSASREQUIRED), which are now deprecated. While xslp_stepBounding is left at its default of -1, those bits continue to determine the step bounding strategy exactly as before; setting xslp_stepBounding to any other value overrides them.
Default:
-1
value meaning -1Automatic: fall back to bits 0 and 1 of xslp_algorithm (default). By default bit 1 is set and bit 0 is not, which is equivalent to 2. 0Do not apply step bounds. 1Always apply step bounds. 2Apply step bounds to SLP delta vectors only when required.
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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:
-1
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 number 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): Feasibility target tolerance ↵
Primary feasibility 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 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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 relative 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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 usually fall between 1e-4 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 is performed ↵
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 usually fall between 1e-3 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 usually fall between 1e-4 and 1e-6.
Range: [-∞, ∞]
Default:
-1
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 = 1Equivalent to xslp_zeroCriterion_nbSLPVar. bit 1 = 2Equivalent to xslp_zeroCriterion_nbDelta. bit 2 = 4Equivalent to xslp_zeroCriterion_slpVarNBUpdateRow. bit 3 = 8Equivalent to xslp_zeroCriterion_deltaNBUpdateRow. bit 4 = 16Equivalent to xslp_zeroCriterion_deltaNBDRRow. bit 5 = 32Equivalent 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. Usebariterlimitin 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. - 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.