A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://scip.zib.de/doc/html/paramset_8c_source.php below:

SCIP Doxygen Documentation: paramset.c Source File

39#if defined(_WIN32) || defined(_WIN64) 63

assert(param !=

NULL

);

75

assert(param !=

NULL

);

76

assert(messagehdlr !=

NULL

);

80 SCIPerrorMessage

(

"parameter <%s> is fixed and cannot be changed. Unfix it to allow changing the value.\n"

, param->

name

);

95

assert(param !=

NULL

);

97

assert(messagehdlr !=

NULL

);

101 SCIPerrorMessage

(

"Invalid value <%u> for bool parameter <%s>. Must be <0> (FALSE) or <1> (TRUE).\n"

, value, param->

name

);

116

assert(param !=

NULL

);

118

assert(messagehdlr !=

NULL

);

122 SCIPerrorMessage

(

"Invalid value <%d> for int parameter <%s>. Must be in range [%d,%d].\n"

,

138

assert(param !=

NULL

);

140

assert(messagehdlr !=

NULL

);

160

assert(param !=

NULL

);

162

assert(messagehdlr !=

NULL

);

166 SCIPerrorMessage

(

"Invalid value <%.15g> for real parameter <%s>. Must be in range [%.15g,%.15g].\n"

,

182

assert(param !=

NULL

);

184

assert(messagehdlr !=

NULL

);

186 if

( value ==

'\b'

|| value ==

'\f'

|| value ==

'\n'

|| value ==

'\r'

|| value ==

'\v'

)

188 SCIPerrorMessage

(

"Invalid value <%d> for char parameter <%s>.\n"

, (

int

)value, param->

name

);

197 while

( *c !=

'\0'

&& *c != value )

202 SCIPerrorMessage

(

"Invalid value <%c> for char parameter <%s>. Must be in set {%s}.\n"

,

221

assert(param !=

NULL

);

223

assert(messagehdlr !=

NULL

);

227 SCIPerrorMessage

(

"Cannot assign a NULL string to a string parameter.\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);

253

assert(param !=

NULL

);

254

assert(messagehdlr !=

NULL

);

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"

,

287 SCIPmessageFPrintInfo

(messagehdlr, file,

"# [type: char, advanced: %s, range: {%s}, default: %c]\n"

,

533

assert(sourceparam !=

NULL

);

534

assert(targetparam !=

NULL

);

554

assert(sourceparam !=

NULL

);

555

assert(targetparam !=

NULL

);

575

assert(sourceparam !=

NULL

);

576

assert(targetparam !=

NULL

);

596

assert(sourceparam !=

NULL

);

597

assert(targetparam !=

NULL

);

617

assert(sourceparam !=

NULL

);

618

assert(targetparam !=

NULL

);

638

assert(sourceparam !=

NULL

);

639

assert(targetparam !=

NULL

);

653

assert(param !=

NULL

);

663

assert(param !=

NULL

);

665 return

param->

name

;

673

assert(param !=

NULL

);

675 return

param->

desc

;

683

assert(param !=

NULL

);

693

assert(param !=

NULL

);

703

assert(param !=

NULL

);

713

assert(param !=

NULL

);

727

assert(param !=

NULL

);

738

assert(param !=

NULL

);

752

assert(param !=

NULL

);

763

assert(param !=

NULL

);

774

assert(param !=

NULL

);

785

assert(param !=

NULL

);

799

assert(param !=

NULL

);

810

assert(param !=

NULL

);

821

assert(param !=

NULL

);

832

assert(param !=

NULL

);

846

assert(param !=

NULL

);

857

assert(param !=

NULL

);

868

assert(param !=

NULL

);

879

assert(param !=

NULL

);

893

assert(param !=

NULL

);

904

assert(param !=

NULL

);

915

assert(param !=

NULL

);

929

assert(param !=

NULL

);

940

assert(param !=

NULL

);

981

assert(param !=

NULL

);

982

assert(name !=

NULL

);

983

assert(desc !=

NULL

);

990

(*param)->paramchgd = paramchgd;

991

(*param)->paramdata = paramdata;

992

(*param)->isadvanced = isadvanced;

993

(*param)->isfixed =

FALSE

;

1013

assert(param !=

NULL

);

1014

assert(name !=

NULL

);

1019

(*param)->data.boolparam.valueptr = valueptr;

1020

(*param)->data.boolparam.defaultvalue = defaultvalue;

1044

assert(param !=

NULL

);

1045

assert(name !=

NULL

);

1050

(*param)->data.intparam.valueptr = valueptr;

1051

(*param)->data.intparam.defaultvalue = defaultvalue;

1052

(*param)->data.intparam.minvalue = minvalue;

1053

(*param)->data.intparam.maxvalue = maxvalue;

1077

assert(param !=

NULL

);

1078

assert(name !=

NULL

);

1083

(*param)->data.longintparam.valueptr = valueptr;

1084

(*param)->data.longintparam.defaultvalue = defaultvalue;

1085

(*param)->data.longintparam.minvalue = minvalue;

1086

(*param)->data.longintparam.maxvalue = maxvalue;

1110

assert(param !=

NULL

);

1111

assert(name !=

NULL

);

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,

1142

assert(param !=

NULL

);

1143

assert(name !=

NULL

);

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,

1177

assert(param !=

NULL

);

1178

assert(name !=

NULL

);

1179

assert(valueptr ==

NULL

|| *valueptr ==

NULL

);

1180

assert(defaultvalue !=

NULL

);

1185

(*param)->data.stringparam.valueptr = valueptr;

1187

(*param)->data.stringparam.curvalue =

NULL

;

1201

assert(param !=

NULL

);

1202

assert(*param !=

NULL

);

1204 switch

( (*param)->paramtype )

1216 if

( (*param)->data.stringparam.valueptr ==

NULL

)

1245

assert(param !=

NULL

);

1248

assert(valuestr !=

NULL

);

1260 SCIPerrorMessage

(

"invalid parameter value <%s> for SCIP_Bool parameter <%s>\n"

, valuestr, param->

name

);

1278

assert(param !=

NULL

);

1281

assert(valuestr !=

NULL

);

1284 if

( sscanf(valuestr,

"%d"

, &value) == 1 )

1290 SCIPerrorMessage

(

"invalid parameter value <%s> for int parameter <%s>\n"

, valuestr, param->

name

);

1308

assert(param !=

NULL

);

1311

assert(valuestr !=

NULL

);

1320 SCIPerrorMessage

(

"invalid parameter value <%s> for SCIP_Longint parameter <%s>\n"

, valuestr, param->

name

);

1338

assert(param !=

NULL

);

1341

assert(valuestr !=

NULL

);

1350 SCIPerrorMessage

(

"invalid parameter value <%s> for SCIP_Real parameter <%s>\n"

, valuestr, param->

name

);

1368

assert(param !=

NULL

);

1371

assert(valuestr !=

NULL

);

1374 if

( sscanf(valuestr,

"%c"

, &value) == 1 )

1380 SCIPerrorMessage

(

"invalid parameter value <%s> for char parameter <%s>\n"

, valuestr, param->

name

);

1398

assert(param !=

NULL

);

1401

assert(valuestr !=

NULL

);

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'

;

1431

assert(paramset !=

NULL

);

1436

hashGetKeyParam, SCIPhashKeyEqString, SCIPhashKeyValString,

NULL

) );

1438

(*paramset)->params =

NULL

;

1439

(*paramset)->nparams = 0;

1440

(*paramset)->paramssize = 0;

1454

assert(paramset !=

NULL

);

1455

assert(*paramset !=

NULL

);

1456

assert((*paramset)->paramssize == 0 || (*paramset)->params !=

NULL

);

1457

assert((*paramset)->paramssize >= (*paramset)->nparams);

1463 for

( i = (*paramset)->nparams - 1; i >= 0; --i )

1465 paramFree

(&(*paramset)->params[i], blkmem);

1481

assert(paramset !=

NULL

);

1482

assert(param !=

NULL

);

1519

assert(paramset !=

NULL

);

1522 SCIP_CALL

(

paramCreateBool

(&param, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) );

1548

assert(paramset !=

NULL

);

1551 SCIP_CALL

(

paramCreateInt

(&param, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,

1552

paramchgd, paramdata) );

1578

assert(paramset !=

NULL

);

1581 SCIP_CALL

(

paramCreateLongint

(&param, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,

1582

paramchgd, paramdata) );

1608

assert(paramset !=

NULL

);

1611 SCIP_CALL

(

paramCreateReal

(&param, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,

1612

paramchgd, paramdata) );

1630 const char

* allowedvalues,

1637

assert(paramset !=

NULL

);

1640 SCIP_CALL

(

paramCreateChar

(&param, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues,

1641

paramchgd, paramdata) );

1658 const char

* defaultvalue,

1665

assert(paramset !=

NULL

);

1668 SCIP_CALL

(

paramCreateString

(&param, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) );

1682 static const char

* paramtypename[] = {

1691 return

paramtypename[(int)paramtype];

1702

assert(paramset !=

NULL

);

1706 if

( param ==

NULL

)

1722

assert(paramset !=

NULL

);

1737

assert(paramset !=

NULL

);

1738

assert(value !=

NULL

);

1742 if

( param ==

NULL

)

1749 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

1769

assert(paramset !=

NULL

);

1770

assert(value !=

NULL

);

1774 if

( param ==

NULL

)

1781 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

1801

assert(paramset !=

NULL

);

1802

assert(value !=

NULL

);

1806 if

( param ==

NULL

)

1813 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

1833

assert(paramset !=

NULL

);

1834

assert(value !=

NULL

);

1838 if

( param ==

NULL

)

1845 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

1865

assert(paramset !=

NULL

);

1866

assert(value !=

NULL

);

1870 if

( param ==

NULL

)

1877 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

1897

assert(paramset !=

NULL

);

1898

assert(value !=

NULL

);

1902 if

( param ==

NULL

)

1909 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

1929

assert(paramset !=

NULL

);

1933 if

( param ==

NULL

)

1955

assert(paramset !=

NULL

);

1960 if

( param ==

NULL

)

1967 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

1989

assert(paramset !=

NULL

);

1994 if

( param ==

NULL

)

2001 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2023

assert(paramset !=

NULL

);

2028 if

( param ==

NULL

)

2035 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2057

assert(paramset !=

NULL

);

2062 if

( param ==

NULL

)

2069 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2091

assert(paramset !=

NULL

);

2096 if

( param ==

NULL

)

2103 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2125

assert(paramset !=

NULL

);

2130 if

( param ==

NULL

)

2137 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2160

assert(paramset !=

NULL

);

2162

assert(name !=

NULL

);

2163

assert(value !=

NULL

);

2167 if

( param ==

NULL

)

2216

assert(paramset !=

NULL

);

2220 if

( param ==

NULL

)

2227 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2247

assert(paramset !=

NULL

);

2251 if

( param ==

NULL

)

2258 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2278

assert(paramset !=

NULL

);

2282 if

( param ==

NULL

)

2289 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2309

assert(paramset !=

NULL

);

2313 if

( param ==

NULL

)

2320 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2340

assert(paramset !=

NULL

);

2344 if

( param ==

NULL

)

2351 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2366 const char

* defaultvalue

2371

assert(paramset !=

NULL

);

2375 if

( param ==

NULL

)

2382 SCIPerrorMessage

(

"wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n"

,

2405 char

* paramvaluestr;

2407

assert( paramset !=

NULL

);

2408

assert( line !=

NULL

);

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;

2563

assert(paramset !=

NULL

);

2564

assert(line !=

NULL

);

2565

assert(foundnormalparam !=

NULL

);

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

2678

assert(paramset !=

NULL

);

2679

assert(filename !=

NULL

);

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);

2704 SCIPerrorMessage

(

"input error in file <%s> line %d\n"

, filename, lineno);

2718 const char

* filename,

2728

assert(paramset !=

NULL

);

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

);

2766 for

( i = 0; i < paramset->

nparams

; ++i )

2768

retcode =

paramWrite

(paramset->

params

[i], messagehdlr, file, comments, onlychanged);

2771 if

( filename !=

NULL

)

2773

assert(file !=

NULL

);

2781 if

( filename !=

NULL

)

2783

assert(file !=

NULL

);

2786 if

( messagehdlr !=

NULL

)

2807 for

( i = 0; i < paramset->

nparams

; ++i )

2827 if

( param !=

NULL

)

2852

heurs =

set

->heurs;

2853

nheurs =

set

->nheurs;

2855 for

( i = 0; i < nheurs; ++i )

2857 const char

* heurname;

2901

heurs =

set

->heurs;

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

)

2923 if

( param !=

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 )

3089

heurs =

set

->heurs;

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;

3146

props =

set

->props;

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 )

3250 if

( param !=

NULL

)

3261 if

( param !=

NULL

)

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;

3425

props =

set

->props;

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;

3483

sepas =

set

->sepas;

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;

3564

sepas =

set

->sepas;

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 )

3584 if

( param !=

NULL

)

3595 if

( deffreq == -1 )

3597 else if

( deffreq == 0 )

3600

newfreq =

MIN

(deffreq, 20);

3609 if

( param !=

NULL

)

3624 if

( param !=

NULL

)

3636

conshdlrs =

set

->conshdlrs;

3637

nconshdlrs =

set

->nconshdlrs;

3640 for

( i = 0; i < nconshdlrs; ++i )

3642 const char

* conshdlrname;

3649 if

( param !=

NULL

)

3660 if

( deffreq == -1 )

3662 else if

( deffreq == 0 )

3665

newfreq =

MIN

(deffreq, 10);

3674 if

( param !=

NULL

)

3750 SCIP_CALL

(

paramSetInt

(paramset,

set

, messagehdlr,

"separating/aggregation/maxsepacutsroot"

, 200, quiet) );

3797

sepas =

set

->sepas;

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) );

3999 SCIP_CALL

(

paramSetInt

(paramset,

set

, messagehdlr,

"branching/fullstrong/priority"

, 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 4092 SCIP_CALL

(

paramSetReal

(paramset,

set

, messagehdlr,

"constraints/nonlinear/conssiderelaxamount"

, 1e-7, quiet) );

4093 SCIP_CALL

(

paramSetReal

(paramset,

set

, messagehdlr,

"constraints/nonlinear/varboundrelaxamount"

, 1e-7, quiet) );

4105 SCIPerrorMessage

(

"the parameter setting <%d> is not allowed for emphasis call\n"

, paramemphasis);

4130

heurs =

set

->heurs;

4131

nheurs =

set

->nheurs;

4134 for

( i = 0; i < nheurs; ++i )

4138 const char

* heurname;

4152 if

( oldfreq == -1 )

4164

sepas =

set

->sepas;

4165

nsepas =

set

->nsepas;

4168 for

( i = 0; i < nsepas; ++i )

4172 const char

* sepaname;

4186 if

( oldfreq == -1 )

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);

4326

assert(paramset !=

NULL

);

4328 return

paramset->

params

;

4336

assert(paramset !=

NULL

);

4355

assert(sourceparamset !=

NULL

);

4356

assert(targetparamset !=

NULL

);

4357

assert(sourceparamset != targetparamset);

4363 for

( i = 0; i < sourceparamset->

nparams

; ++i )

4369

sourceparam = sourceparamset->

params

[i];

4370

assert(sourceparam !=

NULL

);

4377 if

( targetparam ==

NULL

)

4410 if

( strncmp(sourceparam->

name

,

"visual/"

, 7) != 0 )

4426 if

(

set

->reopt_enable )

4445

assert(param !=

NULL

);

4456

assert(param !=

NULL

);

4457 return

( value ==

TRUE

|| value ==

FALSE

);

4466

assert(param !=

NULL

);

4468 return

( value >= param->

data

.

intparam

.

minvalue

&& value <= param->data.intparam.maxvalue );

4477

assert( param !=

NULL

);

4488

assert( param !=

NULL

);

4499

assert( param !=

NULL

);

4501 if

( value ==

'\b'

|| value ==

'\f'

|| value ==

'\n'

|| value ==

'\r'

|| value ==

'\v'

)

4509 while

( *c !=

'\0'

&& *c != value )

4527

assert(param !=

NULL

);

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'

)

4547

assert(param !=

NULL

);

4571 if

( !initialize && param->paramchgd !=

NULL

&&

set

!=

NULL

)

4575

retcode = param->paramchgd(

set

->scip, param);

4609

assert(param !=

NULL

);

4633 if

( !initialize && param->paramchgd !=

NULL

&&

set

!=

NULL

)

4637

retcode = param->paramchgd(

set

->scip, param);

4671

assert(param !=

NULL

);

4695 if

( !initialize && param->paramchgd !=

NULL

&&

set

!=

NULL

)

4699

retcode = param->paramchgd(

set

->scip, param);

4733

assert(param !=

NULL

);

4759 if

( !initialize && param->paramchgd !=

NULL

&&

set

!=

NULL

)

4763

retcode = param->paramchgd(

set

->scip, param);

4797

assert(param !=

NULL

);

4806 char

oldvalue =

'\0'

;

4820 if

( !initialize && param->paramchgd !=

NULL

&&

set

!=

NULL

)

4824

retcode = param->paramchgd(

set

->scip, param);

4858 char

* oldvalue =

NULL

;

4860

assert(param !=

NULL

);

4881 if

( !initialize && param->paramchgd !=

NULL

&&

set

!=

NULL

)

4885

retcode = param->paramchgd(

set

->scip, param);

4925

assert(param !=

NULL

);

4937

assert(param !=

NULL

);

4951

assert(param !=

NULL

);

4965

assert(param !=

NULL

);

4979

assert(param !=

NULL

);

4988 const char

* defaultvalue

4991

assert(param !=

NULL

);

5005

assert(param !=

NULL

);

5010 SCIPsetDebugMsg

(

set

,

"parameter <%s> is fixed and is not reset to its default value.\n"

, param->

name

);

5053 const char

* filename,

5061

assert(param !=

NULL

);

5064 if

( filename !=

NULL

)

5066

file = fopen(filename,

"w"

);

5078

retcode =

paramWrite

(param, messagehdlr, file, comments, onlychanged);

5081 if

( filename !=

NULL

)

5083

assert(file !=

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)

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)

static SCIP_DECL_HASHGETKEY(hashGetKeyParam)

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

SCIP_STRINGPARAM stringparam

SCIP_LONGINTPARAM longintparam

union SCIP_Param::@17 data

SCIP_PARAMDATA * paramdata

datastructures for handling parameter settings

@ SCIP_PARAMSETTING_AGGRESSIVE

@ SCIP_PARAMSETTING_DEFAULT

@ 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

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)

@ SCIP_PARAMETERWRONGTYPE

enum SCIP_Retcode SCIP_RETCODE

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4