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

GAMS/CPLEX: Preprocessing and General Options

GAMS/CPLEX: Simplex Algorithmic Options

GAMS/CPLEX: Simplex Limit Options

GAMS/CPLEX: Simplex Tolerance Options

GAMS/CPLEX: Barrier Specific Options

GAMS/CPLEX: Sifting Specific Options

GAMS/CPLEX: MIP Algorithmic Options

GAMS/CPLEX: MIP Limit Options

GAMS/CPLEX: MIP Solution Pool Options

GAMS/CPLEX: MIP Tolerance Options

GAMS/CPLEX: Output Options

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

addcuts (integer): Indicator for adding cuts from CPLEX master solve ↵

Default: 2

value	meaning
0	Do not add cuts
1	Add cuts from CPLEX master solve at root
2	Add cuts from CPLEX master solve at root and in tree

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	Apply only for first feasible heuristic
-2	Do not apply at all
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: [0, 1.0]

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 (integer): Whether first feasible heuristic continues when it achieves feasibility ↵

Default: 0

value	meaning
0	Do not continue
1	Continue
2	Use in sub-model solves

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

value	meaning
>0	Use this level of effort
<0	Use no more than -firstfeaseffort effort

firstfeaslpitlim (integer): Limit on number of relaxed re-solves in first feasible heuristic ↵

Default: 10

value	meaning
-1	No limit
0	No relaxed re-solves
>0	Limit

firstfeasrelaxcrit (real): Smallest sum of infeasibilites/row where relaxed solution used ↵

Default: 0.01

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

Default: 0

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
5	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

ignoresetslvrparams (boolean): Flag to control whether solver parameters can be dynamically altered by ODH ↵

Default: 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

keypartition (integer): Use of solver partition information ↵

Default: 0

value	meaning
0	Do not use
1	Use solver partition information to generate keys
2	Use keys to generate sub-solver partition information

keysminimum (integer): Minimum number of keys that the automatic decomposition method attempts to find ↵

Default: 512

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

localsearch (boolean): Indicator for local search heuristic ↵

Default: 1

loosefeastol (real): Loose feasibility tolerance ↵

Default: 1e-5

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

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

objthreshold (real): Threshold for absolute value of objective coefficients ↵

Variables with coefficients greater than this value are always considered for optimization.

Default: 1e99

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

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: 10

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: nono

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: 12345

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

sosfind (boolean): Automatic detection of Special Ordered Sets (SOSs) ↵

Default: 0

sosinkey (integer): Assign each SOS to its own sub-model component (key) ↵

Default: 0

value	meaning
0	Treat SOS members as normal i.e. in keys iff declared non-continuous or integeronly =0;
1	SOS members always in keys
2	SOS members always in keys and members of each SOS to their own key

sosmember (string): Automatically detect SOSs whose variable member names match this pattern ↵

sosovar (string): Automatically detect SOSs whose output variable name matches this pattern ↵

sosselect (string): Select sub-set of SOS members ↵

sosselect16 (string): Select sub-set of SOS members for sets with 16 or fewer members only ↵

soswvar (string): Automatically detect SOSs whose input(weight) variable name matches this pattern ↵

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

strictdeterministic (integer): Terminate ODH deterministically when improvement heuristic finishes ↵

Default: 0

value	meaning
0	Terminate ODH as soon as possible which can violate determinism
1	Terminate ODH deterministically

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

subcheckfreq (integer): Frequency with which sub-model LPs are interrupted for mutual communication ↵

Default: 10

value	meaning
0	Do not interrupt sub-model LPs
>0	Interrupt sub-model LPs. The smaller this value then more often they are interrupted.

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

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

tightenprebounds (integer): Level of bound tightening in ODH presolved model ↵

Default: 1

value	meaning
0	Do not tighten bounds
1	Least aggressive
2	Moderate aggressive
3	Most aggressive

tilim (real): overrides the GAMS ResLim option ↵

Default: 1.0e+75

trelim (real): maximum space in memory for tree ↵

Default: 1.0e+75

trialbound (integer): Trial bound heuristic ↵

Default: 0

value	meaning
-1	As option 1 plus retain trial bounds for whole optimization
-2	As option 2 plus retain trial bounds for whole optimization
0	Read trial bounds from trialboundfile if it is specified
1	Read trial bounds from trialboundfile
2	Auto generate trial bounds and write them to trialboundfile if it is specified

trialboundfile (string): The trial bound file ↵

Bounds are used to attempt finding an initial feasible solution

trialboundsetsize (integer): Size adjustment to automatically generated trial bound sets ↵

Default: 0

value	meaning
0	Do not adjust set size
>0	Use no more than this number of set members
<0	Decrease set size by this value

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

usehistory (integer): Use of past sub-model selections in current selection ↵

Default: -1

value	meaning
-1	Automatically determined
0	Never use historical information
1	Always use historical information

varcleanlpmethod (integer): Method used to solve variable cleaning LPs ↵

Default: -1

value	meaning
-1	Automatically determined by solver
0	Primal simplex
1	Dual simplex
2	Barrier

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

Default: 1

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