39#if defined(_WIN32) || defined(_WIN64)
80 SCIPerrorMessage(
"parameter <%s> is fixed and cannot be changed. Unfix it to allow changing the value.\n", param->
name);
101 SCIPerrorMessage(
"Invalid value <%u> for bool parameter <%s>. Must be <0> (FALSE) or <1> (TRUE).\n", value, param->
name);
122 SCIPerrorMessage(
"Invalid value <%d> for int parameter <%s>. Must be in range [%d,%d].\n",
166 SCIPerrorMessage(
"Invalid value <%.15g> for real parameter <%s>. Must be in range [%.15g,%.15g].\n",
186 if( value ==
'\b' || value ==
'\f' || value ==
'\n' || value ==
'\r' || value ==
'\v' )
197 while( *
c !=
'\0' && *
c != value )
202 SCIPerrorMessage(
"Invalid value <%c> for char parameter <%s>. Must be in set {%s}.\n",
231 for(
i = 0;
i < (
unsigned int) strlen(value); ++
i )
233 if( value[
i] ==
'\b' || value[
i] ==
'\f' || value[
i] ==
'\n' || value[
i] ==
'\r' || value[
i] ==
'\v' )
235 SCIPerrorMessage(
"Invalid character <%d> in string parameter <%s> at position %u.\n", (
int)value[
i], param->
name,
i);
267 SCIPmessageFPrintInfo(messagehdlr, file,
"# [type: bool, advanced: %s, range: {TRUE,FALSE}, default: %s]\n",
272 SCIPmessageFPrintInfo(messagehdlr, file,
"# [type: int, advanced: %s, range: [%d,%d], default: %d]\n",
282 SCIPmessageFPrintInfo(messagehdlr, file,
"# [type: real, advanced: %s, range: [%.15g,%.15g], default: %.15g]\n",
990 (*param)->paramchgd = paramchgd;
991 (*param)->paramdata = paramdata;
992 (*param)->isadvanced = isadvanced;
993 (*param)->isfixed =
FALSE;
1019 (*param)->data.boolparam.valueptr = valueptr;
1020 (*param)->data.boolparam.defaultvalue = defaultvalue;
1050 (*param)->data.intparam.valueptr = valueptr;
1051 (*param)->data.intparam.defaultvalue = defaultvalue;
1052 (*param)->data.intparam.minvalue = minvalue;
1053 (*param)->data.intparam.maxvalue = maxvalue;
1083 (*param)->data.longintparam.valueptr = valueptr;
1084 (*param)->data.longintparam.defaultvalue = defaultvalue;
1085 (*param)->data.longintparam.minvalue = minvalue;
1086 (*param)->data.longintparam.maxvalue = maxvalue;
1116 (*param)->data.realparam.valueptr = valueptr;
1117 (*param)->data.realparam.defaultvalue = defaultvalue;
1118 (*param)->data.realparam.minvalue = minvalue;
1119 (*param)->data.realparam.maxvalue = maxvalue;
1137 const char* allowedvalues,
1148 (*param)->data.charparam.valueptr = valueptr;
1149 (*param)->data.charparam.defaultvalue = defaultvalue;
1150 if( allowedvalues !=
NULL )
1155 (*param)->data.charparam.allowedvalues =
NULL;
1172 const char* defaultvalue,
1185 (*param)->data.stringparam.valueptr = valueptr;
1187 (*param)->data.stringparam.curvalue =
NULL;
1204 switch( (*param)->paramtype )
1216 if( (*param)->data.stringparam.valueptr ==
NULL )
1260 SCIPerrorMessage(
"invalid parameter value <%s> for SCIP_Bool parameter <%s>\n", valuestr, param->
name);
1284 if( sscanf(valuestr,
"%d", &value) == 1 )
1290 SCIPerrorMessage(
"invalid parameter value <%s> for int parameter <%s>\n", valuestr, param->
name);
1320 SCIPerrorMessage(
"invalid parameter value <%s> for SCIP_Longint parameter <%s>\n", valuestr, param->
name);
1350 SCIPerrorMessage(
"invalid parameter value <%s> for SCIP_Real parameter <%s>\n", valuestr, param->
name);
1374 if( sscanf(valuestr,
"%c", &value) == 1 )
1380 SCIPerrorMessage(
"invalid parameter value <%s> for char parameter <%s>\n", valuestr, param->
name);
1404 len = (
unsigned int) strlen(valuestr);
1405 if( len <= 1 || valuestr[0] !=
'"' || valuestr[len-1] !=
'"' )
1407 SCIPerrorMessage(
"invalid parameter value <%s> for string parameter <%s> (string has to be in double quotes)\n",
1408 valuestr, param->
name);
1413 valuestr[len-1] =
'\0';
1436 hashGetKeyParam, SCIPhashKeyEqString, SCIPhashKeyValString,
NULL) );
1438 (*paramset)->params =
NULL;
1439 (*paramset)->nparams = 0;
1440 (*paramset)->paramssize = 0;
1456 assert((*paramset)->paramssize == 0 || (*paramset)->params !=
NULL);
1457 assert((*paramset)->paramssize >= (*paramset)->nparams);
1463 for(
i = (*paramset)->nparams - 1;
i >= 0; --
i )
1522 SCIP_CALL(
paramCreateBool(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) );
1551 SCIP_CALL(
paramCreateInt(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,
1552 paramchgd, paramdata) );
1581 SCIP_CALL(
paramCreateLongint(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,
1582 paramchgd, paramdata) );
1611 SCIP_CALL(
paramCreateReal(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,
1612 paramchgd, paramdata) );
1630 const char* allowedvalues,
1640 SCIP_CALL(
paramCreateChar(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues,
1641 paramchgd, paramdata) );
1658 const char* defaultvalue,
1668 SCIP_CALL(
paramCreateString(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) );
1682 static const char* paramtypename[] = {
1691 return paramtypename[(int)paramtype];
1749 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1781 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1813 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1845 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1877 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1909 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1967 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2001 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2035 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2069 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2103 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2137 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2227 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2258 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2289 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2320 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2351 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2366 const char* defaultvalue
2382 SCIPerrorMessage(
"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2405 char* paramvaluestr;
2411 while ( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2413 if ( *line ==
'\0' || *line ==
'\n' || *line ==
'#' )
2418 while ( *line !=
' ' && *line !=
'\t' && *line !=
'\r' && *line !=
'\n' && *line !=
'#' && *line !=
'\0' && *line !=
'=' && *line !=
':' )
2424 if ( strcmp(
paramname,
"default") == 0 )
2427 globalemphasis =
TRUE;
2429 else if ( strcmp(
paramname,
"counter") == 0 )
2432 globalemphasis =
TRUE;
2434 else if ( strcmp(
paramname,
"cpsolver") == 0 )
2437 globalemphasis =
TRUE;
2439 else if ( strcmp(
paramname,
"easycip") == 0 )
2442 globalemphasis =
TRUE;
2444 else if ( strcmp(
paramname,
"feasibility") == 0 )
2447 globalemphasis =
TRUE;
2449 else if ( strcmp(
paramname,
"hardlp") == 0 )
2452 globalemphasis =
TRUE;
2454 else if ( strcmp(
paramname,
"optimality") == 0 )
2457 globalemphasis =
TRUE;
2459 else if ( strcmp(
paramname,
"numerics") == 0 )
2462 globalemphasis =
TRUE;
2464 else if ( strcmp(
paramname,
"benchmark") == 0 )
2467 globalemphasis =
TRUE;
2471 if ( globalemphasis )
2474 while ( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2476 if ( *line !=
'\0' && *line !=
'\n' && *line !=
'#' )
2478 SCIPerrorMessage(
"additional characters after global emphasis setting: %s.\n", line);
2485 while ( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2487 if ( *line ==
'\0' || *line ==
'\n' || *line ==
'#' )
2492 paramvaluestr = line;
2495 while ( *line !=
' ' && *line !=
'\t' && *line !=
'\r' && *line !=
'\n' && *line !=
'#' && *line !=
'\0' )
2500 else if ( *line !=
'\0' )
2505 while ( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2507 if ( *line !=
'\0' && *line !=
'\n' && *line !=
'#' )
2509 SCIPerrorMessage(
"additional characters after emphasis parameter value: %s.\n", line);
2515 if ( strcmp(paramvaluestr,
"default") == 0 )
2517 else if ( strcmp(paramvaluestr,
"aggressive") == 0 )
2519 else if ( strcmp(paramvaluestr,
"fast") == 0 )
2521 else if ( strcmp(paramvaluestr,
"off") == 0 )
2530 if ( strcmp(
paramname,
"heuristics") == 0 )
2534 else if ( strcmp(
paramname,
"presolving") == 0 )
2538 else if ( strcmp(
paramname,
"separating") == 0 )
2557 char* paramvaluestr;
2568 while( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2570 if( *line ==
'\0' || *line ==
'\n' || *line ==
'#' )
2575 while( *line !=
' ' && *line !=
'\t' && *line !=
'\r' && *line !=
'\n' && *line !=
'#' && *line !=
'\0' && *line !=
'=' && *line !=
':' )
2580 while( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2587 if ( strcmp(
paramname,
"emphasis") != 0 )
2594 if ( *foundnormalparam )
2604 else if ( *line !=
'=' )
2613 while( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2615 if( *line ==
'\0' || *line ==
'\n' || *line ==
'#' )
2620 paramvaluestr = line;
2623 quoted = (*paramvaluestr ==
'"');
2625 while( (quoted || (*line !=
' ' && *line !=
'\t' && *line !=
'\r' && *line !=
'\n' && *line !=
'#')) && *line !=
'\0' )
2631 if( lastquote !=
NULL )
2635 else if( *line !=
'\0' )
2640 while( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2642 if( *line ==
'f' && *(line+1) ==
'i' && *(line+2) ==
'x' )
2647 while( *line ==
' ' || *line ==
'\t' || *line ==
'\r' )
2650 if( *line !=
'\0' && *line !=
'\n' && *line !=
'#' )
2652 SCIPerrorMessage(
"additional characters <%c> after parameter value (and possible 'fix' keyword)\n", *line);
2659 *foundnormalparam =
TRUE;
2669 const char* filename
2682 file = fopen(filename,
"r");
2693 while( fgets(line, (
int)
sizeof(line), file) !=
NULL && retcode ==
SCIP_OKAY )
2696 retcode =
paramsetParse(paramset,
set, messagehdlr, line, &foundnormalparam);
2718 const char* filename,
2731 if( filename !=
NULL )
2733 file = fopen(filename,
"w");
2742 if( messagehdlr !=
NULL )
2754#if( SCIP_SUBVERSION == 0 )
2756 SCIP_VERSION_MAJOR, SCIP_VERSION_MINOR, SCIP_VERSION_PATCH);
2759 SCIP_VERSION_MAJOR, SCIP_VERSION_MINOR, SCIP_VERSION_PATCH,
SCIP_SUBVERSION);
2768 retcode =
paramWrite(paramset->
params[
i], messagehdlr, file, comments, onlychanged);
2771 if( filename !=
NULL )
2781 if( filename !=
NULL )
2786 if( messagehdlr !=
NULL )
2853 nheurs =
set->nheurs;
2855 for(
i = 0;
i < nheurs; ++
i )
2857 const char* heurname;
2902 nheurs =
set->nheurs;
2906 for(
i = 0;
i < nheurs; ++
i )
2908 const char* heurname;
2912 if( strcmp(heurname,
"dualval") == 0 )
2916 if( strstr(heurname,
"benders") !=
NULL )
2932 if( deffreq == -1 || deffreq == 0 )
2939 newfreq =
MAX(newfreq, 1);
2996 int nneighborhoods = 9;
2997 const char* neighborhoodnames[] = {
3008 for(
i = 0;
i < nneighborhoods; ++
i )
3034#define NEXPENSIVEHEURFREQS 12
3036 "heuristics/coefdiving/freq",
3037 "heuristics/distributiondiving/freq",
3038 "heuristics/feaspump/freq",
3039 "heuristics/fracdiving/freq",
3040 "heuristics/guideddiving/freq",
3041 "heuristics/linesearchdiving/freq",
3042 "heuristics/nlpdiving/freq",
3043 "heuristics/subnlp/freq",
3044 "heuristics/objpscostdiving/freq",
3045 "heuristics/pscostdiving/freq",
3046 "heuristics/rootsoldiving/freq",
3047 "heuristics/veclendiving/freq"
3055 for(
i = 0;
i < nheurs; ++
i )
3090 nheurs =
set->nheurs;
3094 for(
i = 0;
i < nheurs; ++
i )
3096 const char* heurname;
3131 presols =
set->presols;
3132 npresols =
set->npresols;
3135 for(
i = 0;
i < npresols; ++
i )
3137 const char* presolname;
3147 nprops =
set->nprops;
3150 for(
i = 0;
i < nprops; ++
i )
3152 const char* propname;
3160 conshdlrs =
set->conshdlrs;
3161 nconshdlrs =
set->nconshdlrs;
3164 for(
i = 0;
i < nconshdlrs; ++
i )
3166 const char* conshdlrname;
3228 presols =
set->presols;
3229 npresols =
set->npresols;
3232 for( p = 0; p < npresols; ++p )
3234 const char* presolname;
3238 if( strcmp(presolname,
"convertinttobin") == 0 )
3292 conshdlrs =
set->conshdlrs;
3293 nconshdlrs =
set->nconshdlrs;
3296 for(
i = 0;
i < nconshdlrs; ++
i )
3298 const char* conshdlrname;
3410 presols =
set->presols;
3411 npresols =
set->npresols;
3414 for(
i = 0;
i < npresols; ++
i )
3416 const char* presolname;
3426 nprops =
set->nprops;
3429 for(
i = 0;
i < nprops; ++
i )
3431 const char* propname;
3440 conshdlrs =
set->conshdlrs;
3441 nconshdlrs =
set->nconshdlrs;
3444 for(
i = 0;
i < nconshdlrs; ++
i )
3446 const char* conshdlrname;
3484 nsepas =
set->nsepas;
3487 for(
i = 0;
i < nsepas; ++
i )
3489 const char* sepaname;
3505 conshdlrs =
set->conshdlrs;
3506 nconshdlrs =
set->nconshdlrs;
3509 for(
i = 0;
i < nconshdlrs; ++
i )
3511 const char* conshdlrname;
3565 nsepas =
set->nsepas;
3571 for(
i = 0;
i < nsepas; ++
i )
3573 const char* sepaname;
3577 if( strcmp(sepaname,
"intobj") == 0 || strcmp(sepaname,
"cgmip") == 0 )
3597 else if( deffreq == 0 )
3600 newfreq =
MIN(deffreq, 20);
3636 conshdlrs =
set->conshdlrs;
3637 nconshdlrs =
set->nconshdlrs;
3640 for(
i = 0;
i < nconshdlrs; ++
i )
3642 const char* conshdlrname;
3662 else if( deffreq == 0 )
3665 newfreq =
MIN(deffreq, 10);
3798 nsepas =
set->nsepas;
3801 for(
i = 0;
i < nsepas; ++
i )
3803 const char* sepaname;
3811 conshdlrs =
set->conshdlrs;
3812 nconshdlrs =
set->nconshdlrs;
3815 for(
i = 0;
i < nconshdlrs; ++
i )
3817 const char* conshdlrname;
3851 switch( paramemphasis )
3973 SCIP_CALL(
paramSetInt(paramset,
set, messagehdlr,
"nodeselection/restartdfs/stdpriority", INT_MAX/4, quiet) );
4009 SCIP_CALL(
paramSetInt(paramset,
set, messagehdlr,
"nodeselection/uct/stdpriority", (INT_MAX / 4) + 1, quiet) );
4010 SCIP_CALL(
paramSetInt(paramset,
set, messagehdlr,
"nodeselection/restartdfs/stdpriority", INT_MAX/4, quiet) );
4021 int nheurs =
set->nheurs;
4023 for(
h = 0;
h < nheurs; ++
h )
4086#ifdef SCIP_WITH_PAPILO
4105 SCIPerrorMessage(
"the parameter setting <%d> is not allowed for emphasis call\n", paramemphasis);
4131 nheurs =
set->nheurs;
4134 for(
i = 0;
i < nheurs; ++
i )
4138 const char* heurname;
4165 nsepas =
set->nsepas;
4168 for(
i = 0;
i < nsepas; ++
i )
4172 const char* sepaname;
4227 switch( paramsetting )
4242 SCIPerrorMessage(
"the parameter setting <%d> is not allowed for heuristics\n", paramsetting);
4263 switch( paramsetting )
4278 SCIPerrorMessage(
"the parameter setting <%d> is not allowed for presolving\n", paramsetting);
4299 switch( paramsetting )
4314 SCIPerrorMessage(
"the parameter setting <%d> is not allowed for separating\n", paramsetting);
4357 assert(sourceparamset != targetparamset);
4363 for(
i = 0;
i < sourceparamset->
nparams; ++
i )
4369 sourceparam = sourceparamset->
params[
i];
4377 if( targetparam ==
NULL )
4410 if( strncmp(sourceparam->
name,
"visual/", 7) != 0 )
4426 if(
set->reopt_enable )
4457 return ( value ==
TRUE || value ==
FALSE );
4501 if( value ==
'\b' || value ==
'\f' || value ==
'\n' || value ==
'\r' || value ==
'\v' )
4509 while( *
c !=
'\0' && *
c != value )
4529 for(
i = 0;
i < (
unsigned int) strlen(value); ++
i )
4531 if( value[
i] ==
'\b' || value[
i] ==
'\f' || value[
i] ==
'\n' || value[
i] ==
'\r' || value[
i] ==
'\v' )
4571 if( !initialize && param->paramchgd !=
NULL &&
set !=
NULL )
4575 retcode = param->paramchgd(
set->scip, param);
4633 if( !initialize && param->paramchgd !=
NULL &&
set !=
NULL )
4637 retcode = param->paramchgd(
set->scip, param);
4695 if( !initialize && param->paramchgd !=
NULL &&
set !=
NULL )
4699 retcode = param->paramchgd(
set->scip, param);
4759 if( !initialize && param->paramchgd !=
NULL &&
set !=
NULL )
4763 retcode = param->paramchgd(
set->scip, param);
4806 char oldvalue =
'\0';
4820 if( !initialize && param->paramchgd !=
NULL &&
set !=
NULL )
4824 retcode = param->paramchgd(
set->scip, param);
4858 char* oldvalue =
NULL;
4881 if( !initialize && param->paramchgd !=
NULL &&
set !=
NULL )
4885 retcode = param->paramchgd(
set->scip, param);
4988 const char* defaultvalue
5053 const char* filename,
5064 if( filename !=
NULL )
5066 file = fopen(filename,
"w");
5078 retcode =
paramWrite(param, messagehdlr, file, comments, onlychanged);
5081 if( filename !=
NULL )
#define SCIP_ALLOC_ABORT(x)
#define SCIP_CALL_QUIET(x)
#define SCIP_LONGINT_FORMAT
#define SCIP_HASHSIZE_PARAMS
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
SCIP_RETCODE SCIPhashtableSafeInsert(SCIP_HASHTABLE *hashtable, void *element)
SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)
void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
SCIP_Bool SCIPheurUsesSubscip(SCIP_HEUR *heur)
int SCIPgetNHeurs(SCIP *scip)
const char * SCIPheurGetName(SCIP_HEUR *heur)
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
const char * SCIPpropGetName(SCIP_PROP *prop)
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
SCIP_Bool SCIPsepaUsesSubscip(SCIP_SEPA *sepa)
int SCIPstrcasecmp(const char *s1, const char *s2)
int SCIPsnprintf(char *t, int len, const char *s,...)
void SCIPprintSysError(const char *message)
assert(minobj< SCIPgetCutoffbound(scip))
static const char * paramname[]
#define BMSfreeMemory(ptr)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSduplicateMemoryArray(ptr, source, num)
#define BMSfreeMemoryArray(ptr)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
void SCIPmessagehdlrSetQuiet(SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_Bool SCIPmessagehdlrIsQuiet(SCIP_MESSAGEHDLR *messagehdlr)
SCIP_RETCODE SCIPparamsetGetBool(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool *value)
static SCIP_RETCODE paramParseReal(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char *valuestr)
SCIP_RETCODE SCIPparamsetCreate(SCIP_PARAMSET **paramset, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPparamsetSetDefaultString(SCIP_PARAMSET *paramset, const char *name, const char *defaultvalue)
SCIP_RETCODE SCIPparamSetString(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *value, SCIP_Bool initialize, SCIP_Bool quiet)
static SCIP_RETCODE paramParseChar(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char *valuestr)
SCIP_RETCODE SCIPparamsetSetReal(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Real value)
SCIP_Bool SCIPparamIsDefault(SCIP_PARAM *param)
SCIP_RETCODE SCIPparamsetSetDefaultLongint(SCIP_PARAMSET *paramset, const char *name, SCIP_Longint defaultvalue)
static SCIP_RETCODE paramsetSetSeparatingAggressive(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
void SCIPparamSetDefaultString(SCIP_PARAM *param, const char *defaultvalue)
const char * SCIPparamGetName(SCIP_PARAM *param)
SCIP_Real SCIPparamGetRealMin(SCIP_PARAM *param)
char SCIPparamGetCharDefault(SCIP_PARAM *param)
static SCIP_RETCODE paramTestReal(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Real value)
SCIP_RETCODE SCIPparamsetGetString(SCIP_PARAMSET *paramset, const char *name, char **value)
static SCIP_RETCODE paramsetSetPresolvingOff(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamSetLongint(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Longint value, SCIP_Bool initialize, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamWrite(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
SCIP_RETCODE SCIPparamSetReal(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Real value, SCIP_Bool initialize, SCIP_Bool quiet)
int SCIPparamsetGetNParams(SCIP_PARAMSET *paramset)
static SCIP_RETCODE paramCreateReal(SCIP_PARAM **param, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
static SCIP_RETCODE paramParseBool(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char *valuestr)
#define NEXPENSIVEHEURFREQS
static SCIP_RETCODE paramsetSetSeparatingDefault(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
static SCIP_RETCODE paramSetChar(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *paramname, char value, SCIP_Bool quiet)
static SCIP_RETCODE emphasisParse(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char *line)
void SCIPparamSetDefaultReal(SCIP_PARAM *param, SCIP_Real defaultvalue)
static SCIP_RETCODE paramTestString(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, const char *value)
SCIP_Bool SCIPparamIsValidInt(SCIP_PARAM *param, int value)
SCIP_RETCODE SCIPparamsetSetInt(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, int value)
char * SCIPparamGetCharAllowedValues(SCIP_PARAM *param)
SCIP_RETCODE SCIPparamsetAddString(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_PARAMDATA * SCIPparamGetData(SCIP_PARAM *param)
SCIP_RETCODE SCIPparamsetGetInt(SCIP_PARAMSET *paramset, const char *name, int *value)
static SCIP_RETCODE paramCopyInt(SCIP_PARAM *sourceparam, SCIP_PARAM *targetparam, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_Bool SCIPparamIsValidBool(SCIP_PARAM *param, SCIP_Bool value)
void SCIPparamSetDefaultChar(SCIP_PARAM *param, char defaultvalue)
static SCIP_RETCODE paramsetSetSeparatingFast(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
SCIP_Bool SCIPparamIsValidString(SCIP_PARAM *param, const char *value)
static SCIP_RETCODE paramSetBool(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *paramname, SCIP_Bool value, SCIP_Bool quiet)
static SCIP_RETCODE paramCreateString(SCIP_PARAM **param, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPparamsetGetLongint(SCIP_PARAMSET *paramset, const char *name, SCIP_Longint *value)
static SCIP_RETCODE paramTestChar(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, char value)
SCIP_Bool SCIPparamIsAdvanced(SCIP_PARAM *param)
static SCIP_RETCODE paramsetSetSeparatingOff(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamsetAddChar(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPparamsetSetPresolving(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_PARAMTYPE SCIPparamGetType(SCIP_PARAM *param)
static SCIP_RETCODE paramParseInt(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char *valuestr)
char * SCIPparamGetString(SCIP_PARAM *param)
static SCIP_RETCODE paramParseString(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char *valuestr)
int SCIPparamGetIntMin(SCIP_PARAM *param)
void SCIPparamSetFixed(SCIP_PARAM *param, SCIP_Bool fixed)
void SCIPparamsetFree(SCIP_PARAMSET **paramset, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPparamSetToDefault(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_Longint SCIPparamGetLongintMin(SCIP_PARAM *param)
static SCIP_RETCODE paramsetAdd(SCIP_PARAMSET *paramset, SCIP_PARAM *param)
static const char * paramtypeGetName(SCIP_PARAMTYPE paramtype)
SCIP_RETCODE SCIPparamsetAddInt(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_PARAM * SCIPparamsetGetParam(SCIP_PARAMSET *paramset, const char *name)
SCIP_RETCODE SCIPparamsetRead(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename)
static SCIP_RETCODE paramCreateLongint(SCIP_PARAM **param, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPparamsetSetChar(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
static SCIP_RETCODE paramsetSetHeuristicsOff(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
static SCIP_RETCODE paramSetInt(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *paramname, int value, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamsetSetDefaultChar(SCIP_PARAMSET *paramset, const char *name, char defaultvalue)
SCIP_Bool SCIPparamGetBool(SCIP_PARAM *param)
const char * SCIPparamGetDesc(SCIP_PARAM *param)
SCIP_RETCODE SCIPparamsetSetDefaultBool(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool defaultvalue)
static SCIP_RETCODE paramTestLongint(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Longint value)
SCIP_Bool SCIPparamIsValidLongint(SCIP_PARAM *param, SCIP_Longint value)
void SCIPparamSetDefaultBool(SCIP_PARAM *param, SCIP_Bool defaultvalue)
SCIP_RETCODE SCIPparamsetGetChar(SCIP_PARAMSET *paramset, const char *name, char *value)
int SCIPparamGetInt(SCIP_PARAM *param)
static SCIP_RETCODE paramCreateBool(SCIP_PARAM **param, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Bool SCIPparamGetBoolDefault(SCIP_PARAM *param)
SCIP_RETCODE SCIPparamsetSetToSubscipsOff(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamsetSetToDefaults(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
static SCIP_RETCODE paramsetSetHeuristicsFast(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
SCIP_Bool SCIPparamIsValidReal(SCIP_PARAM *param, SCIP_Real value)
int SCIPparamGetIntMax(SCIP_PARAM *param)
SCIP_Real SCIPparamGetReal(SCIP_PARAM *param)
SCIP_Bool SCIPparamsetIsFixed(SCIP_PARAMSET *paramset, const char *name)
int SCIPparamGetIntDefault(SCIP_PARAM *param)
void SCIPparamSetDefaultLongint(SCIP_PARAM *param, SCIP_Longint defaultvalue)
SCIP_RETCODE SCIPparamsetAddBool(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
char SCIPparamGetChar(SCIP_PARAM *param)
SCIP_Longint SCIPparamGetLongint(SCIP_PARAM *param)
SCIP_Longint SCIPparamGetLongintMax(SCIP_PARAM *param)
SCIP_RETCODE SCIPparamsetWrite(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
SCIP_Real SCIPparamGetRealMax(SCIP_PARAM *param)
SCIP_RETCODE SCIPparamsetSetString(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, const char *value)
SCIP_RETCODE SCIPparamsetSetToDefault(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *paramname)
static SCIP_RETCODE paramTestInt(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, int value)
SCIP_RETCODE SCIPparamsetSetDefaultInt(SCIP_PARAMSET *paramset, const char *name, int defaultvalue)
SCIP_RETCODE SCIPparamsetSetDefaultReal(SCIP_PARAMSET *paramset, const char *name, SCIP_Real defaultvalue)
SCIP_RETCODE SCIPparamsetAddReal(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
static SCIP_RETCODE paramTestBool(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool value)
SCIP_RETCODE SCIPparamsetCopyParams(SCIP_PARAMSET *sourceparamset, SCIP_PARAMSET *targetparamset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_RETCODE SCIPparamSetBool(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool value, SCIP_Bool initialize, SCIP_Bool quiet)
void SCIPparamSetDefaultInt(SCIP_PARAM *param, int defaultvalue)
SCIP_RETCODE SCIPparamsetSetHeuristics(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamsetSetSeparating(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamsetSetLongint(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Longint value)
SCIP_RETCODE SCIPparamsetSetEmphasis(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamsetGetReal(SCIP_PARAMSET *paramset, const char *name, SCIP_Real *value)
static SCIP_RETCODE paramsetSetPresolvingFast(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
SCIP_PARAM ** SCIPparamsetGetParams(SCIP_PARAMSET *paramset)
static SCIP_RETCODE paramCreate(SCIP_PARAM **param, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata, SCIP_Bool isadvanced)
static SCIP_RETCODE paramCopyBool(SCIP_PARAM *sourceparam, SCIP_PARAM *targetparam, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
static SCIP_RETCODE paramCopyReal(SCIP_PARAM *sourceparam, SCIP_PARAM *targetparam, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
static SCIP_RETCODE paramSetLongint(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *paramname, SCIP_Longint value, SCIP_Bool quiet)
SCIP_Bool SCIPparamIsValidChar(SCIP_PARAM *param, const char value)
static SCIP_RETCODE paramCopyLongint(SCIP_PARAM *sourceparam, SCIP_PARAM *targetparam, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
static SCIP_RETCODE paramTestFixed(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_RETCODE SCIPparamsetSet(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, const char *value, SCIP_Bool fix)
static SCIP_RETCODE paramsetSetHeuristicsAggressive(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamsetAddLongint(SCIP_PARAMSET *paramset, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Longint SCIPparamGetLongintDefault(SCIP_PARAM *param)
static SCIP_RETCODE paramsetParse(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char *line, SCIP_Bool *foundnormalparam)
SCIP_RETCODE SCIPparamsetFix(SCIP_PARAMSET *paramset, const char *name, SCIP_Bool fixed)
static void paramFree(SCIP_PARAM **param, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPparamSetChar(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char value, SCIP_Bool initialize, SCIP_Bool quiet)
SCIP_Real SCIPparamGetRealDefault(SCIP_PARAM *param)
static SCIP_RETCODE paramParseLongint(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, char *valuestr)
static SCIP_RETCODE paramCopyChar(SCIP_PARAM *sourceparam, SCIP_PARAM *targetparam, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
static SCIP_RETCODE paramCreateInt(SCIP_PARAM **param, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
static SCIP_RETCODE paramCreateChar(SCIP_PARAM **param, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
static SCIP_RETCODE paramsetSetPresolvingAggressive(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
SCIP_RETCODE SCIPparamsetSetBool(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Bool value)
SCIP_RETCODE SCIPparamSetInt(SCIP_PARAM *param, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, int value, SCIP_Bool initialize, SCIP_Bool quiet)
static SCIP_RETCODE paramSetReal(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *paramname, SCIP_Real value, SCIP_Bool quiet)
static SCIP_RETCODE paramCopyString(SCIP_PARAM *sourceparam, SCIP_PARAM *targetparam, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_Bool SCIPparamIsFixed(SCIP_PARAM *param)
static SCIP_RETCODE paramsetSetHeuristicsDefault(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
static SCIP_RETCODE paramsetSetPresolvingDefault(SCIP_PARAMSET *paramset, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
static SCIP_RETCODE paramWrite(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Bool comments, SCIP_Bool onlychanged)
char * SCIPparamGetStringDefault(SCIP_PARAM *param)
internal methods for handling parameter settings
SCIP_RETCODE SCIPsetSetSeparating(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetSetHeuristics(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetSetReoptimizationParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
SCIP_HEUR * SCIPsetFindHeur(SCIP_SET *set, const char *name)
SCIP_Bool SCIPsetIsParamFixed(SCIP_SET *set, const char *name)
SCIP_CONSHDLR * SCIPsetFindConshdlr(SCIP_SET *set, const char *name)
SCIP_RETCODE SCIPsetChgParamFixed(SCIP_SET *set, const char *name, SCIP_Bool fixed)
SCIP_RETCODE SCIPsetSetPresolving(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_SEPA * SCIPsetFindSepa(SCIP_SET *set, const char *name)
SCIP_PROP * SCIPsetFindProp(SCIP_SET *set, const char *name)
SCIP_PRESOL * SCIPsetFindPresol(SCIP_SET *set, const char *name)
internal methods for global SCIP settings
SCIP_Longint defaultvalue
SCIP_HASHTABLE * hashtable
union SCIP_Param::@254111363252140132224065133032135027020233110274 data
SCIP_STRINGPARAM stringparam
SCIP_LONGINTPARAM longintparam
SCIP_PARAMDATA * paramdata
datastructures for handling parameter settings
struct SCIP_Conshdlr SCIP_CONSHDLR
struct SCIP_Heur SCIP_HEUR
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
#define SCIP_DECL_HASHGETKEY(x)
@ SCIP_PARAMSETTING_AGGRESSIVE
@ SCIP_PARAMSETTING_DEFAULT
struct SCIP_ParamSet SCIP_PARAMSET
@ SCIP_PARAMEMPHASIS_DEFAULT
@ SCIP_PARAMEMPHASIS_NUMERICS
@ SCIP_PARAMEMPHASIS_PHASEIMPROVE
@ SCIP_PARAMEMPHASIS_CPSOLVER
@ SCIP_PARAMEMPHASIS_HARDLP
@ SCIP_PARAMEMPHASIS_FEASIBILITY
@ SCIP_PARAMEMPHASIS_BENCHMARK
@ SCIP_PARAMEMPHASIS_PHASEPROOF
@ SCIP_PARAMEMPHASIS_EASYCIP
@ SCIP_PARAMEMPHASIS_PHASEFEAS
@ SCIP_PARAMEMPHASIS_COUNTER
@ SCIP_PARAMEMPHASIS_OPTIMALITY
struct SCIP_Param SCIP_PARAM
enum SCIP_ParamSetting SCIP_PARAMSETTING
struct SCIP_ParamData SCIP_PARAMDATA
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
enum SCIP_ParamType SCIP_PARAMTYPE
#define SCIP_DECL_PARAMCHGD(x)
struct SCIP_Presol SCIP_PRESOL
struct SCIP_Prop SCIP_PROP
@ SCIP_PARAMETERWRONGTYPE
enum SCIP_Retcode SCIP_RETCODE
struct SCIP_Sepa SCIP_SEPA