### Table of Contents

**Lindo Systems, Inc.**

# Introduction

GAMS/LINDO finds guaranteed globally optimal solutions to general nonlinear problems with continuous and/or discrete variables. GAMS/LINDO supports most mathematical functions, including functions that are nonsmooth, such as abs(x) and or even discontinuous, such as floor(x). Nonlinear solvers employing methods like successive linear programming (SLP) or generalized reduced gradient (GRG) return a local optimal solution to an NLP problem. However, many practical nonlinear models are non-convex and have more than one local optimal solution. In some applications, the user may want to find a global optimal solution.

The LINDO global optimization procedure(GOP) employs branch-and-cut methods to break an NLP model down into a list of subproblems. Each subproblem is analyzed and either a) is shown to not have a feasible or optimal solution, or b) an optimal solution to the subproblem is found, e.g., because the subproblem is shown to be convex, or c) the subproblem is further split into two or more subproblems which are then placed on the list. Given appropriate tolerances, after a finite, though possibly large number of steps a solution provably global optimal to tolerances is returned. Traditional nonlinear solvers can get stuck at suboptimal, local solutions. This is no longer the case when using the global solver.

GAMS/LINDO can automatically linearize a number of nonlinear relationships, such as max(x,y), through the addition of constraints and integer variables, so the transformed linearized model is mathematically equivalent to the original nonlinear model. Keep in mind, however, that each of these strategies will require additional computation time. Thus, formulating models, so they are convex and contain a single extremum, is desirable. In order to decrease required computing power and time it is also possible to disable the global solver and use GAMS/LINDO like a regular nonlinear solver.

GAMS/LINDO has a multistart feature that restarts the standard (non-global) nonlinear solver from a number of intelligently generated points. This allows the solver to find a number of locally optimal points and report the best one found. This alternative can be used when global optimization is costly. A user adjustable parameter controls the maximum number of multistarts to be performed.

LINDO automatically detects problem type and uses an appropriate solver, e.g., if you submit an LP model to LINDO, it will be solved as an LP at LP speed, regardless of what you said in the "solve using" statement. With the NLP parameter * NLP_QUADCHK* turned on, LINDO can detect hidden quadratic expressions and automatically recognize convex QCPs, as well as second-order cones (SOCP), like in Value-at-Risk models, allowing dramatically faster solution times via the barrier solver. When such models have integer variables, LINDO would use the barrier solver to solve all subproblems leading to significantly improved solution times when compared to the case with the standard NLP solver.

## Licensing and software requirements

In order to use GAMS/LINDOGlobal, two licenses are required: a GAMS/LINDOGlobal license and a GAMS/CONOPT license. The additional CONOPT license requirement exists because LINDOGlobal uses CONOPT to solve the nonlinear subproblems. The GAMS/LINDOGlobal license places upper limits on the model size of 3,000 variables and 2,000 constraints.

To use GAMS/LINDO, only a GAMS/LINDO license is required. It imposes no upper limit on the model size and includes the capability to solve stochastic models (see section Stochastic Programming (SP) in GAMS/Lindo ).

Neither the GAMS/LINDO nor the GAMS/LINDOGlobal license includes the Barrier solver option. The Barrier option is enabled via a separate license for the GAMS/MOSEK barrier solver.

## Running GAMS/LINDO

GAMS/LINDO is capable of solving models of the following types: EMP (stochastic), LP, MIP, RMIP, NLP, DNLP, QCP, MIQCP, RMINLP and MINLP. If GAMS/LINDO is not specified as the default solver for these models, it can be invoked by issuing one of the following command before the solve statement:

option xxx=lindo; option xxx=lindoglobal;

where xxx is one of: EMP, LP, MIP, RMIP, NLP, DNLP, QCP, MIQCP, RMINLP, or MINLP.

You can also find global optima to math programs with equilibrium or complementarity constraints, type MPEC, by using the GAMS/NLPEC translator in conjunction with LINDO. You use NLPEC to translate complementarities into standard mathematical statements, e.g. h*y = 0, and then use LINDO as the DNLP(Discontinuous Nonlinear) solver to solve the translated model. The following little GAMS model illustrates:

$TITLE simple mpec example variable f, x1, x2, y1, y2; positive variable y1; y2.lo = -1; y2.up = 1; equations cost, g, h1, h2; cost.. f =E= x1 + x2; g.. sqr(x1) + sqr(x2) =L= 1; h1.. x1 =G= y1 - y2 + 1; h2.. x2 + y2 =N= 0; * declare h and y complementary model example / cost, g, h1.y1, h2.y2 /; option mpec=nlpec; option dnlp=lindo; solve example using mpec min f;

# Supported nonlinear functions

GAMS/LINDO supports most nonlinear functions in global mode, including +, -, *, /, floor, modulo, sign, min, max, sqr, exp, power, ln, log, sqrt, abs, cos, sin, tan, cosh, sinh, tanh, arccos, arcsin, arctan and logic expressions AND, OR, NOT, and IF. Be aware that using highly nonconvex functions may lead to long solve times.

# Diagnosis of Infeasible or Unbounded Models

GAMS/LINDO offers two diagnostic tools, that can help users debug infeasible or unbounded optimization models. These tools can be called after the solver reports an infeasible or unbounded status for the model. When activating IIS Lindo finds an irreducible infeasible set (IIS) of constraints, whereas setting IUS, makes Lindo find an irreducible unbounded set (IUS) of variables. An IIS is a set of constraints that are infeasible taken together, but every strict subset is feasible. Similarly, an IUS is a set of unbounded variables such that fixing any one of them would make the model bounded. The IIS or IUS portion of the model will generally be much smaller than the original model. Thus, the user can track down formulation or data entry errors quickly. By isolating the source of infeasibility or unboundedness, the user can correct the model data such as right-hand side values, objective coefficients, senses of the constraints, and column bounds. Note that the IUS option is available for LPs only.

## Infeasible Models

GAMS/Lindo's IIS option activates the IIS finder, after a model was tried to be solved and the solver returned a "no feasible solution" message. For an LP, if an infeasible basis is not resident in the solver, the IIS finder cannot initiate the process to isolate an IIS. This can occur if the infeasibility is detected in the pre-solver before a basis is created, or the barrier solver has terminated without performing a basis crossover. To obtain an IIS for such cases, the pre-solve option will be turned off automatically and the model gets optimized again.

The constraints and bounds in the IIS are further classified into two disjoint sets: a necessary set and a sufficient set. The *sufficient* set refers to a crucial subset of the IIS in the sense that removing any one of its members from the entire model renders the model feasible. Note that not all infeasible models have *sufficient* sets. The *necessary* set contains those constraints and bounds that are likely to contribute to the overall infeasibility of the entire model. Thus, the *necessary* set requires a correction in at least one member to make the original model feasible. A constraint that has been marked as *sufficient* has a high probability of containing an error. In fact, if the model contains only one bad coefficient, the constraint containing it will be marked as *sufficient*.

To control the level of analysis when locating an IIS, one can set the option IIS_ANALYZE_LEVEL.

## Unbounded Linear Programs

GAMS/Lindo's IUS option is similar to the IIS option, except that it is used to track down the source of an unbounded solution in a linear program. This tool analyzes the model and isolates an "irreducibly unbounded set" (IUS) of variables. As in the infeasibility case, the IUS is partitioned into *sufficient* and *necessary* sets to indicate the role of the member variables for the unboundedness of the overall model.

The variables in the *sufficient* set are crucial in the sense that fixing any of these variables makes the overall model bounded. However, fixing the variables in the *necessary* set does not ensure that there are no other sets of unbounded variables that cause unboundedness for the overall model.

To control the level of analysis when locating an IUS, one can set the option IUS_ANALYZE_LEVEL.

# GAMS/LINDO output

The log output below is obtained for the NLP model mhw4d.gms from the GAMS model library using LINDOs global solver.

LINDO 24Nov11 23.8.0 WIN 30200.30202 VS8 x86/MS Windows LINDO Driver Lindo Systems Inc, www.lindo.com Lindo API version 7.0.1.372 built on Nov 3 2011 21:49:01 Barrier Solver Version 6.0.0.114, Nonlinear Solver Version 3.15B Platform Windows x86 Number of constraints: 3 le: 0, ge: 0, eq: 3, rn: 0 (ne:0) Number of variables : 5 lb: 0, ub: 0, fr: 5, bx: 0 (fx:0) Number of nonzeroes : 8 density=0.0053(%) Nonlinear variables : 5 Nonlinear constraints: 4 Nonlinear nonzeroes : 5+5 Starting global optimization ... Number of nonlinear functions/operators: 3 EP_MULTIPLY EP_POWER EP_SQR Starting GOP presolve ... First Call Local Solver Find local solution, objvalue = 27.871905 Pre-check unboundedness Computing reduced bound... Searching for a better solution... Starting reformulation ... Model Input Operation Atomic Convex Number of variables : 5 6 20 20 Number of constraints: 3 4 18 46 integer variables : 0 0 0 0 nonlinear variables : 5 5 9 0 Starting global search ... Initial upper bound on objective: +2.931083e-002 Initial lower bound on objective: -3.167052e+022 #NODEs BOXES LOWER BOUND UPPER BOUND RGAP TIME(s) 1 1 -3.167052e+022 +2.931083e-002 1.0e+000 0 (*N) 19 17 -2.136461e+000 +2.931083e-002 1.0e+000 0 (*I) 22 20 -1.848574e-001 +2.931083e-002 2.1e-001 0 (*I) 23 21 +2.416053e-003 +2.931083e-002 2.7e-002 0 (*F) Terminating global search ... Global optimum found Objective value : 0.0293108307216 Best Bound : 0.00241605257558 Factors (ok,stb) : 522 (100.00,99.81) Simplex iterations : 2503 Barrier iterations : 0 Nonlinear iterations : 433 Box iterations : 23 Total number of boxes : 21 Max. Depth : 5 First solution time (sec.) : 0 Best solution time (sec.) : 0 Total time (sec.) : 0

After determining the different kinds of nonlinear operators LINDO tries to linearize these within the presolving. When a feasible starting point is found the optimization starts and the log provides information about the progress. At the end it is reported if an optimum could be found and then the results as well as the used resources are summarized.

The following flags can be seen in the progress log:

Flag | Description |
---|---|

(*FP) | found a new MIP solution with feasibility pump |

(*SBB) | found a new MIP solution in tree reorder |

(*SE) | found a new MIP solution in simple enumeration |

(*AB) | found a new MIP solution in advanced branching |

(*AH) | found a new MIP solution with advanced heuristics |

(*C) | found a new MIP solution after cuts added |

(*T) | found a new MIP solution on the top |

(*SRH) | found a new MIP solution in simple rounding heuristics |

(*SB) | found a new MIP solution in strong branching |

(*K) | found a new MIP solution in knapsack enumerator |

(*) | found a new MIP solution normal branching |

(*?-) | found a new MIP solution with advanced heuristics (level$>$10) |

(*N) | found a new incumbent GOP solution |

(*I) | stored a box with the incumbent solution into the GOP solution list |

(*F) | determined the final GOP status |

# The GAMS/LINDO Options

GAMS/LINDO offers a diverse range of user-adjustable parameters to control the behavior of its solvers. While the default values of these parameters work best for most purposes, there may be cases the users prefer to work with different settings for a subset of the available parameters. This section gives a list of available GAMS/LINDO parameters, categorized by type, along with their brief descriptions. A more detailed description is given in the section that follows.

## GAMS/LINDO Options File

In order to set GAMS/LINDO options, you need to set up an option file *lindo.opt* or *lindoglobal.opt* in your GAMS project directory. You must indicate in the model that you want to use the option file by inserting before the solve statement, the line:

<modelname>.optfile = 1;

where

<modelname>

is the name of the model referenced in the model statement. The option file is in plain text format containing a single GAMS/LINDO option per line. Each option identifier is followed by its target value with space or tab characters separating them. The lines starting with * character are treated as comments.

A sample option file *lindo.opt* looks like below

* Use(1) or Disable(0) global optimization for NLP/MINLP models USEGOP 0 * Enable Multistart NLP solver NLP_SOLVER 9 * Allow a maximum of 3 multistart attempts NLP_MAXLOCALSEARCH 3 * Set an overall time limit of 200 secs. SOLVER_TIMLMT 200

# Summary of GAMS/Lindo Options

## General Options

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

DECOMPOSITION_TYPE | decomposition to be performed on a linear or mixed integer model | `1` |

FIND_BLOCK | graph partitioning method to find block structures | `0` |

FIND_SYMMETRY_LEVEL | specifies the symmetry finding level. | `-1` |

FIND_SYMMETRY_PRINT_LEVEL | specifies print level for symmetry finding | `0` |

INSTRUCT_SUBOUT | flag to specify how to deal with fixed variables in the instruction list | `-1` |

MULTITHREAD_MODE | threading mode | `-1` |

NUM_THREADS | number of parallel threads to be used | `GAMS Threads` |

PROFILER_LEVEL | specifies the profiler level to break down the total cpu time into. | `0` |

SOLVER_FEASTOL | feasibility tolerance | `1e-7` |

SOLVER_IUSOL | flag for computing basic solution for infeasible model | `0` |

SOLVER_OPTTOL | dual feasibility tolerance | `1e-7` |

SOLVER_PRE_ELIM_FILL | fill-in introduced by the eliminations during pre-solve | `1000` |

SOLVER_RESTART | starting basis flag | `0` |

SOLVER_TIMLMT | time limit in seconds for continous solver | `GAMS ResLim` |

## LP Options

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

LP_PRELEVEL | controls the amount and type of LP pre-solving | `126` |

PROB_TO_SOLVE | controls whether the explicit primal or dual form of the given LP problem will be solved | `0` |

SOLVER_CONCURRENT_OPTMODE | controls if simplex and interior-point optimizers will run concurrently | `0` |

SOLVER_CUTOFFVAL | solver will exit if optimal solution is worse than this | `0` |

SOLVER_IPMSOL | basis crossover flag for barrier solver | `0` |

SOLVER_USECUTOFFVAL | flag for using cutoff value | `0` |

SPLEX_DPRICING | pricing option for dual simplex method | `-1` |

SPLEX_DUAL_PHASE | controls the dual simplex strategy | `0` |

SPLEX_ITRLMT | simplex iteration limit | `infinity` |

SPLEX_PPRICING | pricing option for primal simplex method | `-1` |

SPLEX_REFACFRQ | number of simplex iterations between two consecutive basis re-factorizations | `100` |

SPLEX_SCALE | scaling flag | `1` |

## IPM Options

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

IPM_BASIS_REL_TOL_S | maximum relative dual bound violation allowed in an optimal basic solution | `1e-12` |

IPM_BASIS_TOL_S | maximum absolute dual bound violation in an optimal basic solution | `1e-7` |

IPM_BASIS_TOL_X | maximum absolute primal bound violation allowed in an optimal basic solution | `1e-7` |

IPM_BI_LU_TOL_REL_PIV | relative pivot tolerance used in the LU factorization in the basis identification procedure | `1e-2` |

IPM_CHECK_CONVEXITY | flag to check convexity of a quadratic program using barrier solver | `1` |

IPM_CO_TOL_INFEAS | maximum bound infeasibility tolerance for Conic solver | `1e-10` |

IPM_MAX_ITERATIONS | ipm iteration limit | `1000` |

IPM_NUM_THREADS | number of threads to run the interiorpoint optimizer on | `1` |

IPM_OFF_COL_TRH | extent for detecting the offending columns in the Jacobian of the constraint matrix | `40` |

IPM_TOL_DFEAS | dual feasibility tolerance | `1e-8` |

IPM_TOL_DSAFE | controls the initial dual starting point | `1` |

IPM_TOL_INFEAS | infeasibility tolerance | `1e-10` |

IPM_TOL_MU_RED | relative complementarity gap tolerance | `1e-16` |

IPM_TOL_PATH | how close to follow the central path | `1e-8` |

IPM_TOL_PFEAS | primal feasibility tolerance | `1e-8` |

IPM_TOL_PSAFE | controls the initial primal starting point | `1` |

IPM_TOL_REL_STEP | relative step size to the boundary | `0.9999` |

## MIP Options

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

MIP_ABSCUTTOL | MIP absolute cut tolerance | `-1.0` |

MIP_ABSOPTTOL | MIP absolute optimality tolerance | `GAMS OptCA` |

MIP_ADDCUTOBJTOL | required objective improvement to continue generating cuts | `1.5625e-5` |

MIP_ADDCUTPER | percentage of constraint cuts that can be added | `0.75` |

MIP_ADDCUTPER_TREE | percentage of constraint cuts that can be added at child nodes | `0.5` |

MIP_AGGCUTLIM_TOP | max number of constraints involved in derivation of aggregation cut at root node | `-1` |

MIP_AGGCUTLIM_TREE | max number of constraints involved in derivation of aggregation cut at tree nodes | `-1` |

MIP_ANODES_SWITCH_DF | threshold on active nodes for switching to depth-first search | `50000` |

MIP_AOPTTIMLIM | time in seconds beyond which the relative optimality tolerance will be applied | `100` |

MIP_BIGM_FOR_INTTOL | threshold for which coefficient of a binary variable would be considered as big-M | `1e8` |

MIP_BRANCHDIR | first branching direction | `0` |

MIP_BRANCHRULE | rule for choosing the variable to branch | `0` |

MIP_BRANCH_LIMIT | limit on the total number of branches to be created during branch and bound | `-1` |

MIP_BRANCH_PRIO | controls how variable selection priorities are set and used | `0` |

MIP_CUTDEPTH | threshold value for the depth of nodes in the branch and bound tree | `8` |

MIP_CUTFREQ | frequency of invoking cut generation at child nodes | `10` |

MIP_CUTLEVEL_TOP | combination of cut types to try at the root node when solving a MIP | `57342` |

MIP_CUTLEVEL_TREE | combination of cut types to try at child nodes in the branch and bound tree when solving a MIP | `53246` |

MIP_CUTOFFOBJ | defines limit for branch and bound | `1e30` |

MIP_CUTTIMLIM | time to be spent in cut generation | `-1` |

MIP_DELTA | near-zero value used in linearizing nonlinear expressions | `1e-6` |

MIP_DUAL_SOLUTION | flag for computing dual solution of LP relaxation | `0` |

MIP_FP_ITRLIM | iteration limit for feasibility pump heuristic | `500` |

MIP_FP_MODE | mode for the feasibility pump heuristic | `-1` |

MIP_FP_OPT_METHOD | optimization and reoptimization method for feasibility pump heuristic | `0` |

MIP_FP_TIMLIM | time limit for feasibility pump heuristic | `1800` |

MIP_FP_WEIGTH | weight of the objective function in the feasibility pump | `1` |

MIP_GENERAL_MODE | general strategy in solving MIPs | `0` |

MIP_HEULEVEL | specifies heuristic used to find integer solution | `3` |

MIP_HEUMINTIMLIM | minimum time in seconds to be spent in finding heuristic solutions | `0` |

MIP_HEU_DROP_OBJ | flag for whether to use without OBJ heuristic | `0` |

MIP_HEU_MODE | heuristic used in MIP solver | `0` |

MIP_INTTOL | absolute integer feasibility tolerance | `1e-6` |

MIP_ITRLIM | iteration limit for branch and bound | `infinity` |

MIP_KBEST_USE_GOP | specifies whether to use gop solver in MIP KBest | `0` |

MIP_KEEPINMEM | flag for keeping LP bases in memory | `1` |

MIP_LBIGM | Big-M value used in linearizing nonlinear expressions | `10000` |

MIP_LSOLTIMLIM | time limit until finding a new integer solution | `-1` |

MIP_MAKECUT_INACTIVE_COUNT | threshold for times a cut could remain active after successive reoptimization | `10` |

MIP_MAXCUTPASS_TOP | number passes to generate cuts on the root node | `200` |

MIP_MAXCUTPASS_TREE | number passes to generate cuts on the child nodes | `2` |

MIP_MAXNONIMP_CUTPASS | number of passes allowed in cut-generation that does not improve current relaxation | `3` |

MIP_MAXNUM_MIP_SOL_STORAGE | maximum number of k-best solutions to store | `1` |

MIP_MINABSOBJSTEP | value to update cutoff value each time a mixed integer solution is found | `0` |

MIP_NODESELRULE | specifies the node selection rule | `0` |

MIP_NUM_THREADS | number of parallel threads to use by the parallel MIP solver | `1` |

MIP_PARA_FP | flag for whether to use parallelization on the feasibility pump heuristic | `1` |

MIP_PARA_FP_MODE | flag for the mode of parallel feasibility pump | `0` |

MIP_PARA_INIT_NODE | number of initial nodes for MIP parallelization | `-1` |

MIP_PARA_ITR_MODE | flag for iteration mode in MIP parallelization | `1` |

MIP_PARA_RND_ITRLMT | iteration limit of each round in MIP parallelization, it is a weighted combination of simplex and barrier iterations | `2.0` |

MIP_PARA_SUB | flag for whether to use MIP parallelization on subproblems solved in MIP preprocessing | `1` |

MIP_PEROPTTOL | MIP relative optimality tolerance in effect after MIP_AOPTTIMLIM seconds | `1e-5` |

MIP_PERSPECTIVE_REFORM | flag for whether to use Perspective Reformulation | `1` |

MIP_POLISH_ALPHA_TARGET | proportion solutions in the pool to initiate a polishing-task at the current node | `0.6` |

MIP_POLISH_MAX_BRANCH_COUNT | maximum number of branches to polish | `2000` |

MIP_POLISH_NUM_BRANCH_NEXT | number of branches to polish in the next round | `4000` |

MIP_PREHEU_DFE_VSTLIM | limit for the variable visit in depth first enumeration | `200` |

MIP_PREHEU_LEVEL | heuristic level for the prerelax solver | `0` |

MIP_PREHEU_TC_ITERLIM | iteration limit for the two change heuristic | `30000000` |

MIP_PREHEU_VAR_SEQ | sequence of the variable considered by the prerelax heuristic | `-1` |

MIP_PRELEVEL | controls the amount and type of MIP pre-solving at root node | `3070` |

MIP_PRELEVEL_TREE | amount and type of MIP pre-solving at tree nodes | `1214` |

MIP_PRE_ELIM_FILL | controls fill-in introduced by eliminations during pre-solve | `100` |

MIP_PSEUDOCOST_RULE | specifies the rule in pseudocost computations for variable selection | `0` |

MIP_PSEUDOCOST_WEIGT | weight in pseudocost computations for variable selection | `1.5625e-05` |

MIP_REDCOSTFIX_CUTOFF | cutoff value as a percentage of the reduced costs | `0.9` |

MIP_REDCOSTFIX_CUTOFF_TREE | cutoff value as a percentage of the reduced costs at tree nodes | `0.9` |

MIP_RELINTTOL | relative integer feasibility tolerance | `8e-6` |

MIP_RELOPTTOL | MIP relative optimality tolerance | `GAMS OptCR` |

MIP_REOPT | optimization method to use when doing reoptimization | `0` |

MIP_SCALING_BOUND | maximum difference between bounds of an integer variable for enabling scaling | `10000` |

MIP_SOLLIM | integer solution limit for MIP solver | `-1` |

MIP_SOLVERTYPE | optimization method to use when solving mixed-integer models | `0` |

MIP_STRONGBRANCHDONUM | minimum number of variables to try the strong branching on | `3` |

MIP_STRONGBRANCHLEVEL | depth from the root in which strong branching is used | `10` |

MIP_SWITCHFAC_SIM_IPM_TIME | factor that multiplies the number of constraints to impose a time limit to simplex method and trigger a switch over to the barrier method | `-1` |

MIP_SYMMETRY_MODE | specifies mip symmetry handling methods | `0` |

MIP_TIMLIM | time limit in seconds for integer solver | `GAMS ResLim` |

MIP_TOPOPT | optimization method to use when there is no previous basis | `0` |

MIP_TREEREORDERLEVEL | tree reordering level | `10` |

MIP_TREEREORDERMODE | tree reordering mode | `1` |

MIP_USECUTOFFOBJ | flag for using branch and bound limit | `1` |

MIP_USE_CUTS_HEU | controls if cut generation is enabled during MIP heuristics | `-1` |

MIP_USE_ENUM_HEU | frequency of enumeration heuristic | `4` |

MIP_USE_INT_ZERO_TOL | controls if all MIP calculations would be based on absolute integer feasibility tolarance | `0` |

## NLP Options

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

NLP_AUTODERIV | defining type of computing derivatives | `0` |

NLP_AUTOHESS | flag for using Second Order Automatic Differentiation for solving NLP | `0` |

NLP_CUTOFFOBJ | as soon as any multi-start thread achieves this value all threads stop | `-1e30` |

NLP_DERIV_DIFFTYPE | flag indicating the technique used in computing derivatives with finite differences | `0` |

NLP_FEASCHK | how to report results when solution satisfies tolerance of scaled but not original model | `1` |

NLP_FEASTOL | feasibility tolerance for nonlinear constraints | `1e-6` |

NLP_INF | numeric infinity for nonlinear models | `1e30` |

NLP_IPM2GRG | switch from IPM solver to GRG solver when IPM fails due to numerical errors | `1` |

NLP_ITERS_PER_LOGLINE | number of nonlinear iterations to elapse before next progress message | `10` |

NLP_ITRLMT | nonlinear iteration limit | `GAMS IterLim` |

NLP_LINEARZ | extent to which the solver will attempt to linearize nonlinear models | `0` |

NLP_LINEARZ_WB_CONSISTENT | determines if linearization process is consistent with WB/excel calculation | `0` |

NLP_MAXLOCALSEARCH | maximum number of local searches | `5` |

NLP_MAXLOCALSEARCH_TREE | maximum number of multistarts | `1` |

NLP_MAX_RETRY | maximum number refinement retries to purify the final NLP solution | `5` |

NLP_MSW_EUCDIST_THRES | euclidean distance threshold in multistart search | `0.001` |

NLP_MSW_FILTMODE | filtering mode to exclude certain domains during sampling in multistart search | `-1` |

NLP_MSW_MAXNOIMP | maximum number of consecutive populations to generate without any improvements | `-1` |

NLP_MSW_MAXPOP | maximum number of populations to generate in multistart search | `-1` |

NLP_MSW_MAXREF | maximum number of reference points to generate trial points in multistart search | `-1` |

NLP_MSW_NORM | norm to measure the distance between two points in multistart search | `2` |

NLP_MSW_NUM_THREADS | number of parallel threads to be used when solving an NLP model with the multistart solver | `1` |

NLP_MSW_OVERLAP_RATIO | rate of replacement in successive populations | `0.1` |

NLP_MSW_POXDIST_THRES | penalty function neighborhood threshold in multistart search | `0.01` |

NLP_MSW_PREPMODE | preprocessing strategies in multistart solver | `-1` |

NLP_MSW_RG_SEED | random number generator seed for the multistart solver | `1019` |

NLP_MSW_SOLIDX | index of the multistart solution to be loaded | `0` |

NLP_MSW_XKKTRAD_FACTOR | KKT solution neighborhood factor in multistart search | `0.85` |

NLP_MSW_XNULRAD_FACTOR | initial solution neighborhood factor in multistart search | `0.5` |

NLP_PRELEVEL | controls the amount and type of NLP pre-solving | `126` |

NLP_PSTEP_FINITEDIFF | value of the step length in computing the derivatives using finite differences | `5e-7` |

NLP_QUADCHK | flag for checking if NLP is quadratic | `1` |

NLP_REDGTOL | tolerance for the gradients of nonlinear functions | `1e-7` |

NLP_SOLVER | type of nonlinear solver | `7` |

NLP_SOLVE_AS_LP | flag indicating if the nonlinear model will be solved as an LP | `0` |

NLP_STALL_ITRLMT | iteration limit before a sequence of non-improving NLP iterations is declared as stalling | `100` |

NLP_STARTPOINT | flag for using initial starting solution for NLP | `1` |

NLP_SUBSOLVER | type of nonlinear subsolver | `1` |

NLP_USECUTOFFOBJ | flag to use parameter NLP_CUTOFFOBJ | `0` |

NLP_USE_CRASH | flag for using simple crash routines for initial solution | `0` |

NLP_USE_LINDO_CRASH | flag for using advanced crash routines for initial solution | `1` |

NLP_USE_SDP | flag to use SDP solver for POSD constraint | `1` |

NLP_USE_SELCONEVAL | flag for using selective constraint evaluations for solving NLP | `1` |

NLP_USE_SLP | flag for using sequential linear programming step directions for updating solution | `1` |

NLP_USE_STEEPEDGE | flag for using steepest edge directions for updating solution | `0` |

## Global Options

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

GOP_ABSOPTTOL | absolute optimality tolerance | `GAMS OptCA` |

GOP_ALGREFORMMD | algebraic reformulation rule for a GOP | `18` |

GOP_BBSRCHMD | node selection rule in GOP branch-and-bound | `1` |

GOP_BNDLIM | max magnitude of variable bounds used in GOP convexification | `1e10` |

GOP_BOXTOL | minimal width of variable intervals | `1e-6` |

GOP_BRANCHMD | direction to branch first when branching on a variable | `5` |

GOP_BRANCH_LIMIT | limit on the total number of branches to be created in GOP tree | `-1` |

GOP_CORELEVEL | strategy of GOP branch-and-bound | `14` |

GOP_DECOMPPTMD | decomposition point selection rule in GOP branch-and-bound | `1` |

GOP_DELTATOL | delta tolerance in GOP convexification | `1e-7` |

GOP_FLTTOL | floating-point tolerance | `1e-10` |

GOP_HEU_MODE | heuristic used in global solver | `0` |

GOP_ITRLIM | GOP iteration limit | `infinity` |

GOP_ITRLIM_IPM | total barrier iteration limit summed over all branches in GOP | `-1` |

GOP_ITRLIM_NLP | total nonlinear iteration limit summed over all branches in GOP | `-1` |

GOP_ITRLIM_SIM | total simplex iteration limit summed over all branches in GOP | `-1` |

GOP_LIM_MODE | flag indicating which heuristic limit on sub-solver in GOP is based | `1` |

GOP_LINEARZ | flag indicating if GOP exploits linearizable model | `1` |

GOP_LSOLBRANLIM | branch limit until finding a new nonlinear solution | `-1` |

GOP_MAXWIDMD | maximum width flag for the global solution | `0` |

GOP_MULTILINEAR | flag indicating if GOP exploits multi linear feature | `1` |

GOP_NUM_THREADS | number of parallel threads to be used when solving a nonlinear model with the global optimization solver | `1` |

GOP_OBJ_THRESHOLD | threshold of objective value in the GOP solver | `-1e+30` |

GOP_OPTCHKMD | criterion used to certify the global optimality | `2` |

GOP_OPT_MODE | mode for GOP optimization | `1` |

GOP_POSTLEVEL | amount and type of GOP postsolving | `6` |

GOP_PRELEVEL | amount and type of GOP presolving | `30` |

GOP_QUAD_METHOD | specifies if the GOP solver should solve the model as a QP when applicable | `-1` |

GOP_RELBRNDMD | reliable rounding in the GOP branch-and-bound | `0` |

GOP_RELOPTTOL | relative optimality tolerance | `GAMS OptCR` |

GOP_SUBOUT_MODE | substituting out fixed variables | `1` |

GOP_TIMLIM | time limit in seconds for GOP branch-and-bound | `GAMS ResLim` |

GOP_USEBNDLIM | max magnitude of variable bounds flag for GOP convexification | `2` |

GOP_WIDTOL | maximal width of variable intervals | `1e-4` |

USEGOP | use global optimization | `1` |

## SP Options

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

CORE_ORDER_BY_STAGE | order nontemporal models or not | `1` |

REPORTEVSOL | solve and report the expected value solution | `0` |

SAMP_CDSINC | correlation matrix diagonal shift increment | `1e-6` |

SAMP_NCM_CUTOBJ | objective cutoff (target) value to stop the nearest correlation matrix (NCM) subproblem | `1e-30` |

SAMP_NCM_DSTORAGE | flag to enable or disable sparse mode in NCM computations | `-1` |

SAMP_NCM_ITERLIM | iteration limit for NCM method | `100` |

SAMP_NCM_METHOD | bitmask to enable methods for solving the nearest correlation matrix (NCM) subproblem | `5` |

SAMP_NCM_OPTTOL | optimality tolerance for NCM method | `1e-7` |

SAMP_SCALE | flag to enable scaling of raw sample data | `0` |

STOC_ABSOPTTOL | absolute optimality tolerance (w.r.t lower and upper bounds on the true objective) to stop the solver | `GAMS OptCA` |

STOC_ADD_MPI | flag to use add-instructions mode when building deteq | `0` |

STOC_ALD_DUAL_FEASTOL | dual feasibility tolerance for ALD | `1e-4` |

STOC_ALD_DUAL_STEPLEN | dual step length for ALD | `0.9` |

STOC_ALD_INNER_ITER_LIM | inner loop iteration limit for ALD | `1000` |

STOC_ALD_OUTER_ITER_LIM | outer loop iteration limit for ALD | `200` |

STOC_ALD_PRIMAL_FEASTOL | primal feasibility tolerance for ALD | `1e-4` |

STOC_ALD_PRIMAL_STEPLEN | primal step length for ALD | `0.5` |

STOC_AUTOAGGR | flag to enable or disable autoaggregation | `1` |

STOC_BENCHMARK_SCEN | benchmark scenario to compare EVPI and EVMU against | `-2` |

STOC_BIGM | big-M value for linearization and penalty functions | `1e7` |

STOC_BUCKET_SIZE | bucket size in Benders decomposition | `-1` |

STOC_CALC_EVPI | flag to enable or disable calculation of EVPI | `1` |

STOC_CORRELATION_TYPE | correlation type associated with correlation matrix | `0` |

STOC_DEQOPT | method to solve the DETEQ problem | `0` |

STOC_DETEQ_TYPE | type of deterministic equivalent | `-1` |

STOC_DS_SUBFORM | subproblem formulation to use in DirectSearch | `-1` |

STOC_ELIM_FXVAR | flag to enable elimination of fixed variables from deteq MPI | `1` |

STOC_INFBND | value to truncate infinite bounds at non-leaf nodes | `1e9` |

STOC_ITER_LIM | iteration limit for stochastic solver | `infinity` |

STOC_MAP_MPI2LP | flag to specify whether stochastic parameters in MPI will be mapped as LP matrix elements | `0` |

STOC_MAX_NUMSCENS | maximum number of scenarios before forcing automatic sampling | `40000` |

STOC_METHOD | stochastic optimization method to solve the model | `-1` |

STOC_NAMEDATA_LEVEL | name data level | `1` |

STOC_NODELP_PRELEVEL | presolve level solving node-models | `0` |

STOC_NSAMPLE_PER_STAGE | list of sample sizes per stage (starting at stage 2) | |

STOC_NSAMPLE_SPAR | common sample size per stochastic parameter | `-1` |

STOC_NSAMPLE_STAGE | common sample size per stage | `-1` |

STOC_NUM_THREADS | number of parallel threads | `1` |

STOC_RELOPTTOL | relative optimality tolerance (w.r.t lower and upper bounds on the true objective) to stop the solver | `GAMS OptCR` |

STOC_REL_DSTEPTOL | dual-step tolerance | `1e-7` |

STOC_REL_PSTEPTOL | primal-step tolerance | `1e-8` |

STOC_REOPT | reoptimization method to solve the node-models | `0` |

STOC_RG_SEED | seed to initialize the random number generator | `1031` |

STOC_SAMP_CONT_ONLY | flag to restrict sampling to continuous stochastic parameters only or not | `1` |

STOC_SBD_MAXCUTS | max cuts to generate for master problem | `-1` |

STOC_SBD_NUMCANDID | maximum number of candidate solutions to generate at SBD root | `-1` |

STOC_SBD_OBJCUTFLAG | flag to enable objective cut in SBD master problem | `1` |

STOC_SBD_OBJCUTVAL | RHS value of objective cut in SBD master problem | `1e-30` |

STOC_SHARE_BEGSTAGE | stage beyond which node-models are shared | `-1` |

STOC_TIME_LIM | time limit for stochastic solver | `GAMS ResLim` |

STOC_TOPOPT | optimization method to solve the root problem | `0` |

STOC_VARCONTROL_METHOD | sampling method for variance reduction | `1` |

STOC_WSBAS | warm start basis for wait-see model | `-1` |

SVR_LS_ANTITHETIC | Sample variance reduction map to Lindo Antithetic algorithm | |

SVR_LS_LATINSQUARE | Sample variance reduction map to Lindo Latin Square algorithm | |

SVR_LS_MONTECARLO | Sample variance reduction map to Lindo Montecarlo algorithm |

## IIS and IUS Options

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

IIS | run the IIS finder if the problem is infeasible | `0` |

IIS_ANALYZE_LEVEL | controls the level of analysis when locating an IIS | `1` |

IIS_GETMODE | flag that controls whether variable bounds in the IIS should be retrieved or the integer restrictions | `0` |

IIS_INFEAS_NORM | specifies the norm to measure infeasibilities in IIS search | `0` |

IIS_ITER_LIMIT | the iteration limit for IIS search | `-1` |

IIS_METHOD | specifies the method to use in analyzing infeasible models to locate an IIS | `0` |

IIS_PRINT_LEVEL | specifies the amount of print to do during IIS search | `2` |

IIS_REOPT | specifies which optimization method to use when starting from a given basis | `0` |

IIS_TIME_LIMIT | the time limit for IIS search | `-1` |

IIS_TOPOPT | specifies which optimization method to use when there is no previous basis | `0` |

IIS_USE_EFILTER | flag that controls whether the Elastic Filter should be enabled as the supplementary filter in analyzing infeasible models | `0` |

IIS_USE_GOP | flag that controls whether the global optimizer should be enabled in analyzing infeasible NLP models | `0` |

IIS_USE_SFILTER | flag indicating is sensitivity filter will be used during IIS search | `1` |

IUS | run the IUS finder if the problem is unbounded | `0` |

IUS_ANALYZE_LEVEL | controls the level of analysis when locating an IUS | `2` |

## Link Options

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

CHECKRANGE | calculate feasible range for variables | `range.gdx` |

READPARAMS | read Lindo parameter file | |

WRITEDEMPI | write deterministic equivalent in MPI format | |

WRITEDEMPS | write deterministic equivalent in MPS format | |

WRITEMPI | write (S)MPI file of processed model | |

WRITEMPS | write (S)MPS file of processed model |

# Detailed Descriptions of GAMS/Lindo Options

**CHECKRANGE** *(string)*: calculate feasible range for variables ↵

If this option is set, Lindo calculates the feasible range (determined by an upper and lower bound) for every variable in each equation while all other variables are fixed to their level. If set, the value of this option defines the name of the GDX file where the results are written to. For every combination of equation- and variable block there will be one symbol in the format

EquBlock_VarBlock(equ_Ind_1, ..., equ_Ind_M, var_Ind_1, ..., var_Ind_N, directions).Default:

`range.gdx`

**CORE_ORDER_BY_STAGE** *(integer)*: order nontemporal models or not ↵

Order nontemporal models or not.

Default:

`1`

**DECOMPOSITION_TYPE** *(integer)*: decomposition to be performed on a linear or mixed integer model ↵

This refers to the type of decomposition to be performed on a linear or mixed integer model.

Default:

`1`

value meaning `0`

Solver decides which type of decomposition to use `1`

Solver does not perform any decompositions and uses the original model `2`

Attempt total decomposition `3`

Decomposed model will have dual angular structure `4`

Decomposed model will have block angular structure `5`

Decomposed model will have both dual and block angular structure

**FIND_BLOCK** *(integer)*: graph partitioning method to find block structures ↵

Specifies the graph partitioning method to find block structures.

Default:

`0`

value meaning `0`

Use an edge-weight minimizing graph partitioning heuristic `1`

Use a vertex-weight minimizing graph partitioning heuristic

**FIND_SYMMETRY_LEVEL** *(integer)*: specifies the symmetry finding level. ↵

Default:

`-1`

value meaning `-1`

Solver decides `0`

Finding orbit only without MIP preprocessing `1`

Finding orbit only with MIP preprocessing `2`

Finding generators without MIP preprocessing `3`

Finding generators with MIP preprocessing `4`

Finding the first generator without MIP preprocessing `5`

Finding the first generator with MIP preprocessing

**FIND_SYMMETRY_PRINT_LEVEL** *(integer)*: specifies print level for symmetry finding ↵

Default:

`0`

value meaning `0`

Nothing printed `+2`

General information `+4`

Time information `+8`

Orbit information `+16`

Partition information

**GOP_ABSOPTTOL** *(real)*: absolute optimality tolerance ↵

Synonym: ABSOPTTOL

This value is the GOP absolute optimality tolerance. Solutions must beat the incumbent by at least this amount to become the new best solution.

Default:

`GAMS OptCA`

**GOP_ALGREFORMMD** *(integer)*: algebraic reformulation rule for a GOP ↵

Synonym: ALGREFORMMD

This controls the algebraic reformulation rule for a GOP. The algebraic reformulation and analysis is very crucial in building a tight convex envelope to enclose the nonlinear/nonconvex functions. A lower degree of overestimation on convex envelopes helps increase the convergence rate to the global optimum.

Default:

`18`

value meaning `+2`

Rearrange and collect terms `+4`

Expand all parentheses `+8`

Retain nonlinear functions `+16`

Selectively expand parentheses

**GOP_BBSRCHMD** *(integer)*: node selection rule in GOP branch-and-bound ↵

Synonym: BBSRCHMD

This specifies the node selection rule for choosing between all active nodes in the GOP branch-and-bound tree when solving global optimization programs.

Default:

`1`

value meaning `0`

Depth first search `1`

Choose node with worst bound

**GOP_BNDLIM** *(real)*: max magnitude of variable bounds used in GOP convexification ↵

Synonym: BNDLIM

This value specifies the maximum magnitude of variable bounds used in the GOP convexification. Any lower bound smaller than the negative of this value will be treated as the negative of this value. Any upper bound greater than this value will be treated as this value. This helps the global solver focus on more productive domains.

Default:

`1e10`

**GOP_BOXTOL** *(real)*: minimal width of variable intervals ↵

Synonym: BOXTOL

This value specifies the minimal width of variable intervals in a box allowed to branch.

Default:

`1e-6`

**GOP_BRANCHMD** *(integer)*: direction to branch first when branching on a variable ↵

Synonym: BRANCHMD

This specifies the direction to branch first when branching on a variable. The branch variable is selected as the one that holds the largest magnitude in the measure.

Default:

`5`

value meaning `0`

Absolute width `1`

Locally relative width `2`

Globally relative width `3`

Globally relative distance from the convex minimum to the bounds `4`

Absolute violation between the function and its convex envelope at the convex minimum `5`

Relative violation between the function and its convex envelope at the convex minimum

**GOP_BRANCH_LIMIT** *(integer)*: limit on the total number of branches to be created in GOP tree ↵

Synonym: BRANCH_LIMIT

This is the limit on the total number of branches to be created during branch-and- bound in GOP tree. The default value is -1, which means no limit is imposed. If the branch limit is reached and a feasible solution was found, it will be installed as the incumbent (best known) solution.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**GOP_CORELEVEL** *(integer)*: strategy of GOP branch-and-bound ↵

Synonym: CORELEVEL

This controls the strategy of GOP branch-and-bound procedure.

Default:

`14`

value meaning `+2`

LP convex relaxation `+4`

NLP solving `+8`

Box Branching

**GOP_DECOMPPTMD** *(integer)*: decomposition point selection rule in GOP branch-and-bound ↵

Synonym: DECOMPPTMD

This specifies the decomposition point selection rule. In the branch step of GOP branch-and-bound, a branch point M is selected to decompose the selected variable interval [Lb, Ub] into two subintervals, [Lb, M] and [M, Ub].

Default:

`1`

value meaning `0`

Mid-point `1`

Local minimum or convex minimum

**GOP_DELTATOL** *(real)*: delta tolerance in GOP convexification ↵

Synonym: DELTATOL

This value is the delta tolerance in the GOP convexification. It is a measure of how closely the additional constraints added as part of convexification should be satisfied.

Default:

`1e-7`

**GOP_FLTTOL** *(real)*: floating-point tolerance ↵

Synonym: FLTTOL

This value is the GOP floating-point tolerance. It specifies the maximum rounding errors in the floating-point computation.

Default:

`1e-10`

**GOP_HEU_MODE** *(integer)*: heuristic used in global solver ↵

Synonym: HEU_MODE

This specifies the heuristic used in the global solver to find a good solution. Typically, if a heuristic is used, this will put more efforts in searching for good solutions, and less in bound tightening.

Default:

`0`

value meaning `0`

No heuristic is used `1`

A simple heuristic is used

**GOP_ITRLIM** *(real)*: GOP iteration limit ↵

Synonym: ITRLIM

This is the total iteration limit (including simplex, barrier and nonlinear iteration) summed over branches in GOP. The default value is -1, which means no iteration limit is imposed. If this limit is reached, GOP will stop.

Range: [

`-1`

, ∞]Default:

`infinity`

**GOP_ITRLIM_IPM** *(real)*: total barrier iteration limit summed over all branches in GOP ↵

Synonym: ITRLIM_IPM

This is the total barrier iteration limit summed over all branches in GOP. The default value is -1, which means no iteration limit is imposed. If this limit is reached, GOP will stop.

Range: [

`-1`

, ∞]Default:

`-1`

**GOP_ITRLIM_NLP** *(real)*: total nonlinear iteration limit summed over all branches in GOP ↵

Synonym: ITRLIM_NLP

This is the total nonlinear iteration limit summed over all branches in GOP. The default value is -1, which means no iteration limit is imposed. If this limit is reached, GOP will stop.

Range: [

`-1`

, ∞]Default:

`-1`

**GOP_ITRLIM_SIM** *(real)*: total simplex iteration limit summed over all branches in GOP ↵

Synonym: ITRLIM_SIM

This is the total simplex iteration limit summed over all branches in GOP. The default value is -1, which means no iteration limit is imposed. If this limit is reached, GOP will stop.

Range: [

`-1`

, ∞]Default:

`-1`

**GOP_LIM_MODE** *(integer)*: flag indicating which heuristic limit on sub-solver in GOP is based ↵

Synonym: LIM_MODE

This is a flag indicating which heuristic limit on sub-solver in GOP is based.

Default:

`1`

value meaning `0`

No limit `1`

Time based limit `2`

Iteration based limit `3`

Both time and iteration based limit

**GOP_LINEARZ** *(integer)*: flag indicating if GOP exploits linearizable model ↵

This is a flag indicating if GOP exploits linearizable model.

Default:

`1`

value meaning `0`

Exploit lineariable model `1`

Do not exploit lineariable model

**GOP_LSOLBRANLIM** *(integer)*: branch limit until finding a new nonlinear solution ↵

Synonym: LSOLBRANLIM

This value controls the branch limit until finding a new nonlinear solution since the last nonlinear solution is found. The default value is -1, which means no branch limit is imposed.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**GOP_MAXWIDMD** *(integer)*: maximum width flag for the global solution ↵

Synonym: MAXWIDMD

This is the maximum width flag for the global solution. The GOP branch-and-bound may continue contracting a box with an incumbent solution until its maximum width is smaller than GOP_WIDTOL.

Default:

`0`

value meaning `0`

The maximum width criterion is suppressed `1`

The maximum width criterion is performed

**GOP_MULTILINEAR** *(integer)*: flag indicating if GOP exploits multi linear feature ↵

This is a flag indicating if GOP exploits multi linear feature.

Default:

`1`

value meaning `0`

Off `1`

On

**GOP_NUM_THREADS** *(integer)*: number of parallel threads to be used when solving a nonlinear model with the global optimization solver ↵

This value specifies the number of parallel threads to be used when solving a nonlinear model with the global optimization solver.

Default:

`1`

**GOP_OBJ_THRESHOLD** *(real)*: threshold of objective value in the GOP solver ↵

This value specifies the threshold of objective value in the GOP solver. For min problem, if current incumbent solution is less than the threshold GOP solver will stop.

Range: [

`-1e+30`

, ∞]Default:

`-1e+30`

**GOP_OPTCHKMD** *(integer)*: criterion used to certify the global optimality ↵

Synonym: OPTCHKMD

This specifies the criterion used to certify the global optimality. When this value is 0, the absolute deviation of objective lower and upper bounds should be smaller than GOP_ABSOPTTOL at the global optimum. When its value is 1, the relative deviation of objective lower and upper bounds should be smaller than GOP_RELOPTTOL at the global optimum. 2 means either absolute or relative tolerance is satisfied at global optimum.

Default:

`2`

**GOP_OPT_MODE** *(integer)*: mode for GOP optimization ↵

Synonym: OPT_MODE

This specifies the mode for GOP optimization.

Default:

`1`

value meaning `0`

Global search for a feasible solution (thus a feasibility certificate) `1`

Global search for an optimal solution `2`

Global search for an unboundedness certificate

**GOP_POSTLEVEL** *(integer)*: amount and type of GOP postsolving ↵

Synonym: POSTLEVEL

This controls the amount and type of GOP post-solving. The default value is: 6 = 2+4 meaning to do both of the below options.

Default:

`6`

value meaning `+2`

Apply LSgetBestBound `+4`

Reoptimize variable bounds

**GOP_PRELEVEL** *(integer)*: amount and type of GOP presolving ↵

Synonym: PRELEVEL

This controls the amount and type of GOP pre-solving. The default value is: 30 = 2+4+8+16 meaning to do all of the below options.

Default:

`30`

value meaning `+2`

Initial local optimization `+4`

Initial linear constraint propagation `+8`

Recursive linear constraint propagation `+16`

Recursive nonlinear constraint propagation

**GOP_QUAD_METHOD** *(integer)*: specifies if the GOP solver should solve the model as a QP when applicable ↵

Default:

`-1`

value meaning `-1`

Solver decides `0`

General GOP solver `1`

Specified QP solver

**GOP_RELBRNDMD** *(integer)*: reliable rounding in the GOP branch-and-bound ↵

Synonym: RELBRNDMD

This controls the reliable rounding rule in the GOP branch-and-bound. The global solver applies many suboptimizations to estimate the lower and upper bounds on the global optimum. A rounding error or numerical instability could unintentionally cut off a good solution. A variety of reliable approaches are available to improve the precision.

Default:

`0`

value meaning `+2`

Use smaller optimality or feasibility tolerances and appropriate presolving options `+4`

Apply interval arithmetic to reverify the solution feasibility

**GOP_RELOPTTOL** *(real)*: relative optimality tolerance ↵

Synonyms: OPTTOL RELOPTTOL

This value is the GOP relative optimality tolerance. Solutions must beat the incumbent by at least this amount to become the new best solution.

Default:

`GAMS OptCR`

**GOP_SUBOUT_MODE** *(integer)*: substituting out fixed variables ↵

Synonym: SUBOUT_MODE

This is a flag indicating whether fixed variables are substituted out of the instruction list used in the global solver.

Default:

`1`

value meaning `0`

Do not substitute out fixed variables `1`

Substitute out fixed variables

**GOP_TIMLIM** *(integer)*: time limit in seconds for GOP branch-and-bound ↵

Synonym: TIMLIM

This is the time limit in seconds for GOP branch-and-bound.

Range: {

`-1`

, ..., ∞}Default:

`GAMS ResLim`

**GOP_USEBNDLIM** *(integer)*: max magnitude of variable bounds flag for GOP convexification ↵

Synonym: USEBNDLIM

This value is a flag for the parameter GOP_BNDLIM.

Default:

`2`

value meaning `0`

Do not use the bound limit on the variables `1`

Use the bound limit right at the beginning of global optimization `2`

Use the bound limit after the initial local optimization if selected

**GOP_WIDTOL** *(real)*: maximal width of variable intervals ↵

Synonym: WIDTOL

This value specifies the maximal width of variable intervals for a box to be considered as an incumbent box containing an incumbent solution. It is used when GOP_MAXWIDMD is set at 1.

Default:

`1e-4`

**IIS** *(boolean)*: run the IIS finder if the problem is infeasible ↵

Default:

`0`

**IIS_ANALYZE_LEVEL** *(integer)*: controls the level of analysis when locating an IIS ↵

Default:

`1`

value meaning `+1`

Search for necessary rows `+2`

Search for necessary columns `+4`

Search for sufficient rows `+8`

Search for sufficient columns `+16`

Consider integrality restrictions as the potential cause of infeasibilities and include it in the analysis `+32`

Compute the underlying LTF matrix and use this as the basis of a ranking score to guide the IIS run `+64`

If the underlying matrix is totally decomposable, rank blocks w.r.t their sizes and debug the smallest independent infeasible block `+128`

Use the nonzero structure of the underlying matrix to compute a ranking score to guide the IIS run `+256`

Treat iter/time limits as intractability

**IIS_GETMODE** *(integer)*: flag that controls whether variable bounds in the IIS should be retrieved or the integer restrictions ↵

Default:

`0`

value meaning `0`

Variable bound `1`

Integer restrictions

**IIS_INFEAS_NORM** *(integer)*: specifies the norm to measure infeasibilities in IIS search ↵

Default:

`0`

value meaning `0`

Solver decides `1`

Use L-1 norm `2`

L-infinity norm

**IIS_ITER_LIMIT** *(integer)*: the iteration limit for IIS search ↵

Range: {

`-1`

, ..., ∞}Default:

`-1`

**IIS_METHOD** *(integer)*: specifies the method to use in analyzing infeasible models to locate an IIS ↵

Default:

`0`

value meaning `0`

Default filter `1`

Standard deletion filter `2`

Standard additive filter `3`

Generalized-binary-search filter `4`

Depth-first-binary-search filter `5`

Fast-scan filter `6`

Standard elastic filter

**IIS_PRINT_LEVEL** *(integer)*: specifies the amount of print to do during IIS search ↵

Default:

`2`

**IIS_REOPT** *(integer)*: specifies which optimization method to use when starting from a given basis ↵

Default:

`0`

value meaning `0`

Free `1`

Primal Simplex `2`

Dual Simplex `3`

Barrier `4`

NLP

**IIS_TIME_LIMIT** *(integer)*: the time limit for IIS search ↵

Range: {

`-1`

, ..., ∞}Default:

`-1`

**IIS_TOPOPT** *(integer)*: specifies which optimization method to use when there is no previous basis ↵

Default:

`0`

value meaning `0`

Free `1`

Primal Simplex `2`

Dual Simplex `3`

Barrier `4`

NLP

**IIS_USE_EFILTER** *(integer)*: flag that controls whether the Elastic Filter should be enabled as the supplementary filter in analyzing infeasible models ↵

Default:

`0`

value meaning `-1`

Solver decides `0`

Do not use elastic filter `1`

Use elastic filter

**IIS_USE_GOP** *(integer)*: flag that controls whether the global optimizer should be enabled in analyzing infeasible NLP models ↵

Default:

`0`

value meaning `-1`

Solver decides `0`

Do not use GOP `1`

Use GOP

**IIS_USE_SFILTER** *(integer)*: flag indicating is sensitivity filter will be used during IIS search ↵

Default:

`1`

value meaning `-1`

Solver decides `0`

Do not use sensitivity filter `1`

Use sensitivity filter

**INSTRUCT_SUBOUT** *(integer)*: flag to specify how to deal with fixed variables in the instruction list ↵

This is a flag indicating whether 1) fixed variables are substituted out of the instruction list, 2) performing numerical calculation on constant numbers and replacing with the results.

Default:

`-1`

value meaning `-1`

Solver decides `0`

Substitutions will not be performed `1`

Substitutions will be performed

**IPM_BASIS_REL_TOL_S** *(real)*: maximum relative dual bound violation allowed in an optimal basic solution ↵

Maximum relative dual bound violation allowed in an optimal basic solution.

Default:

`1e-12`

**IPM_BASIS_TOL_S** *(real)*: maximum absolute dual bound violation in an optimal basic solution ↵

Maximum absolute dual bound violation in an optimal basic solution.

Default:

`1e-7`

**IPM_BASIS_TOL_X** *(real)*: maximum absolute primal bound violation allowed in an optimal basic solution ↵

Maximum absolute primal bound violation allowed in an optimal basic solution.

Default:

`1e-7`

**IPM_BI_LU_TOL_REL_PIV** *(real)*: relative pivot tolerance used in the LU factorization in the basis identification procedure ↵

Relative pivot tolerance used in the LU factorization in the basis identification procedure.

Range: [

`0`

,`0.999999`

]Default:

`1e-2`

**IPM_CHECK_CONVEXITY** *(integer)*: flag to check convexity of a quadratic program using barrier solver ↵

This is a flag to check convexity of a quadratic program using barrier solver.

Default:

`1`

value meaning `-1`

Check convexity only without solving the model `0`

Use barrier solver to check convexity `1`

Do not use barrier solver to check convexity

**IPM_CO_TOL_INFEAS** *(real)*: maximum bound infeasibility tolerance for Conic solver ↵

Maximum bound infeasibility tolerance for Conic solver.

Default:

`1e-10`

**IPM_MAX_ITERATIONS** *(integer)*: ipm iteration limit ↵

Controls the maximum number of iterations allowed in the interior-point optimizer.

Default:

`1000`

**IPM_NUM_THREADS** *(integer)*: number of threads to run the interiorpoint optimizer on ↵

Number of threads to run the interiorpoint optimizer on. This value should be less than or equal to the actual number of processors or cores on a multi-core system.

Default:

`1`

**IPM_OFF_COL_TRH** *(integer)*: extent for detecting the offending columns in the Jacobian of the constraint matrix ↵

Controls the extent for detecting the offending columns in the Jacobian of the constraint matrix. 0 means no offending columns will be detected. 1 means offending columns will be detected. In general, increasing the parameter value beyond the default value of 40 does not improve the result.

Default:

`40`

**IPM_TOL_DFEAS** *(real)*: dual feasibility tolerance ↵

Dual feasibility tolerance used for linear and quadratic optimization problems.

Default:

`1e-8`

**IPM_TOL_DSAFE** *(real)*: controls the initial dual starting point ↵

Controls the initial dual starting point used by the interior-point optimizer. If the interior-point optimizer converges slowly and/or the dual variables associated with constraint or variable bounds are very large, then it might be worthwhile to increase this value.

Range: [

`1e-4`

, ∞]Default:

`1`

**IPM_TOL_INFEAS** *(real)*: infeasibility tolerance ↵

This is the tolerance to declare the model primal or dual infeasible using the interior-point optimizer. A smaller number means the optimizer gets more conservative about declaring the model infeasible.

Default:

`1e-10`

**IPM_TOL_MU_RED** *(real)*: relative complementarity gap tolerance ↵

Relative complementarity gap tolerance.

Default:

`1e-16`

**IPM_TOL_PATH** *(real)*: how close to follow the central path ↵

Controls how close the interior-point optimizer follows the central path. A large value of this parameter means the central path is followed very closely. For numerically unstable problems it might help to increase this parameter.

Range: [

`0`

,`0.5`

]Default:

`1e-8`

**IPM_TOL_PFEAS** *(real)*: primal feasibility tolerance ↵

Primal feasibility tolerance used for linear and quadratic optimization problems.

Default:

`1e-8`

**IPM_TOL_PSAFE** *(real)*: controls the initial primal starting point ↵

Controls the initial primal starting point used by the interior-point optimizer. If the interior-point optimizer converges slowly and/or the constraint or variable bounds are very large, then it might be worthwhile to increase this value.

Range: [

`1e-2`

, ∞]Default:

`1`

**IPM_TOL_REL_STEP** *(real)*: relative step size to the boundary ↵

Relative step size to the boundary for linear and quadratic optimization problems.

Range: [

`0`

,`0.999999`

]Default:

`0.9999`

**IUS** *(boolean)*: run the IUS finder if the problem is unbounded ↵

Default:

`0`

**IUS_ANALYZE_LEVEL** *(integer)*: controls the level of analysis when locating an IUS ↵

Default:

`2`

value meaning `+2`

Search for necessary columns `+8`

Search for sufficient columns

**LP_PRELEVEL** *(integer)*: controls the amount and type of LP pre-solving ↵

This controls the amount and type of LP pre-solving to be used.

Default:

`126`

value meaning `+2`

Simple pre-solving `+4`

Probing `+8`

Coefficient reduction `+16`

Elimination `+32`

Dual reductions `+64`

Use dual information `+512`

Maximum pass

**MIP_ABSCUTTOL** *(real)*: MIP absolute cut tolerance ↵

This is the MIP absolute cut tolerance. If the value is less than or equal to zero, it will use the internal decided tolerace, otherwise it will use this value as the abolute tolerace for adding cuts.

Range: [

`-1.0`

, ∞]Default:

`-1.0`

**MIP_ABSOPTTOL** *(real)*: MIP absolute optimality tolerance ↵

This is the MIP absolute optimality tolerance. Solutions must beat the incumbent by at least this absolute amount to become the new, best solution.

Default:

`GAMS OptCA`

**MIP_ADDCUTOBJTOL** *(real)*: required objective improvement to continue generating cuts ↵

This specifies the minimum required improvement in the objective function for the cut generation phase to continue generating cuts.

Default:

`1.5625e-5`

**MIP_ADDCUTPER** *(real)*: percentage of constraint cuts that can be added ↵

This determines how many constraint cuts can be added as a percentage of the number of original rows in an integer programming model.

Default:

`0.75`

**MIP_ADDCUTPER_TREE** *(real)*: percentage of constraint cuts that can be added at child nodes ↵

This determines how many constraint cuts can be added at child nodes as a percentage of the number of original rows in an integer programming model.

Default:

`0.5`

**MIP_AGGCUTLIM_TOP** *(integer)*: max number of constraints involved in derivation of aggregation cut at root node ↵

This specifies an upper limit on the number of constraints to be involved in the derivation of an aggregation cut at the root node. The default is .1, which means that the solver will decide.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**MIP_AGGCUTLIM_TREE** *(integer)*: max number of constraints involved in derivation of aggregation cut at tree nodes ↵

This specifies an upper limit on the number of constraints to be involved in the derivation of an aggregation cut at the tree nodes. The default is .1, which means that the solver will decide.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**MIP_ANODES_SWITCH_DF** *(integer)*: threshold on active nodes for switching to depth-first search ↵

This specifies the threshold on active nodes for switching to depth-first search rule.

Default:

`50000`

**MIP_AOPTTIMLIM** *(integer)*: time in seconds beyond which the relative optimality tolerance will be applied ↵

This is the time in seconds beyond which the relative optimality tolerance, MIP_PEROPTTOL will be applied.

Default:

`100`

**MIP_BIGM_FOR_INTTOL** *(real)*: threshold for which coefficient of a binary variable would be considered as big-M ↵

This value specifies the threshold for which the coefficient of a binary variable would be considered as big-M (when applicable).

Default:

`1e8`

**MIP_BRANCHDIR** *(integer)*: first branching direction ↵

This specifies the direction to branch first when branching on a variable.

Default:

`0`

value meaning `0`

Solver decides `1`

Always branch up first `2`

Always branch down first

**MIP_BRANCHRULE** *(integer)*: rule for choosing the variable to branch ↵

This specifies the rule for choosing the variable to branch on at the selected node.

Default:

`0`

value meaning `0`

Solver decides `1`

Basis rounding with pseudo reduced costs `2`

Maximum infeasibility `3`

Pseudo reduced costs only `4`

Maximum coefficient only `5`

Previous branching only

**MIP_BRANCH_LIMIT** *(integer)*: limit on the total number of branches to be created during branch and bound ↵

This is the limit on the total number of branches to be created during branch-and- bound. The default value is -1, which means no limit is imposed. If the branch limit is reached and a feasible integer solution was found, it will be installed as the incumbent (best known) solution.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**MIP_BRANCH_PRIO** *(integer)*: controls how variable selection priorities are set and used ↵

This controls how variable selection priorities are set and used.

Default:

`0`

value meaning `0`

If the user has specified priorities then use them Otherwise let LINDO API decide `1`

If user has specified priorities then use them Overwrite users choices if necessary `2`

If user has specified priorities then use them Otherwise do not use any priorities `3`

Let LINDO API set the priorities and ignore any user specified priorities `4`

Binaries always have higher priority over general integers

**MIP_CUTDEPTH** *(integer)*: threshold value for the depth of nodes in the branch and bound tree ↵

This controls a threshold value for the depth of nodes in the B&B tree, so cut generation will be less likely at those nodes deeper than this threshold.

Default:

`8`

**MIP_CUTFREQ** *(integer)*: frequency of invoking cut generation at child nodes ↵

This controls the frequency of invoking cut generation at child nodes. The default value is 10, indicating that the MIP solver will try to generate cuts at every 10 nodes.

Default:

`10`

**MIP_CUTLEVEL_TOP** *(integer)*: combination of cut types to try at the root node when solving a MIP ↵

This controls the combination of cut types to try at the root node when solving a MIP. Bit settings are used to enable the various cut types.

Default:

`57342`

value meaning `+2`

GUB cover `+4`

Flow cover `+8`

Lifting `+16`

Plant location `+32`

Disaggregation `+64`

Knapsack cover `+128`

Lattice `+256`

Gomory `+512`

Coefficient reduction `+1024`

GCD `+2048`

Obj integrality `+4096`

Basis Cuts `+8192`

Cardinality Cuts `+16384`

Disjunk Cuts `+32768`

Soft Knapsack Cuts

**MIP_CUTLEVEL_TREE** *(integer)*: combination of cut types to try at child nodes in the branch and bound tree when solving a MIP ↵

This controls the combination of cut types to try at child nodes in the B&B tree when solving a MIP.

Default:

`53246`

value meaning `+2`

GUB cover `+4`

Flow cover `+8`

Lifting `+16`

Plant location `+32`

Disaggregation `+64`

Knapsack cover `+128`

Lattice `+256`

Gomory `+512`

Coefficient reduction `+1024`

GCD `+2048`

Obj integrality `+4096`

Basis Cuts `+8192`

Cardinality Cuts `+16384`

Disjunk Cuts `+32768`

Soft Knapsack Cuts

**MIP_CUTOFFOBJ** *(real)*: defines limit for branch and bound ↵

If this is specified, then any part of the branch-and-bound tree that has a bound worse than this value will not be considered. This can be used to reduce the running time if a good bound is known.

Default:

`1e30`

**MIP_CUTTIMLIM** *(integer)*: time to be spent in cut generation ↵

This controls the total time to be spent in cut generation throughout the solution of a MIP. The default value is -1, indicating that no time limits will be imposed when generating cuts.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**MIP_DELTA** *(real)*: near-zero value used in linearizing nonlinear expressions ↵

This refers to a near-zero value used in linearizing nonlinear expressions.

Default:

`1e-6`

**MIP_DUAL_SOLUTION** *(integer)*: flag for computing dual solution of LP relaxation ↵

This flag controls whether the dual solution to the LP relaxation that yielded the optimal MIP solution will be computed or not.

Default:

`0`

value meaning `0`

Do not calculate dual solution for LP relaxation `1`

Calculate dual solution for LP relaxation

**MIP_FP_ITRLIM** *(integer)*: iteration limit for feasibility pump heuristic ↵

This is the iteration limit in seconds for feasibility pump heuristic. A value of -1 means no iteration limit is imposed.

Default:

`500`

**MIP_FP_MODE** *(integer)*: mode for the feasibility pump heuristic ↵

Controls the mode for the feasibility pump heuristic.

Default:

`-1`

value meaning `-1`

Solver decides `0`

Off `1`

On until the first solution `2`

Try to get more than one solution

**MIP_FP_OPT_METHOD** *(integer)*: optimization and reoptimization method for feasibility pump heuristic ↵

This specifies optimization and reoptimization method for feasibility pump heuristic.

Default:

`0`

value meaning `0`

Solver decides `1`

Primal simplex `2`

Dual simplex `3`

Barrier

**MIP_FP_TIMLIM** *(real)*: time limit for feasibility pump heuristic ↵

This is the time limit in seconds for feasibility pump heuristic. A value of -1 implies no time limit is imposed.

Default:

`1800`

**MIP_FP_WEIGTH** *(real)*: weight of the objective function in the feasibility pump ↵

Controls the weight of the objective function in the feasibility pump.

Range: [

`0`

,`1`

]Default:

`1`

**MIP_GENERAL_MODE** *(integer)*: general strategy in solving MIPs ↵

This value specifies the general strategy in solving MIPs.

Default:

`0`

value meaning `0`

Solver decides `+2`

Disable all time-driven events for reproducibility of runs `+16`

Disable cut generation before branching

**MIP_HEULEVEL** *(integer)*: specifies heuristic used to find integer solution ↵

This specifies the heuristic used to find the integer solution. Possible values are: 0: No heuristic is used. 1: A simple heuristic is used. Typically, this will find integer solutions only on problems with a certain structure. However, it tends to be fast. 2: This is an advanced heuristic that tries to find a "good" integer solution fast. In general, a value of 2 seems to not increase the total solution time and will find an integer solution fast on many problems. A higher value may find an integer solution faster, or an integer solution where none would have been found with a lower level. Try level 3 or 4 on "difficult" problems where 2 does not help. Higher values cause more time to be spent in the heuristic. The value may be set arbitrarily high. However, >20 is probably not worthwhile. MIP_HEUMINTIMLIM controls the time to be spent in searching heuristic solutions.

Default:

`3`

**MIP_HEUMINTIMLIM** *(integer)*: minimum time in seconds to be spent in finding heuristic solutions ↵

This specifies the minimum time in seconds to be spent in finding heuristic solutions to the MIP model. MIP_HEULEVEL controls the heuristic used to find the integer solution.

Default:

`0`

**MIP_HEU_DROP_OBJ** *(integer)*: flag for whether to use without OBJ heuristic ↵

This is a flag for whether to use without OBJ heuristic.

Default:

`0`

value meaning `0`

Off `1`

On

**MIP_HEU_MODE** *(integer)*: heuristic used in MIP solver ↵

This controls the MIP heuristic mode.

Default:

`0`

value meaning `0`

Solver decides when to stop the heuristic `1`

Solver uses a pre-specified time limit to stop the heuristic. `2`

Solver uses a pre-specified iteration limit to stop the heuristic

**MIP_INTTOL** *(real)*: absolute integer feasibility tolerance ↵

An integer variable is considered integer feasible if the absolute difference from the nearest integer is smaller than this.

Default:

`1e-6`

**MIP_ITRLIM** *(real)*: iteration limit for branch and bound ↵

This is the total LP iteration limit summed over all branches for branch-and-bound. Range for The default value is -1, which means no iteration limit is imposed. If this iteration limit is reached, branch-and-bound will stop and the best feasible integer solution found will be installed as the incumbent (best known) solution.

Range: [

`-1`

, ∞]Default:

`infinity`

**MIP_KBEST_USE_GOP** *(integer)*: specifies whether to use gop solver in MIP KBest ↵

Default:

`0`

value meaning `0`

No `1`

Yes

**MIP_KEEPINMEM** *(integer)*: flag for keeping LP bases in memory ↵

If this is set to 1, the integer pre-solver will try to keep LP bases in memory. This typically gives faster solution times, but uses more memory. Setting this parameter to 0 causes the pre-solver to erase bases from memory.

Default:

`1`

value meaning `0`

Do not keep LP bases in memory `1`

Keep LP bases in memory

**MIP_LBIGM** *(real)*: Big-M value used in linearizing nonlinear expressions ↵

This refers to the Big-M value used in linearizing nonlinear expressions.

Default:

`10000`

**MIP_LSOLTIMLIM** *(integer)*: time limit until finding a new integer solution ↵

Range: {

`-1`

, ..., ∞}Default:

`-1`

**MIP_MAKECUT_INACTIVE_COUNT** *(integer)*: threshold for times a cut could remain active after successive reoptimization ↵

This value specifies the threshold for the times a cut could remain active after successive reoptimization during branch-and-bound. If the count is larger than the specified level the solver will inactive the cut.

Default:

`10`

**MIP_MAXCUTPASS_TOP** *(integer)*: number passes to generate cuts on the root node ↵

This controls the number passes to generate cuts on the root node. Each of these passes will be followed by a reoptimization and a new batch of cuts will be generated at the new solution.

Default:

`200`

**MIP_MAXCUTPASS_TREE** *(integer)*: number passes to generate cuts on the child nodes ↵

This controls the number passes to generate cuts on the child nodes. Each of these passes will be followed by a reoptimization and a new batch of cuts will be generated at the new solution.

Default:

`2`

**MIP_MAXNONIMP_CUTPASS** *(integer)*: number of passes allowed in cut-generation that does not improve current relaxation ↵

This controls the maximum number of passes allowed in cut-generation that does not improve the current relaxation.

Default:

`3`

**MIP_MAXNUM_MIP_SOL_STORAGE** *(integer)*: maximum number of k-best solutions to store ↵

This specifies the maximum number of k-best solutions to store. Possible values are positive integers.

Default:

`1`

**MIP_MINABSOBJSTEP** *(real)*: value to update cutoff value each time a mixed integer solution is found ↵

This specifies the value to update the cutoff value each time a mixed integer solution is found.

Default:

`0`

**MIP_NODESELRULE** *(integer)*: specifies the node selection rule ↵

This specifies the node selection rule for choosing between all active nodes in the branch-and-bound tree when solving integer programs.Possible selections are: 0: Solver decides (default). 1: Depth first search. 2: Choose node with worst bound. 3: Choose node with best bound. 4: Start with best bound. If no improvement in the gap between best bound and best integer solution is obtained for some time, switch to: if (number of active nodes<10000) Best estimate node selection (5). else Worst bound node selection (2). 5: Choose the node with the best estimate, where the new objective estimate is obtained using pseudo costs. 6: Same as (4), but start with the best estimate.

Default:

`0`

value meaning `0`

Solver decides `1`

Depth first search `2`

Choose node with worst bound `3`

Choose node with best bound `4`

Start with best bound `5`

Choose the node with the best estimate `6`

Same as 4 but start with the best estimate

**MIP_NUM_THREADS** *(integer)*: number of parallel threads to use by the parallel MIP solver ↵

This parameter specifies the number of parallel threads to use by the parallel MIP solver. Possible values are positive integers. The default is 1 implying that the parallel solver is disabled.

Range: {

`1`

, ..., ∞}Default:

`1`

**MIP_PARA_FP** *(integer)*: flag for whether to use parallelization on the feasibility pump heuristic ↵

This is a flag for whether to use parallelization on the feasibility pump heuristic.

Default:

`1`

value meaning `0`

Off `1`

On

**MIP_PARA_FP_MODE** *(integer)*: flag for the mode of parallel feasibility pump ↵

This is a flag for the mode of parallel feasibility pump.

Default:

`0`

value meaning `0`

Terminate when all threads finish `1`

Terminate as soon as the master thread finishes

**MIP_PARA_INIT_NODE** *(real)*: number of initial nodes for MIP parallelization ↵

This value specifies the number of initial nodes for MIP parallelization.

Range: [

`-1`

, ∞]Default:

`-1`

**MIP_PARA_ITR_MODE** *(integer)*: flag for iteration mode in MIP parallelization ↵

This is a flag for iteration mode in MIP parallelization.

Default:

`1`

value meaning `0`

Each thread terminates as soon as arrives iteration limit `1`

Each thread terminates until all threads get iteration limit

**MIP_PARA_RND_ITRLMT** *(real)*: iteration limit of each round in MIP parallelization, it is a weighted combination of simplex and barrier iterations ↵

This value specifies the iteration limit of each round in MIP parallelization, it is a weighted combination of simplex and barrier iterations.

Default:

`2.0`

**MIP_PARA_SUB** *(integer)*: flag for whether to use MIP parallelization on subproblems solved in MIP preprocessing ↵

This is a flag for whether to use MIP parallelization on subproblems solved in MIP preprocessing.

Default:

`1`

value meaning `0`

Off `1`

On

**MIP_PEROPTTOL** *(real)*: MIP relative optimality tolerance in effect after MIP_AOPTTIMLIM seconds ↵

This is the MIP relative optimality tolerance that will be in effect after T seconds following the start. The value T should be specified using the MIP_AOPTTIMLIM parameter.

Default:

`1e-5`

**MIP_PERSPECTIVE_REFORM** *(integer)*: flag for whether to use Perspective Reformulation ↵

This is the flag for wether to use Persective Reformulation.

Default:

`1`

value meaning `0`

Off `1`

On

**MIP_POLISH_ALPHA_TARGET** *(real)*: proportion solutions in the pool to initiate a polishing-task at the current node ↵

This value specifies the proportion solutions in the pool to initiate a polishing-task at the current node.

Range: [

`0.01`

,`0.99`

]Default:

`0.6`

**MIP_POLISH_MAX_BRANCH_COUNT** *(integer)*: maximum number of branches to polish ↵

This value specifies the maximum number of branches to polish.

Default:

`2000`

**MIP_POLISH_NUM_BRANCH_NEXT** *(integer)*: number of branches to polish in the next round ↵

This value specifies the number of branches to polish in the next round.

Default:

`4000`

**MIP_PREHEU_DFE_VSTLIM** *(integer)*: limit for the variable visit in depth first enumeration ↵

Limit for the variable visit in depth first enumeration.

Default:

`200`

**MIP_PREHEU_LEVEL** *(integer)*: heuristic level for the prerelax solver ↵

The heuristic level for the prerelax solver.

Default:

`0`

value meaning `0`

Nothing `1`

One-change `2`

One-change and two-change `3`

Depth first enumeration

**MIP_PREHEU_TC_ITERLIM** *(integer)*: iteration limit for the two change heuristic ↵

Iteration limit for the two change heuristic.

Default:

`30000000`

**MIP_PREHEU_VAR_SEQ** *(integer)*: sequence of the variable considered by the prerelax heuristic ↵

The sequence of the variable considered by the prerelax heuristic.

Default:

`-1`

value meaning `-1`

Backward `1`

Forward

**MIP_PRELEVEL** *(integer)*: controls the amount and type of MIP pre-solving at root node ↵

This controls the amount and type of MIP pre-solving at root node.

Default:

`3070`

value meaning `+2`

Simple pre-solving `+4`

Probing `+8`

Coefficient reduction `+16`

Elimination `+32`

Dual reductions `+64`

Use dual information `+128`

Binary row presolving `+256`

Row aggregation `+512`

Coef Probe Lifting `+1024`

Maximum pass `+2048`

Similar row

**MIP_PRELEVEL_TREE** *(integer)*: amount and type of MIP pre-solving at tree nodes ↵

This controls the amount and type of MIP pre-solving at tree nodes.

Default:

`1214`

value meaning `+2`

Simple pre-solving `+4`

Probing `+8`

Coefficient reduction `+16`

Elimination `+32`

Dual reductions `+64`

Use dual information `+128`

Binary row presolving `+256`

Row aggregation `+512`

Coef Probe Lifting `+1024`

Maximum pass

**MIP_PRE_ELIM_FILL** *(integer)*: controls fill-in introduced by eliminations during pre-solve ↵

This is a nonnegative value that controls the fill-in introduced by the eliminations during pre-solve. Smaller values could help when the total nonzeros in the presolved model is significantly more than the original model.

Default:

`100`

**MIP_PSEUDOCOST_RULE** *(integer)*: specifies the rule in pseudocost computations for variable selection ↵

This specifies the rule in pseudocost computations for variable selection.

Default:

`0`

value meaning `0`

Solver decides `1`

Only use min pseudo cost `2`

Only use max pseudo cost `3`

Use quadratic score function and the pseudo cost weigth `4`

Same as 3 without quadratic score

**MIP_PSEUDOCOST_WEIGT** *(real)*: weight in pseudocost computations for variable selection ↵

This specifies the weight in pseudocost computations for variable selection.

Default:

`1.5625e-05`

**MIP_REDCOSTFIX_CUTOFF** *(real)*: cutoff value as a percentage of the reduced costs ↵

This specifies the cutoff value as a percentage of the reduced costs to be used in fixing variables when using the reduced cost fixing heuristic.

Default:

`0.9`

**MIP_REDCOSTFIX_CUTOFF_TREE** *(real)*: cutoff value as a percentage of the reduced costs at tree nodes ↵

This specifies the cutoff value as a percentage of the reduced costs to be used in fixing variables when using the reduced cost fixing heuristic at tree nodes.

Default:

`0.9`

**MIP_RELINTTOL** *(real)*: relative integer feasibility tolerance ↵

An integer variable is considered integer feasible if the difference between its value and the nearest integer value divided by the value of the nearest integer is less than this.

Default:

`8e-6`

**MIP_RELOPTTOL** *(real)*: MIP relative optimality tolerance ↵

This is the MIP relative optimality tolerance. Solutions must beat the incumbent by at least this relative amount to become the new, best solution.

Default:

`GAMS OptCR`

**MIP_REOPT** *(integer)*: optimization method to use when doing reoptimization ↵

This specifies which optimization method to use when doing reoptimization from a given basis.

Default:

`0`

value meaning `0`

Solver decides `1`

Use primal method `2`

Use dual simplex `3`

Use barrier solver

**MIP_SCALING_BOUND** *(integer)*: maximum difference between bounds of an integer variable for enabling scaling ↵

This controls the maximum difference between the upper and lower bounds of an integer variable that will enable the scaling in the simplex solver when solving a subproblem in the branch-and-bound tree.

Default:

`10000`

**MIP_SOLLIM** *(integer)*: integer solution limit for MIP solver ↵

Range: {

`-1`

, ..., ∞}Default:

`-1`

**MIP_SOLVERTYPE** *(integer)*: optimization method to use when solving mixed-integer models ↵

This specifies the optimization method to use when solving mixed-integer models.

Default:

`0`

value meaning `0`

Solver decides `1`

Use Branch and Bound only `2`

Use Enumeration and Knapsack solver only

**MIP_STRONGBRANCHDONUM** *(integer)*: minimum number of variables to try the strong branching on ↵

This value specifies the minimum number of variables, among all the candidates, to try the strong branching on.

Default:

`3`

**MIP_STRONGBRANCHLEVEL** *(integer)*: depth from the root in which strong branching is used ↵

This specifies the depth from the root in which strong branching is used. The default value of 10 means that strong branching is used on a level of 1 to 10 measured from the root. Strong branching finds the real bound for branching on a given variable, which, in most cases, requires a solution of a linear program and may therefore also be quite expensive in computing time. However, if used on nodes close to the root node of the tree, it also gives a much better bound for that part of the tree and can therefore reduce the size of the branch-and-bound tree.

Default:

`10`

**MIP_SWITCHFAC_SIM_IPM_TIME** *(real)*: factor that multiplies the number of constraints to impose a time limit to simplex method and trigger a switch over to the barrier method ↵

This specifies the (positive) factor that multiplies the number of constraints to impose a time limit to simplex method and trigger a switch over to the barrier method. A value of -1.0 means that no time limit is imposed.

Range: [

`-1`

, ∞]Default:

`-1`

**MIP_SYMMETRY_MODE** *(integer)*: specifies mip symmetry handling methods ↵

Default:

`0`

value meaning `0`

Do not use symmetries `1`

Adding symmetry breaking cuts `2`

Orbital fixing

**MIP_TIMLIM** *(integer)*: time limit in seconds for integer solver ↵

This is the time limit in seconds for branch-and-bound. The default value is -1, which means no time limit is imposed. However, the value of SOLVER_TIMLMT will be applied to each continuous subproblem solve. If the value of this parameter is greater than 0, then the value of SOLVER_TIMLMT will be disregarded. If this time limit is reached and a feasible integer solution was found, it will be installed as the incumbent (best known) solution.

Range: {

`-1`

, ..., ∞}Default:

`GAMS ResLim`

**MIP_TOPOPT** *(integer)*: optimization method to use when there is no previous basis ↵

This specifies which optimization method to use when there is no previous basis.

Default:

`0`

value meaning `0`

Solver decides `1`

Use primal method `2`

Use dual simplex `3`

Use barrier solver

**MIP_TREEREORDERLEVEL** *(integer)*: tree reordering level ↵

This specifies the tree reordering level.

Default:

`10`

**MIP_TREEREORDERMODE** *(integer)*: tree reordering mode ↵

This specifies the tree reordering mode.

Default:

`1`

value meaning `1`

Use tree reordering only for subproblems `2`

Use tree reordering for subproblems and the main bnb loop only when LP status is infeasible `3`

Not use tree reordering `4`

Use tree reordering based on MIP_TREEREORDERLEVEL

**MIP_USECUTOFFOBJ** *(integer)*: flag for using branch and bound limit ↵

This is a flag for the parameter MIP_CUTOFFOBJ. If you do not want to lose the value of the parameter MIP_CUTOFFOBJ, this provides an alternative to disabling the cutoff objective.

Default:

`1`

value meaning `0`

Do not use current cutoff value `1`

Use current cutoff value

**MIP_USE_CUTS_HEU** *(integer)*: controls if cut generation is enabled during MIP heuristics ↵

This flag controls if cut generation is enabled during MIP heuristics. The default is -1 (i.e. the solver decides).

Default:

`-1`

value meaning `-1`

Solver decides `0`

Do not use cut heuristic `1`

Use cut heuristic

**MIP_USE_ENUM_HEU** *(integer)*: frequency of enumeration heuristic ↵

This specifies the frequency of enumeration heuristic.

Default:

`4`

value meaning `0`

Off `1`

Only at top (root) node without cuts `2`

Both at top (root) and tree nodes without cuts `3`

Same as 1 with cuts `4`

Same as 2 with cuts

**MIP_USE_INT_ZERO_TOL** *(integer)*: controls if all MIP calculations would be based on absolute integer feasibility tolarance ↵

This flag controls if all MIP calculations would be based on the integrality tolarance specified by MIP_INTTOL.

Default:

`0`

value meaning `0`

Do not base MIP calculations on MIP_INTTOL `1`

Base MIP calculations on MIP_INTTOL

**MULTITHREAD_MODE** *(integer)*: threading mode ↵

This parameter controls the threading mode for solvers with multithreading support.

Default:

`-1`

value meaning `-1`

Solver decides `1`

Try parallel mode but if it is not available try concurrent mode `2`

Try parallel mode only `3`

Try concurrent mode but if it is not available try parallel mode `4`

Try concurrent mode only

**NLP_AUTODERIV** *(integer)*: defining type of computing derivatives ↵

This is a flag to indicate if automatic differentiation is the method of choice for computing derivatives and select the type of differentiation.

Default:

`0`

value meaning `0`

Finite Differences approach will be used `1`

Forward type of Automatic Differentiation will be used `2`

Backward type of Automatic Differentiation will be used

**NLP_AUTOHESS** *(integer)*: flag for using Second Order Automatic Differentiation for solving NLP ↵

This is a flag to indicate if Second Order Automatic Differentiation will be performed in solving a nonlinear model. The second order derivatives provide an exact/precise Hessian matrix to the SQP algorithm, which may lead to less iterations and better solutions, but may also be quite expensive in computing time for some cases.

Default:

`0`

value meaning `0`

Do not use Second Order Automatic Differentiation `1`

Use Second Order Automatic Differentiation

**NLP_CUTOFFOBJ** *(real)*: as soon as any multi-start thread achieves this value all threads stop ↵

If the current best objective of the NLP being solved in a multistart run is better than this value, the solver will terminate early without exhausting the maximum number of multistarts. This is a way of saving computer time if the current best solution is sufficiently attractive.

Range: [

`-1e30`

, ∞]Default:

`-1e30`

**NLP_DERIV_DIFFTYPE** *(integer)*: flag indicating the technique used in computing derivatives with finite differences ↵

This is a flag indicating the technique used in computing derivatives with Finite Differences.

Default:

`0`

value meaning `0`

The solver decides `1`

Use forward differencing method `2`

Use backward differencing method `3`

Use center differencing method

**NLP_FEASCHK** *(integer)*: how to report results when solution satisfies tolerance of scaled but not original model ↵

This input parameter specifies how the NLP solver reports the results when an optimal or local-optimal solution satisfies the feasibililty tolerance (NLP_FEASTOL) of the scaled model but not the original (descaled) one.

Default:

`1`

value meaning `0`

Perform no action accept the final solution `1`

Declare the model status as FEASIBLE if maximum violation in the unscaled model is not higher than 10 times NLP_FEASTOL `2`

Declare the model status as UNKNOWN if maximum violation in the unscaled model is higher than NLP_FEASTOL

**NLP_FEASTOL** *(real)*: feasibility tolerance for nonlinear constraints ↵

This is the feasibility tolerance for nonlinear constraints. A constraint is considered violated if the artificial, slack, or surplus variable associated with the constraint violates its lower or upper bounds by the feasibility tolerance.

Default:

`1e-6`

**NLP_INF** *(real)*: numeric infinity for nonlinear models ↵

Specifies the numeric infinity for nonlinear models. Possible values are positive real numbers. Smaller values could cause numerical problems.

nlp_ipm2grg This is a flag to switch from IPM solver to the standard NLP (GRG) solver when IPM fails due to numerical errors.

Default:

`1e30`

**NLP_IPM2GRG** *(integer)*: switch from IPM solver to GRG solver when IPM fails due to numerical errors ↵

Default:

`1`

value meaning `0`

Do not switch `1`

Switch

**NLP_ITERS_PER_LOGLINE** *(integer)*: number of nonlinear iterations to elapse before next progress message ↵

Number of nonlinear iterations to elapse before next progress message.

Range: {

`1`

, ..., ∞}Default:

`10`

**NLP_ITRLMT** *(integer)*: nonlinear iteration limit ↵

This controls the iteration limit on the number of nonlinear iterations performed.

Range: {

`-1`

, ..., ∞}Default:

`GAMS IterLim`

**NLP_LINEARZ** *(integer)*: extent to which the solver will attempt to linearize nonlinear models ↵

This determines the extent to which the solver will attempt to linearize nonlinear models.

Default:

`0`

value meaning `0`

Solver decides `1`

No linearization occurs `2`

Linearize ABS MAX and MIN functions `3`

Same as option 2 plus IF AND OR NOT and all logical operators are linearized

**NLP_LINEARZ_WB_CONSISTENT** *(integer)*: determines if linearization process is consistent with WB/excel calculation ↵

Default:

`0`

value meaning `0`

No `1`

Yes

**NLP_MAXLOCALSEARCH** *(integer)*: maximum number of local searches ↵

This controls the maximum number of local searches (multistarts) when solving a NLP using the multistart solver.

Default:

`5`

**NLP_MAXLOCALSEARCH_TREE** *(integer)*: maximum number of multistarts ↵

Maximum number of multistarts (at tree nodes)

Default:

`1`

**NLP_MAX_RETRY** *(integer)*: maximum number refinement retries to purify the final NLP solution ↵

Maximum number refinement retries to purify the final NLP solution.

Range: {

`-1`

, ..., ∞}Default:

`5`

**NLP_MSW_EUCDIST_THRES** *(real)*: euclidean distance threshold in multistart search ↵

Euclidean distance threshold in multistart search

Default:

`0.001`

**NLP_MSW_FILTMODE** *(integer)*: filtering mode to exclude certain domains during sampling in multistart search ↵

Filtering mode to exclude certain domains during sampling in multistart search.

Default:

`-1`

value meaning `-1`

Solver decides `+1`

Filter-out the points around known KKT or feasible points previously visited `+2`

Filter-out the points whose p are in the vicinity of p(x) `+4`

Filter-out the points in the vicinity of x where x are initial points of all previous local optimizations `+8`

Filter-out the points whose p(.) values are below a dynamic threshold tolerance

**NLP_MSW_MAXNOIMP** *(integer)*: maximum number of consecutive populations to generate without any improvements ↵

Maximum number of consecutive populations to generate without any improvements.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**NLP_MSW_MAXPOP** *(integer)*: maximum number of populations to generate in multistart search ↵

Maximum number of populations to generate in multistart search.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**NLP_MSW_MAXREF** *(integer)*: maximum number of reference points to generate trial points in multistart search ↵

Maximum number of reference points in the solution space to generate trial points in multistart search.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**NLP_MSW_NORM** *(integer)*: norm to measure the distance between two points in multistart search ↵

Norm to measure the distance between two points in multistart search.

Range: {

`-1`

, ..., ∞}Default:

`2`

**NLP_MSW_NUM_THREADS** *(integer)*: number of parallel threads to be used when solving an NLP model with the multistart solver ↵

This value specifies the number of parallel threads to be used when solving an NLP model with the multistart solver.

Default:

`1`

**NLP_MSW_OVERLAP_RATIO** *(real)*: rate of replacement in successive populations ↵

This value specifies the rate of replacement in successive populations. Higher values favors survival of points in the parent population.

Range: [

`0.0`

,`1.0`

]Default:

`0.1`

**NLP_MSW_POXDIST_THRES** *(real)*: penalty function neighborhood threshold in multistart search ↵

Penalty function neighborhood threshold in multistart search

Default:

`0.01`

**NLP_MSW_PREPMODE** *(integer)*: preprocessing strategies in multistart solver ↵

This value specifies the preprocessing strategies in multistart solver.

Default:

`-1`

value meaning `-1`

Solver decides `+1`

Truncate free variables `+2`

Scale reference points to origin `+4`

Enable expansive scaling of radius[k] by hit[k] `+8`

Skewed sampling allowing values in the vicinity of origin. `+16`

Get best bounds by presolver `+32`

Get best bounds using GOP `+64`

Enable sampling of free variables (not recommended) `+128`

Collect sufficiently many trial points prior to local solves `+256`

Enable power solver, trying several different local strategies

**NLP_MSW_RG_SEED** *(integer)*: random number generator seed for the multistart solver ↵

This value specified the random number generator seed for the multistart solver.

Default:

`1019`

**NLP_MSW_SOLIDX** *(integer)*: index of the multistart solution to be loaded ↵

Index of the multistart solution to be loaded main solution structures.

Default:

`0`

**NLP_MSW_XKKTRAD_FACTOR** *(real)*: KKT solution neighborhood factor in multistart search ↵

KKT solution neighborhood factor in multistart search

Default:

`0.85`

**NLP_MSW_XNULRAD_FACTOR** *(real)*: initial solution neighborhood factor in multistart search ↵

Initial solution neighborhood factor in multistart search

Default:

`0.5`

**NLP_PRELEVEL** *(integer)*: controls the amount and type of NLP pre-solving ↵

This controls the amount and type of NLP pre-solving.

Default:

`126`

value meaning `+2`

Simple pre-solving `+4`

Probing `+8`

Coefficient reduction `+16`

Elimination `+32`

Dual reductions `+64`

Use dual information `+512`

Maximum pass

**NLP_PSTEP_FINITEDIFF** *(real)*: value of the step length in computing the derivatives using finite differences ↵

This controls the value of the step length in computing the derivatives using finite differences.

Default:

`5e-7`

**NLP_QUADCHK** *(integer)*: flag for checking if NLP is quadratic ↵

This is a flag indicating if the nonlinear model should be examined to check if it is a quadratic model.

Default:

`1`

value meaning `0`

Do not check if NLP is quadratic `1`

Check if NLP is quadratic

**NLP_REDGTOL** *(real)*: tolerance for the gradients of nonlinear functions ↵

This is the tolerance for the gradients of nonlinear functions. The (projected) gradient of a function is considered to be the zero-vector if its norm is below this tolerance.

Default:

`1e-7`

**NLP_SOLVER** *(integer)*: type of nonlinear solver ↵

This value determines the type of nonlinear solver.

Default:

`7`

value meaning `4`

Solver decides `5`

Uses Levenberg-Marquardt method to solve nonlinear least-squares problem `6`

Uses Barrier solver for convex QCP models `7`

Uses CONOPTs reduced gradient solver `8`

Uses SLP solver `9`

Uses CONOPT with multistart feature enabled

**NLP_SOLVE_AS_LP** *(integer)*: flag indicating if the nonlinear model will be solved as an LP ↵

This is a flag indicating if the nonlinear model will be solved as an LP. 1 means that an LP using first order approximations of the nonlinear terms in the model will be used when optimizing the model with the LSoptimize() function.

Default:

`0`

value meaning `0`

NLP will not be solved as LP `1`

NLP will be solved as LP

**NLP_STALL_ITRLMT** *(integer)*: iteration limit before a sequence of non-improving NLP iterations is declared as stalling ↵

This specifies the iteration limit before a sequence of non-improving NLP iterations is declared as stalling, thus causing the solver to terminate.

Default:

`100`

**NLP_STARTPOINT** *(integer)*: flag for using initial starting solution for NLP ↵

This is a flag indicating if the nonlinear solver should accept initial starting solutions.

Default:

`1`

value meaning `0`

Do not use initial starting solution for NLP `1`

Use initial starting solution for NLP

**NLP_SUBSOLVER** *(integer)*: type of nonlinear subsolver ↵

This controls the type of linear solver to be used for solving linear subproblems when solving nonlinear models.

Default:

`1`

value meaning `1`

Primal simplex method `2`

Dual simplex method `3`

Barrier solver with or without crossover

**NLP_USECUTOFFOBJ** *(integer)*: flag to use parameter NLP_CUTOFFOBJ ↵

This is a flag for the parameter NLP_CUTOFFOBJ. The value of 0 means NLP_CUTOFFOBJ will be ignored, else it will be used as specified.

Default:

`0`

value meaning `-1`

Solver decides `0`

No `1`

Yes

**NLP_USE_CRASH** *(integer)*: flag for using simple crash routines for initial solution ↵

This is a flag indicating if an initial solution will be computed using simple crash routines.

Default:

`0`

value meaning `0`

Do not use simple crash routines `1`

Use simple crash routines

**NLP_USE_LINDO_CRASH** *(integer)*: flag for using advanced crash routines for initial solution ↵

This is a flag indicating if an initial solution will be computed using advanced crash routines.

Default:

`1`

value meaning `0`

Do not use advanced crash routines `1`

Use advanced crash routines

**NLP_USE_SDP** *(integer)*: flag to use SDP solver for POSD constraint ↵

Default:

`1`

value meaning `0`

No `1`

Yes

**NLP_USE_SELCONEVAL** *(integer)*: flag for using selective constraint evaluations for solving NLP ↵

This is a flag indicating if selective constraint evaluations will be performed in solving a nonlinear model.

Default:

`1`

value meaning `0`

Do not use selective constraint evaluations `1`

Use selective constraint evaluations

**NLP_USE_SLP** *(integer)*: flag for using sequential linear programming step directions for updating solution ↵

This is a flag indicating if sequential linear programming step directions should be used in updating the solution.

Default:

`1`

value meaning `-1`

Solver decides `0`

Do not use sequential linear programming step directions `1`

Use sequential linear programming step directions

**NLP_USE_STEEPEDGE** *(integer)*: flag for using steepest edge directions for updating solution ↵

This is a flag indicating if steepest edge directions should be used in updating the solution.

Default:

`0`

value meaning `0`

Do not use steepest edge directions `1`

Use steepest edge directions

**NUM_THREADS** *(integer)*: number of parallel threads to be used ↵

Synonym: gthreads

Number of threads to use in the solver routine to be called. It is a solver-independent parameter which internally sets solver-specific threading parameters automatically.

Range: {

`1`

, ..., ∞}Default:

`GAMS Threads`

**PROB_TO_SOLVE** *(integer)*: controls whether the explicit primal or dual form of the given LP problem will be solved ↵

This flag controls whether the explicit primal or dual form of the given LP problem will be solved.

Default:

`0`

value meaning `0`

Solver decides `1`

Explicit primal form `2`

Explicit dual form

**PROFILER_LEVEL** *(integer)*: specifies the profiler level to break down the total cpu time into. ↵

Specifies the profiler level to break down the total cpu time into.

Default:

`0`

value meaning `0`

Profiler is off `+1`

Enable for simplex solver `+2`

Enable for integer solver `+4`

Enable for multistart solver `+8`

Enable for global solver

**READPARAMS** *(string)*: read Lindo parameter file ↵

**REPORTEVSOL** *(no value)*: solve and report the expected value solution ↵

Default:

`0`

**SAMP_CDSINC** *(real)*: correlation matrix diagonal shift increment ↵

Correlation matrix diagonal shift increment.

Default:

`1e-6`

**SAMP_NCM_CUTOBJ** *(real)*: objective cutoff (target) value to stop the nearest correlation matrix (NCM) subproblem ↵

Objective cutoff (target) value to stop the nearest correlation matrix (NCM) subproblem.

Default:

`1e-30`

**SAMP_NCM_DSTORAGE** *(integer)*: flag to enable or disable sparse mode in NCM computations ↵

Flag to enable/disable sparse mode in NCM computations.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**SAMP_NCM_ITERLIM** *(integer)*: iteration limit for NCM method ↵

Iteration limit for NCM method.

Default:

`100`

**SAMP_NCM_METHOD** *(integer)*: bitmask to enable methods for solving the nearest correlation matrix (NCM) subproblem ↵

Bitmask to enable methods for solving the nearest correlation matrix (NCM) subproblem.

Default:

`5`

**SAMP_NCM_OPTTOL** *(real)*: optimality tolerance for NCM method ↵

Optimality tolerance for NCM method.

Default:

`1e-7`

**SAMP_SCALE** *(integer)*: flag to enable scaling of raw sample data ↵

Flag to enable scaling of raw sample data.

Default:

`0`

**SOLVER_CONCURRENT_OPTMODE** *(integer)*: controls if simplex and interior-point optimizers will run concurrently ↵

Controls if simplex and interior-point optimizers will run concurrently, 0 means no concurrent runs will be performed, 1 means both optimizers will run concurrently if at least two threads exist in system, 2 means both optimizers will run concurrently.

Default:

`0`

value meaning `0`

no concurrent runs `1`

run concurrently if at least 2 threads exist `2`

run concurrently

**SOLVER_CUTOFFVAL** *(real)*: solver will exit if optimal solution is worse than this ↵

If the optimal objective value of the LP being solved is shown to be worse than this (e.g., if the dual simplex method is being used), then the solver will exit without finding a feasible solution. This is a way of saving computer time if there is no sufficiently attractive solution. SOLVER_USECUTOFFVAL needs to be set to 1 to activate this value.

Default:

`0`

**SOLVER_FEASTOL** *(real)*: feasibility tolerance ↵

This is the feasibility tolerance. A constraint is considered violated if the artificial, slack, or surplus variable associated with the constraint violates its lower or upper bounds by the feasibility tolerance.

Default:

`1e-7`

**SOLVER_IPMSOL** *(integer)*: basis crossover flag for barrier solver ↵

This flag controls whether a basis crossover will be performed when solving LPs with the barrier solver. A value of 0 indicates that a crossover to a basic solution will be performed. If the value is 1, then the barrier solution will be left intact. For example, if alternate optima exist, the barrier method will return a solution that is, loosely speaking, the average of all alternate optima.

Default:

`0`

value meaning `0`

Perform crossover to basis solution `1`

Leave barrier solution intact

**SOLVER_IUSOL** *(integer)*: flag for computing basic solution for infeasible model ↵

This is a flag that, when set to 1, will force the solver to compute a basic solution to an infeasible model that minimizes the sum of infeasibilities and a basic feasible solution to an unbounded problem from which an extreme direction originates. When set to the default of 0, the solver will return with an appopriate status flag as soon as infeasibility or unboundedness is detected. If infeasibility or unboundedness is declared with presolver's determination, no solution will be computed.

Default:

`0`

value meaning `0`

Return appropriate status if infeasibility is encountered `1`

Force the solver to compute a basic solution to an infeasible model

**SOLVER_OPTTOL** *(real)*: dual feasibility tolerance ↵

This is the optimality tolerance. It is also referred to as the dual feasibility tolerance. A dual slack (reduced cost) is considered violated if it violates its lower bound by the optimality tolerance.

Default:

`1e-7`

**SOLVER_PRE_ELIM_FILL** *(integer)*: fill-in introduced by the eliminations during pre-solve ↵

This is a nonnegative value that controls the fill-in introduced by the eliminations during pre-solve. Smaller values could help when the total nonzeros in the presolved model is significantly more than the original model.

Default:

`1000`

**SOLVER_RESTART** *(integer)*: starting basis flag ↵

This is the starting basis flag. 1 means LINDO API will perform warm starts using any basis currently in memory. 0 means LINDO API will perform cold starts discarding any basis in memory and starting from scratch.

Default:

`0`

value meaning `0`

Perform cold start `1`

Perform warm start

**SOLVER_TIMLMT** *(integer)*: time limit in seconds for continous solver ↵

This is a time limit in seconds for the LP solver. The default value of -1 imposes no time limit.

Range: {

`-1`

, ..., ∞}Default:

`GAMS ResLim`

**SOLVER_USECUTOFFVAL** *(integer)*: flag for using cutoff value ↵

This is a flag for the parameter SOLVER_CUTOFFVAL

Default:

`0`

value meaning `0`

Do not use cutoff value `1`

Use cutoff value

**SPLEX_DPRICING** *(integer)*: pricing option for dual simplex method ↵

This is the pricing option to be used by the dual simplex method.

Default:

`-1`

value meaning `-1`

Solver decides the dual pricing method `0`

Partial pricing `1`

Steepest edge

**SPLEX_DUAL_PHASE** *(integer)*: controls the dual simplex strategy ↵

This controls the dual simplex strategy, single-phase versus two-phase.

Default:

`0`

value meaning `0`

Solver decides `1`

Single-phase `2`

Two-phase

**SPLEX_ITRLMT** *(integer)*: simplex iteration limit ↵

This is a limit on the number of iterations the solver will perform before terminating. If this value is a nonnegative integer, then it will be used as an upper bound on the number of iterations the solver will perform. If this value is -1, then no iteration limit will be used. The solution may be infeasible.

Range: {

`-1`

, ..., ∞}Default:

`infinity`

**SPLEX_PPRICING** *(integer)*: pricing option for primal simplex method ↵

This is the pricing option to be used by the primal simplex method.

Default:

`-1`

value meaning `-1`

Solver decides the primal pricing method `0`

Partial pricing `1`

Devex

**SPLEX_REFACFRQ** *(integer)*: number of simplex iterations between two consecutive basis re-factorizations ↵

This is a positive integer scalar referring to the simplex iterations between two consecutive basis re-factorizations. For numerically unstable models, setting this parameter to smaller values may help.

Default:

`100`

**SPLEX_SCALE** *(integer)*: scaling flag ↵

This is the scaling flag. Scaling multiplies the rows and columns of the model by appropriate factors in an attempt to avoid numerical difficulties by reducing the range of coefficient values.

Default:

`1`

value meaning `0`

Scaling is suppressed `1`

Scaling is performed

**STOC_ABSOPTTOL** *(real)*: absolute optimality tolerance (w.r.t lower and upper bounds on the true objective) to stop the solver ↵

Absolute optimality tolerance (w.r.t lower and upper bounds on the true objective) to stop the solver. . Possible values are reals in (0,1) interval.

Default:

`GAMS OptCA`

**STOC_ADD_MPI** *(integer)*: flag to use add-instructions mode when building deteq ↵

Flag to use add-instructions mode when building deteq.

Default:

`0`

**STOC_ALD_DUAL_FEASTOL** *(real)*: dual feasibility tolerance for ALD ↵

Dual feasibility tolerance for ALD.

Default:

`1e-4`

**STOC_ALD_DUAL_STEPLEN** *(real)*: dual step length for ALD ↵

Dual step length for ALD.

Default:

`0.9`

**STOC_ALD_INNER_ITER_LIM** *(integer)*: inner loop iteration limit for ALD ↵

Inner loop iteration limit for ALD.

Default:

`1000`

**STOC_ALD_OUTER_ITER_LIM** *(integer)*: outer loop iteration limit for ALD ↵

Outer loop iteration limit for ALD.

Default:

`200`

**STOC_ALD_PRIMAL_FEASTOL** *(real)*: primal feasibility tolerance for ALD ↵

Primal feasibility tolerance for ALD.

Default:

`1e-4`

**STOC_ALD_PRIMAL_STEPLEN** *(real)*: primal step length for ALD ↵

Primal step length for ALD.

Default:

`0.5`

**STOC_AUTOAGGR** *(integer)*: flag to enable or disable autoaggregation ↵

Flag to enable or disable autoaggregation.

Default:

`1`

**STOC_BENCHMARK_SCEN** *(integer)*: benchmark scenario to compare EVPI and EVMU against ↵

Benchmark scenario to compare EVPI and EVMU against.

Range: {

`-2`

, ..., ∞}Default:

`-2`

**STOC_BIGM** *(real)*: big-M value for linearization and penalty functions ↵

Big-M value for linearization and penalty functions.

Default:

`1e7`

**STOC_BUCKET_SIZE** *(integer)*: bucket size in Benders decomposition ↵

Bucket size in Benders decomposition. Possible values are positive integers or (-1) for solver decides.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**STOC_CALC_EVPI** *(integer)*: flag to enable or disable calculation of EVPI ↵

Flag to enable/disable calculation of lower bounds on EVPI.

Default:

`1`

value meaning `0`

disable `1`

enable

**STOC_CORRELATION_TYPE** *(integer)*: correlation type associated with correlation matrix ↵

Correlation type associated with the correlation matrix.

Default:

`0`

value meaning `-1`

Target correlation `0`

Pearson correlation `1`

Kendall correlation `2`

Spearman correlation

**STOC_DEQOPT** *(integer)*: method to solve the DETEQ problem ↵

This specifies the method to use when solving the deterministic equivalent.

Default:

`0`

value meaning `0`

Solver decides `10`

Use simple Benders Decomposition

**STOC_DETEQ_TYPE** *(integer)*: type of deterministic equivalent ↵

Type of deterministic equivalent to be used by the solver. Implicit determinisitc equivalent is valid for linear and integer models only.

Default:

`-1`

value meaning `-1`

Solver decides `0`

Implicit determinisitc equivalent `1`

Explicit determinisitc equivalent

**STOC_DS_SUBFORM** *(integer)*: subproblem formulation to use in DirectSearch ↵

This parameter specifies the type of subproblem formulation to be used in heuristic search.

Default:

`-1`

value meaning `-1`

Solver decides `0`

Perform heuristic search in the original solution space `1`

Perform heuristic search in the space of discrete variables coupled with optimizations in the linear space

**STOC_ELIM_FXVAR** *(integer)*: flag to enable elimination of fixed variables from deteq MPI ↵

Flag to enable elimination of fixed variables from deteq MPI.

Default:

`1`

**STOC_INFBND** *(real)*: value to truncate infinite bounds at non-leaf nodes ↵

Value to truncate infinite bounds at nonleaf nodes.

Default:

`1e9`

**STOC_ITER_LIM** *(integer)*: iteration limit for stochastic solver ↵

Iteration limit for stochastic solver. Possible values are positive integers or (-1) no limit.

Range: {

`-1`

, ..., ∞}Default:

`infinity`

**STOC_MAP_MPI2LP** *(integer)*: flag to specify whether stochastic parameters in MPI will be mapped as LP matrix elements ↵

Flag to specify whether stochastic parameters in MPI will be mapped as LP matrix elements.

Default:

`0`

**STOC_MAX_NUMSCENS** *(integer)*: maximum number of scenarios before forcing automatic sampling ↵

Maximum number of scenarios before forcing automatic sampling. Possible values are positive integers.

Default:

`40000`

**STOC_METHOD** *(integer)*: stochastic optimization method to solve the model ↵

Stochastic optimization method to solve the model.

Default:

`-1`

value meaning `-1`

Solve with the method chosen by the solver `0`

Solve the deterministic equivalent (DETEQ) `1`

Solve with the Nested Benders Decomposition (NBD) method

**STOC_NAMEDATA_LEVEL** *(integer)*: name data level ↵

Name data level.

Default:

`1`

**STOC_NODELP_PRELEVEL** *(integer)*: presolve level solving node-models ↵

Presolve level solving node-models.

Default:

`0`

value meaning `+2`

Simple pre-solving `+4`

Probing `+8`

Coefficient reduction `+16`

Elimination `+32`

Dual reductions `+64`

Use dual information `+512`

Maximum pass

**STOC_NSAMPLE_PER_STAGE** *(string)*: list of sample sizes per stage (starting at stage 2) ↵

Comma separated list of sample sizes per stage. The sample size of stage 1 is assumed to be 1 so that this list starts with stage stage 2.

**STOC_NSAMPLE_SPAR** *(integer)*: common sample size per stochastic parameter ↵

Common sample size per stochastic parameter. Possible values are positive integers.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**STOC_NSAMPLE_STAGE** *(integer)*: common sample size per stage ↵

Common sample size per stage.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**STOC_NUM_THREADS** *(integer)*: number of parallel threads ↵

This value specifies the number of parallel threads to be used when solving a stochastic programming model.

Default:

`1`

**STOC_RELOPTTOL** *(real)*: relative optimality tolerance (w.r.t lower and upper bounds on the true objective) to stop the solver ↵

Relative optimality tolerance (w.r.t lower and upper bounds on the true objective) to stop the solver. Possible values are reals in (0,1) interval.

Default:

`GAMS OptCR`

**STOC_REL_DSTEPTOL** *(real)*: dual-step tolerance ↵

This value specifies the dual-step tolerance in decomposition based algorithms.

Default:

`1e-7`

**STOC_REL_PSTEPTOL** *(real)*: primal-step tolerance ↵

This value specifies the primal-step tolerance in decomposition based algorithms.

Default:

`1e-8`

**STOC_REOPT** *(integer)*: reoptimization method to solve the node-models ↵

Reoptimization method to solve the node-models.

Default:

`0`

value meaning `0`

Solver decides `1`

Use primal method `2`

Use dual simplex `3`

Use barrier solver `4`

Use NLP solver

**STOC_RG_SEED** *(integer)*: seed to initialize the random number generator ↵

Seed to initialize the random number generator. Possible values are positive integers.

Default:

`1031`

**STOC_SAMP_CONT_ONLY** *(integer)*: flag to restrict sampling to continuous stochastic parameters only or not ↵

Flag to restrict sampling to continuous stochastic parameters only or not.

Default:

`1`

value meaning `0`

disable `1`

enable

**STOC_SBD_MAXCUTS** *(integer)*: max cuts to generate for master problem ↵

Max cuts to generate for master problem.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**STOC_SBD_NUMCANDID** *(integer)*: maximum number of candidate solutions to generate at SBD root ↵

Maximum number of candidate solutions to generate at SBD root.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**STOC_SBD_OBJCUTFLAG** *(integer)*: flag to enable objective cut in SBD master problem ↵

Flag to enable objective cut in SBD master problem.

Default:

`1`

**STOC_SBD_OBJCUTVAL** *(real)*: RHS value of objective cut in SBD master problem ↵

RHS value of objective cut in SBD master problem.

Default:

`1e-30`

**STOC_SHARE_BEGSTAGE** *(integer)*: stage beyond which node-models are shared ↵

Stage beyond which node-models share the same model structure. Possible values are positive integers less than or equal to number of stages in the model or (-1) for solver decides.

Range: {

`-1`

, ..., ∞}Default:

`-1`

**STOC_TIME_LIM** *(real)*: time limit for stochastic solver ↵

Time limit for stochastic solver. Possible values are nonnegative real numbers or -1 for solver decides.

Range: [

`-1`

, ∞]Default:

`GAMS ResLim`

**STOC_TOPOPT** *(integer)*: optimization method to solve the root problem ↵

Optimization method to solve the root problem.

Default:

`0`

value meaning `0`

Solver decides `1`

Use primal method `2`

Use dual simplex `3`

Use barrier solver `4`

Use NLP solver `6`

Use multi-start solver `7`

Use global solver

**STOC_VARCONTROL_METHOD** *(integer)*: sampling method for variance reduction ↵

Sampling method for variance reduction.

Default:

`1`

value meaning `0`

Montecarlo sampling `1`

Latinsquare sampling `2`

Antithetic sampling

**STOC_WSBAS** *(integer)*: warm start basis for wait-see model ↵

Warm start basis for wait-see model .

Range: {

`-1`

, ..., ∞}Default:

`-1`

**SVR_LS_ANTITHETIC** *(string)*: Sample variance reduction map to Lindo Antithetic algorithm ↵

**SVR_LS_LATINSQUARE** *(string)*: Sample variance reduction map to Lindo Latin Square algorithm ↵

**SVR_LS_MONTECARLO** *(string)*: Sample variance reduction map to Lindo Montecarlo algorithm ↵

**USEGOP** *(integer)*: use global optimization ↵

This value determines whether the global optimization will be used.

Default:

`1`

value meaning `0`

Do not use global optimization `1`

Use global optimization

**WRITEDEMPI** *(string)*: write deterministic equivalent in MPI format ↵

**WRITEDEMPS** *(string)*: write deterministic equivalent in MPS format ↵

**WRITEMPI** *(string)*: write (S)MPI file of processed model ↵

If this option is set, Lindo write an MPI file of processed model. If set, the value of this option defines the name of the MPI file.

**WRITEMPS** *(string)*: write (S)MPS file of processed model ↵

# Stochastic Programming (SP) in GAMS/Lindo

GAMS/Lindo can also solve stochastic programming models. The syntax to set up an SP problem in GAMS is explained in the chapter Stochastic Programming (SP) with EMP. The options to control LINDOs stochastic solver are described in the subsection SP Options.