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}