Lindo Systems, Inc.

Introduction

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

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

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

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

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

Licensing and software requirements

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

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

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

Running GAMS/LINDO

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

option xxx=lindo;
option xxx=lindoglobal;

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

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

   $TITLE simple mpec example
   variable f, x1, x2, y1, y2; positive
   variable y1; y2.lo = -1; y2.up = 1;

   equations cost, g, h1, h2;

   cost..  f =E= x1 + x2;
      g..  sqr(x1) + sqr(x2) =L= 1;
     h1..  x1 =G= y1 - y2 + 1;
     h2..  x2 + y2 =N= 0;

   * declare h and y complementary
   model example / cost, g, h1.y1, h2.y2 /;

   option mpec=nlpec;
   option dnlp=lindo;
   solve example using mpec min f;

Supported nonlinear functions

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

Diagnosis of Infeasible or Unbounded Models

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

Infeasible Models

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

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

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

Unbounded Linear Programs

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

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

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

GAMS/LINDO output

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

LINDO                 24Nov11 23.8.0 WIN 30200.30202 VS8 x86/MS Windows

   LINDO Driver
   Lindo Systems Inc, www.lindo.com

Lindo API version 7.0.1.372 built on Nov  3 2011 21:49:01
Barrier Solver Version 6.0.0.114, Nonlinear Solver Version 3.15B
Platform Windows x86

Number of constraints:       3    le:       0, ge:       0, eq:       3, rn:
   0 (ne:0)
Number of variables  :       5    lb:       0, ub:       0, fr:       5, bx:
   0 (fx:0)
Number of nonzeroes  :       8    density=0.0053(%)

Nonlinear variables  :       5
Nonlinear constraints:       4
Nonlinear nonzeroes  :       5+5

Starting global optimization ...

Number of nonlinear functions/operators:  3
 EP_MULTIPLY  EP_POWER  EP_SQR

Starting GOP presolve ...
First Call Local Solver
Find local solution, objvalue =    27.871905

Pre-check unboundedness
Computing reduced bound...
Searching for a better solution...

Starting reformulation ...

Model                    Input     Operation    Atomic       Convex

Number of variables  :       5             6        20           20
Number of constraints:       3             4        18           46
integer variables    :       0             0         0            0
nonlinear variables  :       5             5         9            0

Starting global search ...
 Initial upper bound on objective: +2.931083e-002
 Initial lower bound on objective: -3.167052e+022


 #NODEs  BOXES   LOWER BOUND     UPPER BOUND      RGAP   TIME(s)

     1       1  -3.167052e+022  +2.931083e-002  1.0e+000      0 (*N)
    19      17  -2.136461e+000  +2.931083e-002  1.0e+000      0 (*I)
    22      20  -1.848574e-001  +2.931083e-002  2.1e-001      0 (*I)
    23      21  +2.416053e-003  +2.931083e-002  2.7e-002      0 (*F)


Terminating global search ...

 Global optimum found
 Objective value              :        0.0293108307216
 Best Bound                   :       0.00241605257558
 Factors (ok,stb)             :                    522 (100.00,99.81)
 Simplex iterations           :                   2503
 Barrier iterations           :                      0
 Nonlinear iterations         :                    433
 Box iterations               :                     23
 Total number of boxes        :                     21
 Max. Depth                   :                      5
 First solution time (sec.)   :                      0
 Best solution time (sec.)    :                      0
 Total time (sec.)            :                      0

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

The following flags can be seen in the progress log:

Flag	Description
*(FP)**	found a new MIP solution with feasibility pump
*(SBB)**	found a new MIP solution in tree reorder
*(SE)**	found a new MIP solution in simple enumeration
*(AB)**	found a new MIP solution in advanced branching
*(AH)**	found a new MIP solution with advanced heuristics
*(C)**	found a new MIP solution after cuts added
*(T)**	found a new MIP solution on the top
*(SRH)**	found a new MIP solution in simple rounding heuristics
*(SB)**	found a new MIP solution in strong branching
*(K)**	found a new MIP solution in knapsack enumerator
*()**	found a new MIP solution normal branching
*(?-)**	found a new MIP solution with advanced heuristics (level$>$10)
*(N)**	found a new incumbent GOP solution
*(I)**	stored a box with the incumbent solution into the GOP solution list
*(F)**	determined the final GOP status

The GAMS/LINDO Options

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

GAMS/LINDO Options File

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

  <modelname>.optfile = 1;

where

<modelname>

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

A sample option file lindo.opt looks like below

    * Use(1) or Disable(0) global optimization for NLP/MINLP models
    USEGOP               0

    * Enable Multistart NLP solver
    NLP_SOLVER           9

    * Allow a maximum of 3 multistart attempts
    NLP_MAXLOCALSEARCH   3

    * Set an overall time limit of 200 secs.
    SOLVER_TIMLMT      200

Summary of GAMS/Lindo Options

General Options

Option	Description	Default
DECOMPOSITION_TYPE	decomposition to be performed on a linear or mixed integer model	`1`
FIND_BLOCK	graph partitioning method to find block structures	`0`
FIND_SYMMETRY_LEVEL	specifies the symmetry finding level.	`-1`
FIND_SYMMETRY_PRINT_LEVEL	specifies print level for symmetry finding	`0`
INSTRUCT_SUBOUT	flag to specify how to deal with fixed variables in the instruction list	`-1`
MULTITHREAD_MODE	threading mode	`-1`
NUM_THREADS	number of parallel threads to be used	`GAMS Threads`
PROFILER_LEVEL	specifies the profiler level to break down the total cpu time into.	`0`
SOLVER_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_FEASTOL	feasibility tolerance	`1e-7`
SOLVER_IPMSOL	basis crossover flag for barrier solver	`0`
SOLVER_IUSOL	flag for computing basic solution for infeasible model	`0`
SOLVER_METHOD	specifies the method to use when generic solver is invoked	`0`
SOLVER_MODE	controls some of the advanced strategies when solving LPs	`1`
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`
SOLVER_USECUTOFFVAL	flag for using cutoff value	`0`
TUNER_PRINT_LEVEL	specifies the amount of print to do during parameter tuning	`1`

LP Options

Option	Description	Default
LP_AIJ_ZEROTOL	coefficient matrix zero tolerance	`2.22045e-16`
LP_BIGM	big-M for phase-I	`1e6`
LP_BNDINF	big-M to truncate lower and upper bounds in single phase dual-simplex	`1e15`
LP_DPSWITCH	specifies whether LP primal-dual simplex switch is enabled or not	`1`
LP_DRATIO	controls the dual min-ratio strategy	`1`
LP_DYNOBJFACT	Dynamic obj factor	`0.75`
LP_DYNOBJMODE	Dynamic obj mode	`0`
LP_ITRLMT	simplex iteration limit	`infinity`
LP_PIV_BIGTOL	simplex maximum pivot tolerance	`1e-5`
LP_PIV_ZEROTOL	simplex pivot zero tolerance	`1e-8`
LP_PPARTIAL	primal simplex partial pricing method	`0`
LP_PRELEVEL	controls the amount and type of LP pre-solving	`126`
LP_RATRANGE	controls the number of pivot-candidates to consider when searching for a stable pivot in LU decomposition	`4`
LP_SCALE	scaling flag	`1`
LP_SPRINT_COLFACT	maximum number of columns in Sprint as a factor of number of rows	`10`
LP_SPRINT_MAXPASS	maximum number of passes in Sprint method	`100`
LP_SPRINT_SUB	LP method for subproblem in Sprint method	`0`
PROB_TO_SOLVE	controls whether the explicit primal or dual form of the given LP problem will be solved	`0`
SPLEX_DPRICING	pricing option for dual simplex method	`-1`
SPLEX_DUAL_PHASE	controls the dual simplex strategy	`0`
SPLEX_PPRICING	pricing option for primal simplex method	`-1`
SPLEX_REFACFRQ	number of simplex iterations between two consecutive basis re-factorizations	`100`

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_DFEAS	dual feasibility tolerance for Conic solver	`1e-8`
IPM_CO_TOL_INFEAS	maximum bound infeasibility tolerance for Conic solver	`1e-12`
IPM_CO_TOL_MU_RED	optimality tolerance for Conic solver	`1e-8`
IPM_CO_TOL_PFEAS	primal feasibility tolerance for Conic solver	`1e-8`
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_CONCURRENT_REOPTMODE	specifies the concurrent optimization mode with warm start	`0`
MIP_CONCURRENT_STRATEGY	controls the concurrent MIP strategy	`-1`
MIP_CONCURRENT_TOPOPTMODE	specifies the concurrent optimization mode with cold start	`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_FIXINIT_ITRLIM	iteration limit of the LP solved after fixing integer variables to their initial values	`-1`
MIP_FP_HEU_MODE	specifies the feasibility-pump (FP) heuristic mode	`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_PROJECTION	type of objective function of LPs in projection step of the feasibility pump heuristic	`0`
MIP_FP_TIMLIM	time limit for feasibility pump heuristic	`1800`
MIP_FP_WEIGTH	weight of the objective function in the feasibility pump	`1`
MIP_GENERAL_MODE	general strategy in solving MIPs	`0`
MIP_HEULEVEL	specifies heuristic used to find integer solution	`3`
MIP_HEUMINTIMLIM	minimum time in seconds to be spent in finding heuristic solutions	`0`
MIP_HEU_DROP_OBJ	flag for whether to use without OBJ heuristic	`0`
MIP_HEU_MODE	heuristic used in MIP solver	`0`
MIP_INTTOL	absolute integer feasibility tolerance	`1e-6`
MIP_ITRLIM	iteration limit for branch and bound	`infinity`
MIP_KBEST_USE_GOP	specifies whether to use gop solver in MIP KBest	`0`
MIP_KEEPINMEM	flag for keeping LP bases in memory	`1`
MIP_LBIGM	Big-M value used in linearizing nonlinear expressions	`10000`
MIP_LSOLTIMLIM	time limit until finding a new integer solution	`-1`
MIP_MAKECUT_INACTIVE_COUNT	threshold for times a cut could remain active after successive reoptimization	`10`
MIP_MAXCUTPASS_TOP	number passes to generate cuts on the root node	`200`
MIP_MAXCUTPASS_TREE	number passes to generate cuts on the child nodes	`2`
MIP_MAXNONIMP_CUTPASS	number of passes allowed in cut-generation that does not improve current relaxation	`3`
MIP_MAXNUM_MIP_SOL_STORAGE	maximum number of k-best solutions to store	`1`
MIP_MINABSOBJSTEP	value to update cutoff value each time a mixed integer solution is found	`0`
MIP_NODESELRULE	specifies the node selection rule	`0`
MIP_NUM_THREADS	number of parallel threads to use by the parallel MIP solver	`1`
MIP_PARA_FP	flag for whether to use parallelization on the feasibility pump heuristic	`1`
MIP_PARA_FP_MODE	flag for the mode of parallel feasibility pump	`0`
MIP_PARA_INIT_NODE	number of initial nodes for MIP parallelization	`-1`
MIP_PARA_ITR_MODE	flag for iteration mode in MIP parallelization	`1`
MIP_PARA_RND_ITRLMT	iteration limit of each round in MIP parallelization, it is a weighted combination of simplex and barrier iterations	`2.0`
MIP_PARA_SUB	flag for whether to use MIP parallelization on subproblems solved in MIP preprocessing	`1`
MIP_PEROPTTOL	MIP relative optimality tolerance in effect after MIP_AOPTTIMLIM seconds	`1e-5`
MIP_PERSPECTIVE_REFORM	flag for whether to use Perspective Reformulation	`1`
MIP_POLISH_ALPHA_TARGET	proportion solutions in the pool to initiate a polishing-task at the current node	`0.6`
MIP_POLISH_MAX_BRANCH_COUNT	maximum number of branches to polish	`2000`
MIP_POLISH_NUM_BRANCH_NEXT	number of branches to polish in the next round	`4000`
MIP_PREHEU_DFE_VSTLIM	limit for the variable visit in depth first enumeration	`200`
MIP_PREHEU_LEVEL	heuristic level for the prerelax solver	`0`
MIP_PREHEU_TC_ITERLIM	iteration limit for the two change heuristic	`30000000`
MIP_PREHEU_VAR_SEQ	sequence of the variable considered by the prerelax heuristic	`-1`
MIP_PRELEVEL	controls the amount and type of MIP pre-solving at root node	`3070`
MIP_PRELEVEL_TREE	amount and type of MIP pre-solving at tree nodes	`1214`
MIP_PRE_ELIM_FILL	controls fill-in introduced by eliminations during pre-solve	`100`
MIP_PSEUDOCOST_RULE	specifies the rule in pseudocost computations for variable selection	`0`
MIP_PSEUDOCOST_WEIGT	weight in pseudocost computations for variable selection	`1.5625e-05`
MIP_REDCOSTFIX_CUTOFF	cutoff value as a percentage of the reduced costs	`0.9`
MIP_REDCOSTFIX_CUTOFF_TREE	cutoff value as a percentage of the reduced costs at tree nodes	`0.9`
MIP_RELINTTOL	relative integer feasibility tolerance	`8e-6`
MIP_RELOPTTOL	MIP relative optimality tolerance	`GAMS OptCR`
MIP_REOPT	optimization method to use when doing reoptimization	`0`
MIP_SCALING_BOUND	maximum difference between bounds of an integer variable for enabling scaling	`10000`
MIP_SOLLIM	integer solution limit for MIP solver	`-1`
MIP_SOLVERTYPE	optimization method to use when solving mixed-integer models	`0`
MIP_STRONGBRANCHDONUM	minimum number of variables to try the strong branching on	`3`
MIP_STRONGBRANCHLEVEL	depth from the root in which strong branching is used	`10`
MIP_SWITCHFAC_SIM_IPM_ITER	specifies the (positive) factor that multiplies the number of constraints to impose an iteration limit to simplex method and trigger a switch over to the barrier method	`-1`
MIP_SWITCHFAC_SIM_IPM_TIME	factor that multiplies the number of constraints to impose a time limit to simplex method and trigger a switch over to the barrier method	`-1`
MIP_SYMMETRY_MODE	specifies mip symmetry handling methods	`0`
MIP_SYMMETRY_NONZ	limit on number of nonzeros to look for symmetries	`50000`
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_CONIC_REFORM	determines if to explore conic reformulation	`1`
NLP_CONOPT_VER	specifies the CONOPT version to be used in NLP optimizations	`3`
NLP_CUTOFFOBJ	as soon as any multi-start thread achieves this value all threads stop	`-1e30`
NLP_DERIV_DIFFTYPE	flag indicating the technique used in computing derivatives with finite differences	`0`
NLP_FEASCHK	how to report results when solution satisfies tolerance of scaled but not original model	`1`
NLP_FEASTOL	feasibility tolerance for nonlinear constraints	`1e-6`
NLP_INF	numeric infinity for nonlinear models	`1e30`
NLP_IPM2GRG	switch from IPM solver to GRG solver when IPM fails due to numerical errors	`1`
NLP_ITERS_PER_LOGLINE	number of nonlinear iterations to elapse before next progress message	`10`
NLP_ITRLMT	nonlinear iteration limit	`GAMS IterLim`
NLP_LINEARZ	extent to which the solver will attempt to linearize nonlinear models	`-1`
NLP_LINEARZ_WB_CONSISTENT	determines if linearization process is consistent with WB/excel calculation	`0`
NLP_MAXLOCALSEARCH	maximum number of local searches	`5`
NLP_MAXLOCALSEARCH_TREE	maximum number of multistarts	`1`
NLP_MAX_RETRY	maximum number refinement retries to purify the final NLP solution	`5`
NLP_MSW_EUCDIST_THRES	euclidean distance threshold in multistart search	`0.001`
NLP_MSW_FILTMODE	filtering mode to exclude certain domains during sampling in multistart search	`-1`
NLP_MSW_MAXNOIMP	maximum number of consecutive populations to generate without any improvements	`-1`
NLP_MSW_MAXPOP	maximum number of populations to generate in multistart search	`-1`
NLP_MSW_MAXREF	maximum number of reference points to generate trial points in multistart search	`-1`
NLP_MSW_NORM	norm to measure the distance between two points in multistart search	`2`
NLP_MSW_NUM_THREADS	number of parallel threads to be used when solving an NLP model with the multistart solver	`1`
NLP_MSW_OVERLAP_RATIO	rate of replacement in successive populations	`0.1`
NLP_MSW_POXDIST_THRES	penalty function neighborhood threshold in multistart search	`0.01`
NLP_MSW_PREPMODE	preprocessing strategies in multistart solver	`-1`
NLP_MSW_RG_SEED	random number generator seed for the multistart solver	`1019`
NLP_MSW_RMAPMODE	specifies the mode to map reference points in the unit cube into the original space	`-1`
NLP_MSW_SOLIDX	index of the multistart solution to be loaded	`0`
NLP_MSW_XKKTRAD_FACTOR	KKT solution neighborhood factor in multistart search	`0.85`
NLP_MSW_XNULRAD_FACTOR	initial solution neighborhood factor in multistart search	`0.5`
NLP_PRELEVEL	controls the amount and type of NLP pre-solving	`126`
NLP_PSTEP_FINITEDIFF	value of the step length in computing the derivatives using finite differences	`5e-7`
NLP_QUADCHK	flag for checking if NLP is quadratic	`1`
NLP_REDGTOL	tolerance for the gradients of nonlinear functions	`1e-7`
NLP_SOLVER	type of nonlinear solver	`7`
NLP_SOLVE_AS_LP	flag indicating if the nonlinear model will be solved as an LP	`0`
NLP_STALL_ITRLMT	iteration limit before a sequence of non-improving NLP iterations is declared as stalling	`100`
NLP_STARTPOINT	flag for using initial starting solution for NLP	`1`
NLP_SUBSOLVER	type of nonlinear subsolver	`1`
NLP_USECUTOFFOBJ	flag to use parameter NLP_CUTOFFOBJ	`0`
NLP_USE_CRASH	flag for using simple crash routines for initial solution	`0`
NLP_USE_LINDO_CRASH	flag for using advanced crash routines for initial solution	`1`
NLP_USE_SDP	flag to use SDP solver for POSD constraint	`1`
NLP_USE_SELCONEVAL	flag for using selective constraint evaluations for solving NLP	`1`
NLP_USE_SLP	flag for using sequential linear programming step directions for updating solution	`1`
NLP_USE_STEEPEDGE	flag for using steepest edge directions for updating solution	`0`

Global Options

Option	Description	Default
GOP_ABSOPTTOL	absolute optimality tolerance	`GAMS OptCA`
GOP_ALGREFORMMD	algebraic reformulation rule for a GOP	`18`
GOP_BBSRCHMD	node selection rule in GOP branch-and-bound	`1`
GOP_BNDLIM	max magnitude of variable bounds used in GOP convexification	`1e10`
GOP_BOXTOL	minimal width of variable intervals	`1e-6`
GOP_BRANCHMD	direction to branch first when branching on a variable	`5`
GOP_BRANCH_LIMIT	limit on the total number of branches to be created in GOP tree	`-1`
GOP_CMINLP	flag indicating if GOP exploits convex MINLP model	`0`
GOP_CONIC_REFORM	flag indicating if GOP explore conic reformulation	`1`
GOP_CORELEVEL	strategy of GOP branch-and-bound	`14`
GOP_DECOMPPTMD	decomposition point selection rule in GOP branch-and-bound	`1`
GOP_DELTATOL	delta tolerance in GOP convexification	`1e-7`
GOP_FLTTOL	floating-point tolerance	`1e-10`
GOP_HEU_MODE	heuristic used in global solver	`0`
GOP_ITRLIM	GOP iteration limit	`infinity`
GOP_ITRLIM_IPM	total barrier iteration limit summed over all branches in GOP	`-1`
GOP_ITRLIM_NLP	total nonlinear iteration limit summed over all branches in GOP	`-1`
GOP_ITRLIM_SIM	total simplex iteration limit summed over all branches in GOP	`-1`
GOP_LIM_MODE	flag indicating which heuristic limit on sub-solver in GOP is based	`1`
GOP_LINEARZ	flag indicating if GOP exploits linearizable model	`1`
GOP_LSOLBRANLIM	branch limit until finding a new nonlinear solution	`-1`
GOP_MAXWIDMD	maximum width flag for the global solution	`0`
GOP_MULTILINEAR	flag indicating if GOP exploits multi linear feature	`1`
GOP_NUM_THREADS	number of parallel threads to be used when solving a nonlinear model with the global optimization solver	`1`
GOP_OBJ_THRESHOLD	threshold of objective value in the GOP solver	`-1e+30`
GOP_OPTCHKMD	criterion used to certify the global optimality	`2`
GOP_OPT_MODE	mode for GOP optimization	`1`
GOP_POSTLEVEL	amount and type of GOP postsolving	`6`
GOP_PRELEVEL	amount and type of GOP presolving	`30`
GOP_QUADMD	flag indicating if GOP exploits quadratic feature	`-1`
GOP_QUAD_METHOD	specifies if the GOP solver should solve the model as a QP when applicable	`-1`
GOP_RELBRNDMD	reliable rounding in the GOP branch-and-bound	`0`
GOP_RELOPTTOL	relative optimality tolerance	`GAMS OptCR`
GOP_SOLLIM	integer solution limit for GOP branch-and-bound	`-1`
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`
EMPINFOFILE	Path and name of file containing additional EMP-SP information as randvar, jrandvar, stage etc.
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_NUM_THREADS	specifies the number of parallel threads to be used when sampling	`0`
SAMP_RG_BUFFER_SIZE	specifies the buffer size for random number generators in running in parallel mode	`0`
SAMP_SCALE	flag to enable scaling of raw sample data	`0`
STOC_ABSOPTTOL	absolute optimality tolerance (w.r.t lower and upper bounds on the true objective) to stop the solver	`GAMS OptCA`
STOC_ADD_MPI	flag to use add-instructions mode when building deteq	`0`
STOC_ALD_DUAL_FEASTOL	dual feasibility tolerance for ALD	`1e-4`
STOC_ALD_DUAL_STEPLEN	dual step length for ALD	`0.9`
STOC_ALD_INNER_ITER_LIM	inner loop iteration limit for ALD	`1000`
STOC_ALD_OUTER_ITER_LIM	outer loop iteration limit for ALD	`200`
STOC_ALD_PRIMAL_FEASTOL	primal feasibility tolerance for ALD	`1e-4`
STOC_ALD_PRIMAL_STEPLEN	primal step length for ALD	`0.5`
STOC_AUTOAGGR	flag to enable or disable autoaggregation	`1`
STOC_BENCHMARK_SCEN	benchmark scenario to compare EVPI and EVMU against	`-2`
STOC_BIGM	big-M value for linearization and penalty functions	`1e7`
STOC_BUCKET_SIZE	bucket size in Benders decomposition	`-1`
STOC_CALC_EVPI	flag to enable or disable calculation of EVPI	`1`
STOC_CORRELATION_TYPE	correlation type associated with correlation matrix	`0`
STOC_DEQOPT	method to solve the DETEQ problem	`0`
STOC_DETEQ_TYPE	type of deterministic equivalent	`-1`
STOC_DS_SUBFORM	subproblem formulation to use in DirectSearch	`-1`
STOC_ELIM_FXVAR	flag to enable elimination of fixed variables from deteq MPI	`1`
STOC_INFBND	value to truncate infinite bounds at non-leaf nodes	`1e9`
STOC_ITER_LIM	iteration limit for stochastic solver	`infinity`
STOC_MAP_MPI2LP	flag to specify whether stochastic parameters in MPI will be mapped as LP matrix elements	`0`
STOC_MAX_NUMSCENS	maximum number of scenarios before forcing automatic sampling	`40000`
STOC_METHOD	stochastic optimization method to solve the model	`-1`
STOC_NAMEDATA_LEVEL	name data level	`1`
STOC_NODELP_PRELEVEL	presolve level solving node-models	`0`
STOC_NSAMPLE_PER_STAGE	list of sample sizes per stage (starting at stage 2)
STOC_NSAMPLE_SPAR	common sample size per stochastic parameter	`-1`
STOC_NSAMPLE_STAGE	common sample size per stage	`-1`
STOC_NUM_THREADS	number of parallel threads	`1`
STOC_RELOPTTOL	relative optimality tolerance (w.r.t lower and upper bounds on the true objective) to stop the solver	`GAMS OptCR`
STOC_REL_DSTEPTOL	dual-step tolerance	`1e-7`
STOC_REL_PSTEPTOL	primal-step tolerance	`1e-8`
STOC_REOPT	reoptimization method to solve the node-models	`0`
STOC_RG_SEED	seed to initialize the random number generator	`1031`
STOC_SAMP_CONT_ONLY	flag to restrict sampling to continuous stochastic parameters only or not	`1`
STOC_SBD_MAXCUTS	max cuts to generate for master problem	`-1`
STOC_SBD_NUMCANDID	maximum number of candidate solutions to generate at SBD root	`-1`
STOC_SBD_OBJCUTFLAG	flag to enable objective cut in SBD master problem	`1`
STOC_SBD_OBJCUTVAL	RHS value of objective cut in SBD master problem	`1e-30`
STOC_SHARE_BEGSTAGE	stage beyond which node-models are shared	`-1`
STOC_TIME_LIM	time limit for stochastic solver	`GAMS ResLim`
STOC_TOPOPT	optimization method to solve the root problem	`0`
STOC_VARCONTROL_METHOD	sampling method for variance reduction	`1`
STOC_WSBAS	warm start basis for wait-see model	`-1`
SVR_LS_ANTITHETIC	Sample variance reduction map to Lindo Antithetic algorithm
SVR_LS_LATINSQUARE	Sample variance reduction map to Lindo Latin Square algorithm
SVR_LS_MONTECARLO	Sample variance reduction map to Lindo Montecarlo algorithm

IIS and IUS Options

Option	Description	Default
IIS	run the IIS finder if the problem is infeasible	`0`
IIS_ANALYZE_LEVEL	controls the level of analysis when locating an IIS	`1`
IIS_GETMODE	flag that controls whether variable bounds in the IIS should be retrieved or the integer restrictions	`0`
IIS_INFEAS_NORM	specifies the norm to measure infeasibilities in IIS search	`0`
IIS_ITER_LIMIT	the iteration limit for IIS search	`-1`
IIS_METHOD	specifies the method to use in analyzing infeasible models to locate an IIS	`0`
IIS_PRINT_LEVEL	specifies the amount of print to do during IIS search	`2`
IIS_REOPT	specifies which optimization method to use when starting from a given basis	`0`
IIS_TIME_LIMIT	the time limit for IIS search	`-1`
IIS_TOPOPT	specifies which optimization method to use when there is no previous basis	`0`
IIS_USE_EFILTER	flag that controls whether the Elastic Filter should be enabled as the supplementary filter in analyzing infeasible models	`0`
IIS_USE_GOP	flag that controls whether the global optimizer should be enabled in analyzing infeasible NLP models	`0`
IIS_USE_SFILTER	flag indicating is sensitivity filter will be used during IIS search	`1`
IUS	run the IUS finder if the problem is unbounded	`0`
IUS_ANALYZE_LEVEL	controls the level of analysis when locating an IUS	`2`

Link Options

Option	Description	Default
CHECKRANGE	calculate feasible range for variables	`range.gdx`
READPARAMS	read Lindo parameter file
WRITEDEMPI	write deterministic equivalent in MPI format
WRITEDEMPS	write deterministic equivalent in MPS format
WRITEMPI	write (S)MPI file of processed model
WRITEMPS	write (S)MPS file of processed model

Detailed Descriptions of GAMS/Lindo Options

CHECKRANGE (string): calculate feasible range for variables ↵

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

Default: range.gdx

CORE_ORDER_BY_STAGE (integer): order nontemporal models or not ↵

Order nontemporal models or not.

Default: 1

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

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

Default: 1

value meaning

0 Solver decides which type of decomposition to use

1 Solver does not perform any decompositions and uses the original model

2 Attempt total decomposition

3 Decomposed model will have dual angular structure

4 Decomposed model will have block angular structure

5 Decomposed model will have both dual and block angular structure

EMPINFOFILE (string): Path and name of file containing additional EMP-SP information as randvar, jrandvar, stage etc. ↵

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

Specifies the graph partitioning method to find block structures.

Default: 0

value meaning

0 Use an edge-weight minimizing graph partitioning heuristic

1 Use a vertex-weight minimizing graph partitioning heuristic

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

Default: -1

value meaning

-1 Solver decides

0 Finding orbit only without MIP preprocessing

1 Finding orbit only with MIP preprocessing

2 Finding generators without MIP preprocessing

3 Finding generators with MIP preprocessing

4 Finding the first generator without MIP preprocessing

5 Finding the first generator with MIP preprocessing

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

Default: 0

value meaning

0 Nothing printed

+2 General information

+4 Time information

+8 Orbit information

+16 Partition information

GOP_ABSOPTTOL (real): absolute optimality tolerance ↵

Synonym: ABSOPTTOL

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

Default: GAMS OptCA

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

Synonym: ALGREFORMMD

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

Default: 18

value meaning

+2 Rearrange and collect terms

+4 Expand all parentheses

+8 Retain nonlinear functions

+16 Selectively expand parentheses

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

Synonym: BBSRCHMD

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

Default: 1

value meaning

0 Depth first search

1 Choose node with worst bound

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

Synonym: BNDLIM

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

Default: 1e10

GOP_BOXTOL (real): minimal width of variable intervals ↵

Synonym: BOXTOL

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

Default: 1e-6

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

Synonym: BRANCHMD

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

Default: 5

value meaning

0 Absolute width

1 Locally relative width

2 Globally relative width

3 Globally relative distance from the convex minimum to the bounds

4 Absolute violation between the function and its convex envelope at the convex minimum

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

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

Synonym: BRANCH_LIMIT

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

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

Default: -1

GOP_CMINLP (integer): flag indicating if GOP exploits convex MINLP model ↵

Default: 0

value meaning

0 Off

1 On

GOP_CONIC_REFORM (integer): flag indicating if GOP explore conic reformulation ↵

Default: 1

value meaning

0 Off

1 On

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

Synonym: CORELEVEL

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

Default: 14

value meaning

+2 LP convex relaxation

+4 NLP solving

+8 Box Branching

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

Synonym: DECOMPPTMD

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

Default: 1

value meaning

0 Mid-point

1 Local minimum or convex minimum

GOP_DELTATOL (real): delta tolerance in GOP convexification ↵

Synonym: DELTATOL

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

Default: 1e-7

GOP_FLTTOL (real): floating-point tolerance ↵

Synonym: FLTTOL

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

Default: 1e-10

GOP_HEU_MODE (integer): heuristic used in global solver ↵

Synonym: HEU_MODE

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

Default: 0

value meaning

0 No heuristic is used

1 A simple heuristic is used

GOP_ITRLIM (real): GOP iteration limit ↵

Synonym: ITRLIM

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

Range: [-1, ∞]

Default: infinity

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

Synonym: ITRLIM_IPM

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

Range: [-1, ∞]

Default: -1

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

Synonym: ITRLIM_NLP

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

Range: [-1, ∞]

Default: -1

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

Synonym: ITRLIM_SIM

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

Range: [-1, ∞]

Default: -1

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

Synonym: LIM_MODE

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

Default: 1

value meaning

0 No limit

1 Time based limit

2 Iteration based limit

3 Both time and iteration based limit

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

This is a flag indicating if GOP exploits linearizable model.

Default: 1

value meaning

0 Exploit lineariable model

1 Do not exploit lineariable model

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

Synonym: LSOLBRANLIM

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

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

Default: -1

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

Synonym: MAXWIDMD

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

Default: 0

value meaning

0 The maximum width criterion is suppressed

1 The maximum width criterion is performed

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

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

Default: 1

value meaning

0 Off

1 On

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

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

Default: 1

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

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

Range: [-1e+30, ∞]

Default: -1e+30

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

Synonym: OPTCHKMD

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

Default: 2

GOP_OPT_MODE (integer): mode for GOP optimization ↵

Synonym: OPT_MODE

This specifies the mode for GOP optimization.

Default: 1

value meaning

0 Global search for a feasible solution (thus a feasibility certificate)

1 Global search for an optimal solution

2 Global search for an unboundedness certificate

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

Synonym: POSTLEVEL

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

Default: 6

value meaning

+2 Apply LSgetBestBound

+4 Reoptimize variable bounds

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

Synonym: PRELEVEL

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

Default: 30

value meaning

+2 Initial local optimization

+4 Initial linear constraint propagation

+8 Recursive linear constraint propagation

+16 Recursive nonlinear constraint propagation

GOP_QUADMD (integer): flag indicating if GOP exploits quadratic feature ↵

Default: -1

value meaning

-1 Solver decides

0 No

1 Yes

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

Default: -1

value meaning

-1 Solver decides

0 General GOP solver

1 Specified QP solver

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

Synonym: RELBRNDMD

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

Default: 0

value meaning

+2 Use smaller optimality or feasibility tolerances and appropriate presolving options

+4 Apply interval arithmetic to reverify the solution feasibility

GOP_RELOPTTOL (real): relative optimality tolerance ↵

Synonyms: OPTTOL RELOPTTOL

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

Default: GAMS OptCR

GOP_SOLLIM (integer): integer solution limit for GOP branch-and-bound ↵

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

Default: -1

GOP_SUBOUT_MODE (integer): substituting out fixed variables ↵

Synonym: SUBOUT_MODE

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

Default: 1

value meaning

0 Do not substitute out fixed variables

1 Substitute out fixed variables

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

Synonym: TIMLIM

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

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

Default: GAMS ResLim

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

Synonym: USEBNDLIM

This value is a flag for the parameter GOP_BNDLIM.

Default: 2

value meaning

0 Do not use the bound limit on the variables

1 Use the bound limit right at the beginning of global optimization

2 Use the bound limit after the initial local optimization if selected

GOP_WIDTOL (real): maximal width of variable intervals ↵

Synonym: WIDTOL

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

Default: 1e-4

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

Default: 0

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

Default: 1

value meaning

+1 Search for necessary rows

+2 Search for necessary columns

+4 Search for sufficient rows

+8 Search for sufficient columns

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

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

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

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

+256 Treat iter/time limits as intractability

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

Default: 0

value meaning

0 Variable bound

1 Integer restrictions

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

Default: 0

value meaning

0 Solver decides

1 Use L-1 norm

2 L-infinity norm

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

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

Default: -1

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

Default: 0

value meaning

0 Default filter

1 Standard deletion filter

2 Standard additive filter

3 Generalized-binary-search filter

4 Depth-first-binary-search filter

5 Fast-scan filter

6 Standard elastic filter

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

Default: 2

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

Default: 0

value meaning

0 Free

1 Primal Simplex

2 Dual Simplex

3 Barrier

4 NLP

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

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

Default: -1

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

Default: 0

value meaning

0 Free

1 Primal Simplex

2 Dual Simplex

3 Barrier

4 NLP

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

Default: 0

value meaning

-1 Solver decides

0 Do not use elastic filter

1 Use elastic filter

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

Default: 0

value meaning

-1 Solver decides

0 Do not use GOP

1 Use GOP

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

Default: 1

value meaning

-1 Solver decides

0 Do not use sensitivity filter

1 Use sensitivity filter

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

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

Default: -1

value meaning

-1 Solver decides

0 Substitutions will not be performed

1 Substitutions will be performed

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

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

Default: 1e-12

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

Maximum absolute dual bound violation in an optimal basic solution.

Default: 1e-7

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

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

Default: 1e-7

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

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

Range: [0, 0.999999]

Default: 1e-2

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

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

Default: 1

value meaning

-1 Check convexity only without solving the model

0 Use barrier solver to check convexity

1 Do not use barrier solver to check convexity

IPM_CO_TOL_DFEAS (real): dual feasibility tolerance for Conic solver ↵

Default: 1e-8

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

Maximum bound infeasibility tolerance for Conic solver.

Default: 1e-12

IPM_CO_TOL_MU_RED (real): optimality tolerance for Conic solver ↵

Default: 1e-8

IPM_CO_TOL_PFEAS (real): primal feasibility tolerance for Conic solver ↵

Default: 1e-8

IPM_MAX_ITERATIONS (integer): ipm iteration limit ↵

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

Default: 1000

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

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

Default: 1

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

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

Default: 40

IPM_TOL_DFEAS (real): dual feasibility tolerance ↵

Dual feasibility tolerance used for linear and quadratic optimization problems.

Default: 1e-8

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

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

Range: [1e-4, ∞]

Default: 1

IPM_TOL_INFEAS (real): infeasibility tolerance ↵

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

Default: 1e-10

IPM_TOL_MU_RED (real): relative complementarity gap tolerance ↵

Relative complementarity gap tolerance.

Default: 1e-16

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

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

Range: [0, 0.5]

Default: 1e-8

IPM_TOL_PFEAS (real): primal feasibility tolerance ↵

Primal feasibility tolerance used for linear and quadratic optimization problems.

Default: 1e-8

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

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

Range: [1e-2, ∞]

Default: 1

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

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

Range: [0, 0.999999]

Default: 0.9999

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

Default: 0

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

Default: 2

value meaning

+2 Search for necessary columns

+8 Search for sufficient columns

LP_AIJ_ZEROTOL (real): coefficient matrix zero tolerance ↵

Default: 2.22045e-16

LP_BIGM (real): big-M for phase-I ↵

Default: 1e6

LP_BNDINF (real): big-M to truncate lower and upper bounds in single phase dual-simplex ↵

Default: 1e15

LP_DPSWITCH (integer): specifies whether LP primal-dual simplex switch is enabled or not ↵

Range: {0, ..., 1}

Default: 1

LP_DRATIO (integer): controls the dual min-ratio strategy ↵

Range: {0, ..., 2}

Default: 1

LP_DYNOBJFACT (real): Dynamic obj factor ↵

Range: [0, 1]

Default: 0.75

LP_DYNOBJMODE (integer): Dynamic obj mode ↵

Default: 0

LP_ITRLMT (integer): simplex iteration limit ↵

Synonym: SPLEX_ITRLMT

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

Default: infinity

LP_PIV_BIGTOL (real): simplex maximum pivot tolerance ↵

Default: 1e-5

LP_PIV_ZEROTOL (real): simplex pivot zero tolerance ↵

Default: 1e-8

LP_PPARTIAL (integer): primal simplex partial pricing method ↵

Range: {0, ..., 3}

Default: 0

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

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

Default: 126

value meaning

+2 Simple pre-solving

+4 Probing

+8 Coefficient reduction

+16 Elimination

+32 Dual reductions

+64 Use dual information

+512 Maximum pass

LP_RATRANGE (integer): controls the number of pivot-candidates to consider when searching for a stable pivot in LU decomposition ↵

Range: {1, ..., ∞}

Default: 4

LP_SCALE (integer): scaling flag ↵

Synonym: SPLEX_SCALE

Default: 1

value meaning

0 Scaling is suppressed

1 Scaling is performed

LP_SPRINT_COLFACT (integer): maximum number of columns in Sprint as a factor of number of rows ↵

Range: {1, ..., ∞}

Default: 10

LP_SPRINT_MAXPASS (integer): maximum number of passes in Sprint method ↵

Range: {1, ..., ∞}

Default: 100

LP_SPRINT_SUB (integer): LP method for subproblem in Sprint method ↵

Default: 0

MIP_ABSCUTTOL (real): MIP absolute cut tolerance ↵

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

Range: [-1.0, ∞]

Default: -1.0

MIP_ABSOPTTOL (real): MIP absolute optimality tolerance ↵

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

Default: GAMS OptCA

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

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

Default: 1.5625e-5

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

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

Default: 0.75

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

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

Default: 0.5

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

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

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

Default: -1

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

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

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

Default: -1

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

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

Default: 50000

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

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

Default: 100

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

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

Default: 1e8

MIP_BRANCHDIR (integer): first branching direction ↵

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

Default: 0

value meaning

0 Solver decides

1 Always branch up first

2 Always branch down first

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

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

Default: 0

value meaning

0 Solver decides

1 Basis rounding with pseudo reduced costs

2 Maximum infeasibility

3 Pseudo reduced costs only

4 Maximum coefficient only

5 Previous branching only

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

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

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

Default: -1

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

This controls how variable selection priorities are set and used.

Default: 0

value meaning

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

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

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

3 Let LINDO API set the priorities and ignore any user specified priorities

4 Binaries always have higher priority over general integers

MIP_CONCURRENT_REOPTMODE (integer): specifies the concurrent optimization mode with warm start ↵

Default: 0

value meaning

0 no concurrent runs

1 run concurrently if at least 2 threads exist

2 run concurrently

MIP_CONCURRENT_STRATEGY (integer): controls the concurrent MIP strategy ↵

Default: -1

value meaning

-1 Solver decides

1 Defines built-in priority lists for each thread

3 Defines heuristic based strategies for each thread

MIP_CONCURRENT_TOPOPTMODE (integer): specifies the concurrent optimization mode with cold start ↵

Default: 0

value meaning

0 no concurrent runs

1 run concurrently if at least 2 threads exist

2 run concurrently

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

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

Default: 8

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

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

Default: 10

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

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

Default: 57342

value meaning

+2 GUB cover

+4 Flow cover

+8 Lifting

+16 Plant location

+32 Disaggregation

+64 Knapsack cover

+128 Lattice

+256 Gomory

+512 Coefficient reduction

+1024 GCD

+2048 Obj integrality

+4096 Basis Cuts

+8192 Cardinality Cuts

+16384 Disjunk Cuts

+32768 Soft Knapsack Cuts

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

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

Default: 53246

value meaning

+2 GUB cover

+4 Flow cover

+8 Lifting

+16 Plant location

+32 Disaggregation

+64 Knapsack cover

+128 Lattice

+256 Gomory

+512 Coefficient reduction

+1024 GCD

+2048 Obj integrality

+4096 Basis Cuts

+8192 Cardinality Cuts

+16384 Disjunk Cuts

+32768 Soft Knapsack Cuts

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

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

Default: 1e30

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

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

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

Default: -1

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

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

Default: 1e-6

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

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

Default: 0

value meaning

0 Do not calculate dual solution for LP relaxation

1 Calculate dual solution for LP relaxation

MIP_FIXINIT_ITRLIM (integer): iteration limit of the LP solved after fixing integer variables to their initial values ↵

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

Default: -1

MIP_FP_HEU_MODE (integer): specifies the feasibility-pump (FP) heuristic mode ↵

Default: 0

value meaning

0 FP is disabled

1 Solver decides

2 Enable FP if no cutoff value or initial mip solution was defined

3 Enable FP independent of cutoff values and initial mip solutions

4 Same as 2 but also enable FP on child nodes in branch-bound tree

5 Same as 3 but also enable FP on child nodes in branch-bound tree

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

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

Default: 500

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

Controls the mode for the feasibility pump heuristic.

Default: -1

value meaning

-1 Solver decides

0 Off

1 On until the first solution

2 Try to get more than one solution

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

This specifies optimization and reoptimization method for feasibility pump heuristic.

Default: 0

value meaning

0 Solver decides

1 Primal simplex

2 Dual simplex

3 Barrier

MIP_FP_PROJECTION (integer): type of objective function of LPs in projection step of the feasibility pump heuristic ↵

Range: {0, ..., 1}

Default: 0

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

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

Default: 1800

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

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

Range: [0, 1]

Default: 1

MIP_GENERAL_MODE (integer): general strategy in solving MIPs ↵

This value specifies the general strategy in solving MIPs.

Default: 0

value meaning

0 Solver decides

+2 Disable all time-driven events for reproducibility of runs

+16 Disable cut generation before branching

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

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

Default: 3

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

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

Default: 0

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

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

Default: 0

value meaning

0 Off

1 On

MIP_HEU_MODE (integer): heuristic used in MIP solver ↵

This controls the MIP heuristic mode.

Default: 0

value meaning

0 Solver decides when to stop the heuristic

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

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

MIP_INTTOL (real): absolute integer feasibility tolerance ↵

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

Default: 1e-6

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

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

Range: [-1, ∞]

Default: infinity

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

Default: 0

value meaning

0 No

1 Yes

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

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

Default: 1

value meaning

0 Do not keep LP bases in memory

1 Keep LP bases in memory

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

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

Default: 10000

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

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

Default: -1

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

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

Default: 10

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

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

Default: 200

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

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

Default: 2

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

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

Default: 3

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

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

Default: 1

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

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

Default: 0

MIP_NODESELRULE (integer): specifies the node selection rule ↵

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

Default: 0

value meaning

0 Solver decides

1 Depth first search

2 Choose node with worst bound

3 Choose node with best bound

4 Start with best bound

5 Choose the node with the best estimate

6 Same as 4 but start with the best estimate

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

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

Range: {1, ..., ∞}

Default: 1

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

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

Default: 1

value meaning

0 Off

1 On

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

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

Default: 0

value meaning

0 Terminate when all threads finish

1 Terminate as soon as the master thread finishes

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

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

Range: [-1, ∞]

Default: -1

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

This is a flag for iteration mode in MIP parallelization.

Default: 1

value meaning

0 Each thread terminates as soon as arrives iteration limit

1 Each thread terminates until all threads get iteration limit

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

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

Default: 2.0

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

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

Default: 1

value meaning

0 Off

1 On

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

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

Default: 1e-5

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

This is the flag for wether to use Persective Reformulation.

Default: 1

value meaning

0 Off

1 On

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

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

Range: [0.01, 0.99]

Default: 0.6

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

This value specifies the maximum number of branches to polish.

Default: 2000

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

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

Default: 4000

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

Limit for the variable visit in depth first enumeration.

Default: 200

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

The heuristic level for the prerelax solver.

Default: 0

value meaning

0 Nothing

1 One-change

2 One-change and two-change

3 Depth first enumeration

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

Iteration limit for the two change heuristic.

Default: 30000000

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

The sequence of the variable considered by the prerelax heuristic.

Default: -1

value meaning

-1 Backward

1 Forward

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

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

Default: 3070

value meaning

+2 Simple pre-solving

+4 Probing

+8 Coefficient reduction

+16 Elimination

+32 Dual reductions

+64 Use dual information

+128 Binary row presolving

+256 Row aggregation

+512 Coef Probe Lifting

+1024 Maximum pass

+2048 Similar row

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

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

Default: 1214

value meaning

+2 Simple pre-solving

+4 Probing

+8 Coefficient reduction

+16 Elimination

+32 Dual reductions

+64 Use dual information

+128 Binary row presolving

+256 Row aggregation

+512 Coef Probe Lifting

+1024 Maximum pass

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

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

Default: 100

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

This specifies the rule in pseudocost computations for variable selection.

Default: 0

value meaning

0 Solver decides

1 Only use min pseudo cost

2 Only use max pseudo cost

3 Use quadratic score function and the pseudo cost weigth

4 Same as 3 without quadratic score

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

This specifies the weight in pseudocost computations for variable selection.

Default: 1.5625e-05

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

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

Default: 0.9

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

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

Default: 0.9

MIP_RELINTTOL (real): relative integer feasibility tolerance ↵

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

Default: 8e-6

MIP_RELOPTTOL (real): MIP relative optimality tolerance ↵

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

Default: GAMS OptCR

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

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

Default: 0

value meaning

0 Solver decides

1 Use primal method

2 Use dual simplex

3 Use barrier solver

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

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

Default: 10000

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

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

Default: -1

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

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

Default: 0

value meaning

0 Solver decides

1 Use Branch and Bound only

2 Use Enumeration and Knapsack solver only

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

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

Default: 3

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

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

Default: 10

MIP_SWITCHFAC_SIM_IPM_ITER (integer): specifies the (positive) factor that multiplies the number of constraints to impose an iteration limit to simplex method and trigger a switch over to the barrier method ↵

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

Default: -1

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

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

Range: [-1, ∞]

Default: -1

MIP_SYMMETRY_MODE (integer): specifies mip symmetry handling methods ↵

Default: 0

value meaning

0 Do not use symmetries

1 Adding symmetry breaking cuts

2 Orbital fixing

MIP_SYMMETRY_NONZ (integer): limit on number of nonzeros to look for symmetries ↵

Range: {0, ..., ∞}

Default: 50000

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

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

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

Default: GAMS ResLim

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

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

Default: 0

value meaning

0 Solver decides

1 Use primal method

2 Use dual simplex

3 Use barrier solver

MIP_TREEREORDERLEVEL (integer): tree reordering level ↵

This specifies the tree reordering level.

Default: 10

MIP_TREEREORDERMODE (integer): tree reordering mode ↵

This specifies the tree reordering mode.

Default: 1

value meaning

1 Use tree reordering only for subproblems

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

3 Not use tree reordering

4 Use tree reordering based on MIP_TREEREORDERLEVEL

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

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

Default: 1

value meaning

0 Do not use current cutoff value

1 Use current cutoff value

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

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

Default: -1

value meaning

-1 Solver decides

0 Do not use cut heuristic

1 Use cut heuristic

MIP_USE_ENUM_HEU (integer): frequency of enumeration heuristic ↵

This specifies the frequency of enumeration heuristic.

Default: 4

value meaning

0 Off

1 Only at top (root) node without cuts

2 Both at top (root) and tree nodes without cuts

3 Same as 1 with cuts

4 Same as 2 with cuts

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

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

Default: 0

value meaning

0 Do not base MIP calculations on MIP_INTTOL

1 Base MIP calculations on MIP_INTTOL

MULTITHREAD_MODE (integer): threading mode ↵

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

Default: -1

value meaning

-1 Solver decides

1 Try parallel mode but if it is not available try concurrent mode

2 Try parallel mode only

3 Try concurrent mode but if it is not available try parallel mode

4 Try concurrent mode only

NLP_AUTODERIV (integer): defining type of computing derivatives ↵

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

Default: 0

value meaning

0 Finite Differences approach will be used

1 Forward type of Automatic Differentiation will be used

2 Backward type of Automatic Differentiation will be used

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

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

Default: 0

value meaning

0 Do not use Second Order Automatic Differentiation

1 Use Second Order Automatic Differentiation

NLP_CONIC_REFORM (integer): determines if to explore conic reformulation ↵

Default: 1

value meaning

0 No

1 Yes

NLP_CONOPT_VER (integer): specifies the CONOPT version to be used in NLP optimizations ↵

Range: {3, ..., 4}

Default: 3

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

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

Range: [-1e30, ∞]

Default: -1e30

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

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

Default: 0

value meaning

0 The solver decides

1 Use forward differencing method

2 Use backward differencing method

3 Use center differencing method

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

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

Default: 1

value meaning

0 Perform no action accept the final solution

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

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

NLP_FEASTOL (real): feasibility tolerance for nonlinear constraints ↵

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

Default: 1e-6

NLP_INF (real): numeric infinity for nonlinear models ↵

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

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

Default: 1e30

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

Default: 1

value meaning

0 Do not switch

1 Switch

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

Number of nonlinear iterations to elapse before next progress message.

Range: {1, ..., ∞}

Default: 10

NLP_ITRLMT (integer): nonlinear iteration limit ↵

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

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

Default: GAMS IterLim

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

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

Default: -1

value meaning

-1 Solver decides

0 No linearization occurs

1 Linearize ABS, MAX, MIN and similar

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

4 Same as previoys plus Nonlinear operators involving integer/binary variables

256 Same as previous plus DIVIDE reformulation

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

Default: 0

value meaning

0 No

1 Yes

NLP_MAXLOCALSEARCH (integer): maximum number of local searches ↵

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

Default: 5

NLP_MAXLOCALSEARCH_TREE (integer): maximum number of multistarts ↵

Maximum number of multistarts (at tree nodes)

Default: 1

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

Maximum number refinement retries to purify the final NLP solution.

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

Default: 5

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

Euclidean distance threshold in multistart search

Default: 0.001

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

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

Default: -1

value meaning

-1 Solver decides

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

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

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

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

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

Maximum number of consecutive populations to generate without any improvements.

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

Default: -1

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

Maximum number of populations to generate in multistart search.

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

Default: -1

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

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

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

Default: -1

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

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

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

Default: 2

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

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

Default: 1

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

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

Range: [0.0, 1.0]

Default: 0.1

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

Penalty function neighborhood threshold in multistart search

Default: 0.01

NLP_MSW_PREPMODE (integer): preprocessing strategies in multistart solver ↵

This value specifies the preprocessing strategies in multistart solver.

Default: -1

value meaning

-1 Solver decides

+1 Truncate free variables

+2 Scale reference points to origin

+4 Enable expansive scaling of radius[k] by hit[k]

+8 Skewed sampling allowing values in the vicinity of origin.

+16 Get best bounds by presolver

+32 Get best bounds using GOP

+64 Enable sampling of free variables (not recommended)

+128 Collect sufficiently many trial points prior to local solves

+256 Enable power solver, trying several different local strategies

+512 Share presolver stack for large models

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_RMAPMODE (integer): specifies the mode to map reference points in the unit cube into the original space ↵

Default: -1

value meaning

-1 Solver decides

0 Use original variable bounds

1 Use min-max values over all sample points per each dimension

2 Use min-max values over all sample points over all dimensions

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

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

Default: 0

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

KKT solution neighborhood factor in multistart search

Default: 0.85

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

Initial solution neighborhood factor in multistart search

Default: 0.5

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

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

Default: 126

value meaning

+2 Simple pre-solving

+4 Probing

+8 Coefficient reduction

+16 Elimination

+32 Dual reductions

+64 Use dual information

+512 Maximum pass

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

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

Default: 5e-7

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

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

Default: 1

value meaning

0 Do not check if NLP is quadratic

1 Check if NLP is quadratic

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

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

Default: 1e-7

NLP_SOLVER (integer): type of nonlinear solver ↵

This value determines the type of nonlinear solver.

Default: 7

value meaning

4 Solver decides

5 Uses Levenberg-Marquardt method to solve nonlinear least-squares problem

6 Uses Barrier solver for convex QCP models

7 Uses CONOPTs reduced gradient solver

8 Uses SLP solver

9 Uses CONOPT with multistart feature enabled

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

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

Default: 0

value meaning

0 NLP will not be solved as LP

1 NLP will be solved as LP

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

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

Default: 100

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

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

Default: 1

value meaning

0 Do not use initial starting solution for NLP

1 Use initial starting solution for NLP

NLP_SUBSOLVER (integer): type of nonlinear subsolver ↵

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

Default: 1

value meaning

1 Primal simplex method

2 Dual simplex method

3 Barrier solver with or without crossover

NLP_USECUTOFFOBJ (integer): flag to use parameter NLP_CUTOFFOBJ ↵

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

Default: 0

value meaning

-1 Solver decides

0 No

1 Yes

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

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

Default: 0

value meaning

0 Do not use simple crash routines

1 Use simple crash routines

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

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

Default: 1

value meaning

0 Do not use advanced crash routines

1 Use advanced crash routines

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

Default: 1

value meaning

0 No

1 Yes

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

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

Default: 1

value meaning

0 Do not use selective constraint evaluations

1 Use selective constraint evaluations

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

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

Default: 1

value meaning

-1 Solver decides

0 Do not use sequential linear programming step directions

1 Use sequential linear programming step directions

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

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

Default: 0

value meaning

0 Do not use steepest edge directions

1 Use steepest edge directions

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

Synonym: gthreads

Number of threads to use in the solver routine to be called. It is a solver-independent parameter which internally sets solver-specific threading parameters automatically. If the GAMS threads parameter is set to 0, the Lindo default will be used, which is 1.

Range: {1, ..., ∞}

Default: GAMS Threads

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

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

Default: 0

value meaning

0 Solver decides

1 Explicit primal form

2 Explicit dual form

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

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

Default: 0

value meaning

0 Profiler is off

+1 Enable for simplex solver

+2 Enable for integer solver

+4 Enable for multistart solver

+8 Enable for global solver

READPARAMS (string): read Lindo parameter file ↵

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

Default: 0

SAMP_CDSINC (real): correlation matrix diagonal shift increment ↵

Correlation matrix diagonal shift increment.

Default: 1e-6

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

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

Default: 1e-30

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

Flag to enable/disable sparse mode in NCM computations.

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

Default: -1

SAMP_NCM_ITERLIM (integer): iteration limit for NCM method ↵

Iteration limit for NCM method.

Default: 100

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

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

Default: 5

SAMP_NCM_OPTTOL (real): optimality tolerance for NCM method ↵

Optimality tolerance for NCM method.

Default: 1e-7

SAMP_NUM_THREADS (integer): specifies the number of parallel threads to be used when sampling ↵

Default: 0

SAMP_RG_BUFFER_SIZE (integer): specifies the buffer size for random number generators in running in parallel mode ↵

Default: 0

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

Flag to enable scaling of raw sample data.

Default: 0

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

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

Default: 0

value meaning

0 no concurrent runs

1 run concurrently if at least 2 threads exist

2 run concurrently

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

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

Default: 0

SOLVER_FEASTOL (real): feasibility tolerance ↵

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

Default: 1e-7

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

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

Default: 0

value meaning

0 Perform crossover to basis solution

1 Leave barrier solution intact

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

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

Default: 0

value meaning

0 Return appropriate status if infeasibility is encountered

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

SOLVER_METHOD (integer): specifies the method to use when generic solver is invoked ↵

Default: 0

value meaning

0 FREE

1 PSIMPLEX

2 DSIMPLEX

3 BARRIER

4 NLP

5 MIP

6 MULTIS

7 GOP

8 IIS

9 IUS

10 SBD

11 SPRINT

12 GA

SOLVER_MODE (integer): controls some of the advanced strategies when solving LPs ↵

Default: 1

value meaning

+1 Add distinct basic solutions to the pool of alternate optimal solutions

+2 Add edge/nonbasic solutions to the pool of alternate optimal solutions

+4 Favor basic solutions with integer values when choosing solutions to add to the pool of alternate optimal solutions

+32 Export each lex-model

+64 Export failed lex-model when numerical issues are encountered

+128 Resolve failed lex-model with presolver off

+256 Eliminate all dependent variables from the formulation by substitution

SOLVER_OPTTOL (real): dual feasibility tolerance ↵

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

Default: 1e-7

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

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

Default: 1000

SOLVER_RESTART (integer): starting basis flag ↵

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

Default: 0

value meaning

0 Perform cold start

1 Perform warm start

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

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

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

Default: GAMS ResLim

SOLVER_USECUTOFFVAL (integer): flag for using cutoff value ↵

This is a flag for the parameter SOLVER_CUTOFFVAL

Default: 0

value meaning

0 Do not use cutoff value

1 Use cutoff value

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

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

Default: -1

value meaning

-1 Solver decides the dual pricing method

0 Partial pricing

1 Steepest edge

SPLEX_DUAL_PHASE (integer): controls the dual simplex strategy ↵

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

Default: 0

value meaning

0 Solver decides

1 Single-phase

2 Two-phase

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

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

Default: -1

value meaning

-1 Solver decides the primal pricing method

0 Partial pricing

1 Devex

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

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

Default: 100

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

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

Default: GAMS OptCA

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

Flag to use add-instructions mode when building deteq.

Default: 0

STOC_ALD_DUAL_FEASTOL (real): dual feasibility tolerance for ALD ↵

Dual feasibility tolerance for ALD.

Default: 1e-4

STOC_ALD_DUAL_STEPLEN (real): dual step length for ALD ↵

Dual step length for ALD.

Default: 0.9

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

Inner loop iteration limit for ALD.

Default: 1000

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

Outer loop iteration limit for ALD.

Default: 200

STOC_ALD_PRIMAL_FEASTOL (real): primal feasibility tolerance for ALD ↵

Primal feasibility tolerance for ALD.

Default: 1e-4

STOC_ALD_PRIMAL_STEPLEN (real): primal step length for ALD ↵

Primal step length for ALD.

Default: 0.5

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

Flag to enable or disable autoaggregation.

Default: 1

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

Benchmark scenario to compare EVPI and EVMU against.

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

Default: -2

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

Big-M value for linearization and penalty functions.

Default: 1e7

STOC_BUCKET_SIZE (integer): bucket size in Benders decomposition ↵

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

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

Default: -1

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

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

Default: 1

value meaning

0 disable

1 enable

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

Correlation type associated with the correlation matrix.

Default: 0

value meaning

-1 Target correlation

0 Pearson correlation

1 Kendall correlation

2 Spearman correlation

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

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

Default: 0

value meaning

0 Solver decides

10 Use simple Benders Decomposition

STOC_DETEQ_TYPE (integer): type of deterministic equivalent ↵

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

Default: -1

value meaning

-1 Solver decides

0 Implicit determinisitc equivalent

1 Explicit determinisitc equivalent

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

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

Default: -1

value meaning

-1 Solver decides

0 Perform heuristic search in the original solution space

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

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

Flag to enable elimination of fixed variables from deteq MPI.

Default: 1

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

Value to truncate infinite bounds at nonleaf nodes.

Default: 1e9

STOC_ITER_LIM (integer): iteration limit for stochastic solver ↵

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

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

Default: infinity

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

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

Default: 0

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

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

Default: 40000

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

Stochastic optimization method to solve the model.

Default: -1

value meaning

-1 Solve with the method chosen by the solver

0 Solve the deterministic equivalent (DETEQ)

1 Solve with the Nested Benders Decomposition (NBD) method

STOC_NAMEDATA_LEVEL (integer): name data level ↵

Name data level.

Default: 1

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

Presolve level solving node-models.

Default: 0

value meaning

+2 Simple pre-solving

+4 Probing

+8 Coefficient reduction

+16 Elimination

+32 Dual reductions

+64 Use dual information

+512 Maximum pass

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

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

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

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

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

Default: -1

STOC_NSAMPLE_STAGE (integer): common sample size per stage ↵

Common sample size per stage.

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

Default: -1

STOC_NUM_THREADS (integer): number of parallel threads ↵

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

Default: 1

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

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

Default: GAMS OptCR

STOC_REL_DSTEPTOL (real): dual-step tolerance ↵

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

Default: 1e-7

STOC_REL_PSTEPTOL (real): primal-step tolerance ↵

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

Default: 1e-8

STOC_REOPT (integer): reoptimization method to solve the node-models ↵

Reoptimization method to solve the node-models.

Default: 0

value meaning

0 Solver decides

1 Use primal method

2 Use dual simplex

3 Use barrier solver

4 Use NLP solver

STOC_RG_SEED (integer): seed to initialize the random number generator ↵

Seed to initialize the random number generator. Possible values are positive integers.

Default: 1031

STOC_SAMP_CONT_ONLY (integer): flag to restrict sampling to continuous stochastic parameters only or not ↵

Flag to restrict sampling to continuous stochastic parameters only or not.

Default: 1

value meaning

0 disable

1 enable

STOC_SBD_MAXCUTS (integer): max cuts to generate for master problem ↵

Max cuts to generate for master problem.

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

Default: -1

STOC_SBD_NUMCANDID (integer): maximum number of candidate solutions to generate at SBD root ↵

Maximum number of candidate solutions to generate at SBD root.

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

Default: -1

STOC_SBD_OBJCUTFLAG (integer): flag to enable objective cut in SBD master problem ↵

Flag to enable objective cut in SBD master problem.

Default: 1

STOC_SBD_OBJCUTVAL (real): RHS value of objective cut in SBD master problem ↵

RHS value of objective cut in SBD master problem.

Default: 1e-30

STOC_SHARE_BEGSTAGE (integer): stage beyond which node-models are shared ↵

Stage beyond which node-models share the same model structure. Possible values are positive integers less than or equal to number of stages in the model or (-1) for solver decides.

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

Default: -1

STOC_TIME_LIM (real): time limit for stochastic solver ↵

Time limit for stochastic solver. Possible values are nonnegative real numbers or -1 for solver decides.

Range: [-1, ∞]

Default: GAMS ResLim

STOC_TOPOPT (integer): optimization method to solve the root problem ↵

Optimization method to solve the root problem.

Default: 0

value meaning

0 Solver decides

1 Use primal method

2 Use dual simplex

3 Use barrier solver

4 Use NLP solver

6 Use multi-start solver

7 Use global solver

STOC_VARCONTROL_METHOD (integer): sampling method for variance reduction ↵

Sampling method for variance reduction.

Default: 1

value meaning

0 Montecarlo sampling

1 Latinsquare sampling

2 Antithetic sampling

STOC_WSBAS (integer): warm start basis for wait-see model ↵

Warm start basis for wait-see model .

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

Default: -1

SVR_LS_ANTITHETIC (string): Sample variance reduction map to Lindo Antithetic algorithm ↵

SVR_LS_LATINSQUARE (string): Sample variance reduction map to Lindo Latin Square algorithm ↵

SVR_LS_MONTECARLO (string): Sample variance reduction map to Lindo Montecarlo algorithm ↵

TUNER_PRINT_LEVEL (integer): specifies the amount of print to do during parameter tuning ↵

Default: 1

value meaning

0 Do not print anything default

>0 Print more information

USEGOP (integer): use global optimization ↵

This value determines whether the global optimization will be used.

Default: 1

value meaning

0 Do not use global optimization

1 Use global optimization

WRITEDEMPI (string): write deterministic equivalent in MPI format ↵

WRITEDEMPS (string): write deterministic equivalent in MPS format ↵

WRITEMPI (string): write (S)MPI file of processed model ↵

If this option is set, Lindo write an MPI file of processed model. If set, the value of this option defines the name of the MPI file.

WRITEMPS (string): write (S)MPS file of processed model ↵

Stochastic Programming (SP) in GAMS/Lindo

GAMS/Lindo can also solve stochastic programming models. The syntax to set up an SP problem in GAMS is explained in the chapter Stochastic Programming (SP) with EMP. The options to control LINDOs stochastic solver are described in the subsection SP Options.

value	meaning
`0`	Solver decides which type of decomposition to use
`1`	Solver does not perform any decompositions and uses the original model
`2`	Attempt total decomposition
`3`	Decomposed model will have dual angular structure
`4`	Decomposed model will have block angular structure
`5`	Decomposed model will have both dual and block angular structure

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

value	meaning
`-1`	Solver decides
`0`	Finding orbit only without MIP preprocessing
`1`	Finding orbit only with MIP preprocessing
`2`	Finding generators without MIP preprocessing
`3`	Finding generators with MIP preprocessing
`4`	Finding the first generator without MIP preprocessing
`5`	Finding the first generator with MIP preprocessing

value	meaning
`0`	Nothing printed
`+2`	General information
`+4`	Time information
`+8`	Orbit information
`+16`	Partition information

value	meaning
`+2`	Rearrange and collect terms
`+4`	Expand all parentheses
`+8`	Retain nonlinear functions
`+16`	Selectively expand parentheses

value	meaning
`0`	Absolute width
`1`	Locally relative width
`2`	Globally relative width
`3`	Globally relative distance from the convex minimum to the bounds
`4`	Absolute violation between the function and its convex envelope at the convex minimum
`5`	Relative violation between the function and its convex envelope at the convex minimum

value	meaning
`0`	No limit
`1`	Time based limit
`2`	Iteration based limit
`3`	Both time and iteration based limit

value	meaning
`0`	Exploit lineariable model
`1`	Do not exploit lineariable model

value	meaning
`0`	The maximum width criterion is suppressed
`1`	The maximum width criterion is performed

value	meaning
`0`	Global search for a feasible solution (thus a feasibility certificate)
`1`	Global search for an optimal solution
`2`	Global search for an unboundedness certificate

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

value	meaning
`-1`	Solver decides
`0`	General GOP solver
`1`	Specified QP solver

value	meaning
`+2`	Use smaller optimality or feasibility tolerances and appropriate presolving options
`+4`	Apply interval arithmetic to reverify the solution feasibility

value	meaning
`0`	Do not substitute out fixed variables
`1`	Substitute out fixed variables

value	meaning
`0`	Do not use the bound limit on the variables
`1`	Use the bound limit right at the beginning of global optimization
`2`	Use the bound limit after the initial local optimization if selected

value	meaning
`+1`	Search for necessary rows
`+2`	Search for necessary columns
`+4`	Search for sufficient rows
`+8`	Search for sufficient columns
`+16`	Consider integrality restrictions as the potential cause of infeasibilities and include it in the analysis
`+32`	Compute the underlying LTF matrix and use this as the basis of a ranking score to guide the IIS run
`+64`	If the underlying matrix is totally decomposable, rank blocks w.r.t their sizes and debug the smallest independent infeasible block
`+128`	Use the nonzero structure of the underlying matrix to compute a ranking score to guide the IIS run
`+256`	Treat iter/time limits as intractability

value	meaning
`0`	Default filter
`1`	Standard deletion filter
`2`	Standard additive filter
`3`	Generalized-binary-search filter
`4`	Depth-first-binary-search filter
`5`	Fast-scan filter
`6`	Standard elastic filter

value	meaning
`-1`	Solver decides
`0`	Do not use elastic filter
`1`	Use elastic filter

value	meaning
`-1`	Solver decides
`0`	Do not use sensitivity filter
`1`	Use sensitivity filter

value	meaning
`-1`	Solver decides
`0`	Substitutions will not be performed
`1`	Substitutions will be performed

Table of Contents

Introduction

Licensing and software requirements

Running GAMS/LINDO

Supported nonlinear functions

Diagnosis of Infeasible or Unbounded Models

Infeasible Models

Unbounded Linear Programs

GAMS/LINDO output

The GAMS/LINDO Options

GAMS/LINDO Options File

Summary of GAMS/Lindo Options

General Options

LP Options

IPM Options

MIP Options

NLP Options

Global Options

SP Options

IIS and IUS Options

Link Options

Detailed Descriptions of GAMS/Lindo Options

Stochastic Programming (SP) in GAMS/Lindo

value	meaning
`-1`	Check convexity only without solving the model
`0`	Use barrier solver to check convexity
`1`	Do not use barrier solver to check convexity

value	meaning
`+2`	Simple pre-solving
`+4`	Probing
`+8`	Coefficient reduction
`+16`	Elimination
`+32`	Dual reductions
`+64`	Use dual information
`+512`	Maximum pass

value	meaning
`0`	Solver decides
`1`	Always branch up first
`2`	Always branch down first

value	meaning
`0`	Solver decides
`1`	Basis rounding with pseudo reduced costs
`2`	Maximum infeasibility
`3`	Pseudo reduced costs only
`4`	Maximum coefficient only
`5`	Previous branching only

value	meaning
`0`	If the user has specified priorities then use them Otherwise let LINDO API decide
`1`	If user has specified priorities then use them Overwrite users choices if necessary
`2`	If user has specified priorities then use them Otherwise do not use any priorities
`3`	Let LINDO API set the priorities and ignore any user specified priorities
`4`	Binaries always have higher priority over general integers

value	meaning
`0`	no concurrent runs
`1`	run concurrently if at least 2 threads exist
`2`	run concurrently

value	meaning
`-1`	Solver decides
`1`	Defines built-in priority lists for each thread
`3`	Defines heuristic based strategies for each thread

value	meaning
`+2`	GUB cover
`+4`	Flow cover
`+8`	Lifting
`+16`	Plant location
`+32`	Disaggregation
`+64`	Knapsack cover
`+128`	Lattice
`+256`	Gomory
`+512`	Coefficient reduction
`+1024`	GCD
`+2048`	Obj integrality
`+4096`	Basis Cuts
`+8192`	Cardinality Cuts
`+16384`	Disjunk Cuts
`+32768`	Soft Knapsack Cuts

value	meaning
`0`	Do not calculate dual solution for LP relaxation
`1`	Calculate dual solution for LP relaxation

value	meaning
`0`	FP is disabled
`1`	Solver decides
`2`	Enable FP if no cutoff value or initial mip solution was defined
`3`	Enable FP independent of cutoff values and initial mip solutions
`4`	Same as 2 but also enable FP on child nodes in branch-bound tree
`5`	Same as 3 but also enable FP on child nodes in branch-bound tree