barrier_limits_growth [1000000, 100000000000000] [1000000000000]l #BARGROWTH. Barrier growth limit. Allegedly called bargrowth. Somewhat numerical. Now that I check results numerically this can be optimized. No auto, in R+, >=1.0. Was: in 1e+6,1e+8,1e+10,1e+12,1e+14, default 1e+12
barrier_algorithm {0,1,2,3}[0] # barrier algorithm. Auto, cat
barrier_crossover {-1,0,1,2}[0] # barrier crossover algorithm. Auto, cat
barrier_limits_corrections {-1,0,1,4,16,64}[-1] # barrier maximum correction limit. Auto=-1, in N+, poorly informed
barrier_ordering {0,1,2,3} [0] # barrier ordering algorithm. Auto, cat
barrier_startalg {1,2,3,4}[1] # barrier starting point algorithm. Auto, cat
emphasis_memory {no}[no] #MEMORYEMPHASIS. No auto. Binary. Disallow emphasis_memory yes -> writes temp files.
emphasis_mip {0,1,2,3,4}[0] # MIP emphasis switch. Auto, cat
emphasis_numerical {yes,no}[no] # numerical precision emphasis. No auto, cat. Since I penalize (too) poor numerical precision this is an optimization parameter
feasopt_mode {0,1,2,3,4,5}[0] # mode of FeasOpt. Auto, cat
lpmethod {0,1,2,3,4,5,6}[0] # algorithm for continuous problems. Auto, cat
mip_cuts_cliques {-1,0,1,2,3}[0] # MIP cliques switch. Auto, cat
mip_cuts_covers {-1,0,1,2,3}[0] # MIP covers switch. Auto, cat
mip_cuts_disjunctive {-1,0,1,2,3}[0] # MIP disjunctive cuts switch. Auto, cat
mip_cuts_flowcovers {-1,0,1,2}[0] # MIP flow cover cuts switch. Auto, cat
mip_cuts_gomory {-1,0,1,2}[0] # MIP Gomory fractional cuts switch. Auto, cat
mip_cuts_gubcovers {-1,0,1,2}[0] # MIP GUB cuts switch. Auto, cat
mip_cuts_implied {-1,0,1,2}[0] # MIP implied bound cuts switch. Auto, cat
mip_cuts_mcfcut {-1,0,1,2}[0] # MCF cut switch. Auto, cat
mip_cuts_mircut {-1,0,1,2}[0] # MIP MIR (mixed integer rounding) cut switch. Auto, cat
mip_cuts_pathcut {-1,0,1,2}[0] # MIP flow path cut switch. Auto, cat
mip_cuts_zerohalfcut {-1,0,1,2} [0] # MIP zero-half cuts switch. Auto, cat
mip_limits_aggforcut [0,10][3]i #AGGCUTLIM. Constraint aggregation limit for cut generatio. No auto. Was: in 0,1,2,3,5,10, default 3
mip_limits_cutsfactor [1,16][4]l #CUTSFACTOR. No auto. R+ Was in 1,2,4,8,16, default 4
mip_limits_cutpasses {-1,0,1,4,16,64}[0] # number of cutting plane passes. Auto=0, in N+, poorly informed
mip_limits_gomorycand [50,800][200]il #FRACCAND. No auto. Candidate limit for generating Gomory fractional cuts N+ Was: in 50,100,200,400,800, default 200
mip_limits_gomorypass {0,1,4,16,64}[0] # pass limit for generating Gomory fractional cuts. Auto=0, in N+, poorly informed
mip_limits_strongcand [2,40][10]il #STRONGCANDLIM. MIP strong branching candidate list limit. No auto. N+ Was: in 2,5,10,20,40, def 10
mip_limits_strongit {0,1,4,16,64}[0] # MIP strong branching iterations limit. Auto=0, in N+ , poorly informed
mip_limits_submipnodelim [125,2000][500]il #SUBMIPNODELIM. Limit on nodes explored when a subMIP is being solved. No auto. N+ Was: in 125,250,500,1000,2000, def 500
mip_ordertype {0,1,2,3}[0] # MIP priority order generation. No auto, cat
mip_strategy_backtrack {0.9,0.99,0.999,0.9999,0.99999,0.999999} [0.9999] # backtracking tolerance. No auto, any number from 0.0 to 1.0. Despite the name this is not a tolerance parameter
mip_strategy_bbinterval [1,1000][7]il #BBINTERVAL. N+_0. MIP strategy best bound interval. *2011-07-18: see note 1. Was: in 0,2,4,7,15,30, def 7
mip_strategy_branch {-1,0,1} [0] # MIP branching direction. Auto, cat
mip_strategy_dive {0,1,2,3}[0] # MIP dive strategy. Auto, cat
mip_strategy_file {0,1}[1] #node storage file switch. No auto. Cat.  DISALLOW values 2 and 3 => they write files to disk (stuff will break and we run out of space)
mip_strategy_fpheur {-1,0,1,2}[0] # feasibility pump switch. Auto, cat. Does NOT apply for MIQCP
mip_strategy_heuristicfreq {-1,0,5,10,20,40,80}[0] # MIP heuristic frequency. Auto=0, in N+. 20 is an example used in the manual. It may be totally off...
mip_strategy_lbheur {yes,no}[no] # local branching heuristic. No auto, cat
mip_strategy_nodeselect {0,1,2,3}[1] # MIP node selection strategy. No auto, cat
mip_strategy_order {yes,no}[yes] # MIP priority order switch. No auto, cat. 
mip_strategy_presolvenode {-1,0,1,2}[0] # node presolve switch. Auto, cat
mip_strategy_probe {-1,0,1,2,3}[0] # MIP probing level. Auto, cat
mip_strategy_rinsheur {-1,0,5,10,20,40,80}[0] # RINS heuristic frequency. Auto=0, 20 is an example from the CPLEX parameter reference; could be totally off
mip_strategy_search {0,1,2} [0] # MIP dynamic search switch. Auto, cat. NOT compatible with callbacks (fine in our case, where we don't use those)
mip_strategy_startalgorithm {0,1,2,3,4,5,6}[0] # MIP starting algorithm. Auto, cat. SPECIAL CASES: MIQCP and MIQP only allow some of these
mip_strategy_subalgorithm {0,1,2,3,4,5}[0] # MIP subproblem algorithm. Auto, cat.
mip_strategy_variableselect {-1,0,1,2,3,4} [0] # MIP variable selection strategy. Auto, cat
network_netfind {1,2,3}[2] # simplex network extraction level. No auto, cat
network_pricing {0,1,2}[0] # network simplex pricing algorithm. Auto, cat. The CPLEX parameter reference says the default (0) is identical to option 3, which I thus disabled.
perturbation_constant [0.00000001, 0.0001][0.000001]l # Part 2 of parameter "simplex_perturbation", conditional on part1=1. Was: in 1e-8,1e-7,1e-6,1e-5,1e-4, default 1e-6
preprocessing_aggregator {-1,0,1,4,16,64}[-1] # preprocessing aggregator application limit
preprocessing_boundstrength {-1,0,1}[-1] # bound strengthening switch. Auto, cat
preprocessing_coeffreduce {0,1,2} [2] # coefficient reduction setting. Auto, cat
preprocessing_dependency {-1,0,1,2,3}[-1] # dependency switch. Auto, cat
preprocessing_dual {-1,0,1}[0] # presolve dual setting. Auto, cat 
preprocessing_fill [2,40][10]il #AGGFILL. Preprocessing aggregator fill. No auto, in N+.
preprocessing_linear {0,1}[1] # linear reduction switch. No auto, cat
preprocessing_numpass {-1,0,1,4,16,64}[-1] # limit on the number of presolve passes made. Auto=-1, in N+, poorly informed
preprocessing_reduce {0,1,2,3}[3] # primal and dual reduction type. Auto, cat
preprocessing_relax {-1,0,1}[-1] # relaxed LP presolve switch. Auto, cat
preprocessing_repeatpresolve {-1,0,1,2,3}[-1] # MIP repeat presolve switch. Auto, cat
preprocessing_symmetry {-1,0,1,2,3,4,5} [-1] # symmetry breaking. Auto, cat
read_scale {-1,0,1}[0] # scale parameter. Auto, cat
sifting_algorithm {0,1,2,3,4}[0] # sifting subproblem algorithm. Auto, cat
simplex_crash {-1,0,1}[1] # simplex crash ordering. Auto, cat
simplex_dgradient {0,1,2,3,4,5}[0] # dual simplex pricing algorithm. Auto, cat
simplex_limits_perturbation {0,1,4,16,64}[0] # simplex perturbation limit. Auto=0, in N+, poorly informed
simplex_limits_singularity [2,40][10]il #SINGLIM. Simplex singularity repair limit. No auto. N+ Was: in 2,5,10,20,40, def 10
simplex_perturbation_switch {no,yes}[no] # part 1 of parameter "simplex_perturbation"
simplex_pgradient {-1,0,1,2,3,4}[0] # primal simplex pricing algorithm. Auto, cat
simplex_pricing {0,1,4,16,64}[0] # simplex pricing candidate list size. Auto=0, in N+, poorly informed
simplex_refactor {0,4,16,64,256} [0] #simplex refactoring frequency. 0=Auto. N+. Simplex refactorization interval. Hoyt's LP notes say Chvtal suggests an optimal refactorization interval of 16. 
simplex_tolerances_markowitz [0.0001,0.5][0.01]l # Markowitz tolerance. 0.0001 to 0.99999. Was: in 0.0001, 0.001, 0.01, 0.1, 0.5, default 0.01

Conditionals:
mip_limits_strongcand | mip_strategy_variableselect in {3}
mip_limits_strongit | mip_strategy_variableselect in {3}
mip_strategy_order | mip_ordertype in {1,2,3}
perturbation_constant | simplex_perturbation_switch in {yes}

# *1 [2011-07-18] bbinterval (was [0.01,30][7]il). N_0+ 0=NEVER, 1=ALWAYS, ... 7=SOMETIMES(default) ... INF=NEVER.
