ODHCPLEX

Introduction

GAMS/ODHCPLEX is a solver from Optimization Direct Inc. that implements a set of heuristic methods (named ODHeuristics) for finding feasible solutions to Mixed Integer Programming (MIP and MIQCP) models that uses IBM CPLEX as its underlying solver engine. It is designed for large-scale models which a MIP solver would find intractable: either by it being unable to find feasible solutions at all or; more usually, by being unable to find feasible solutions of adequate quality in the time available to its user.

It is intended for users who are familiar with MIP modelling and have some knowledge of using the GAMS/CPLEX solver. GAMS/ODHCPLEX does not demand expert specialism in this field.

ODHCPLEX can be used in two ways: it is implemented as a stand-alone ODHeuristic engine, which can be used on its own (ODHeuristicMethod=STANDALONE); and also within the CPLEX optimizer, within which it can supply and receive solutions from the main CPLEX caller (ODHeuristicMethod=ODH-CPLEX (default)) thereby accelerating optimization compared with GAMS/CPLEX run on its own.

The ODHeuristic engine has a heuristic method for finding an initial feasible solution that it designed to complement, those of CPLEX. Since its main algorithmic procedure works by improving an incumbent feasible solution, getting an initial one is important and may consume a significant part of its total runtime. When used on its own (i.e. ODHeuristicMethod=STANDALONE), users should experiment to discover whether ODHeuristics' or CPLEX's initial feasible solution methods work best, but within ODH-CPLEX (i.e. ODHeuristicMethod=ODH-CPLEX) both methods are run in parallel and the winner is chosen automatically.

ODHeuristics' principal algorithm works by solving a sequence of sub-models. An innovative aspect of this process is its ability to use the model's symbolic structure to achieve the sub-model decomposition. It does this by analyzing the symbolic names that the user gives to the decision variables and careful specification of how this should be done this is worthwhile. ODHCPLEX can work without this analysis, but it usually takes about twice as much runtime.

Specifying Model Structure

The ODHeuristic method needs to break the model down into sub-models. It can do this in one of three ways:

  1. Automatically using its decomposition heuristic;
  2. Using information specified by the user in the IndexKey parameter;
  3. By simply assigning each variable to a different block (or key); or
  4. By using the dot option notatation with the option .key.

By default, the program will use information specified by the IndexKey parameter if it is set and its automatic decomposition heuristic otherwise. This may be overridden by the Decomposition parameter. If it is set to 0 (zero), option 3 above is selected. If it is set to 1, its automatic decomposition method is used, and if it is set to 2, option 4 above is selected.

Whilst the automatic decomposition method often works well, there may be an advantage to specifying decomposition through the IndexKey parameter. After performing the decomposition in whatever way, the program analyses the decomposition and displays statistics showing the maximum and minimum number of variables in each key or block and showing a percentage score to the decomposition as a whole. A typical display is of the form:

Variables/key 205.58 (+/-304.79), max/min variables/key 933(32) / 60(113).
There are 227 keys (4149 keys were dropped) with 46872 values.
Decomposition score 13.66%, graph score 2074/3135232.

Other things (such as the distribution of variables in keys and the number of keys) being equal, the smaller the percentage decomposition score, the better the decomposition is and the more effective the program will be.

Using the IndexKey parameter

The program needs to associate sets of variables with distinct values of a single index. The user can specify this association with a pattern to which some or all of the variables conform. The pattern is in standard C scanf format (see, for example, Kernighan and Ritchie's 2nd edition of The C Programming Language, section B1.3 Formatted Input). Currently allowable index values must be non-negative integers, so the pattern must include d. For example, if we have variables x whose first index names starts with a number of letters then an underscore followed by a numeric index value (like x(firstone_1), x(another_1), x(firstone_2), x(another_2), ..) the pattern

x(%*[a-z]_%d)

associates those variables whose name ends in _1 with index value 1, those whose name ends in _2 with index value 2 and so on. The pattern is called an index key referred to by the program as the option parameter IndexKey, for example

IndexKey=%*[xy](t_%d)

It may, however, be desirable to consider variables whose names are, say, x(t_2) and y(t_2), to belong to different index values, i.e. to belong to different groups. One way of doing this is to identify them with separate index keys. These can be supplied to IndexKey as two fields separated by a semi-colon, for example

IndexKey=x(t_%d);y(t_%d)

Up to 10 fields can be specified in this way.

On the other hand, it may be desirable to consider such variables as having the same index key and their nomenclature may not permit their identification by a single key field. For example, suppose there are variables john(t_1), john(t_2),.., jane(t_1), jane(t_2),.. and johnny(t_1), johnny(t_2),.. and we want to associate john(t_x) and jane(t_x) as belonging to key value x, but want to ignore johnny(t_x).

Two key fields can be used to do this by

INDEXKEY=john(t_%d);jane(t_%d)

By default john(t_2) and jane(t_2) would not share the same index value, but if the option parameter KeyType, is set to 1, the heuristic will group them together so as to share the same index.

If IndexKey is not specified, the program uses a default decomposition.

The program divides the model up into parts associated with different values of the IndexKey (if specified), using an integer interval divisor. Initially this is a number not less than 2 and it is increased as the search progresses. When no improved solution is found after a number, MaxRepeat, of attempts with the maximum interval divisor, MaxInterDiv, the program terminates. Default values are provided for MaxRepeat and MaxInterDiv, so these do not have to be specified by the user.

Heuristic Parameters

There are a number of other parameters which control the behaviour of the heuristic program. These may be left at their default values or specified on the GAMS/ODHCPLEX option file. In addition, many GAMS/CPLEX options can be supplied in the GAMS/ODHCPLEX option file to tweak the CPLEX behavior, see tables below. Note however that - although they can be technically set - these GAMS/CPLEX options may not have any influence on a GAMS/ODHCPLEX solve. For detailed descriptions of the GAMS/CPLEX options, see Detailed Descriptions of CPLEX Options.

Parameter names and their meanings are summarized in the table below.

GAMS/ODHCPLEX: General Options

Option Description Default
cpxpresolve Applies CPLEX presolve to full model 0
decompdensity Matrix density above which automatic decomposition assigns each variable to a separate key 0.3
decomposition Model decomposition method. -1
deterministic Specifies whether the solution improvement heuristic is run in deterministic or opportunistic (i.e. non-deterministic) mode 1
divisor Initial divisor for sub models automatic
dynamicsearch Search strategy for CPLEX caller and sub-model solves -1
extracplexlog Write addition CPLEX output to log 0
feastol Feasibility tolerance 1e-6
firstfeas Use first feasible heuristic for finding an initial feasible solution -1
firstfeascontinue Whether first feasible heuristic continues when it achieves feasibility 0
firstfeaseffort Effort limit on first feasible heuristic -500
firstfeasshift First feasible heuristic variable shifting in found solutions 1
globalbounds Use of global bounds from CPLEX caller 2
indexkey Pattern used to match variable names for grouping into sub-models discussed above
integeronly Variables to include in INDEXKEY -1
integertol Integrality tolerance for variable values 1e-5
interdiv Initial divisor value 4
.key Variable block or key number 0
keytype Treatment of multiple INDEXKEYs 0
maxbacktrack The maximum number of backtracks permitted in sub-model solves -1
maxbound The largest(smallest) non infinite bound value ODH will accept for upper(lower) bounds 1e+9
maxinfrepeat Maximum divisor value when solution is infeasible 0
maxinterdiv Maximum divisor value 0
maxrepeat Maximum number of sub-model repeat solves for each divisor value 0
newcallback CPLEX call-back type used 1
objtarget Target objective value 0
odheuristicmethod ODHeuristic method section ODH-CPLEX
odhfeasopt Optimization method for sub-models in phaseI 0
odhpresolve Indicator for the ODHeuristics engine using a separate presolve within ODH-CPLEX 1
odhthreads The number of heuristic threads used by ODH-CPLEX or STANDALONE -1
odhtimelimit Elapsed time limit in seconds GAMS ResLim
penalty The objective function coefficient value for penalties -1
penperturb Perturbation tolerance for penalties coefficients 0
phase12 Specifies whether to use a phaseI/phaseII method to remove infeasibilities 1
processorlock Thread allocation 0
quickfirstsolve Accelerate initial CPLEX solve 0
recurse Recurse using heuristic to solve sub-models when a feasible solution has been obtained 0
recursedecomp Recursed model decomposition method 0
recurseiterlim Recursed heuristic iteration limit for sub-solves 40
recurselog Write thread log files for recursed sub-solves 0
recurseminiterlim Recursed heuristic minimum iterations before a solution is found in sub-solves 0
recursesoliterlim Recursed heuristic sub-solves quit after these iterations if a solution is found maxint
rejectinfsol Reject infeasible solutions to sub-models 2
relaxsos2 Treatment of SOS2 members 1
seed Initial random number seed 1234
strategy ODH-Cplex Strategy 1
subnodelimit Node limit for submodel searches -1
suborder Use of priority order in sub-solves 1
subpresolve Use of CPLEX presolve in sub-solves 1
sub_cpx_threads Threads availble for the solves within ODHeuristic 1
syncfreq Thread synchronization frequency in deterministic parallel mode 1
threadlog Write thread log files 0
threadzerosync Which CPLEX threads to use for synchronization 0
variableclean Clean variable values from sub-models 0
zerotol Zero tolerance for variable values 1e-9

GAMS/CPLEX: Preprocessing and General Options

Option Description Default
advind advanced basis use 1
aggfill aggregator fill parameter 10
aggind aggregator on/off -1
calcqcpduals calculate the dual values of a quadratically constrained problem 1
clocktype clock type for computation time 2
coeredind coefficient reduction on/off -1
cpumask switch and mask to bind threads to processors (Linux only) auto
cutoff GMO cutoff 0.0
datacheck controls data consistency checking and modeling assistance 0
depind dependency checker on/off -1
dettilim deterministic time limit 1.0e+75
domlim domain violation number 0
eprelax relaxation for feasOpt 1.0e-06
feasoptmode mode of FeasOpt 0
fixoptfile name of option file which is read just before solving the fixed problem
folding LP folding will be attempted during the preprocessing phase -1
freegamsmodel preserves memory by dumping the GAMS model instance representation temporarily to disk 0
indicoptstrict abort in case of an error in indicator constraint in solver option file 1
lpmethod algorithm to be used for LP problems 0
memoryemphasis reduces use of memory 0
multobjdisplay level of display during multiobjective optimization 1
names load GAMS names into Cplex 1
numericalemphasis emphasizes precision in numerically unstable or difficult problems 0
optimalitytarget type of optimality that Cplex targets 0
parallelmode parallel optimization mode 0
paramdisplay display the nondefault parameters before optimization 1
predual give dual problem to the optimizer 0
preind turn presolver on/off 1
prelinear linear reduction indicator 1
prepass number of presolve applications to perform -1
prereform set presolve reformulations 3
printoptions list values of all options to GAMS listing file 0
qextractalg quadratic extraction algorithm in GAMS interface 0
qpmethod algorithm to be used for QP problems 0
qtolin linearization of the quadratic terms in the objective function of a QP or MIQP model -1
randomseed sets the random seed differently for diversity of solutions 202009243
record Records invocations of Callable Library routines 0
reduce primal and dual reduction type 3
relaxfixedinfeas accept small infeasibilties in the solve of the fixed problem 0
relaxpreind presolve for initial relaxation on/off -1
rerun rerun problem if presolve infeasible or unbounded yes
scaind matrix scaling on/off 0
solutiontype type of solution (basic or non basic) for an LP or QP 0
threads global default thread count 0
tilim overrides the GAMS ResLim option 1.0e+75
tryint GMO tryint 0.0
tuningdettilim tuning deterministic time limit per model or suite 1.0e+75
tuningdisplay level of information reported by the tuning tool 1
tuningmeasure measure for evaluating progress for a suite of models 1
tuningrepeat number of times tuning is to be repeated on perturbed versions 1
tuningtilim tuning time limit per model or suite 1.0e+75
usebasis GMO usebasis 0
warninglimit determines how many times warnings of a specific type (datacheck=2) will be displayed 10
workdir directory for working files .
workmem memory available for working storage 2048.0

GAMS/CPLEX: Simplex Algorithmic Options

Option Description Default
conflictalg algorithm CPLEX uses in the conflict refiner to discover a minimal set of conflicting constraints in an infeasible model 0
conflictdisplay decides how much information CPLEX reports when the conflict refiner is working 1
craind crash strategy (used to obtain starting basis) 1
dpriind dual simplex pricing 0
dynamicrows switch for dynamic management of rows -1
epper perturbation constant 1.0e-06
netfind attempt network extraction 2
netppriind network simplex pricing 0
perind force initial perturbation 0
perlim number of stalled iterations before perturbation 0
ppriind primal simplex pricing 0
pricelim pricing candidate list 0
reinv refactorization frequency 0
sifting switch for sifting from simplex optimization 1

GAMS/CPLEX: Simplex Limit Options

Option Description Default
itlim iteration limit 2147483647
netitlim iteration limit for network simplex 2147483647
objllim objective function lower limit -1.0e+75
objulim objective function upper limit 1.0e+75
singlim limit on singularity repairs 10

GAMS/CPLEX: Simplex Tolerance Options

Option Description Default
epmrk Markowitz pivot tolerance 0.01
epopt optimality tolerance 1.0e-06
eprhs feasibility tolerance 1.0e-06
netepopt optimality tolerance for the network simplex method 1.0e-06
neteprhs feasibility tolerance for the network simplex method 1.0e-06

GAMS/CPLEX: Barrier Specific Options

Option Description Default
baralg algorithm selection 0
barcolnz dense column handling 0
barcrossalg barrier crossover method 0
barepcomp convergence tolerance 1.0e-08
bargrowth unbounded face detection 1.0e+12
baritlim iteration limit 2147483647
barmaxcor maximum correction limit -1
barobjrng maximum objective function 1.0e+20
barorder row ordering algorithm selection 0
barqcpepcomp convergence tolerance for the barrier optimizer for QCPs 1.0e-07
barstartalg barrier starting point algorithm 1

GAMS/CPLEX: Sifting Specific Options

Option Description Default
siftalg sifting subproblem algorithm 0
siftitlim limit on sifting iterations 2147483647

GAMS/CPLEX: MIP Algorithmic Options

Option Description Default
bbinterval best bound interval 7
bendersstrategy Benders decomposition algorithm as a strategy 0
bndstrenind bound strengthening -1
bqpcuts boolean quadric polytope cuts for nonconvex QP or MIQP solved to global optimality 0
brdir set branching direction 0
bttol backtracking limit 1.0
cliques clique cut generation 0
covers cover cut generation 0
cutlo lower cutoff for tree search -1.0e+75
cuts default cut generation 0
cutsfactor cut limit -1.0
cutup upper cutoff for tree search 1.0e+75
disjcuts disjunctive cuts generation 0
divetype MIP dive strategy 0
eachcutlim sets a limit for each type of cut 2100000000
flowcovers flow cover cut generation 0
flowpaths flow path cut generation 0
fpheur feasibility pump heuristic 0
fraccuts Gomory fractional cut generation 0
gubcovers GUB cover cut generation 0
heurfreq heuristic frequency 0
heuristiceffort the effort that CPLEX spends on heuristics during a MIP solve 1.0
implbd implied bound cut generation 0
.lazy Lazy constraints activation 0
lazyconstraints Indicator to use lazy constraints 0
lbheur local branching heuristic 0
liftprojcuts lift-and-project cuts 0
localimplied generation of locally valid implied bound cuts 0
mcfcuts multi-commodity flow cut generation 0
mipemphasis MIP solution tactics 0
mipkappastats MIP kappa computation 0
mipordind priority list on/off 1
mipordtype priority order generation 0
mipsearch search strategy for mixed integer programs 0
mipstart use mip starting values 0
miqcpstrat MIQCP relaxation choice 0
mircuts mixed integer rounding cut generation 0
multimipstart use multiple mipstarts provided via gdx files
nodecuts decide whether or not cutting planes are separated at the nodes of the branch-and-bound tree 0
nodefileind node storage file indicator 1
nodesel node selection strategy 1
preslvnd node presolve selector 0
probe perform probing before solving a MIP 0
qpmakepsdind adjust MIQP formulation to make the quadratic matrix positive-semi-definite 1
repeatpresolve reapply presolve at root after preprocessing -1
rinsheur relaxation induced neighborhood search frequency 0
rltcuts Reformulation Linearization Technique (RLT) cuts 0
solvefinal switch to solve the problem with fixed discrete variables 1
sos1reform automatic logarithmic reformulation of special ordered sets of type 1 (SOS1) 0
sos2reform automatic logarithmic reformulation of special ordered sets of type 2 (SOS2) 0
startalg MIP starting algorithm 0
strongcandlim size of the candidates list for strong branching 10
strongitlim limit on iterations per branch for strong branching 0
subalg algorithm for subproblems 0
submipnodelim limit on number of nodes in an RINS subMIP 500
submipscale scale the problem matrix when CPLEX solves a subMIP during MIP optimization 0
submipstartalg starting algorithm for a subMIP of a MIP 0
submipsubalg algorithm for subproblems of a subMIP of a MIP 0
symmetry symmetry breaking cuts -1
varsel variable selection strategy at each node 0
workeralgorithm set method for optimizing benders subproblems 0
zerohalfcuts zero-half cuts 0

GAMS/CPLEX: MIP Limit Options

Option Description Default
aggcutlim aggregation limit for cut generation 3
auxrootthreads number of threads for auxiliary tasks at the root node 0
cutpass maximum number of cutting plane passes 0
fraccand candidate limit for generating Gomory fractional cuts 200
fracpass maximum number of passes for generating Gomory fractional cuts 0
intsollim maximum number of integer solutions 2147483647
nodelim maximum number of nodes to solve 2147483647
polishafterdettime deterministic time before starting to polish a feasible solution 1.0e+75
polishafterepagap absolute MIP gap before starting to polish a feasible solution 0.0
polishafterepgap relative MIP gap before starting to polish a solution 0.0
polishafterintsol MIP integer solutions to find before starting to polish a feasible solution 2147483647
polishafternode nodes to process before starting to polish a feasible solution 2147483647
polishaftertime time before starting to polish a feasible solution 1.0e+75
probedettime deterministic time spent probing 1.0e+75
probetime time spent probing 1.0e+75
repairtries try to repair infeasible MIP start 0
trelim maximum space in memory for tree 1.0e+75

GAMS/CPLEX: MIP Solution Pool Options

Option Description Default
.divflt solution pool range filter coefficients 0
divfltlo lower bound on diversity mindouble
divfltup upper bound on diversity maxdouble
populatelim limit of solutions generated for the solution pool by populate method 20
readflt reads Cplex solution pool filter file
solnpool solution pool file name
solnpoolagap absolute tolerance for the solutions in the solution pool 1.0e+75
solnpoolcapacity limits of solutions kept in the solution pool 2100000000
solnpoolgap relative tolerance for the solutions in the solution pool 1.0e+75
solnpoolintensity solution pool intensity for ability to produce multiple solutions 0
solnpoolmerge solution pool file name for merged solutions
solnpoolnumsym maximum number of variable symbols when writing merged solutions 10
solnpoolprefix file name prefix for GDX solution files soln
solnpoolreplace strategy for replacing a solution in the solution pool 0

GAMS/CPLEX: MIP Tolerance Options

Option Description Default
bendersfeascuttol Tolerance for whether a feasibility cut has been violated in Benders decomposition 1.0e-06
bendersoptcuttol Tolerance for optimality cuts in Benders decomposition 1.0e-06
epagap absolute stopping tolerance 1.0e-06
epgap relative stopping tolerance 1.0e-04
epint integrality tolerance 1.0e-05
eplin degree of tolerance used in linearization 0.001
objdif overrides GAMS Cheat parameter 0.0
relobjdif relative cheat parameter 0.0

GAMS/CPLEX: Output Options

Option Description Default
bardisplay progress display level 1
clonelog enable clone logs 0
mipdisplay progress display level 2
mipinterval progress display interval 0
mpslongnum MPS file format precision of numeric output 1
netdisplay network display level 2
quality write solution quality statistics 0
siftdisplay sifting display level 1
simdisplay simplex display level 1
writeannotation produce a Cplex annotation file
writebas produce a Cplex basis file
writeflt produce a Cplex solution pool filter file
writelp produce a Cplex LP file
writemps produce a Cplex MPS file
writemst produce a Cplex mst file
writeord produce a Cplex ord file
writeparam produce a Cplex parameter file with all active options
writepre produce a Cplex LP/MPS/SAV file of the presolved problem
writeprob produce a Cplex problem file and inferrs the type from the extension
writesav produce a Cplex binary problem file

Parallel execution using multiple threads

Both ODHeuristicMethods STANDALONE and ODH-CPLEX can use multiple simultaneous threads. ODH-CPLEX must use separate threads for the main CPLEX solve and for the ODHeuristics engine. The STANDALONE just uses the ODHeuristics engine which may use multiple simultaneous threads. Thus the processing capability of multi-core hardware can be exploited effectively.

GAMS/ODHCPLEX will ignore the GAMS threads parameter and use its own default. The default ODHeuristic method (i.e. ODH-CPLEX) requires multiple threads to works and with the GAMS threads default of 1 this will not work.

Whilst there are good defaults for allocating available threads, it may be worthwhile to give some attention to the allocation of threads between the main CPLEX solver and the ODHeuristics engine for ODH-CPLEX and STANDALONE.

If the option ODHThreads is set to n, n threads are allocated in total, otherwise the total number of threads allocated for both ODH-CPLEX and STANDALONE is set to the number of physical processors available on the computer. If the ODHThreads option is set to a number greater than the number of available processors, multiple threads will have to share the same processor, which may severely degrade performance.

In general, the more threads allocated to the main CPLEX solver, the faster it will run, and similarly, the more allocated to the ODHeuristics engine, the faster it will run. The best balance depends on the model being solved and whether it is intended to run to optimality or to an optimality gap of (say) 0.05 or 0.1. If the GAMS/Cplex Threads is not set, ODH-CPLEX defaults to allocating a quarter of the threads to the ODHeuristics engine and the remainder to the main CPLEX solve. Otherwise it allocates the specified number of threads to the main CPLEX solver and the remainder to the ODHeuristics engine.

Within the ODHeuristics engine, the principal heuristic algorithm can run in parallel on multiple threads. Each algorithmic thread uses CPLEX to solve sub-models and each such instance of CPLEX can itself run on multiple threads. So some attention needs to be given to the allocation of threads between them. If SUB_CPX_THREADS is not set, the CPLEX solver will use one thread for each available logical processor to solve the sub-models. This means that only one thread will be available for the solution improvement heuristic. If the option SUB_CPX_THREADS is set, then by default the heuristic engine sets its number of algorithmic threads to

number_of_available_processors / SUB_CPX_THREADS

where number_of_available_processors is: the number of logical processors for STANDALONE; and for ODH-CPLEX it is this number less those allocated to the main CPLEX solver.

Many Intel and compatible processors support hyperthreading (where this is enabled on the computer and operating system) and if so there will be two logical processors for every physical core. Using them can severely degrade performance, so if they are enabled it is often a good idea to set ODHThreads to the number of physical processors. Note that on machines with a large number of processors (cores), the principal bottleneck for large scale optimization is usually memory access. In practice it is often better to use only about half of the available cores on (say) a 24 core Intel Xeon system. This is model dependent and some experimentation is worthwhile.

Although the operating system's scheduler usually allocates threads to logical processors so that they run on separate physical cores where possible, it will have more threads to manage than those of the heuristic or CPLEX and so will change this allocation as the heuristic and CPLEX run so as to balance its workload effectively. There is a performance penalty to doing this from the perspective of the heuristic run time. For the ODHeuristics STANDALONE, this can be avoided by locking the heuristic threads to specific processors by setting the heuristic option parameter ProcessorLock to 1. It is not supported for ODH-CPLEX. Under Windows, beware that the threads need to be locked at an above normal priority so this may have a negative impact on other programs concurrently running on the machine.

Determinism

Many users require that repeated runs of their applications under the same conditions give the same results, albeit in slightly variable times. The heuristic runs in this way by default. However, there is a performance penalty that has to be paid for synchronizing the threads. On average, performance can be considerably improved performance at the expense of non-repeatable execution by setting the heuristic option parameter Deterministic to 0. This is often preferred by users with particularly large and difficult models.

Detailed Descriptions of ODHCLPEX Options

advind (integer): advanced basis use

Default: 1

aggcutlim (integer): aggregation limit for cut generation

Default: 3

aggfill (integer): aggregator fill parameter

Default: 10

aggind (integer): aggregator on/off

Default: -1

auxrootthreads (integer): number of threads for auxiliary tasks at the root node

Default: 0

baralg (integer): algorithm selection

Default: 0

barcolnz (integer): dense column handling

Default: 0

barcrossalg (integer): barrier crossover method

Default: 0

bardisplay (integer): progress display level

Default: 1

barepcomp (real): convergence tolerance

Default: 1.0e-08

bargrowth (real): unbounded face detection

Default: 1.0e+12

baritlim (integer): iteration limit

Default: 2147483647

barmaxcor (integer): maximum correction limit

Default: -1

barobjrng (real): maximum objective function

Default: 1.0e+20

barorder (integer): row ordering algorithm selection

Default: 0

barqcpepcomp (real): convergence tolerance for the barrier optimizer for QCPs

Default: 1.0e-07

barstartalg (integer): barrier starting point algorithm

Default: 1

bbinterval (integer): best bound interval

Default: 7

bendersfeascuttol (real): Tolerance for whether a feasibility cut has been violated in Benders decomposition

Default: 1.0e-06

bendersoptcuttol (real): Tolerance for optimality cuts in Benders decomposition

Default: 1.0e-06

bendersstrategy (integer): Benders decomposition algorithm as a strategy

Default: 0

bndstrenind (integer): bound strengthening

Default: -1

bqpcuts (integer): boolean quadric polytope cuts for nonconvex QP or MIQP solved to global optimality

Default: 0

brdir (integer): set branching direction

Default: 0

bttol (real): backtracking limit

Default: 1.0

calcqcpduals (integer): calculate the dual values of a quadratically constrained problem

Default: 1

cliques (integer): clique cut generation

Default: 0

clocktype (integer): clock type for computation time

Default: 2

clonelog (integer): enable clone logs

Default: 0

coeredind (integer): coefficient reduction on/off

Default: -1

conflictalg (integer): algorithm CPLEX uses in the conflict refiner to discover a minimal set of conflicting constraints in an infeasible model

Default: 0

conflictdisplay (integer): decides how much information CPLEX reports when the conflict refiner is working

Default: 1

covers (integer): cover cut generation

Default: 0

cpumask (string): switch and mask to bind threads to processors (Linux only)

Default: auto

cpxpresolve (integer): Applies CPLEX presolve to full model

Default: 0

value meaning
-1 Do not apply
0 Automatically determined
1 Always applied

craind (integer): crash strategy (used to obtain starting basis)

Default: 1

cutlo (real): lower cutoff for tree search

Default: -1.0e+75

cutoff (real): GMO cutoff

Default: 0.0

cutpass (integer): maximum number of cutting plane passes

Default: 0

cuts (string): default cut generation

Default: 0

cutsfactor (real): cut limit

Default: -1.0

cutup (real): upper cutoff for tree search

Default: 1.0e+75

datacheck (integer): controls data consistency checking and modeling assistance

Default: 0

decompdensity (real): Matrix density above which automatic decomposition assigns each variable to a separate key

Default: 0.3

decomposition (integer): Model decomposition method.

Default: -1

value meaning
-1 Automatically determined
0 Assign each variable to a separate key
1 Use automatic decomosition method
2 Use decomposition based on dot option .key

depind (integer): dependency checker on/off

Default: -1

deterministic (boolean): Specifies whether the solution improvement heuristic is run in deterministic or opportunistic (i.e. non-deterministic) mode

Default: 1

value meaning
0 Opportunistic
1 Deterministic

dettilim (real): deterministic time limit

Default: 1.0e+75

disjcuts (integer): disjunctive cuts generation

Default: 0

divetype (integer): MIP dive strategy

Default: 0

.divflt (real): solution pool range filter coefficients

Default: 0

divfltlo (real): lower bound on diversity

Default: mindouble

divfltup (real): upper bound on diversity

Default: maxdouble

divisor (integer): Initial divisor for sub models

Initial sub model size is model_size times 1 over Divisor. Ignored if InterDiv is set.

Default: automatic

domlim (integer): domain violation number

Default: 0

dpriind (integer): dual simplex pricing

Default: 0

dynamicrows (integer): switch for dynamic management of rows

Default: -1

dynamicsearch (integer): Search strategy for CPLEX caller and sub-model solves

Default: -1

value meaning
-1 Automatically determined
0 Use traditional branch & cut
1 Use dynamic search

eachcutlim (integer): sets a limit for each type of cut

Default: 2100000000

epagap (real): absolute stopping tolerance

Synonym: optca

Default: 1.0e-06

epgap (real): relative stopping tolerance

Synonym: optcr

Default: 1.0e-04

epint (real): integrality tolerance

Default: 1.0e-05

eplin (real): degree of tolerance used in linearization

Default: 0.001

epmrk (real): Markowitz pivot tolerance

Default: 0.01

epopt (real): optimality tolerance

Default: 1.0e-06

epper (real): perturbation constant

Default: 1.0e-06

eprelax (real): relaxation for feasOpt

Default: 1.0e-06

eprhs (real): feasibility tolerance

Default: 1.0e-06

extracplexlog (boolean): Write addition CPLEX output to log

Default: 0

value meaning
0 Do not write extra CPLEX informtion
1 Write extra CPLEX information

feasoptmode (integer): mode of FeasOpt

Default: 0

feastol (real): Feasibility tolerance

Range: [1e-9, 0.1]

Default: 1e-6

firstfeas (integer): Use first feasible heuristic for finding an initial feasible solution

The default for ODH-CPLEX is 1 while for the heuristic engine the default is -1.

Default: -1

value meaning
-1 Do not use
0 Use if no solution found during initial presolve
1 Always use

firstfeascontinue (boolean): Whether first feasible heuristic continues when it achieves feasibility

Default: 0

value meaning
0 Do not continue
1 Continue

firstfeaseffort (integer): Effort limit on first feasible heuristic

If the option value is positive the exact value is used as the level of effort. If the value is negative no more than the absolute value of the option is used as the level of effort. The larger the effort level, the more effort is expended before giving up.

Default: -500

firstfeasshift (integer): First feasible heuristic variable shifting in found solutions

Default: 1

value meaning
0 Do not shift
1 Moderate shifting
2 Aggressive shifting

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

flowcovers (integer): flow cover cut generation

Default: 0

flowpaths (integer): flow path cut generation

Default: 0

folding (integer): LP folding will be attempted during the preprocessing phase

Default: -1

fpheur (integer): feasibility pump heuristic

Default: 0

fraccand (integer): candidate limit for generating Gomory fractional cuts

Default: 200

fraccuts (integer): Gomory fractional cut generation

Default: 0

fracpass (integer): maximum number of passes for generating Gomory fractional cuts

Default: 0

freegamsmodel (boolean): preserves memory by dumping the GAMS model instance representation temporarily to disk

Default: 0

globalbounds (integer): Use of global bounds from CPLEX caller

Default: 2

value meaning
0 Never use
2 Always use
1-4 Intensity of use

gubcovers (integer): GUB cover cut generation

Default: 0

heurfreq (integer): heuristic frequency

Default: 0

heuristiceffort (real): the effort that CPLEX spends on heuristics during a MIP solve

Default: 1.0

implbd (integer): implied bound cut generation

Default: 0

indexkey (string): Pattern used to match variable names for grouping into sub-models discussed above

indicoptstrict (boolean): abort in case of an error in indicator constraint in solver option file

Default: 1

integeronly (integer): Variables to include in INDEXKEY

Default: -1

value meaning
-1 Automatically determined
0 All variables
1 Only non-continuous variables

integertol (real): Integrality tolerance for variable values

Default: 1e-5

interdiv (integer): Initial divisor value

Default: 4

intsollim (integer): maximum number of integer solutions

Default: 2147483647

itlim (integer): iteration limit

Synonym: iterlim

Default: 2147483647

.key (integer): Variable block or key number

Default: 0

keytype (boolean): Treatment of multiple INDEXKEYs

Default: 0

value meaning
0 Considered separately e.g. INDEXKEY=x_d;y_d means x_2 and y_2 belong to separate groups
1 Considered together e.g. INDEXKEY=x_d;y_d means x_2 and y_2 belong to the same group

.lazy (boolean): Lazy constraints activation

Default: 0

lazyconstraints (boolean): Indicator to use lazy constraints

Default: 0

lbheur (boolean): local branching heuristic

Default: 0

liftprojcuts (integer): lift-and-project cuts

Default: 0

localimplied (integer): generation of locally valid implied bound cuts

Default: 0

lpmethod (integer): algorithm to be used for LP problems

Default: 0

maxbacktrack (integer): The maximum number of backtracks permitted in sub-model solves

Default: -1

value meaning
-1 Automatically determined
0 Infinite
>0 Use this value if a better solution is available

maxbound (real): The largest(smallest) non infinite bound value ODH will accept for upper(lower) bounds

If this value is positive, bounds exceeding MAXBOUND are reduced to MAXBOUND; if this value is negative, bounds exceeding -MAXBOUND are ignored.

Default: 1e+9

maxinfrepeat (integer): Maximum divisor value when solution is infeasible

Default: 0

value meaning
0 Automatically determined
>0 Use this value

maxinterdiv (integer): Maximum divisor value

Default: 0

maxrepeat (integer): Maximum number of sub-model repeat solves for each divisor value

Default: 0

value meaning
0 Automatically determined
>0 Use this value

mcfcuts (integer): multi-commodity flow cut generation

Default: 0

memoryemphasis (boolean): reduces use of memory

Default: 0

mipdisplay (integer): progress display level

Default: 2

mipemphasis (integer): MIP solution tactics

Default: 0

mipinterval (integer): progress display interval

Default: 0

mipkappastats (integer): MIP kappa computation

Default: 0

mipordind (boolean): priority list on/off

Synonym: prioropt

Default: 1

mipordtype (integer): priority order generation

Default: 0

mipsearch (integer): search strategy for mixed integer programs

Default: 0

mipstart (integer): use mip starting values

Default: 0

miqcpstrat (integer): MIQCP relaxation choice

Default: 0

mircuts (integer): mixed integer rounding cut generation

Default: 0

mpslongnum (boolean): MPS file format precision of numeric output

Default: 1

multimipstart (string): use multiple mipstarts provided via gdx files

multobjdisplay (integer): level of display during multiobjective optimization

Default: 1

names (boolean): load GAMS names into Cplex

Default: 1

netdisplay (integer): network display level

Default: 2

netepopt (real): optimality tolerance for the network simplex method

Default: 1.0e-06

neteprhs (real): feasibility tolerance for the network simplex method

Default: 1.0e-06

netfind (integer): attempt network extraction

Default: 2

netitlim (integer): iteration limit for network simplex

Default: 2147483647

netppriind (integer): network simplex pricing

Default: 0

newcallback (integer): CPLEX call-back type used

Default: 1

value meaning
0 Use legacy call-backs
1 Use new call-backs for main CPLEX solve
2 Use new call-backs for sub-model solves
3 Use new call-backs for main CPLEX solve and sub-model solves

nodecuts (integer): decide whether or not cutting planes are separated at the nodes of the branch-and-bound tree

Default: 0

nodefileind (integer): node storage file indicator

Default: 1

nodelim (integer): maximum number of nodes to solve

Synonym: nodlim

Default: 2147483647

nodesel (integer): node selection strategy

Default: 1

numericalemphasis (boolean): emphasizes precision in numerically unstable or difficult problems

Default: 0

objdif (real): overrides GAMS Cheat parameter

Synonym: cheat

Default: 0.0

objllim (real): objective function lower limit

Default: -1.0e+75

objtarget (real): Target objective value

ODHeuristics terminates when this value is reached. Defaults to -infinity for minimization or +infinity for maximization models.

Default: 0

objulim (real): objective function upper limit

Default: 1.0e+75

odheuristicmethod (string): ODHeuristic method section

Default: ODH-CPLEX

value meaning
ODH-CPLEX ODHeuristic within the CPLEX optimizer
STANDALONE Stand-alone ODHeuristic engine

odhfeasopt (boolean): Optimization method for sub-models in phaseI

Default: 0

odhpresolve (integer): Indicator for the ODHeuristics engine using a separate presolve within ODH-CPLEX

Default: 1

value meaning
1 One-step presolve
2 Two-step presolve

odhthreads (integer): The number of heuristic threads used by ODH-CPLEX or STANDALONE

Default: -1

value meaning
-1 Automatically determined
0 Run in serial mode
>0 Use the specified number of threads

odhtimelimit (real): Elapsed time limit in seconds

Synonym: reslim

Default: GAMS ResLim

optimalitytarget (integer): type of optimality that Cplex targets

Default: 0

parallelmode (integer): parallel optimization mode

Default: 0

paramdisplay (boolean): display the nondefault parameters before optimization

Default: 1

penalty (real): The objective function coefficient value for penalties

The objective function coefficient value for the penalties introduced to deal with infeasibilities in the solution improvement heuristic. It is set by default when required and if not specified.

Default: -1

penperturb (real): Perturbation tolerance for penalties coefficients

Default: 0

perind (boolean): force initial perturbation

Default: 0

perlim (integer): number of stalled iterations before perturbation

Default: 0

phase12 (boolean): Specifies whether to use a phaseI/phaseII method to remove infeasibilities

Default: 1

value meaning
0 Use composite objective method
1 Use phaseI/phaseII method

polishafterdettime (real): deterministic time before starting to polish a feasible solution

Default: 1.0e+75

polishafterepagap (real): absolute MIP gap before starting to polish a feasible solution

Default: 0.0

polishafterepgap (real): relative MIP gap before starting to polish a solution

Default: 0.0

polishafterintsol (integer): MIP integer solutions to find before starting to polish a feasible solution

Default: 2147483647

polishafternode (integer): nodes to process before starting to polish a feasible solution

Default: 2147483647

polishaftertime (real): time before starting to polish a feasible solution

Default: 1.0e+75

populatelim (integer): limit of solutions generated for the solution pool by populate method

Default: 20

ppriind (integer): primal simplex pricing

Default: 0

predual (integer): give dual problem to the optimizer

Default: 0

preind (boolean): turn presolver on/off

Default: 1

prelinear (boolean): linear reduction indicator

Default: 1

prepass (integer): number of presolve applications to perform

Default: -1

prereform (integer): set presolve reformulations

Default: 3

preslvnd (integer): node presolve selector

Default: 0

pricelim (integer): pricing candidate list

Default: 0

printoptions (boolean): list values of all options to GAMS listing file

Default: 0

probe (integer): perform probing before solving a MIP

Default: 0

probedettime (real): deterministic time spent probing

Default: 1.0e+75

probetime (real): time spent probing

Default: 1.0e+75

processorlock (boolean): Thread allocation

Default: 0

value meaning
0 Do not lock threads to processors
1 Lock threads to processors

qextractalg (integer): quadratic extraction algorithm in GAMS interface

Default: 0

qpmakepsdind (boolean): adjust MIQP formulation to make the quadratic matrix positive-semi-definite

Default: 1

qpmethod (integer): algorithm to be used for QP problems

Default: 0

qtolin (integer): linearization of the quadratic terms in the objective function of a QP or MIQP model

Default: -1

quality (boolean): write solution quality statistics

Default: 0

quickfirstsolve (boolean): Accelerate initial CPLEX solve

Default: 0

value meaning
0 Do not unless presolve applied to full model
1 Use existing presolved model

randomseed (integer): sets the random seed differently for diversity of solutions

Default: 202009243

readflt (string): reads Cplex solution pool filter file

record (boolean): Records invocations of Callable Library routines

Default: 0

recurse (integer): Recurse using heuristic to solve sub-models when a feasible solution has been obtained

Default: 0

value meaning
0 Do not recurse
1 Recurse thread 0 only
2 Recurse odd numbered threads
3 Recurse all threads
<0 Recurse when working with an infeasible solution. values are negated (e.g. -3 = recursion of all threads)

recursedecomp (integer): Recursed model decomposition method

Default: 0

value meaning
-1 Use initial model decomposition
0 Assign each variable to a separate key
1 Use automatic decomposition method

recurseiterlim (integer): Recursed heuristic iteration limit for sub-solves

Default: 40

recurselog (boolean): Write thread log files for recursed sub-solves

Default: 0

recurseminiterlim (integer): Recursed heuristic minimum iterations before a solution is found in sub-solves

Default: 0

recursesoliterlim (integer): Recursed heuristic sub-solves quit after these iterations if a solution is found

Default: maxint

reduce (integer): primal and dual reduction type

Default: 3

reinv (integer): refactorization frequency

Default: 0

rejectinfsol (integer): Reject infeasible solutions to sub-models

Default: 2

value meaning
0 Do not check feasibility or reject
1 Check feasibility and warn if infeasible, but accept
2 Check feasibility and reject if infeasible

relaxfixedinfeas (boolean): accept small infeasibilties in the solve of the fixed problem

Default: 0

relaxpreind (integer): presolve for initial relaxation on/off

Default: -1

relaxsos2 (integer): Treatment of SOS2 members

Default: 1

value meaning
0 Aggressive use in reducing sub-model size
1 Moderate use in reducing sub-model size
2 Ignored in sub-model creation

relobjdif (real): relative cheat parameter

Default: 0.0

repairtries (integer): try to repair infeasible MIP start

Default: 0

repeatpresolve (integer): reapply presolve at root after preprocessing

Default: -1

rerun (string): rerun problem if presolve infeasible or unbounded

Default: yes

rinsheur (integer): relaxation induced neighborhood search frequency

Default: 0

rltcuts (integer): Reformulation Linearization Technique (RLT) cuts

Default: 0

scaind (integer): matrix scaling on/off

Default: 0

seed (integer): Initial random number seed

Default: 1234

siftalg (integer): sifting subproblem algorithm

Default: 0

siftdisplay (integer): sifting display level

Default: 1

sifting (boolean): switch for sifting from simplex optimization

Default: 1

siftitlim (integer): limit on sifting iterations

Default: 2147483647

simdisplay (integer): simplex display level

Default: 1

singlim (integer): limit on singularity repairs

Default: 10

solnpool (string): solution pool file name

solnpoolagap (real): absolute tolerance for the solutions in the solution pool

Default: 1.0e+75

solnpoolcapacity (integer): limits of solutions kept in the solution pool

Default: 2100000000

solnpoolgap (real): relative tolerance for the solutions in the solution pool

Default: 1.0e+75

solnpoolintensity (integer): solution pool intensity for ability to produce multiple solutions

Default: 0

solnpoolmerge (string): solution pool file name for merged solutions

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

Default: 10

solnpoolprefix (string): file name prefix for GDX solution files

Default: soln

solnpoolreplace (integer): strategy for replacing a solution in the solution pool

Default: 0

solutiontype (integer): type of solution (basic or non basic) for an LP or QP

Default: 0

solvefinal (boolean): switch to solve the problem with fixed discrete variables

Default: 1

sos1reform (integer): automatic logarithmic reformulation of special ordered sets of type 1 (SOS1)

Default: 0

sos2reform (integer): automatic logarithmic reformulation of special ordered sets of type 2 (SOS2)

Default: 0

startalg (integer): MIP starting algorithm

Default: 0

strategy (integer): ODH-Cplex Strategy

The aggressive setting attempt to make more progress with each sub-model solve at the cost of more expensive sub solves. Amongst other changes, it sets InterDiv, MaxInterDiv and MaxRepeat if they are not explicitly set by the user.

Default: 1

value meaning
0 Conservative
1 Normal
2 Aggressiv

strongcandlim (integer): size of the candidates list for strong branching

Default: 10

strongitlim (integer): limit on iterations per branch for strong branching

Default: 0

subalg (integer): algorithm for subproblems

Default: 0

submipnodelim (integer): limit on number of nodes in an RINS subMIP

Default: 500

submipscale (integer): scale the problem matrix when CPLEX solves a subMIP during MIP optimization

Default: 0

submipstartalg (integer): starting algorithm for a subMIP of a MIP

Default: 0

submipsubalg (integer): algorithm for subproblems of a subMIP of a MIP

Default: 0

subnodelimit (integer): Node limit for submodel searches

Default: -1

value meaning
-1 Automatically determined
>0 Set node limit to this value

suborder (integer): Use of priority order in sub-solves

Default: 1

value meaning
0 Do not use any supplied priority order information in sub-solves
1 Use any supplied priority order information in sub-solves

subpresolve (integer): Use of CPLEX presolve in sub-solves

Default: 1

value meaning
1 Use normal presolve
2 Use two-step presolve

sub_cpx_threads (integer): Threads availble for the solves within ODHeuristic

Default: 1

symmetry (integer): symmetry breaking cuts

Default: -1

syncfreq (integer): Thread synchronization frequency in deterministic parallel mode

Default: 1

value meaning
0 Low frequency
1 High frequency

threadlog (boolean): Write thread log files

Default: 0

threads (integer): global default thread count

Synonym: gthreads

Default: 0

threadzerosync (integer): Which CPLEX threads to use for synchronization

Default: 0

value meaning
0 Synchronize with multiple CPLEX threads
1 Only synchronize with CPLEX thread 0

tilim (real): overrides the GAMS ResLim option

Default: 1.0e+75

trelim (real): maximum space in memory for tree

Default: 1.0e+75

tryint (real): GMO tryint

Default: 0.0

tuningdettilim (real): tuning deterministic time limit per model or suite

Default: 1.0e+75

tuningdisplay (integer): level of information reported by the tuning tool

Default: 1

tuningmeasure (integer): measure for evaluating progress for a suite of models

Default: 1

tuningrepeat (integer): number of times tuning is to be repeated on perturbed versions

Default: 1

tuningtilim (real): tuning time limit per model or suite

Default: 1.0e+75

usebasis (boolean): GMO usebasis

Default: 0

variableclean (integer): Clean variable values from sub-models

Default: 0

value meaning
0 No cleaning
1 Quick cleaning and allow feasible uncleaned solutions if unable to clean
2 Quick cleaning and disallow uncleaned solutions
3 Thorough cleaning

varsel (integer): variable selection strategy at each node

Default: 0

warninglimit (integer): determines how many times warnings of a specific type (datacheck=2) will be displayed

Default: 10

workdir (string): directory for working files

Default: .

workeralgorithm (integer): set method for optimizing benders subproblems

Default: 0

workmem (real): memory available for working storage

Default: 2048.0

writeannotation (string): produce a Cplex annotation file

writebas (string): produce a Cplex basis file

writeflt (string): produce a Cplex solution pool filter file

writelp (string): produce a Cplex LP file

writemps (string): produce a Cplex MPS file

writemst (string): produce a Cplex mst file

writeord (string): produce a Cplex ord file

writeparam (string): produce a Cplex parameter file with all active options

writepre (string): produce a Cplex LP/MPS/SAV file of the presolved problem

writeprob (string): produce a Cplex problem file and inferrs the type from the extension

writesav (string): produce a Cplex binary problem file

zerohalfcuts (integer): zero-half cuts

Default: 0

zerotol (real): Zero tolerance for variable values

Default: 1e-9