barrier_limits_growth {1e+6,1e+8,1e+10,1e+12,1e+14}[1e+12] # barrier growth limit. Allegedly called bargrowth. in R, >= 1.0. Now that I check results numerically this can be optimized
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 {yes,no}[no] #MEMORYEMPHASIS. No auto. Binary.
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,1,2,3,5,10}[3] # constraint aggregation limit for cut generation. No auto, in N+_0
mip_limits_cutsfactor {1,2,4,8,16}[4] # row multiplier factor for cuts. in R+
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,100,200,400,800}[200] # candidate limit for generating Gomory fractional cuts. No auto, in N+
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,5,10,20,40}[10] # MIP strong branching candidate list limit. No auto, in N_0+
mip_limits_strongit {0,1,4,16,64}[0] # MIP strong branching iterations limit. Auto=0, in N+ , poorly informed
mip_limits_submipnodelim {125,250,500,1000,2000}[500] # limit on nodes explored when a subMIP is being solved. No auto, in N_0+
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 {0,2,4,7,15,30}[7] # MIP strategy best bound interval. No auto, in N+_0
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 {1e-8,1e-7,1e-6,1e-5,1e-4}[1e-6] # part 2 of parameter "simplex_perturbation", conditional on part1=1
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,5,10,20,40}[10] # 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,5,10,20,40}[10] # simplex singularity repair limit. No auto, in N_0+
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.001, 0.01, 0.1, 0.5} [0.01] # Markowitz tolerance. 0.0001 to 0.99999

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}