pub type SCIP_SET = SCIP_Set;Expand description
global SCIP settings
Aliased Type§
#[repr(C)]pub struct SCIP_SET {Show 439 fields
pub stage: u32,
pub scip: *mut Scip,
pub paramset: *mut SCIP_ParamSet,
pub buffer: *mut BMS_BufMem,
pub cleanbuffer: *mut BMS_BufMem,
pub readers: *mut *mut SCIP_Reader,
pub pricers: *mut *mut SCIP_Pricer,
pub conshdlrs: *mut *mut SCIP_Conshdlr,
pub conshdlrs_sepa: *mut *mut SCIP_Conshdlr,
pub conshdlrs_enfo: *mut *mut SCIP_Conshdlr,
pub conshdlrs_include: *mut *mut SCIP_Conshdlr,
pub conflicthdlrs: *mut *mut SCIP_Conflicthdlr,
pub presols: *mut *mut SCIP_Presol,
pub relaxs: *mut *mut SCIP_Relax,
pub sepas: *mut *mut SCIP_Sepa,
pub cutsels: *mut *mut SCIP_Cutsel,
pub props: *mut *mut SCIP_Prop,
pub props_presol: *mut *mut SCIP_Prop,
pub heurs: *mut *mut SCIP_Heur,
pub comprs: *mut *mut SCIP_Compr,
pub eventhdlrs: *mut *mut SCIP_Eventhdlr,
pub nodesels: *mut *mut SCIP_Nodesel,
pub nodesel: *mut SCIP_Nodesel,
pub branchrules: *mut *mut SCIP_Branchrule,
pub iisfinders: *mut *mut SCIP_IISfinder,
pub disps: *mut *mut SCIP_Disp,
pub tables: *mut *mut SCIP_Table,
pub dialogs: *mut *mut SCIP_Dialog,
pub exprhdlrs: *mut *mut SCIP_Exprhdlr,
pub exprhdlrvar: *mut SCIP_Exprhdlr,
pub exprhdlrval: *mut SCIP_Exprhdlr,
pub exprhdlrsum: *mut SCIP_Exprhdlr,
pub exprhdlrproduct: *mut SCIP_Exprhdlr,
pub exprhdlrpow: *mut SCIP_Exprhdlr,
pub nlpis: *mut *mut SCIP_Nlpi,
pub concsolvertypes: *mut *mut SCIP_ConcSolverType,
pub concsolvers: *mut *mut SCIP_ConcSolver,
pub benders: *mut *mut SCIP_Benders,
pub debugsoldata: *mut SCIP_DebugSolData,
pub banditvtables: *mut *mut SCIP_BanditVTable,
pub extcodenames: *mut *mut i8,
pub extcodedescs: *mut *mut i8,
pub nreaders: i32,
pub readerssize: i32,
pub npricers: i32,
pub nactivepricers: i32,
pub pricerssize: i32,
pub nconshdlrs: i32,
pub conshdlrssize: i32,
pub nconflicthdlrs: i32,
pub conflicthdlrssize: i32,
pub npresols: i32,
pub presolssize: i32,
pub nrelaxs: i32,
pub relaxssize: i32,
pub nsepas: i32,
pub sepassize: i32,
pub ncutsels: i32,
pub cutselssize: i32,
pub nprops: i32,
pub propssize: i32,
pub nheurs: i32,
pub heurssize: i32,
pub ncomprs: i32,
pub comprssize: i32,
pub neventhdlrs: i32,
pub eventhdlrssize: i32,
pub nnodesels: i32,
pub nodeselssize: i32,
pub nbranchrules: i32,
pub branchrulessize: i32,
pub niisfinders: i32,
pub iisfinderssize: i32,
pub ndisps: i32,
pub dispssize: i32,
pub ntables: i32,
pub tablessize: i32,
pub ndialogs: i32,
pub dialogssize: i32,
pub nexprhdlrs: i32,
pub exprhdlrssize: i32,
pub nnlpis: i32,
pub nlpissize: i32,
pub nconcsolvertypes: i32,
pub concsolvertypessize: i32,
pub nconcsolvers: i32,
pub concsolverssize: i32,
pub nbenders: i32,
pub nactivebenders: i32,
pub benderssize: i32,
pub nextcodes: i32,
pub extcodessize: i32,
pub nbanditvtables: i32,
pub banditvtablessize: i32,
pub pricerssorted: u32,
pub pricersnamesorted: u32,
pub conflicthdlrssorted: u32,
pub conflicthdlrsnamesorted: u32,
pub presolssorted: u32,
pub presolsnamesorted: u32,
pub relaxssorted: u32,
pub relaxsnamesorted: u32,
pub sepassorted: u32,
pub sepasnamesorted: u32,
pub cutselssorted: u32,
pub propssorted: u32,
pub propspresolsorted: u32,
pub propsnamesorted: u32,
pub heurssorted: u32,
pub heursnamesorted: u32,
pub comprssorted: u32,
pub comprsnamesorted: u32,
pub branchrulessorted: u32,
pub branchrulesnamesorted: u32,
pub iisfinderssorted: u32,
pub tablessorted: u32,
pub exprhdlrssorted: u32,
pub nlpissorted: u32,
pub benderssorted: u32,
pub bendersnamesorted: u32,
pub limitchanged: u32,
pub subscipsoff: u32,
pub branch_scorefunc: i8,
pub branch_firstsbchild: i8,
pub branch_scorefac: f64,
pub branch_preferbinary: u32,
pub branch_clamp: f64,
pub branch_midpull: f64,
pub branch_midpullreldomtrig: f64,
pub branch_lpgainnorm: i8,
pub branch_delaypscost: u32,
pub branch_divingpscost: u32,
pub branch_collectancpscost: u32,
pub branch_forceall: u32,
pub branch_checksbsol: u32,
pub branch_roundsbsol: u32,
pub branch_sumadjustscore: u32,
pub conf_maxvarsfac: f64,
pub conf_maxvarsfracres: f64,
pub conf_minmaxvars: i32,
pub conf_maxlploops: i32,
pub conf_lpiterations: i32,
pub conf_fuiplevels: i32,
pub conf_resfuiplevels: i32,
pub conf_interconss: i32,
pub conf_maxconss: i32,
pub conf_maxstoresize: i32,
pub conf_reconvlevels: i32,
pub conf_enable: u32,
pub conf_cleanbnddepend: u32,
pub conf_useprop: u32,
pub conf_usegenres: u32,
pub conf_useinflp: i8,
pub conf_useboundlp: i8,
pub conf_usesb: u32,
pub conf_reduction: i8,
pub conf_mbreduction: u32,
pub conf_usepseudo: u32,
pub conf_prefinfproof: u32,
pub conf_preferbinary: u32,
pub conf_allowlocal: u32,
pub conf_settlelocal: u32,
pub conf_repropagate: u32,
pub conf_keepreprop: u32,
pub conf_separate: u32,
pub conf_dynamic: u32,
pub conf_removable: u32,
pub conf_depthscorefac: f64,
pub conf_proofscorefac: f64,
pub conf_uplockscorefac: f64,
pub conf_downlockscorefac: f64,
pub conf_scorefac: f64,
pub conf_restartnum: i32,
pub conf_restartfac: f64,
pub conf_ignorerelaxedbd: u32,
pub conf_maxvarsdetectimpliedbounds: i32,
pub conf_fullshortenconflict: u32,
pub conf_conflictweight: f64,
pub conf_conflictgraphweight: f64,
pub conf_weightsize: f64,
pub conf_weightrepropdepth: f64,
pub conf_weightvaliddepth: f64,
pub conf_sepaaltproofs: u32,
pub conf_minimprove: f64,
pub conf_uselocalrows: u32,
pub conf_maxcoefquot: f64,
pub conf_fixandcontinue: u32,
pub cons_agelimit: i32,
pub cons_obsoleteage: i32,
pub cons_disableenfops: u32,
pub disp_verblevel: u32,
pub disp_width: i32,
pub disp_freq: i32,
pub disp_headerfreq: i32,
pub disp_lpinfo: u32,
pub disp_allviols: u32,
pub disp_relevantstats: u32,
pub heur_useuctsubscip: u32,
pub history_valuebased: u32,
pub history_allowmerge: u32,
pub history_allowtransfer: u32,
pub iisfinder_irreducible: u32,
pub iisfinder_removebounds: u32,
pub iisfinder_silent: u32,
pub iisfinder_stopafterone: u32,
pub iisfinder_removeunusedvars: u32,
pub iisfinder_time: f64,
pub iisfinder_nodes: i64,
pub limit_time: f64,
pub limit_memory: f64,
pub limit_gap: f64,
pub limit_absgap: f64,
pub limit_primal: f64,
pub limit_dual: f64,
pub limit_nodes: i64,
pub limit_totalnodes: i64,
pub limit_stallnodes: i64,
pub limit_solutions: i32,
pub limit_bestsol: i32,
pub limit_maxsol: i32,
pub limit_maxorigsol: i32,
pub limit_restarts: i32,
pub limit_autorestartnodes: i32,
pub istimelimitfinite: u32,
pub lp_solvefreq: i32,
pub lp_iterlim: i64,
pub lp_rootiterlim: i64,
pub lp_solvedepth: i32,
pub lp_minsolvedepth: i32,
pub lp_initalgorithm: i8,
pub lp_resolvealgorithm: i8,
pub lp_pricing: i8,
pub lp_clearinitialprobinglp: u32,
pub lp_resolverestore: u32,
pub lp_freesolvalbuffers: u32,
pub lp_colagelimit: i32,
pub lp_rowagelimit: i32,
pub lp_cleanupcols: u32,
pub lp_cleanupcolsroot: u32,
pub lp_cleanuprows: u32,
pub lp_cleanuprowsroot: u32,
pub lp_checkstability: u32,
pub lp_conditionlimit: f64,
pub lp_markowitz: f64,
pub lp_checkprimfeas: u32,
pub lp_checkdualfeas: u32,
pub lp_checkfarkas: u32,
pub lp_fastmip: i32,
pub lp_scaling: i32,
pub lp_presolving: u32,
pub lp_lexdualalgo: u32,
pub lp_lexdualrootonly: u32,
pub lp_lexdualmaxrounds: i32,
pub lp_lexdualbasic: u32,
pub lp_lexdualstalling: u32,
pub lp_disablecutoff: i32,
pub lp_rowrepswitch: f64,
pub lp_threads: i32,
pub lp_resolveiterfac: f64,
pub lp_resolveitermin: i32,
pub lp_solutionpolishing: i32,
pub lp_refactorinterval: i32,
pub lp_alwaysgetduals: u32,
pub nlp_disable: u32,
pub nlp_solver: *mut i8,
pub mem_savefac: f64,
pub mem_arraygrowfac: f64,
pub mem_treegrowfac: f64,
pub mem_pathgrowfac: f64,
pub mem_arraygrowinit: i32,
pub mem_treegrowinit: i32,
pub mem_pathgrowinit: i32,
pub misc_catchctrlc: u32,
pub misc_usevartable: u32,
pub misc_useconstable: u32,
pub misc_usesmalltables: u32,
pub misc_resetstat: u32,
pub misc_improvingsols: u32,
pub misc_printreason: u32,
pub misc_estimexternmem: u32,
pub misc_avoidmemout: u32,
pub misc_transorigsols: u32,
pub misc_transsolsorig: u32,
pub misc_calcintegral: u32,
pub misc_finitesolstore: u32,
pub misc_outputorigsol: u32,
pub misc_allowstrongdualreds: u32,
pub misc_allowweakdualreds: u32,
pub misc_referencevalue: f64,
pub misc_usesymmetry: i32,
pub misc_debugsol: *mut i8,
pub misc_scaleobj: u32,
pub misc_showdivingstats: u32,
pub random_randomseedshift: i32,
pub random_randomseedshiftmultiplier: i32,
pub random_permutationseed: i32,
pub random_randomseed: i32,
pub random_permuteconss: u32,
pub random_permutevars: u32,
pub nodesel_childsel: i8,
pub num_infinity: f64,
pub num_epsilon: f64,
pub num_sumepsilon: f64,
pub num_feastol: f64,
pub num_checkfeastolfac: f64,
pub num_lpfeastolfactor: f64,
pub num_dualfeastol: f64,
pub num_barrierconvtol: f64,
pub num_boundstreps: f64,
pub num_pseudocosteps: f64,
pub num_pseudocostdelta: f64,
pub num_recompfac: f64,
pub num_hugeval: f64,
pub num_relaxfeastol: f64,
pub presol_abortfac: f64,
pub presol_maxrounds: i32,
pub presol_maxrestarts: i32,
pub presol_clqtablefac: f64,
pub presol_restartfac: f64,
pub presol_immrestartfac: f64,
pub presol_subrestartfac: f64,
pub presol_restartminred: f64,
pub presol_donotmultaggr: u32,
pub presol_donotaggr: u32,
pub price_abortfac: f64,
pub price_maxvars: i32,
pub price_maxvarsroot: i32,
pub price_delvars: u32,
pub price_delvarsroot: u32,
pub decomp_benderslabels: u32,
pub decomp_applybenders: u32,
pub decomp_maxgraphedge: i32,
pub decomp_disablemeasures: u32,
pub benders_soltol: f64,
pub benders_cutlpsol: u32,
pub benders_copybenders: u32,
pub prop_maxrounds: i32,
pub prop_maxroundsroot: i32,
pub prop_abortoncutoff: u32,
pub reopt_objsimsol: f64,
pub reopt_objsimrootlp: f64,
pub reopt_objsimdelay: f64,
pub reopt_varorderinterdiction: i8,
pub reopt_forceheurrestart: i32,
pub reopt_maxcutage: i32,
pub reopt_maxdiffofnodes: i32,
pub reopt_maxsavednodes: i32,
pub reopt_solvelp: i32,
pub reopt_solvelpdiff: i32,
pub reopt_savesols: i32,
pub reopt_commontimelimit: u32,
pub reopt_enable: u32,
pub reopt_reducetofrontier: u32,
pub reopt_saveprop: u32,
pub reopt_sbinit: u32,
pub reopt_shrinkinner: u32,
pub reopt_sepaglbinfsubtrees: u32,
pub reopt_sepabestsol: u32,
pub reopt_storevarhistory: u32,
pub reopt_usepscost: u32,
pub reopt_usecuts: u32,
pub reopt_usesplitcons: u32,
pub sepa_maxbounddist: f64,
pub sepa_maxlocalbounddist: f64,
pub sepa_maxcoefratio: f64,
pub sepa_maxcoefratiofacrowprep: f64,
pub sepa_minefficacy: f64,
pub sepa_minefficacyroot: f64,
pub sepa_minortho: f64,
pub sepa_minorthoroot: f64,
pub sepa_minactivityquot: f64,
pub sepa_orthofunc: i8,
pub sepa_efficacynorm: i8,
pub sepa_cutselrestart: i8,
pub sepa_cutselsubscip: i8,
pub sepa_filtercutpoolrel: u32,
pub sepa_maxruns: i32,
pub sepa_maxrounds: i32,
pub sepa_maxroundsroot: i32,
pub sepa_maxroundsrootsubrun: i32,
pub sepa_maxaddrounds: i32,
pub sepa_maxstallrounds: i32,
pub sepa_maxstallroundsroot: i32,
pub sepa_maxcutsgenfactor: f64,
pub sepa_maxcutsrootgenfactor: f64,
pub sepa_maxcuts: i32,
pub sepa_maxcutsroot: i32,
pub sepa_cutagelimit: i32,
pub sepa_poolfreq: i32,
pub parallel_mode: i32,
pub parallel_minnthreads: i32,
pub parallel_maxnthreads: i32,
pub concurrent_changeseeds: u32,
pub concurrent_changechildsel: u32,
pub concurrent_commvarbnds: u32,
pub concurrent_presolvebefore: u32,
pub concurrent_initseed: i32,
pub concurrent_freqinit: f64,
pub concurrent_freqmax: f64,
pub concurrent_freqfactor: f64,
pub concurrent_targetprogress: f64,
pub concurrent_maxnsols: i32,
pub concurrent_nbestsols: i32,
pub concurrent_maxnsyncdelay: i32,
pub concurrent_minsyncdelay: f64,
pub concurrent_paramsetprefix: *mut i8,
pub time_clocktype: u32,
pub time_enabled: u32,
pub time_reading: u32,
pub time_rareclockcheck: u32,
pub time_statistictiming: u32,
pub time_nlpieval: u32,
pub compr_enable: u32,
pub compr_time: f64,
pub visual_vbcfilename: *mut i8,
pub visual_bakfilename: *mut i8,
pub visual_realtime: u32,
pub visual_dispsols: u32,
pub visual_displb: u32,
pub visual_objextern: u32,
pub exact_enable: u32,
pub exact_improvingsols: u32,
pub exact_interleavedbstrat: i32,
pub exact_safedbmethod: i8,
pub exact_psdualcolselection: i32,
pub exact_lpinfo: u32,
pub exact_allownegslack: u32,
pub exact_cutmaxdenom: i64,
pub exact_cutapproxmaxboundval: i64,
pub certificate_filename: *mut i8,
pub certificate_maxfilesize: f64,
pub read_initialconss: u32,
pub read_dynamicconss: u32,
pub read_dynamiccols: u32,
pub read_dynamicrows: u32,
pub write_allconss: u32,
pub write_printzeros: u32,
pub write_genoffset: i32,
pub write_implintlevel: i32,
}Fields§
§stage: u32< SCIP operation stage
scip: *mut Scip< very ugly: pointer to scip main data structure for callback methods
paramset: *mut SCIP_ParamSet< set of parameters
buffer: *mut BMS_BufMem< memory buffers for short living temporary objects
cleanbuffer: *mut BMS_BufMem< memory buffers for short living temporary objects init. to all zero
readers: *mut *mut SCIP_Reader< file readers
pricers: *mut *mut SCIP_Pricer< variable pricers
conshdlrs: *mut *mut SCIP_Conshdlr< constraint handlers (sorted by check priority)
conshdlrs_sepa: *mut *mut SCIP_Conshdlr< constraint handlers (sorted by separation priority)
conshdlrs_enfo: *mut *mut SCIP_Conshdlr< constraint handlers (sorted by enforcement priority)
conshdlrs_include: *mut *mut SCIP_Conshdlr< constraint handlers (sorted by inclusion order)
conflicthdlrs: *mut *mut SCIP_Conflicthdlr< conflict handlers
presols: *mut *mut SCIP_Presol< presolvers
relaxs: *mut *mut SCIP_Relax< relaxators
sepas: *mut *mut SCIP_Sepa< separators
cutsels: *mut *mut SCIP_Cutsel< cut selectors
props: *mut *mut SCIP_Prop< propagators
props_presol: *mut *mut SCIP_Prop< propagators (sorted by presol priority)
heurs: *mut *mut SCIP_Heur< primal heuristics
comprs: *mut *mut SCIP_Compr< tree compressions
eventhdlrs: *mut *mut SCIP_Eventhdlr< event handlers
nodesels: *mut *mut SCIP_Nodesel< node selectors
nodesel: *mut SCIP_Nodesel< currently used node selector, or NULL if invalid
branchrules: *mut *mut SCIP_Branchrule< branching rules
iisfinders: *mut *mut SCIP_IISfinder< irreducible infeasible subsystem (IIS) rules
disps: *mut *mut SCIP_Disp< display columns
tables: *mut *mut SCIP_Table< statistics tables
dialogs: *mut *mut SCIP_Dialog< dialogs
exprhdlrs: *mut *mut SCIP_Exprhdlr< expression handlers
exprhdlrvar: *mut SCIP_Exprhdlr< expression handler for variables (for quick access)
exprhdlrval: *mut SCIP_Exprhdlr< expression handler for constant values (for quick access)
exprhdlrsum: *mut SCIP_Exprhdlr< expression handler for sums (for quick access)
exprhdlrproduct: *mut SCIP_Exprhdlr< expression handler for products (for quick access)
exprhdlrpow: *mut SCIP_Exprhdlr< expression handler for power (for quick access)
nlpis: *mut *mut SCIP_Nlpi< interfaces to NLP solvers
concsolvertypes: *mut *mut SCIP_ConcSolverType< concurrent solver types
concsolvers: *mut *mut SCIP_ConcSolver< the concurrent solvers used for solving
benders: *mut *mut SCIP_Benders< the data structures managing the Benders’ decomposition algorithm
debugsoldata: *mut SCIP_DebugSolData< data for debug solutions
banditvtables: *mut *mut SCIP_BanditVTable< virtual function tables for bandit algorithms
extcodenames: *mut *mut i8< names of externals codes
extcodedescs: *mut *mut i8< descriptions of external codes
nreaders: i32< number of file readers
readerssize: i32< size of readers array
npricers: i32< number of variable pricers
nactivepricers: i32< number of variable pricers used in the current problem
pricerssize: i32< size of pricers array
nconshdlrs: i32< number of constraint handlers
conshdlrssize: i32< size of conshdlrs array
nconflicthdlrs: i32< number of conflict handlers
conflicthdlrssize: i32< size of conflicthdlrs array
npresols: i32< number of presolvers
presolssize: i32< size of presols array
nrelaxs: i32< number of relaxators
relaxssize: i32< size of relaxs array
nsepas: i32< number of separators
sepassize: i32< size of sepas array
ncutsels: i32< number of cut selectors
cutselssize: i32< size of cutsels array
nprops: i32< number of propagators
propssize: i32< size of props array
nheurs: i32< number of primal heuristics
heurssize: i32< size of heurs array
ncomprs: i32< number of tree compressions
comprssize: i32< size of comprs array
neventhdlrs: i32< number of event handlers
eventhdlrssize: i32< size of eventhdlrs array
nnodesels: i32< number of node selectors
nodeselssize: i32< size of nodesels array
nbranchrules: i32< number of branching rules
branchrulessize: i32< size of branchrules array
niisfinders: i32< number of IIS rules
iisfinderssize: i32< size of IIS finders array
ndisps: i32< number of display columns
dispssize: i32< size of disps array
ntables: i32< number of statistics tables
tablessize: i32< size of tables array
ndialogs: i32< number of dialogs
dialogssize: i32< size of dialogs array
nexprhdlrs: i32< number of expression handlers
exprhdlrssize: i32< size of expression handlers array
nnlpis: i32< number of NLPIs
nlpissize: i32< size of NLPIs array
nconcsolvertypes: i32< number of concurrent solver types
concsolvertypessize: i32< size of concurrent solver types array
nconcsolvers: i32< number of concurrent solvers used for solving
concsolverssize: i32< size of concurrent solvers array
nbenders: i32< number of Benders’ decomposition algorithms
nactivebenders: i32< number of Benders’ decomposition algorithms that are used
benderssize: i32< size of Benders’ decomposition algorithms array
nextcodes: i32< number of external codes
extcodessize: i32< size of external code arrays
nbanditvtables: i32< number of bandit algorithm virtual function tables
banditvtablessize: i32< size of banditvtables array
pricerssorted: u32< are the pricers sorted by activity and priority?
pricersnamesorted: u32< are the pricers sorted by name?
conflicthdlrssorted: u32< are the conflict handlers sorted by priority?
conflicthdlrsnamesorted: u32< are the conflict handlers sorted by name?
presolssorted: u32< are the presolvers sorted by priority?
presolsnamesorted: u32< are the presolvers sorted by name?
relaxssorted: u32< are the relaxators sorted by priority?
relaxsnamesorted: u32< are the relaxators sorted by name?
sepassorted: u32< are the separators sorted by priority?
sepasnamesorted: u32< are the separators sorted by name?
cutselssorted: u32< are the cutsels sorted by priority?
propssorted: u32< are the propagators sorted by priority?
propspresolsorted: u32< are the propagators in prop_presol sorted?
propsnamesorted: u32< are the propagators sorted by name?
heurssorted: u32< are the heuristics sorted by priority?
heursnamesorted: u32< are the heuristics sorted by name?
comprssorted: u32< are the compressions sorted by priority?
comprsnamesorted: u32< are the compressions sorted by name?
branchrulessorted: u32< are the branching rules sorted by priority?
branchrulesnamesorted: u32< are the branching rules sorted by name?
iisfinderssorted: u32< are the IIS rules sorted by priority
tablessorted: u32< are the tables sorted by position?
exprhdlrssorted: u32< are the expression handlers sorted by name?
nlpissorted: u32< are the NLPIs sorted by priority?
benderssorted: u32< are the Benders’ algorithms sorted by activity and priority?
bendersnamesorted: u32< are the Benders’ algorithms sorted by name?
limitchanged: u32< marks whether any of the limit parameters was changed
subscipsoff: u32< marks whether the sub-SCIPs have been deactivated
branch_scorefunc: i8< branching score function (’s’um, ’p’roduct, ’q’uotient)
branch_firstsbchild: i8< child node to be regarded first during strong branching (only with propagation): ’u’p child, ’d’own child, ’h’istory-based, or ’a’utomatic
branch_scorefac: f64< branching score factor to weigh downward and upward gain prediction in sum score function
branch_preferbinary: u32< should branching on binary variables be preferred?
branch_clamp: f64< minimal fractional distance of branching point to a continuous variable’ bounds; a value of 0.5 leads to branching always in the middle of a bounded domain
branch_midpull: f64< fraction by which to move branching point of a continuous variable towards the middle of the domain; a value of 1.0 leads to branching always in the middle of the domain
branch_midpullreldomtrig: f64< multiply midpull by relative domain width if the latter is below this value
branch_lpgainnorm: i8< strategy for normalizing LP gain when updating pseudo costs of continuous variables
branch_delaypscost: u32< whether to delay pseudo costs updates for continuous variables to after separation
branch_divingpscost: u32< should pseudo costs be updated also in diving and probing mode?
branch_collectancpscost: u32< should ancestral pseudo costs be updated?
branch_forceall: u32< should all strong branching children be regarded even if one is detected to be infeasible? (only with propagation)
branch_checksbsol: u32< should LP solutions during strong branching with propagation be checked for feasibility?
branch_roundsbsol: u32< should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE)
branch_sumadjustscore: u32< score adjustment near zero by \b adding epsilon (TRUE) or using maximum (FALSE)
conf_maxvarsfac: f64< maximal fraction of variables involved in a conflict constraint
conf_maxvarsfracres: f64< maximal fraction of variables involved in a resolution conflict constraint
conf_minmaxvars: i32< minimal absolute maximum of variables involved in a conflict constraint
conf_maxlploops: i32< maximal number of LP resolving loops during conflict analysis (-1: no limit)
conf_lpiterations: i32< maximal number of LP iterations in each LP resolving loop (-1: no limit)
conf_fuiplevels: i32< number of depth levels up to which first UIP’s are used in conflict analysis (-1: use All-FirstUIP rule)
conf_resfuiplevels: i32< number of depth levels up to which first UIP’s are used in resolution conflict analysis (-1: use All-FirstUIP rule)
conf_interconss: i32< maximal number of intermediate conflict constraints generated in conflict graph (-1: use every intermediate constraint)
conf_maxconss: i32< maximal number of conflict constraints accepted at an infeasible node (-1: use all generated conflict constraints)
conf_maxstoresize: i32< maximal size of conflict store
conf_reconvlevels: i32< number of depth levels up to which UIP reconvergence constraints are generated (-1: generate reconvergence constraints in all depth levels)
conf_enable: u32< should conflict analysis be enabled?
conf_cleanbnddepend: u32< should conflicts related to an old cutoff bound be removed?
conf_useprop: u32< should propagation conflict analysis be used? (uses conflict graph only)
conf_usegenres: u32< should generalized resolution conflict analysis be used?
conf_useinflp: i8< should infeasible LP conflict analysis be used? (’o’ff, ’c’onflict graph, ’d’ual ray, ’b’oth conflict graph and dual ray)
conf_useboundlp: i8< should bound exceeding LP conflict analysis be used? (’o’ff, ’c’onflict graph, ’d’ual ray, ’b’oth conflict graph and dual ray)
conf_usesb: u32< should infeasible/bound exceeding strong branching conflict analysis be used?
conf_reduction: i8< which reduction should be used? (’o’ff, ’m’ir)
conf_mbreduction: u32< should apply the mixed binary reduction?
conf_usepseudo: u32< should pseudo solution conflict analysis be used?
conf_prefinfproof: u32< prefer infeasibility proof to boundexceeding proof
conf_preferbinary: u32< should binary conflicts be preferred?
conf_allowlocal: u32< should conflict constraints be generated that are only valid locally?
conf_settlelocal: u32< should conflict constraints be attached only to the local subtree where they can be useful?
conf_repropagate: u32< should earlier nodes be repropagated in order to replace branching decisions by deductions?
conf_keepreprop: u32< should constraints be kept for repropagation even if they are too long?
conf_separate: u32< should the conflict constraints be separated?
conf_dynamic: u32< should the conflict constraints be subject to aging?
conf_removable: u32< should the conflict’s relaxations be subject to LP aging and cleanup?
conf_depthscorefac: f64< score factor for depth level in bound relaxation heuristic
conf_proofscorefac: f64< score factor for contribution to infeasibility proof in bound relaxation heuristic
conf_uplockscorefac: f64< score factor for number of up locks in bound relaxation heuristic
conf_downlockscorefac: f64< score factor for number of down locks in bound relaxation heuristic
conf_scorefac: f64< factor to decrease importance of variables’ earlier conflict scores
conf_restartnum: i32< number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts)
conf_restartfac: f64< factor to increase restartnum with after each restart
conf_ignorerelaxedbd: u32< should relaxed bounds be ignored?
conf_maxvarsdetectimpliedbounds: i32< maximal number of variables to try to detect global bound implications and shorten the whole conflict set (0: disabled )
conf_fullshortenconflict: u32< try to shorten the whole conflict set or terminate early (depending on the ‘maxvarsdetectimpliedbounds’ parameter)
conf_conflictweight: f64< the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict
conf_conflictgraphweight: f64< the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph
conf_weightsize: f64< weight of the size of a conflict used in score calculation
conf_weightrepropdepth: f64< weight of the prepropagtion depth of a conflict used in score calculation
conf_weightvaliddepth: f64< weight of the valid depth of a conflict used in score calculation
conf_sepaaltproofs: u32< separate valid inequalities from dualray proofs
conf_minimprove: f64< minimal improvement of primal bound to remove conflicts depending on a previous incumbent.
conf_uselocalrows: u32< use local rows to construct infeasibility proofs
conf_maxcoefquot: f64< largest allowed quotient of max, min coefficient in a conflict constraint generated by generalized resolution.
conf_fixandcontinue: u32< should we fix unresolvable bound changes and continue?
cons_agelimit: i32< maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, -1: disable aging)
cons_obsoleteage: i32< age of a constraint after which it is marked obsolete (0: dynamic, -1: disable obsoletion)
cons_disableenfops: u32< should enforcement of pseudo solution be disabled?
disp_verblevel: u32< verbosity level of output
disp_width: i32< maximal number of characters in a node information line
disp_freq: i32< frequency for displaying node information lines
disp_headerfreq: i32< frequency for displaying header lines (every n’th node information line)
disp_lpinfo: u32< should the LP solver display status messages?
disp_allviols: u32< display all violations of the best solution after the solving process finished?
disp_relevantstats: u32< should the relevant statistics be displayed at the end of solving?
heur_useuctsubscip: u32< should setting of common subscip parameters include the activation of the UCT node selector?
history_valuebased: u32< should statistics be collected for variable domain value pairs?
history_allowmerge: u32< should variable histories be merged from sub-SCIPs whenever possible?
history_allowtransfer: u32< should variable histories be transferred to initialize SCIP copies?
iisfinder_irreducible: u32< should the resultant infeasible set be irreducible, i.e., an IIS not an IS
iisfinder_removebounds: u32< should bounds of the problem be considered for removal
iisfinder_silent: u32< should the IIS finders be run silently
iisfinder_stopafterone: u32< should the IIS search stop after a single IIS finder is run (excluding post processing)
iisfinder_removeunusedvars: u32< should vars that do not feature in any constraints be removed at the end of the IIS process
iisfinder_time: f64< maximal time in seconds for all IIS finders to run
iisfinder_nodes: i64< maximal number of nodes to process for all IIS finders (-1: no limit)
limit_time: f64< maximal time in seconds to run
limit_memory: f64< maximal memory usage in MB
limit_gap: f64< solving stops, if the given gap is reached
limit_absgap: f64< solving stops, if the absolute difference between primal and dual bound reaches this value
limit_primal: f64< solving stops, if primal bound is at least as good as given value
limit_dual: f64< solving stops, if dual bound is at least as good as given value
limit_nodes: i64< maximal number of nodes to process (-1: no limit)
limit_totalnodes: i64< maximal number of total nodes (incl. restarts) to process (-1: no limit)
limit_stallnodes: i64< solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (-1: no limit)
limit_solutions: i32< solving stops, if the given number of solutions were found; this limit is first checked in presolving (-1: no limit)
limit_bestsol: i32< solving stops, if the given number of solution improvements were found (-1: no limit)
limit_maxsol: i32< maximal number of solutions to store in the solution storage
limit_maxorigsol: i32< maximal number of solutions candidates to store in the solution storage of the original problem
limit_restarts: i32< solving stops, if the given number of restarts was triggered (-1: no limit)
limit_autorestartnodes: i32< nodes to trigger automatic restart
istimelimitfinite: u32< is the time limit finite
lp_solvefreq: i32< frequency for solving LP at the nodes (-1: never; 0: only root LP)
lp_iterlim: i64< iteration limit for each single LP solve; -1: no limit
lp_rootiterlim: i64< iteration limit for initial root LP solve; -1: no limit
lp_solvedepth: i32< maximal depth for solving LP at the nodes (-1: no depth limit)
lp_minsolvedepth: i32< minimal depth for solving LP at the nodes
lp_initalgorithm: i8< LP algorithm for solving initial LP relaxations (’s’implex, ’b’arrier, barrier with ’c’rossover)
lp_resolvealgorithm: i8< LP algorithm for resolving LP relaxations if a starting basis exists (’s’implex, ’b’arrier, barrier with ’c’rossover)
lp_pricing: i8< LP pricing strategy (’a’uto, ’f’ull pricing, ’s’teepest edge pricing, ’q’uickstart steepest edge pricing, ’d’evex pricing)
lp_clearinitialprobinglp: u32< should lp state be cleared at the end of probing mode when LP was initially unsolved, e.g., when called right after presolving?
lp_resolverestore: u32< should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?
lp_freesolvalbuffers: u32< should the buffers for storing LP solution values during diving be freed at end of diving?
lp_colagelimit: i32< maximum age a column can reach before it is deleted from the SCIP_LP (-1: don’t delete columns due to aging)
lp_rowagelimit: i32< maximum age a row can reach before it is deleted from the LP (-1: don’t delete rows due to aging)
lp_cleanupcols: u32< should new non-basic columns be removed after LP solving?
lp_cleanupcolsroot: u32< should new non-basic columns be removed after root LP solving?
lp_cleanuprows: u32< should new basic rows be removed after LP solving?
lp_cleanuprowsroot: u32< should new basic rows be removed after root LP solving?
lp_checkstability: u32< should LP solver’s return status be checked for stability?
lp_conditionlimit: f64< maximum condition number of LP basis counted as stable (-1.0: no check)
lp_markowitz: f64< minimal Markowitz threshold to control sparsity/stability in LU factorization
lp_checkprimfeas: u32< should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?
lp_checkdualfeas: u32< should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?
lp_checkfarkas: u32< should infeasibility proofs from the LP be checked?
lp_fastmip: i32< which FASTMIP setting of LP solver should be used? 0: off, 1: medium, 2: full
lp_scaling: i32< LP scaling (0: none, 1: normal, 2: aggressive)
lp_presolving: u32< should presolving of LP solver be used?
lp_lexdualalgo: u32< should the lexicographic dual algorithm be used?
lp_lexdualrootonly: u32< should the lexicographic dual algorithm be applied only at the root node
lp_lexdualmaxrounds: i32< maximum number of rounds in the lexicographic dual algorithm
lp_lexdualbasic: u32< choose fractional basic variables in lexicographic dual algorithm
lp_lexdualstalling: u32< turn on the lex dual algorithm only when stalling?
lp_disablecutoff: i32< disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)
lp_rowrepswitch: f64< simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value
lp_threads: i32< number of threads used for solving the LP (0: automatic)
lp_resolveiterfac: f64< factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)
lp_resolveitermin: i32< minimum number of iterations that are allowed for LP resolve
lp_solutionpolishing: i32< LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)
lp_refactorinterval: i32< LP refactorization interval (0: automatic)
lp_alwaysgetduals: u32< should the dual solution always be collected for LP solutions.
nlp_disable: u32< should the NLP be disabled even if a constraint handler enabled it?
nlp_solver: *mut i8< name of NLP solver to use
mem_savefac: f64< fraction of maximal memory usage resulting in switch to memory saving mode
mem_arraygrowfac: f64< memory growing factor for dynamically allocated arrays
mem_treegrowfac: f64< memory growing factor for tree array
mem_pathgrowfac: f64< memory growing factor for path array
mem_arraygrowinit: i32< initial size of dynamically allocated arrays
mem_treegrowinit: i32< initial size of tree array
mem_pathgrowinit: i32< initial size of path array
misc_catchctrlc: u32< should the CTRL-C interrupt be caught by SCIP?
misc_usevartable: u32< should a hashtable be used to map from variable names to variables?
misc_useconstable: u32< should a hashtable be used to map from constraint names to constraints?
misc_usesmalltables: u32< should smaller hashtables be used? yields better performance for small problems with about 100 variables
misc_resetstat: u32< should the statistics be reset if the transformed problem is freed otherwise the statistics get reset after original problem is freed (in case of bender decomposition this parameter should be set to FALSE and therefore can be used to collect statistics over all runs)
misc_improvingsols: u32< should only solutions be checked which improve the primal bound
misc_printreason: u32< should the reason be printed if a given start solution is infeasible?
misc_estimexternmem: u32< should the usage of external memory be estimated?
misc_avoidmemout: u32< try to avoid running into memory limit by restricting plugins like heuristics?
misc_transorigsols: u32< should SCIP try to transfer original solutions to the transformed space (after presolving)?
misc_transsolsorig: u32< should SCIP try to transfer transformed solutions to the original space (after solving)?
misc_calcintegral: u32< should SCIP calculate the primal dual integral value which may require a large number of additional clock calls (and decrease the performance)?
misc_finitesolstore: u32< should SCIP try to remove infinite fixings from solutions copied to the solution store?
misc_outputorigsol: u32< should the best solution be transformed to the orignal space and be output in command line run?
misc_allowstrongdualreds: u32< should strong dual reductions be allowed in propagation and presolving?
misc_allowweakdualreds: u32< should weak dual reductions be allowed in propagation and presolving?
misc_referencevalue: f64< objective value for reference purposes
misc_usesymmetry: i32< bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks); 2: orbital fixing; 3: orbitopes and orbital fixing; 4: Schreier Sims cuts; 5: Schreier Sims cuts and symresacks)
misc_debugsol: *mut i8< path to a debug solution
misc_scaleobj: u32< should the objective function be scaled?
misc_showdivingstats: u32< should detailed statistics for diving heuristics be shown?
random_randomseedshift: i32< global shift of all random seeds in the plugins, this will have no impact on the permutation and LP seeds
random_randomseedshiftmultiplier: i32< multiplier for global shift random_randomseedshift
random_permutationseed: i32< seed value for permuting the problem after reading/transformation (0: no permutation)
random_randomseed: i32< random seed for LP solver, e.g. for perturbations in the simplex (0: LP default)
random_permuteconss: u32< should order of constraints be permuted (depends on permutationseed)?
random_permutevars: u32< should order of variables be permuted (depends on permutationseed)?
nodesel_childsel: i8< child selection rule (’d’own, ’u’p, ’p’seudo costs, ’i’nference, ’l’p value, ’r’oot LP value difference, ’h’brid inference/root LP value difference)
num_infinity: f64< values larger than this are considered infinity
num_epsilon: f64< absolute values smaller than this are considered zero
num_sumepsilon: f64< absolute values of sums smaller than this are considered zero
num_feastol: f64< feasibility tolerance for constraints
num_checkfeastolfac: f64< factor to change the feasibility tolerance when testing the best solution for feasibility (after solving process)
num_lpfeastolfactor: f64< factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver (user parameter, see also num_relaxfeastol)
num_dualfeastol: f64< feasibility tolerance for reduced costs
num_barrierconvtol: f64< convergence tolerance used in barrier algorithm
num_boundstreps: f64< minimal improve for strengthening bounds
num_pseudocosteps: f64< minimal variable distance value to use for pseudo cost updates
num_pseudocostdelta: f64< minimal objective distance value to use for pseudo cost updates
num_recompfac: f64< minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update
num_hugeval: f64< values larger than this are considered huge and should be handled separately (e.g., in activity computation)
num_relaxfeastol: f64< primal feasibility tolerance for relaxations (set by core or plugins, not a parameter)
presol_abortfac: f64< abort presolve, if l.t. this frac of the problem was changed in last round
presol_maxrounds: i32< maximal number of presolving rounds (-1: unlimited)
presol_maxrestarts: i32< maximal number of restarts (-1: unlimited)
presol_clqtablefac: f64< limit on number of entries in clique table relative to number of problem nonzeros
presol_restartfac: f64< fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation
presol_immrestartfac: f64< fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing
presol_subrestartfac: f64< fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing
presol_restartminred: f64< minimal fraction of integer variables removed after restart to allow for an additional restart
presol_donotmultaggr: u32< should multi-aggregation of variables be forbidden?
presol_donotaggr: u32< should aggregation of variables be forbidden?
price_abortfac: f64< pricing is aborted, if fac * maxpricevars pricing candidates were found
price_maxvars: i32< maximal number of variables priced in per pricing round
price_maxvarsroot: i32< maximal number of priced variables at the root node
price_delvars: u32< should variables created at the current node be deleted when the node is solved in case they are not present in the LP anymore?
price_delvarsroot: u32< should variables created at the root node be deleted when the root is solved in case they are not present in the LP anymore?
decomp_benderslabels: u32< should the variables be labeled for the application of Benders’ decomposition
decomp_applybenders: u32< if a decomposition exists, should Benders’ decomposition be applied
decomp_maxgraphedge: i32< maximum number of edges in block graph computation (-1: no limit, 0: disable block graph computation)
decomp_disablemeasures: u32< disable expensive measures
benders_soltol: f64< the tolerance for checking optimality in Benders’ decomposition
benders_cutlpsol: u32< should cuts be generated from the solution to the LP relaxation?
benders_copybenders: u32< should Benders’ decomposition be copied for sub-SCIPs?
prop_maxrounds: i32< maximal number of propagation rounds per node (-1: unlimited)
prop_maxroundsroot: i32< maximal number of propagation rounds in the root node (-1: unlimited)
prop_abortoncutoff: u32< should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints
reopt_objsimsol: f64< similarity of two objective functions to reuse stored solutions.
reopt_objsimrootlp: f64< similarity of two sequential objective function to disable solving the root LP.
reopt_objsimdelay: f64< minimum similarity for using reoptimization of the search tree.
reopt_varorderinterdiction: i8§reopt_forceheurrestart: i32< force a restart if the last n optimal solutions were found by heuristic reoptsols
reopt_maxcutage: i32< maximal age of cuts to use them in reoptimization
reopt_maxdiffofnodes: i32< maximal number of bound changes between two stored nodes on one path
reopt_maxsavednodes: i32< maximal number of saved nodes
reopt_solvelp: i32< strategy for solving the LP at nodes from reoptimization
reopt_solvelpdiff: i32< maximal number of bound changes at node to skip solving the LP
reopt_savesols: i32< number of best solutions which should be saved for the following runs. (-1: save all)
reopt_commontimelimit: u32< time limit over all reoptimization rounds?
reopt_enable: u32< enable reoptimization
reopt_reducetofrontier: u32< delete stored nodes which were not reoptimized
reopt_saveprop: u32< save constraint and propagator propagations
reopt_sbinit: u32< try to fix variables before reoptimizing by probing like strong branching
reopt_shrinkinner: u32< replace branched inner nodes by their child nodes, if the number of bound changes is not to large
reopt_sepaglbinfsubtrees: u32< save global constraints to separate infeasible subtrees
reopt_sepabestsol: u32< separate only the best solution, i.e., for constrained shortest path
reopt_storevarhistory: u32< use variable history of the previous solve if the objective function has changed only slightly
reopt_usepscost: u32< reuse pseudo costs if the objective function changed only slightly
reopt_usecuts: u32< reoptimize cuts found at the root node
reopt_usesplitcons: u32< use constraints to reconstruct the subtree pruned be dual reduction when reactivating the node
sepa_maxbounddist: f64< maximal relative distance from current node’s dual bound to primal bound compared to best node’s dual bound for applying separation (0.0: only on current best node, 1.0: on all nodes)
sepa_maxlocalbounddist: f64< maximal relative distance from current node’s dual bound to primal bound compared to best node’s dual bound for applying local separation (0.0: only on current best node, 1.0: on all nodes)
sepa_maxcoefratio: f64< maximal ratio between coefficients in strongcg, cmir, and flowcover cuts
sepa_maxcoefratiofacrowprep: f64< maximal ratio between coefficients (as factor of 1/feastol) to ensure in rowprep cleanup
sepa_minefficacy: f64< minimal efficacy for a cut to enter the LP
sepa_minefficacyroot: f64< minimal efficacy for a cut to enter the LP in the root node
sepa_minortho: f64< minimal orthogonality for a cut to enter the LP
sepa_minorthoroot: f64< minimal orthogonality for a cut to enter the LP in the root node
sepa_minactivityquot: f64< minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted)
sepa_orthofunc: i8< function used for calc. scalar prod. in orthogonality test (’e’uclidean, ’d’iscrete)
sepa_efficacynorm: i8< row norm to use for efficacy calculation (’e’uclidean, ’m’aximum, ’s’um, ’d’iscrete)
sepa_cutselrestart: i8< cut selection during restart (’a’ge, activity ’q’uotient)
sepa_cutselsubscip: i8< cut selection for sub SCIPs (’a’ge, activity ’q’uotient)
sepa_filtercutpoolrel: u32< should cutpool separate only cuts with high relative efficacy?
sepa_maxruns: i32< maximal number of runs for which separation is enabled (-1: unlimited)
sepa_maxrounds: i32< maximal number of separation rounds per node (-1: unlimited)
sepa_maxroundsroot: i32< maximal number of separation rounds in the root node (-1: unlimited)
sepa_maxroundsrootsubrun: i32< maximal number of separation rounds in the root node of a subsequent run (-1: unlimited)
sepa_maxaddrounds: i32< maximal additional number of separation rounds in subsequent price-and-cut loops (-1: no additional restriction)
sepa_maxstallrounds: i32< maximal number of consecutive separation rounds without objective or integrality improvement (-1: no additional restriction)
sepa_maxstallroundsroot: i32< maximal number of consecutive separation rounds without objective or integrality improvement (-1: no additional restriction)
sepa_maxcutsgenfactor: f64< factor w.r.t. maxcuts for maximal number of cuts generated per separation round (-1.0: no limit, >= 0.0: valid finite limit)
sepa_maxcutsrootgenfactor: f64< factor w.r.t. maxcutsroot for maximal number of generated cuts at the root node (-1.0: no limit, >= 0.0: valid finite limit)
sepa_maxcuts: i32< maximal number of cuts separated per separation round
sepa_maxcutsroot: i32< maximal number of separated cuts at the root node
sepa_cutagelimit: i32< maximum age a cut can reach before it is deleted from the global cut pool
sepa_poolfreq: i32< separation frequency for the global cut pool
parallel_mode: i32< the mode for the parallel implementation. 0: opportunistic or 1: deterministic
parallel_minnthreads: i32< the minimum number of threads used for parallel code
parallel_maxnthreads: i32< the maximum number of threads used for parallel code
concurrent_changeseeds: u32< change the seeds in the different solvers?
concurrent_changechildsel: u32< change the child selection rule in different solvers?
concurrent_commvarbnds: u32< should the concurrent solvers communicate global variable bound changes?
concurrent_presolvebefore: u32< should the problem be presolved before it is copied to the concurrent solvers?
concurrent_initseed: i32< the seed for computing the concurrent solver seeds
concurrent_freqinit: f64< initial frequency of synchronization
concurrent_freqmax: f64< maximal frequency of synchronization
concurrent_freqfactor: f64< factor by which the frequency of synchronization changes
concurrent_targetprogress: f64< when adapting the synchronization frequency this value is the targeted relative difference by which the absolute gap decreases per synchronization
concurrent_maxnsols: i32< maximum number of solutions that will get stored in one synchronization
concurrent_nbestsols: i32< number of best solutions that should be considered for synchronization
concurrent_maxnsyncdelay: i32< max number of synchronizations before data is used
concurrent_minsyncdelay: f64< min offset before synchronization data is used
concurrent_paramsetprefix: *mut i8< path prefix for parameter setting files of concurrent solver scip-custom
time_clocktype: u32< default clock type to use
time_enabled: u32< is timing enabled?
time_reading: u32< belongs reading time to solving time?
time_rareclockcheck: u32< should clock checks of solving time be performed less frequently (might exceed time limit slightly)
time_statistictiming: u32< should timing for statistic output be enabled?
time_nlpieval: u32< should time for evaluation in NLP solves be measured?
compr_enable: u32< should automatic tree compression after presolving be enabled? (only for reoptimization)
compr_time: f64< maximum time to run tree compression heuristics
visual_vbcfilename: *mut i8< name of the VBC tool output file, or - if no VBC output should be created
visual_bakfilename: *mut i8< name of the BAK tool output file, or - if no BAK output should be created
visual_realtime: u32< should the real solving time be used instead of time step counter in visualization?
visual_dispsols: u32< should the node where solutions are found be visualized?
visual_displb: u32< should lower bound information be visualized?
visual_objextern: u32< should be output the external value of the objective?
exact_enable: u32< should the problem be solved exactly (without numerical tolerances)?
exact_improvingsols: u32< should only exact solutions be checked which improve the primal bound?
exact_interleavedbstrat: i32< strategy to interleave safe dual bounding with exact LP solve (0: never, 1: only close to cutoff bound, 2: only at depth lvl 2,4,8,16,…, 3: close to cutoff bound OR at depth lvl 2,4,8,16,…)
exact_safedbmethod: i8< method for computing safe dual bounds (’n’eumaier-shcherbina, ’p’roject-and-shift, ’e’xact LP, ’a’utomatic)
exact_psdualcolselection: i32< strategy for dual column selection in project-and-shift to compute interior point (0: no sel, 1: active rows of inexact primal LP, 2: active rows of exact primal LP)
exact_lpinfo: u32< should exact the LP solver display status messages?
exact_allownegslack: u32< should negative slack variables be used for gomory cuts in exact solving mode?
exact_cutmaxdenom: i64< maximal denominator in cut coefficients, leading to slightly weaker but numerically better cuts (0: disabled)
exact_cutapproxmaxboundval: i64< maximal absolute bound value for wich cut coefficient should be approximated with bounded denominator (0: no restriction)
certificate_filename: *mut i8< name of the certificate file, or “-” if no output should be created
certificate_maxfilesize: f64< maximum size of the certificate file in MB (stop printing when reached)
read_initialconss: u32< should model constraints be marked as initial?
read_dynamicconss: u32< should model constraints be subject to aging?
read_dynamiccols: u32< should columns be added and removed dynamically to the LP?
read_dynamicrows: u32< should rows be added and removed dynamically to the LP?
write_allconss: u32< should all constraints be written (including the redundant constraints)?
write_printzeros: u32< should variables set to zero be printed?
write_genoffset: i32< when writing the problem with generic names, we start with index 0; using this parameter we can change the starting index to be different
write_implintlevel: i32< should integrality constraints (i.c.) be written for implied integral variables? (0: use original i.c., 1: add i.c. to strongly implied integral vars, 2: add i.c. to all implied integral vars, -1: remove i.c. from strongly implied integral vars, -2: remove i.c. from all implied integral vars)“