[ Home | Downloads | Documentation | Solvers | APIs | Tools | Model Libraries | Resources | Sales | Support | Contact Us | Search ]

LINDO and LINDOGlobal

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, users need a GAMS/LINDOGlobal license. Additionally a GAMS/CONOPT license is required for solving nonlinear subproblems. The GAMS/LINDOGlobal license places upper limits on model size of 3,000 variables and 2,000 constraints.

To use GAMS/LINDO, no additional license is required. Also, there is no upper limit on the model size with GAMS/LINDO and, in addition, it allows to solve stochastic models (see section Stochastic Programming (SP) in GAMS/Lindo ).

Neither the GAMS/LINDO not the GAMS/LINDOGlobal license does include the Barrier solver option. LINDO would be able to use the barrier solver when the user has 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.

# 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`
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_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 wether to use Persective 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_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_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_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_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_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_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_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_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

Option Description Default
CHECKRANGE calculate feasible range for variables `range.gdx`
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`

valuemeaning
`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`

valuemeaning
`0` Use an edge-weight minimizing graph partitioning heuristic
`1` Use a vertex-weight minimizing graph partitioning heuristic

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`

valuemeaning
`+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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`+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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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_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`

valuemeaning
`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`

valuemeaning
`+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`

valuemeaning
`+2` Initial local optimization
`+4` Initial linear constraint propagation
`+8` Recursive linear constraint propagation
`+16` Recursive nonlinear constraint propagation

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`

valuemeaning
`+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`

valuemeaning
`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`

valuemeaning
`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`

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`

valuemeaning
`-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`

valuemeaning
`-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`

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`

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`

valuemeaning
`+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`

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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`+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`

valuemeaning
`+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`

valuemeaning
`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`

valuemeaning
`-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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`0` Off
`1` On

MIP_HEU_MODE (integer): heuristic used in MIP solver

This controls the MIP heuristic mode.

Default: `0`

valuemeaning
`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_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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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 wether to use Persective Reformulation

This is the flag for wether to use Persective Reformulation.

Default: `1`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`-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`

valuemeaning
`+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`

valuemeaning
`+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`

valuemeaning
`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`

valuemeaning
`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_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`

valuemeaning
`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_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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`-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`

valuemeaning
`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`

valuemeaning
`0` Do not base MIP calculations on MIP_INTTOL
`1` Base MIP calculations on MIP_INTTOL

Default: `-1`

valuemeaning
`-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`

valuemeaning
`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`

valuemeaning
`0` Do not use Second Order Automatic Differentiation
`1` Use Second Order Automatic Differentiation

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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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_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`

valuemeaning
`-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`

valuemeaning
`-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`

valuemeaning
`+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`

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

Default: `1`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`1` Primal simplex method
`2` Dual simplex method
`3` Barrier solver with or without crossover

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`

valuemeaning
`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`

valuemeaning
`0` Do not use advanced crash routines
`1` Use advanced crash routines

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`

valuemeaning
`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`

valuemeaning
`-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`

valuemeaning
`0` Do not use steepest edge directions
`1` Use steepest edge directions

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`

valuemeaning
`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`

valuemeaning
`0` Profiler is off
`+1` Enable for simplex solver
`+2` Enable for integer solver
`+4` Enable for multistart solver
`+8` Enable for global solver

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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`-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`

valuemeaning
`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`

valuemeaning
`-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`

valuemeaning
`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`

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`

valuemeaning
`0` disable
`1` enable

STOC_CORRELATION_TYPE (integer): correlation type associated with correlation matrix

Correlation type associated with the correlation matrix.

Default: `0`

valuemeaning
`-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`

valuemeaning
`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`

valuemeaning
`-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`

valuemeaning
`-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`

valuemeaning
`-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`

valuemeaning
`+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`

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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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`

valuemeaning
`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.