1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2021 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15
16 /**@file paramset.c
17 * @ingroup OTHER_CFILES
18 * @brief methods for handling parameter settings
19 * @author Tobias Achterberg
20 * @author Timo Berthold
21 * @author Stefan Heinz
22 * @author Gerald Gamrath
23 * @author Marc Pfetsch
24 */
25
26 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
27
28 #include <assert.h>
29 #include <string.h>
30 #if defined(_WIN32) || defined(_WIN64)
31 #else
32 #include <strings.h> /*lint --e{766}*/
33 #endif
34
35 #include "scip/scip.h"
36 #include "scip/set.h"
37 #include "scip/paramset.h"
38
39 #include "scip/struct_paramset.h"
40
41
42
43 /*
44 * Parameter methods
45 */
46
47 /** hash key retrieval function for parameters */
48 static
SCIP_DECL_HASHGETKEY(hashGetKeyParam)49 SCIP_DECL_HASHGETKEY(hashGetKeyParam)
50 { /*lint --e{715}*/
51 SCIP_PARAM* param;
52
53 param = (SCIP_PARAM*)elem;
54 assert(param != NULL);
55
56 return param->name;
57 }
58
59 /** tests whether parameter can be changed and issues an error message if it is fixed */
60 static
paramTestFixed(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr)61 SCIP_RETCODE paramTestFixed(
62 SCIP_PARAM* param, /**< parameter */
63 SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
64 )
65 { /*lint --e{715}*/
66 assert(param != NULL);
67 assert(messagehdlr != NULL);
68
69 if( param->isfixed )
70 {
71 SCIPerrorMessage("parameter <%s> is fixed and cannot be changed. Unfix it to allow changing the value.\n", param->name);
72 return SCIP_PARAMETERWRONGVAL;
73 }
74
75 return SCIP_OKAY;
76 }
77
78 /** tests parameter value according to the given feasible domain; issues an error message if value was invalid */
79 static
paramTestBool(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool value)80 SCIP_RETCODE paramTestBool(
81 SCIP_PARAM* param, /**< parameter */
82 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
83 SCIP_Bool value /**< value to test */
84 )
85 { /*lint --e{715}*/
86 assert(param != NULL);
87 assert(param->paramtype == SCIP_PARAMTYPE_BOOL);
88 assert(messagehdlr != NULL);
89
90 if( value != TRUE && value != FALSE )
91 {
92 SCIPerrorMessage("Invalid value <%d> for bool parameter <%s>. Must be <0> (FALSE) or <1> (TRUE).\n", value, param->name);
93 return SCIP_PARAMETERWRONGVAL;
94 }
95
96 return SCIP_OKAY;
97 }
98
99 /** tests parameter value according to the given feasible domain; issues an error message if value was invalid */
100 static
paramTestInt(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr,int value)101 SCIP_RETCODE paramTestInt(
102 SCIP_PARAM* param, /**< parameter */
103 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
104 int value /**< value to test */
105 )
106 { /*lint --e{715}*/
107 assert(param != NULL);
108 assert(param->paramtype == SCIP_PARAMTYPE_INT);
109 assert(messagehdlr != NULL);
110
111 if( value < param->data.intparam.minvalue || value > param->data.intparam.maxvalue )
112 {
113 SCIPerrorMessage("Invalid value <%d> for int parameter <%s>. Must be in range [%d,%d].\n",
114 value, param->name, param->data.intparam.minvalue, param->data.intparam.maxvalue);
115 return SCIP_PARAMETERWRONGVAL;
116 }
117
118 return SCIP_OKAY;
119 }
120
121 /** tests parameter value according to the given feasible domain; issues an error message if value was invalid */
122 static
paramTestLongint(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Longint value)123 SCIP_RETCODE paramTestLongint(
124 SCIP_PARAM* param, /**< parameter */
125 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
126 SCIP_Longint value /**< value to test */
127 )
128 { /*lint --e{715}*/
129 assert(param != NULL);
130 assert(param->paramtype == SCIP_PARAMTYPE_LONGINT);
131 assert(messagehdlr != NULL);
132
133 if( value < param->data.longintparam.minvalue || value > param->data.longintparam.maxvalue )
134 {
135 SCIPerrorMessage("Invalid value <%" SCIP_LONGINT_FORMAT "> for longint parameter <%s>. Must be in range [%" SCIP_LONGINT_FORMAT ",%" SCIP_LONGINT_FORMAT "].\n",
136 value, param->name, param->data.longintparam.minvalue, param->data.longintparam.maxvalue);
137 return SCIP_PARAMETERWRONGVAL;
138 }
139
140 return SCIP_OKAY;
141 }
142
143 /** tests parameter value according to the given feasible domain; issues an error message if value was invalid */
144 static
paramTestReal(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Real value)145 SCIP_RETCODE paramTestReal(
146 SCIP_PARAM* param, /**< parameter */
147 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
148 SCIP_Real value /**< value to test */
149 )
150 { /*lint --e{715}*/
151 assert(param != NULL);
152 assert(param->paramtype == SCIP_PARAMTYPE_REAL);
153 assert(messagehdlr != NULL);
154
155 if( value < param->data.realparam.minvalue || value > param->data.realparam.maxvalue )
156 {
157 SCIPerrorMessage("Invalid value <%.15g> for real parameter <%s>. Must be in range [%.15g,%.15g].\n",
158 value, param->name, param->data.realparam.minvalue, param->data.realparam.maxvalue);
159 return SCIP_PARAMETERWRONGVAL;
160 }
161
162 return SCIP_OKAY;
163 }
164
165 /** tests parameter value according to the given feasible domain; issues an error message if value was invalid */
166 static
paramTestChar(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr,char value)167 SCIP_RETCODE paramTestChar(
168 SCIP_PARAM* param, /**< parameter */
169 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
170 char value /**< value to test */
171 )
172 { /*lint --e{715}*/
173 assert(param != NULL);
174 assert(param->paramtype == SCIP_PARAMTYPE_CHAR);
175 assert(messagehdlr != NULL);
176
177 if( value == '\b' || value == '\f' || value == '\n' || value == '\r' || value == '\v' )
178 {
179 SCIPerrorMessage("Invalid value <%x> for char parameter <%s>.\n", (int)value, param->name);
180 return SCIP_PARAMETERWRONGVAL;
181 }
182
183 if( param->data.charparam.allowedvalues != NULL )
184 {
185 char* c;
186
187 c = param->data.charparam.allowedvalues;
188 while( *c != '\0' && *c != value )
189 c++;
190
191 if( *c != value )
192 {
193 SCIPerrorMessage("Invalid value <%c> for char parameter <%s>. Must be in set {%s}.\n",
194 value, param->name, param->data.charparam.allowedvalues);
195 return SCIP_PARAMETERWRONGVAL;
196 }
197 }
198
199 return SCIP_OKAY;
200 }
201
202 /** tests parameter value according to the given feasible domain; issues an error message if value was invalid */
203 static
paramTestString(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr,const char * value)204 SCIP_RETCODE paramTestString(
205 SCIP_PARAM* param, /**< parameter */
206 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
207 const char* value /**< value to test */
208 )
209 { /*lint --e{715}*/
210 unsigned int i;
211
212 assert(param != NULL);
213 assert(param->paramtype == SCIP_PARAMTYPE_STRING);
214 assert(messagehdlr != NULL);
215
216 if( value == NULL )
217 {
218 SCIPerrorMessage("Cannot assign a NULL string to a string parameter.\n");
219 return SCIP_PARAMETERWRONGVAL;
220 }
221
222 for( i = 0; i < (unsigned int) strlen(value); ++i )
223 {
224 if( value[i] == '\b' || value[i] == '\f' || value[i] == '\n' || value[i] == '\r' || value[i] == '\v' )
225 {
226 SCIPerrorMessage("Invalid character <%x> in string parameter <%s> at position %d.\n", (int)value[i], param->name, i);
227 return SCIP_PARAMETERWRONGVAL;
228 }
229 }
230
231 return SCIP_OKAY;
232 }
233
234 /** writes the parameter to a file */
235 static
paramWrite(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr,FILE * file,SCIP_Bool comments,SCIP_Bool onlychanged)236 SCIP_RETCODE paramWrite(
237 SCIP_PARAM* param, /**< parameter */
238 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
239 FILE* file, /**< file stream to write parameter to, or NULL for stdout */
240 SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
241 SCIP_Bool onlychanged /**< should only the parameters been written, that are changed from default? */
242 )
243 {
244 assert(param != NULL);
245 assert(messagehdlr != NULL);
246
247 /* write parameters at default values only, if the onlychanged flag is not set or if the parameter is fixed */
248 if( onlychanged && SCIPparamIsDefault(param) && !SCIPparamIsFixed(param) )
249 return SCIP_OKAY;
250
251 /* write parameter description, bounds, and defaults as comments */
252 if( comments )
253 {
254 SCIPmessageFPrintInfo(messagehdlr, file, "# %s\n", param->desc);
255 switch( param->paramtype )
256 {
257 case SCIP_PARAMTYPE_BOOL:
258 SCIPmessageFPrintInfo(messagehdlr, file, "# [type: bool, advanced: %s, range: {TRUE,FALSE}, default: %s]\n",
259 SCIPparamIsAdvanced(param) ? "TRUE" : "FALSE",
260 param->data.boolparam.defaultvalue ? "TRUE" : "FALSE");
261 break;
262 case SCIP_PARAMTYPE_INT:
263 SCIPmessageFPrintInfo(messagehdlr, file, "# [type: int, advanced: %s, range: [%d,%d], default: %d]\n",
264 SCIPparamIsAdvanced(param) ? "TRUE" : "FALSE",
265 param->data.intparam.minvalue, param->data.intparam.maxvalue, param->data.intparam.defaultvalue);
266 break;
267 case SCIP_PARAMTYPE_LONGINT:
268 SCIPmessageFPrintInfo(messagehdlr, file, "# [type: longint, advanced: %s, range: [%" SCIP_LONGINT_FORMAT ",%" SCIP_LONGINT_FORMAT "], default: %" SCIP_LONGINT_FORMAT "]\n",
269 SCIPparamIsAdvanced(param) ? "TRUE" : "FALSE",
270 param->data.longintparam.minvalue, param->data.longintparam.maxvalue, param->data.longintparam.defaultvalue);
271 break;
272 case SCIP_PARAMTYPE_REAL:
273 SCIPmessageFPrintInfo(messagehdlr, file, "# [type: real, advanced: %s, range: [%.15g,%.15g], default: %.15g]\n",
274 SCIPparamIsAdvanced(param) ? "TRUE" : "FALSE",
275 param->data.realparam.minvalue, param->data.realparam.maxvalue, param->data.realparam.defaultvalue);
276 break;
277 case SCIP_PARAMTYPE_CHAR:
278 SCIPmessageFPrintInfo(messagehdlr, file, "# [type: char, advanced: %s, range: {%s}, default: %c]\n",
279 SCIPparamIsAdvanced(param) ? "TRUE" : "FALSE",
280 param->data.charparam.allowedvalues != NULL ? param->data.charparam.allowedvalues : "all chars",
281 param->data.charparam.defaultvalue);
282 break;
283 case SCIP_PARAMTYPE_STRING:
284 SCIPmessageFPrintInfo(messagehdlr, file, "# [type: string, advanced: %s, default: \"%s\"]\n",
285 SCIPparamIsAdvanced(param) ? "TRUE" : "FALSE",
286 param->data.stringparam.defaultvalue);
287 break;
288 default:
289 SCIPerrorMessage("unknown parameter type\n");
290 return SCIP_INVALIDDATA;
291 }
292 }
293
294 /* write parameter value */
295 SCIPmessageFPrintInfo(messagehdlr, file, "%s = ", param->name);
296 switch( param->paramtype )
297 {
298 case SCIP_PARAMTYPE_BOOL:
299 SCIPmessageFPrintInfo(messagehdlr, file, "%s", SCIPparamGetBool(param) ? "TRUE" : "FALSE");
300 break;
301 case SCIP_PARAMTYPE_INT:
302 SCIPmessageFPrintInfo(messagehdlr, file, "%d", SCIPparamGetInt(param));
303 break;
304 case SCIP_PARAMTYPE_LONGINT:
305 SCIPmessageFPrintInfo(messagehdlr, file, "%" SCIP_LONGINT_FORMAT "", SCIPparamGetLongint(param));
306 break;
307 case SCIP_PARAMTYPE_REAL:
308 SCIPmessageFPrintInfo(messagehdlr, file, "%.15g", SCIPparamGetReal(param));
309 break;
310 case SCIP_PARAMTYPE_CHAR:
311 SCIPmessageFPrintInfo(messagehdlr, file, "%c", SCIPparamGetChar(param));
312 break;
313 case SCIP_PARAMTYPE_STRING:
314 SCIPmessageFPrintInfo(messagehdlr, file, "\"%s\"", SCIPparamGetString(param));
315 break;
316 default:
317 SCIPerrorMessage("unknown parameter type\n");
318 return SCIP_INVALIDDATA;
319 }
320
321 /* write "fix" after value if parameter is fixed */
322 if( SCIPparamIsFixed(param) )
323 SCIPmessageFPrintInfo(messagehdlr, file, " fix");
324
325 SCIPmessageFPrintInfo(messagehdlr, file, "\n");
326
327 if( comments )
328 SCIPmessageFPrintInfo(messagehdlr, file, "\n");
329
330 return SCIP_OKAY;
331 }
332
333 /** if a bool parameter exits with the given parameter name it is set to the new value */
334 static
paramSetBool(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * paramname,SCIP_Bool value,SCIP_Bool quiet)335 SCIP_RETCODE paramSetBool(
336 SCIP_PARAMSET* paramset, /**< parameter set */
337 SCIP_SET* set, /**< global SCIP settings */
338 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
339 const char* paramname, /**< parameter name */
340 SCIP_Bool value, /**< new value of the parameter */
341 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
342 )
343 {
344 SCIP_PARAM* param;
345
346 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
347 if( param != NULL )
348 {
349 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_BOOL);
350
351 if( SCIPparamIsFixed(param) )
352 {
353 SCIPsetDebugMsg(set, "hard coded parameter <%s> is fixed and is thus not changed.\n", param->name);
354
355 return SCIP_OKAY;
356 }
357 SCIP_CALL( SCIPparamSetBool(param, set, messagehdlr, value, FALSE, quiet) );
358 }
359 #ifndef NDEBUG
360 else
361 {
362 SCIPmessagePrintWarning(messagehdlr, "unknown hard coded bool parameter <%s>\n", paramname);
363 }
364 #endif
365
366 return SCIP_OKAY;
367 }
368
369 /** if an char parameter exits with the given parameter name it is set to the new value */
370 static
paramSetChar(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * paramname,char value,SCIP_Bool quiet)371 SCIP_RETCODE paramSetChar(
372 SCIP_PARAMSET* paramset, /**< parameter set */
373 SCIP_SET* set, /**< global SCIP settings */
374 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
375 const char* paramname, /**< parameter name */
376 char value, /**< new value of the parameter */
377 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
378 )
379 {
380 SCIP_PARAM* param;
381
382 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
383 if( param != NULL )
384 {
385 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_CHAR);
386
387 if( SCIPparamIsFixed(param) )
388 {
389 SCIPsetDebugMsg(set, "hard coded parameter <%s> is fixed and is thus not changed.\n", param->name);
390
391 return SCIP_OKAY;
392 }
393 SCIP_CALL( SCIPparamSetChar(param, set, messagehdlr, value, FALSE, quiet) );
394 }
395 #ifndef NDEBUG
396 else
397 {
398 SCIPmessagePrintWarning(messagehdlr, "unknown hard coded char parameter <%s>\n", paramname);
399 }
400 #endif
401
402 return SCIP_OKAY;
403 }
404
405 /** if an integer parameter exits with the given parameter name it is set to the new value */
406 static
paramSetInt(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * paramname,int value,SCIP_Bool quiet)407 SCIP_RETCODE paramSetInt(
408 SCIP_PARAMSET* paramset, /**< parameter set */
409 SCIP_SET* set, /**< global SCIP settings */
410 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
411 const char* paramname, /**< parameter name */
412 int value, /**< new value of the parameter */
413 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
414 )
415 {
416 SCIP_PARAM* param;
417
418 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
419 if( param != NULL )
420 {
421 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
422
423 if( SCIPparamIsFixed(param) )
424 {
425 SCIPsetDebugMsg(set, "hard coded parameter <%s> is fixed and is thus not changed.\n", param->name);
426
427 return SCIP_OKAY;
428 }
429 SCIP_CALL( SCIPparamSetInt(param, set, messagehdlr, value, FALSE, quiet) );
430 }
431 #ifndef NDEBUG
432 else
433 {
434 SCIPmessagePrintWarning(messagehdlr, "unknown hard coded int parameter <%s>\n", paramname);
435 }
436 #endif
437
438 return SCIP_OKAY;
439 }
440
441 /** if a long integer parameter exits with the given parameter name it is set to the new value */
442 static
paramSetLongint(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * paramname,SCIP_Longint value,SCIP_Bool quiet)443 SCIP_RETCODE paramSetLongint(
444 SCIP_PARAMSET* paramset, /**< parameter set */
445 SCIP_SET* set, /**< global SCIP settings */
446 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
447 const char* paramname, /**< parameter name */
448 SCIP_Longint value, /**< new value of the parameter */
449 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
450 )
451 {
452 SCIP_PARAM* param;
453
454 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
455 if( param != NULL )
456 {
457 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_LONGINT);
458
459 if( SCIPparamIsFixed(param) )
460 {
461 SCIPsetDebugMsg(set, "hard coded parameter <%s> is fixed and is thus not changed.\n", param->name);
462
463 return SCIP_OKAY;
464 }
465 SCIP_CALL( SCIPparamSetLongint(param, set, messagehdlr, value, FALSE, quiet) );
466 }
467 #ifndef NDEBUG
468 else
469 {
470 SCIPmessagePrintWarning(messagehdlr, "unknown hard coded longint parameter <%s>\n", paramname);
471 }
472 #endif
473
474 return SCIP_OKAY;
475 }
476
477 /** if a real parameter exits with the given parameter name it is set to the new value */
478 static
paramSetReal(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * paramname,SCIP_Real value,SCIP_Bool quiet)479 SCIP_RETCODE paramSetReal(
480 SCIP_PARAMSET* paramset, /**< parameter set */
481 SCIP_SET* set, /**< global SCIP settings */
482 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
483 const char* paramname, /**< parameter name */
484 SCIP_Real value, /**< new value of the parameter */
485 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
486 )
487 {
488 SCIP_PARAM* param;
489
490 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
491 if( param != NULL )
492 {
493 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_REAL);
494
495 if( SCIPparamIsFixed(param) )
496 {
497 SCIPsetDebugMsg(set, "hard coded parameter <%s> is fixed and is thus not changed.\n", param->name);
498
499 return SCIP_OKAY;
500 }
501 SCIP_CALL( SCIPparamSetReal(param, set, messagehdlr, value, FALSE, quiet) );
502 }
503 #ifndef NDEBUG
504 else
505 {
506 SCIPmessagePrintWarning(messagehdlr, "unknown hard coded real parameter <%s>\n", paramname);
507 }
508 #endif
509
510 return SCIP_OKAY;
511 }
512
513 /** copies value of source Bool parameter to target Bool parameter*/
514 static
paramCopyBool(SCIP_PARAM * sourceparam,SCIP_PARAM * targetparam,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)515 SCIP_RETCODE paramCopyBool(
516 SCIP_PARAM* sourceparam, /**< source Bool parameter */
517 SCIP_PARAM* targetparam, /**< target Bool parameter */
518 SCIP_SET* set, /**< global SCIP settings of target SCIP */
519 SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
520 )
521 {
522 SCIP_Bool value;
523
524 assert(sourceparam != NULL);
525 assert(targetparam != NULL);
526
527 /* get value of source parameter and copy it to target parameter */
528 value = SCIPparamGetBool(sourceparam);
529 SCIP_CALL( SCIPparamSetBool(targetparam, set, messagehdlr, value, FALSE, TRUE) );
530
531 return SCIP_OKAY;
532 }
533
534 /** copies value of source int parameter to target int parameter*/
535 static
paramCopyInt(SCIP_PARAM * sourceparam,SCIP_PARAM * targetparam,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)536 SCIP_RETCODE paramCopyInt(
537 SCIP_PARAM* sourceparam, /**< source int parameter */
538 SCIP_PARAM* targetparam, /**< target int parameter */
539 SCIP_SET* set, /**< global SCIP settings of target SCIP */
540 SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
541 )
542 {
543 int value;
544
545 assert(sourceparam != NULL);
546 assert(targetparam != NULL);
547
548 /* get value of source parameter and copy it to target parameter */
549 value = SCIPparamGetInt(sourceparam);
550 SCIP_CALL( SCIPparamSetInt(targetparam, set, messagehdlr, value, FALSE, TRUE) );
551
552 return SCIP_OKAY;
553 }
554
555 /** copies value of source longint parameter to target longint parameter*/
556 static
paramCopyLongint(SCIP_PARAM * sourceparam,SCIP_PARAM * targetparam,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)557 SCIP_RETCODE paramCopyLongint(
558 SCIP_PARAM* sourceparam, /**< source longint parameter */
559 SCIP_PARAM* targetparam, /**< target longint parameter */
560 SCIP_SET* set, /**< global SCIP settings of target SCIP */
561 SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
562 )
563 {
564 SCIP_Longint value;
565
566 assert(sourceparam != NULL);
567 assert(targetparam != NULL);
568
569 /* get value of source parameter and copy it to target parameter */
570 value = SCIPparamGetLongint(sourceparam);
571 SCIP_CALL( SCIPparamSetLongint(targetparam, set, messagehdlr, value, FALSE, TRUE) );
572
573 return SCIP_OKAY;
574 }
575
576 /** copies value of source real parameter to target real parameter*/
577 static
paramCopyReal(SCIP_PARAM * sourceparam,SCIP_PARAM * targetparam,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)578 SCIP_RETCODE paramCopyReal(
579 SCIP_PARAM* sourceparam, /**< source real parameter */
580 SCIP_PARAM* targetparam, /**< target real parameter */
581 SCIP_SET* set, /**< global SCIP settings of target SCIP */
582 SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
583 )
584 {
585 SCIP_Real value;
586
587 assert(sourceparam != NULL);
588 assert(targetparam != NULL);
589
590 /* get value of source parameter and copy it to target parameter */
591 value = SCIPparamGetReal(sourceparam);
592 SCIP_CALL( SCIPparamSetReal(targetparam, set, messagehdlr, value, FALSE, TRUE) );
593
594 return SCIP_OKAY;
595 }
596
597 /** copies value of source char parameter to target char parameter*/
598 static
paramCopyChar(SCIP_PARAM * sourceparam,SCIP_PARAM * targetparam,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)599 SCIP_RETCODE paramCopyChar(
600 SCIP_PARAM* sourceparam, /**< source char parameter */
601 SCIP_PARAM* targetparam, /**< target char parameter */
602 SCIP_SET* set, /**< global SCIP settings of target SCIP */
603 SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
604 )
605 {
606 char value;
607
608 assert(sourceparam != NULL);
609 assert(targetparam != NULL);
610
611 /* get value of source parameter and copy it to target parameter */
612 value = SCIPparamGetChar(sourceparam);
613 SCIP_CALL( SCIPparamSetChar(targetparam, set, messagehdlr, value, FALSE, TRUE) );
614
615 return SCIP_OKAY;
616 }
617
618 /** copies value of source string parameter to target string parameter*/
619 static
paramCopyString(SCIP_PARAM * sourceparam,SCIP_PARAM * targetparam,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)620 SCIP_RETCODE paramCopyString(
621 SCIP_PARAM* sourceparam, /**< source string parameter */
622 SCIP_PARAM* targetparam, /**< target string parameter */
623 SCIP_SET* set, /**< global SCIP settings of target SCIP */
624 SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
625 )
626 {
627 char* value;
628
629 assert(sourceparam != NULL);
630 assert(targetparam != NULL);
631
632 /* get value of source parameter and copy it to target parameter */
633 value = SCIPparamGetString(sourceparam);
634 SCIP_CALL( SCIPparamSetString(targetparam, set, messagehdlr, value, TRUE) );
635
636 return SCIP_OKAY;
637 }
638
639 /** returns type of parameter */
SCIPparamGetType(SCIP_PARAM * param)640 SCIP_PARAMTYPE SCIPparamGetType(
641 SCIP_PARAM* param /**< parameter */
642 )
643 {
644 assert(param != NULL);
645
646 return param->paramtype;
647 }
648
649 /** returns name of parameter */
SCIPparamGetName(SCIP_PARAM * param)650 const char* SCIPparamGetName(
651 SCIP_PARAM* param /**< parameter */
652 )
653 {
654 assert(param != NULL);
655
656 return param->name;
657 }
658
659 /** returns description of parameter */
SCIPparamGetDesc(SCIP_PARAM * param)660 const char* SCIPparamGetDesc(
661 SCIP_PARAM* param /**< parameter */
662 )
663 {
664 assert(param != NULL);
665
666 return param->desc;
667 }
668
669 /** returns locally defined parameter specific data */
SCIPparamGetData(SCIP_PARAM * param)670 SCIP_PARAMDATA* SCIPparamGetData(
671 SCIP_PARAM* param /**< parameter */
672 )
673 {
674 assert(param != NULL);
675
676 return param->paramdata;
677 }
678
679 /** returns whether parameter is advanced */
SCIPparamIsAdvanced(SCIP_PARAM * param)680 SCIP_Bool SCIPparamIsAdvanced(
681 SCIP_PARAM* param /**< parameter */
682 )
683 {
684 assert(param != NULL);
685
686 return param->isadvanced;
687 }
688
689 /** returns whether parameter is fixed */
SCIPparamIsFixed(SCIP_PARAM * param)690 SCIP_Bool SCIPparamIsFixed(
691 SCIP_PARAM* param /**< parameter */
692 )
693 {
694 assert(param != NULL);
695
696 return param->isfixed;
697 }
698
699 /** returns value of SCIP_Bool parameter */
SCIPparamGetBool(SCIP_PARAM * param)700 SCIP_Bool SCIPparamGetBool(
701 SCIP_PARAM* param /**< parameter */
702 )
703 {
704 assert(param != NULL);
705 assert(param->paramtype == SCIP_PARAMTYPE_BOOL);
706
707 if( param->data.boolparam.valueptr != NULL )
708 return *param->data.boolparam.valueptr;
709 else
710 return param->data.boolparam.curvalue;
711 }
712
713 /** returns default value of SCIP_Bool parameter */
SCIPparamGetBoolDefault(SCIP_PARAM * param)714 SCIP_Bool SCIPparamGetBoolDefault(
715 SCIP_PARAM* param /**< parameter */
716 )
717 {
718 assert(param != NULL);
719 assert(param->paramtype == SCIP_PARAMTYPE_BOOL);
720
721 return param->data.boolparam.defaultvalue;
722 }
723
724 /** returns value of int parameter */
SCIPparamGetInt(SCIP_PARAM * param)725 int SCIPparamGetInt(
726 SCIP_PARAM* param /**< parameter */
727 )
728 {
729 assert(param != NULL);
730 assert(param->paramtype == SCIP_PARAMTYPE_INT);
731
732 if( param->data.intparam.valueptr != NULL )
733 return *param->data.intparam.valueptr;
734 else
735 return param->data.intparam.curvalue;
736 }
737
738 /** returns minimal value of int parameter */
SCIPparamGetIntMin(SCIP_PARAM * param)739 int SCIPparamGetIntMin(
740 SCIP_PARAM* param /**< parameter */
741 )
742 {
743 assert(param != NULL);
744 assert(param->paramtype == SCIP_PARAMTYPE_INT);
745
746 return param->data.intparam.minvalue;
747 }
748
749 /** returns maximal value of int parameter */
SCIPparamGetIntMax(SCIP_PARAM * param)750 int SCIPparamGetIntMax(
751 SCIP_PARAM* param /**< parameter */
752 )
753 {
754 assert(param != NULL);
755 assert(param->paramtype == SCIP_PARAMTYPE_INT);
756
757 return param->data.intparam.maxvalue;
758 }
759
760 /** returns default value of int parameter */
SCIPparamGetIntDefault(SCIP_PARAM * param)761 int SCIPparamGetIntDefault(
762 SCIP_PARAM* param /**< parameter */
763 )
764 {
765 assert(param != NULL);
766 assert(param->paramtype == SCIP_PARAMTYPE_INT);
767
768 return param->data.intparam.defaultvalue;
769 }
770
771 /** returns value of SCIP_Longint parameter */
SCIPparamGetLongint(SCIP_PARAM * param)772 SCIP_Longint SCIPparamGetLongint(
773 SCIP_PARAM* param /**< parameter */
774 )
775 {
776 assert(param != NULL);
777 assert(param->paramtype == SCIP_PARAMTYPE_LONGINT);
778
779 if( param->data.longintparam.valueptr != NULL )
780 return *param->data.longintparam.valueptr;
781 else
782 return param->data.longintparam.curvalue;
783 }
784
785 /** returns minimal value of longint parameter */
SCIPparamGetLongintMin(SCIP_PARAM * param)786 SCIP_Longint SCIPparamGetLongintMin(
787 SCIP_PARAM* param /**< parameter */
788 )
789 {
790 assert(param != NULL);
791 assert(param->paramtype == SCIP_PARAMTYPE_LONGINT);
792
793 return param->data.longintparam.minvalue;
794 }
795
796 /** returns maximal value of longint parameter */
SCIPparamGetLongintMax(SCIP_PARAM * param)797 SCIP_Longint SCIPparamGetLongintMax(
798 SCIP_PARAM* param /**< parameter */
799 )
800 {
801 assert(param != NULL);
802 assert(param->paramtype == SCIP_PARAMTYPE_LONGINT);
803
804 return param->data.longintparam.maxvalue;
805 }
806
807 /** returns default value of SCIP_Longint parameter */
SCIPparamGetLongintDefault(SCIP_PARAM * param)808 SCIP_Longint SCIPparamGetLongintDefault(
809 SCIP_PARAM* param /**< parameter */
810 )
811 {
812 assert(param != NULL);
813 assert(param->paramtype == SCIP_PARAMTYPE_LONGINT);
814
815 return param->data.longintparam.defaultvalue;
816 }
817
818 /** returns value of SCIP_Real parameter */
SCIPparamGetReal(SCIP_PARAM * param)819 SCIP_Real SCIPparamGetReal(
820 SCIP_PARAM* param /**< parameter */
821 )
822 {
823 assert(param != NULL);
824 assert(param->paramtype == SCIP_PARAMTYPE_REAL);
825
826 if( param->data.realparam.valueptr != NULL )
827 return *param->data.realparam.valueptr;
828 else
829 return param->data.realparam.curvalue;
830 }
831
832 /** returns minimal value of real parameter */
SCIPparamGetRealMin(SCIP_PARAM * param)833 SCIP_Real SCIPparamGetRealMin(
834 SCIP_PARAM* param /**< parameter */
835 )
836 {
837 assert(param != NULL);
838 assert(param->paramtype == SCIP_PARAMTYPE_REAL);
839
840 return param->data.realparam.minvalue;
841 }
842
843 /** returns maximal value of real parameter */
SCIPparamGetRealMax(SCIP_PARAM * param)844 SCIP_Real SCIPparamGetRealMax(
845 SCIP_PARAM* param /**< parameter */
846 )
847 {
848 assert(param != NULL);
849 assert(param->paramtype == SCIP_PARAMTYPE_REAL);
850
851 return param->data.realparam.maxvalue;
852 }
853
854 /** returns default value of SCIP_Real parameter */
SCIPparamGetRealDefault(SCIP_PARAM * param)855 SCIP_Real SCIPparamGetRealDefault(
856 SCIP_PARAM* param /**< parameter */
857 )
858 {
859 assert(param != NULL);
860 assert(param->paramtype == SCIP_PARAMTYPE_REAL);
861
862 return param->data.realparam.defaultvalue;
863 }
864
865 /** returns value of char parameter */
SCIPparamGetChar(SCIP_PARAM * param)866 char SCIPparamGetChar(
867 SCIP_PARAM* param /**< parameter */
868 )
869 {
870 assert(param != NULL);
871 assert(param->paramtype == SCIP_PARAMTYPE_CHAR);
872
873 if( param->data.charparam.valueptr != NULL )
874 return *param->data.charparam.valueptr;
875 else
876 return param->data.charparam.curvalue;
877 }
878
879 /** returns allowed values of char parameter, or NULL if everything is allowed */
SCIPparamGetCharAllowedValues(SCIP_PARAM * param)880 char* SCIPparamGetCharAllowedValues(
881 SCIP_PARAM* param /**< parameter */
882 )
883 {
884 assert(param != NULL);
885 assert(param->paramtype == SCIP_PARAMTYPE_CHAR);
886
887 return param->data.charparam.allowedvalues;
888 }
889
890 /** returns default value of char parameter */
SCIPparamGetCharDefault(SCIP_PARAM * param)891 char SCIPparamGetCharDefault(
892 SCIP_PARAM* param /**< parameter */
893 )
894 {
895 assert(param != NULL);
896 assert(param->paramtype == SCIP_PARAMTYPE_CHAR);
897
898 return param->data.charparam.defaultvalue;
899 }
900
901 /** returns value of string parameter */
SCIPparamGetString(SCIP_PARAM * param)902 char* SCIPparamGetString(
903 SCIP_PARAM* param /**< parameter */
904 )
905 {
906 assert(param != NULL);
907 assert(param->paramtype == SCIP_PARAMTYPE_STRING);
908
909 if( param->data.stringparam.valueptr != NULL )
910 return *param->data.stringparam.valueptr;
911 else
912 return param->data.stringparam.curvalue;
913 }
914
915 /** returns default value of String parameter */
SCIPparamGetStringDefault(SCIP_PARAM * param)916 char* SCIPparamGetStringDefault(
917 SCIP_PARAM* param /**< parameter */
918 )
919 {
920 assert(param != NULL);
921 assert(param->paramtype == SCIP_PARAMTYPE_STRING);
922
923 return param->data.stringparam.defaultvalue;
924 }
925
926 /** returns whether the parameter is on its default setting */
SCIPparamIsDefault(SCIP_PARAM * param)927 SCIP_Bool SCIPparamIsDefault(
928 SCIP_PARAM* param /**< parameter */
929 )
930 {
931 assert(param != NULL);
932
933 switch( param->paramtype )
934 {
935 case SCIP_PARAMTYPE_BOOL:
936 return (SCIPparamGetBool(param) == SCIPparamGetBoolDefault(param));
937
938 case SCIP_PARAMTYPE_INT:
939 return (SCIPparamGetInt(param) == SCIPparamGetIntDefault(param));
940
941 case SCIP_PARAMTYPE_LONGINT:
942 return (SCIPparamGetLongint(param) == SCIPparamGetLongintDefault(param));
943
944 case SCIP_PARAMTYPE_REAL:
945 return EPSZ(SCIPparamGetReal(param) - SCIPparamGetRealDefault(param), 1e-16);
946
947 case SCIP_PARAMTYPE_CHAR:
948 return (SCIPparamGetChar(param) == SCIPparamGetCharDefault(param));
949
950 case SCIP_PARAMTYPE_STRING:
951 return (strcmp(SCIPparamGetString(param), SCIPparamGetStringDefault(param)) == 0);
952
953 default:
954 SCIPerrorMessage("unknown parameter type\n");
955 SCIPABORT();
956 return FALSE; /*lint !e527*/
957 }
958 }
959
960 /** creates a parameter with name and description, does not set the type specific parameter values themselves */
961 static
paramCreate(SCIP_PARAM ** param,BMS_BLKMEM * blkmem,const char * name,const char * desc,SCIP_DECL_PARAMCHGD ((* paramchgd)),SCIP_PARAMDATA * paramdata,SCIP_Bool isadvanced)962 SCIP_RETCODE paramCreate(
963 SCIP_PARAM** param, /**< pointer to the parameter */
964 BMS_BLKMEM* blkmem, /**< block memory */
965 const char* name, /**< name of the parameter */
966 const char* desc, /**< description of the parameter */
967 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
968 SCIP_PARAMDATA* paramdata, /**< locally defined parameter specific data */
969 SCIP_Bool isadvanced /**< is the parameter advanced? */
970 )
971 {
972 assert(param != NULL);
973 assert(name != NULL);
974 assert(desc != NULL);
975
976 SCIP_ALLOC( BMSallocBlockMemory(blkmem, param) );
977
978 SCIP_ALLOC( BMSduplicateMemoryArray(&(*param)->name, name, strlen(name)+1) );
979 SCIP_ALLOC( BMSduplicateMemoryArray(&(*param)->desc, desc, strlen(desc)+1) );
980
981 (*param)->paramchgd = paramchgd;
982 (*param)->paramdata = paramdata;
983 (*param)->isadvanced = isadvanced;
984 (*param)->isfixed = FALSE;
985
986 return SCIP_OKAY;
987 }
988
989 /** creates a SCIP_Bool parameter, and sets its value to default */
990 static
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)991 SCIP_RETCODE paramCreateBool(
992 SCIP_PARAM** param, /**< pointer to the parameter */
993 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
994 BMS_BLKMEM* blkmem, /**< block memory */
995 const char* name, /**< name of the parameter */
996 const char* desc, /**< description of the parameter */
997 SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
998 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
999 SCIP_Bool defaultvalue, /**< default value of the parameter */
1000 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1001 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1002 )
1003 {
1004 assert(param != NULL);
1005 assert(name != NULL);
1006
1007 SCIP_CALL( paramCreate(param, blkmem, name, desc, paramchgd, paramdata, isadvanced) );
1008
1009 (*param)->paramtype = SCIP_PARAMTYPE_BOOL;
1010 (*param)->data.boolparam.valueptr = valueptr;
1011 (*param)->data.boolparam.defaultvalue = defaultvalue;
1012
1013 SCIP_CALL( SCIPparamSetBool(*param, NULL, messagehdlr, defaultvalue, TRUE, TRUE) );
1014
1015 return SCIP_OKAY;
1016 }
1017
1018 /** creates a int parameter, and sets its value to default */
1019 static
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)1020 SCIP_RETCODE paramCreateInt(
1021 SCIP_PARAM** param, /**< pointer to the parameter */
1022 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1023 BMS_BLKMEM* blkmem, /**< block memory */
1024 const char* name, /**< name of the parameter */
1025 const char* desc, /**< description of the parameter */
1026 int* valueptr, /**< pointer to store the current parameter value, or NULL */
1027 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1028 int defaultvalue, /**< default value of the parameter */
1029 int minvalue, /**< minimum value for parameter */
1030 int maxvalue, /**< maximum value for parameter */
1031 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1032 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1033 )
1034 {
1035 assert(param != NULL);
1036 assert(name != NULL);
1037
1038 SCIP_CALL( paramCreate(param, blkmem, name, desc, paramchgd, paramdata, isadvanced) );
1039
1040 (*param)->paramtype = SCIP_PARAMTYPE_INT;
1041 (*param)->data.intparam.valueptr = valueptr;
1042 (*param)->data.intparam.defaultvalue = defaultvalue;
1043 (*param)->data.intparam.minvalue = minvalue;
1044 (*param)->data.intparam.maxvalue = maxvalue;
1045
1046 SCIP_CALL( SCIPparamSetInt(*param, NULL, messagehdlr, defaultvalue, TRUE, TRUE) );
1047
1048 return SCIP_OKAY;
1049 }
1050
1051 /** creates a SCIP_Longint parameter, and sets its value to default */
1052 static
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)1053 SCIP_RETCODE paramCreateLongint(
1054 SCIP_PARAM** param, /**< pointer to the parameter */
1055 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1056 BMS_BLKMEM* blkmem, /**< block memory */
1057 const char* name, /**< name of the parameter */
1058 const char* desc, /**< description of the parameter */
1059 SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
1060 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1061 SCIP_Longint defaultvalue, /**< default value of the parameter */
1062 SCIP_Longint minvalue, /**< minimum value for parameter */
1063 SCIP_Longint maxvalue, /**< maximum value for parameter */
1064 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1065 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1066 )
1067 {
1068 assert(param != NULL);
1069 assert(name != NULL);
1070
1071 SCIP_CALL( paramCreate(param, blkmem, name, desc, paramchgd, paramdata, isadvanced) );
1072
1073 (*param)->paramtype = SCIP_PARAMTYPE_LONGINT;
1074 (*param)->data.longintparam.valueptr = valueptr;
1075 (*param)->data.longintparam.defaultvalue = defaultvalue;
1076 (*param)->data.longintparam.minvalue = minvalue;
1077 (*param)->data.longintparam.maxvalue = maxvalue;
1078
1079 SCIP_CALL( SCIPparamSetLongint(*param, NULL, messagehdlr, defaultvalue, TRUE, TRUE) );
1080
1081 return SCIP_OKAY;
1082 }
1083
1084 /** creates a SCIP_Real parameter, and sets its value to default */
1085 static
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)1086 SCIP_RETCODE paramCreateReal(
1087 SCIP_PARAM** param, /**< pointer to the parameter */
1088 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1089 BMS_BLKMEM* blkmem, /**< block memory */
1090 const char* name, /**< name of the parameter */
1091 const char* desc, /**< description of the parameter */
1092 SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
1093 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1094 SCIP_Real defaultvalue, /**< default value of the parameter */
1095 SCIP_Real minvalue, /**< minimum value for parameter */
1096 SCIP_Real maxvalue, /**< maximum value for parameter */
1097 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1098 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1099 )
1100 {
1101 assert(param != NULL);
1102 assert(name != NULL);
1103
1104 SCIP_CALL( paramCreate(param, blkmem, name, desc, paramchgd, paramdata, isadvanced) );
1105
1106 (*param)->paramtype = SCIP_PARAMTYPE_REAL;
1107 (*param)->data.realparam.valueptr = valueptr;
1108 (*param)->data.realparam.defaultvalue = defaultvalue;
1109 (*param)->data.realparam.minvalue = minvalue;
1110 (*param)->data.realparam.maxvalue = maxvalue;
1111
1112 SCIP_CALL( SCIPparamSetReal(*param, NULL, messagehdlr, defaultvalue, TRUE, TRUE) );
1113
1114 return SCIP_OKAY;
1115 }
1116
1117 /** creates a char parameter, and sets its value to default */
1118 static
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)1119 SCIP_RETCODE paramCreateChar(
1120 SCIP_PARAM** param, /**< pointer to the parameter */
1121 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1122 BMS_BLKMEM* blkmem, /**< block memory */
1123 const char* name, /**< name of the parameter */
1124 const char* desc, /**< description of the parameter */
1125 char* valueptr, /**< pointer to store the current parameter value, or NULL */
1126 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1127 char defaultvalue, /**< default value of the parameter */
1128 const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
1129 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1130 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1131 )
1132 {
1133 assert(param != NULL);
1134 assert(name != NULL);
1135
1136 SCIP_CALL( paramCreate(param, blkmem, name, desc, paramchgd, paramdata, isadvanced) );
1137
1138 (*param)->paramtype = SCIP_PARAMTYPE_CHAR;
1139 (*param)->data.charparam.valueptr = valueptr;
1140 (*param)->data.charparam.defaultvalue = defaultvalue;
1141 if( allowedvalues != NULL )
1142 {
1143 SCIP_ALLOC( BMSduplicateMemoryArray(&(*param)->data.charparam.allowedvalues, allowedvalues, strlen(allowedvalues)+1) );
1144 }
1145 else
1146 (*param)->data.charparam.allowedvalues = NULL;
1147
1148 SCIP_CALL( SCIPparamSetChar(*param, NULL, messagehdlr, defaultvalue, TRUE, TRUE) );
1149
1150 return SCIP_OKAY;
1151 }
1152
1153 /** creates a string parameter, and sets its value to default */
1154 static
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)1155 SCIP_RETCODE paramCreateString(
1156 SCIP_PARAM** param, /**< pointer to the parameter */
1157 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1158 BMS_BLKMEM* blkmem, /**< block memory */
1159 const char* name, /**< name of the parameter */
1160 const char* desc, /**< description of the parameter */
1161 char** valueptr, /**< pointer to store the current parameter value, or NULL */
1162 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1163 const char* defaultvalue, /**< default value of the parameter */
1164 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1165 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1166 )
1167 {
1168 assert(param != NULL);
1169 assert(name != NULL);
1170 assert(valueptr == NULL || *valueptr == NULL);
1171 assert(defaultvalue != NULL);
1172
1173 SCIP_CALL( paramCreate(param, blkmem, name, desc, paramchgd, paramdata, isadvanced) );
1174
1175 (*param)->paramtype = SCIP_PARAMTYPE_STRING;
1176 (*param)->data.stringparam.valueptr = valueptr;
1177 SCIP_ALLOC( BMSduplicateMemoryArray(&(*param)->data.stringparam.defaultvalue, defaultvalue, strlen(defaultvalue)+1) );
1178 (*param)->data.stringparam.curvalue = NULL;
1179
1180 SCIP_CALL( SCIPparamSetString(*param, NULL, messagehdlr, defaultvalue, TRUE) );
1181
1182 return SCIP_OKAY;
1183 }
1184
1185 /** frees a single parameter */
1186 static
paramFree(SCIP_PARAM ** param,BMS_BLKMEM * blkmem)1187 void paramFree(
1188 SCIP_PARAM** param, /**< pointer to the parameter */
1189 BMS_BLKMEM* blkmem /**< block memory */
1190 )
1191 {
1192 assert(param != NULL);
1193 assert(*param != NULL);
1194
1195 switch( (*param)->paramtype )
1196 {
1197 case SCIP_PARAMTYPE_BOOL:
1198 case SCIP_PARAMTYPE_INT:
1199 case SCIP_PARAMTYPE_LONGINT:
1200 case SCIP_PARAMTYPE_REAL:
1201 break;
1202 case SCIP_PARAMTYPE_CHAR:
1203 BMSfreeMemoryArrayNull(&(*param)->data.charparam.allowedvalues);
1204 break;
1205 case SCIP_PARAMTYPE_STRING:
1206 BMSfreeMemoryArray(&(*param)->data.stringparam.defaultvalue);
1207 if( (*param)->data.stringparam.valueptr == NULL )
1208 {
1209 BMSfreeMemoryArray(&(*param)->data.stringparam.curvalue);
1210 }
1211 else
1212 {
1213 BMSfreeMemoryArray((*param)->data.stringparam.valueptr);
1214 }
1215 break;
1216 default:
1217 SCIPerrorMessage("invalid parameter type\n");
1218 /* just continuing the function in this case seems save */
1219 SCIPABORT();
1220 }
1221
1222 BMSfreeMemoryArray(&(*param)->name);
1223 BMSfreeMemoryArray(&(*param)->desc);
1224 BMSfreeBlockMemory(blkmem, param);
1225 }
1226
1227 /** sets SCIP_Bool parameter according to the value of the given string */
1228 static
paramParseBool(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char * valuestr)1229 SCIP_RETCODE paramParseBool(
1230 SCIP_PARAM* param, /**< parameter */
1231 SCIP_SET* set, /**< global SCIP settings */
1232 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1233 char* valuestr /**< value in string format (may be modified during parse) */
1234 )
1235 {
1236 assert(param != NULL);
1237 assert(param->paramtype == SCIP_PARAMTYPE_BOOL);
1238 assert(set != NULL);
1239 assert(valuestr != NULL);
1240
1241 if( strcasecmp(valuestr, "TRUE") == 0 )
1242 {
1243 SCIP_CALL( SCIPparamSetBool(param, set, messagehdlr, TRUE, FALSE, TRUE) );
1244 }
1245 else if( strcasecmp(valuestr, "FALSE") == 0 )
1246 {
1247 SCIP_CALL( SCIPparamSetBool(param, set, messagehdlr, FALSE, FALSE, TRUE) );
1248 }
1249 else
1250 {
1251 SCIPerrorMessage("invalid parameter value <%s> for SCIP_Bool parameter <%s>\n", valuestr, param->name);
1252 return SCIP_READERROR;
1253 }
1254
1255 return SCIP_OKAY;
1256 }
1257
1258 /** sets int parameter according to the value of the given string */
1259 static
paramParseInt(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char * valuestr)1260 SCIP_RETCODE paramParseInt(
1261 SCIP_PARAM* param, /**< parameter */
1262 SCIP_SET* set, /**< global SCIP settings */
1263 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1264 char* valuestr /**< value in string format (may be modified during parse) */
1265 )
1266 {
1267 int value;
1268
1269 assert(param != NULL);
1270 assert(param->paramtype == SCIP_PARAMTYPE_INT);
1271 assert(set != NULL);
1272 assert(valuestr != NULL);
1273
1274 /* coverity[secure_coding] */
1275 if( sscanf(valuestr, "%d", &value) == 1 )
1276 {
1277 SCIP_CALL( SCIPparamSetInt(param, set, messagehdlr, value, FALSE, TRUE) );
1278 }
1279 else
1280 {
1281 SCIPerrorMessage("invalid parameter value <%s> for int parameter <%s>\n", valuestr, param->name);
1282 return SCIP_READERROR;
1283 }
1284
1285 return SCIP_OKAY;
1286 }
1287
1288 /** sets SCIP_Longint parameter according to the value of the given string */
1289 static
paramParseLongint(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char * valuestr)1290 SCIP_RETCODE paramParseLongint(
1291 SCIP_PARAM* param, /**< parameter */
1292 SCIP_SET* set, /**< global SCIP settings */
1293 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1294 char* valuestr /**< value in string format (may be modified during parse) */
1295 )
1296 {
1297 SCIP_Longint value;
1298
1299 assert(param != NULL);
1300 assert(param->paramtype == SCIP_PARAMTYPE_LONGINT);
1301 assert(set != NULL);
1302 assert(valuestr != NULL);
1303
1304 /* coverity[secure_coding] */
1305 if( sscanf(valuestr, "%" SCIP_LONGINT_FORMAT, &value) == 1 )
1306 {
1307 SCIP_CALL( SCIPparamSetLongint(param, set, messagehdlr, value, FALSE, TRUE) );
1308 }
1309 else
1310 {
1311 SCIPerrorMessage("invalid parameter value <%s> for SCIP_Longint parameter <%s>\n", valuestr, param->name);
1312 return SCIP_READERROR;
1313 }
1314
1315 return SCIP_OKAY;
1316 }
1317
1318 /** sets SCIP_Real parameter according to the value of the given string */
1319 static
paramParseReal(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char * valuestr)1320 SCIP_RETCODE paramParseReal(
1321 SCIP_PARAM* param, /**< parameter */
1322 SCIP_SET* set, /**< global SCIP settings */
1323 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1324 char* valuestr /**< value in string format (may be modified during parse) */
1325 )
1326 {
1327 SCIP_Real value;
1328
1329 assert(param != NULL);
1330 assert(param->paramtype == SCIP_PARAMTYPE_REAL);
1331 assert(set != NULL);
1332 assert(valuestr != NULL);
1333
1334 /* coverity[secure_coding] */
1335 if( sscanf(valuestr, "%" SCIP_REAL_FORMAT, &value) == 1 )
1336 {
1337 SCIP_CALL( SCIPparamSetReal(param, set, messagehdlr, value, FALSE, TRUE) );
1338 }
1339 else
1340 {
1341 SCIPerrorMessage("invalid parameter value <%s> for SCIP_Real parameter <%s>\n", valuestr, param->name);
1342 return SCIP_READERROR;
1343 }
1344
1345 return SCIP_OKAY;
1346 }
1347
1348 /** sets Char parameter according to the value of the given string */
1349 static
paramParseChar(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char * valuestr)1350 SCIP_RETCODE paramParseChar(
1351 SCIP_PARAM* param, /**< parameter */
1352 SCIP_SET* set, /**< global SCIP settings */
1353 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1354 char* valuestr /**< value in string format (may be modified during parse) */
1355 )
1356 {
1357 char value;
1358
1359 assert(param != NULL);
1360 assert(param->paramtype == SCIP_PARAMTYPE_CHAR);
1361 assert(set != NULL);
1362 assert(valuestr != NULL);
1363
1364 /* coverity[secure_coding] */
1365 if( sscanf(valuestr, "%c", &value) == 1 )
1366 {
1367 SCIP_CALL( SCIPparamSetChar(param, set, messagehdlr, value, FALSE, TRUE) );
1368 }
1369 else
1370 {
1371 SCIPerrorMessage("invalid parameter value <%s> for char parameter <%s>\n", valuestr, param->name);
1372 return SCIP_READERROR;
1373 }
1374
1375 return SCIP_OKAY;
1376 }
1377
1378 /** sets string parameter according to the value of the given string */
1379 static
paramParseString(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char * valuestr)1380 SCIP_RETCODE paramParseString(
1381 SCIP_PARAM* param, /**< parameter */
1382 SCIP_SET* set, /**< global SCIP settings */
1383 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1384 char* valuestr /**< value in string format (may be modified during parse) */
1385 )
1386 {
1387 unsigned int len;
1388
1389 assert(param != NULL);
1390 assert(param->paramtype == SCIP_PARAMTYPE_STRING);
1391 assert(set != NULL);
1392 assert(valuestr != NULL);
1393
1394 /* check for quotes */
1395 len = (unsigned int) strlen(valuestr);
1396 if( len <= 1 || valuestr[0] != '"' || valuestr[len-1] != '"' )
1397 {
1398 SCIPerrorMessage("invalid parameter value <%s> for string parameter <%s> (string has to be in double quotes)\n",
1399 valuestr, param->name);
1400 return SCIP_READERROR;
1401 }
1402
1403 /* remove the quotes */
1404 valuestr[len-1] = '\0';
1405 valuestr++;
1406 SCIP_CALL( SCIPparamSetString(param, set, messagehdlr, valuestr, TRUE) );
1407
1408 return SCIP_OKAY;
1409 }
1410
1411
1412 /*
1413 * Parameter set methods
1414 */
1415
1416 /** creates parameter set */
SCIPparamsetCreate(SCIP_PARAMSET ** paramset,BMS_BLKMEM * blkmem)1417 SCIP_RETCODE SCIPparamsetCreate(
1418 SCIP_PARAMSET** paramset, /**< pointer to store the parameter set */
1419 BMS_BLKMEM* blkmem /**< block memory */
1420 )
1421 {
1422 assert(paramset != NULL);
1423
1424 SCIP_ALLOC( BMSallocMemory(paramset) );
1425
1426 SCIP_CALL( SCIPhashtableCreate(&(*paramset)->hashtable, blkmem, SCIP_HASHSIZE_PARAMS,
1427 hashGetKeyParam, SCIPhashKeyEqString, SCIPhashKeyValString, NULL) );
1428
1429 (*paramset)->params = NULL;
1430 (*paramset)->nparams = 0;
1431 (*paramset)->paramssize = 0;
1432
1433 return SCIP_OKAY;
1434 }
1435
1436 /** frees parameter set */
SCIPparamsetFree(SCIP_PARAMSET ** paramset,BMS_BLKMEM * blkmem)1437 void SCIPparamsetFree(
1438 SCIP_PARAMSET** paramset, /**< pointer to the parameter set */
1439 BMS_BLKMEM* blkmem /**< block memory */
1440 )
1441 {
1442 int i;
1443
1444 assert(paramset != NULL);
1445 assert(*paramset != NULL);
1446 assert((*paramset)->paramssize == 0 || (*paramset)->params != NULL);
1447 assert((*paramset)->paramssize >= (*paramset)->nparams);
1448
1449 for( i = (*paramset)->nparams - 1; i >= 0; --i )
1450 {
1451 paramFree(&(*paramset)->params[i], blkmem);
1452 }
1453
1454 SCIPhashtableFree(&(*paramset)->hashtable);
1455
1456 BMSfreeMemoryArrayNull(&(*paramset)->params);
1457 BMSfreeMemory(paramset);
1458 }
1459
1460 /** adds parameter to the parameter set */
1461 static
paramsetAdd(SCIP_PARAMSET * paramset,SCIP_PARAM * param)1462 SCIP_RETCODE paramsetAdd(
1463 SCIP_PARAMSET* paramset, /**< parameter set */
1464 SCIP_PARAM* param /**< parameter to add */
1465 )
1466 {
1467 assert(paramset != NULL);
1468 assert(param != NULL);
1469
1470 /* insert the parameter name to the hash table */
1471 SCIP_CALL( SCIPhashtableSafeInsert(paramset->hashtable, (void*)param) );
1472
1473 /* ensure, that there is enough space in the params array */
1474 if( paramset->nparams >= paramset->paramssize )
1475 {
1476 paramset->paramssize *= 2;
1477 paramset->paramssize = MAX(paramset->paramssize, paramset->nparams+1);
1478 SCIP_ALLOC( BMSreallocMemoryArray(¶mset->params, paramset->paramssize) );
1479 }
1480 assert(paramset->nparams < paramset->paramssize);
1481
1482 /* insert parameter in the params array */
1483 paramset->params[paramset->nparams] = param;
1484 paramset->nparams++;
1485
1486 return SCIP_OKAY;
1487 }
1488
1489 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set */
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)1490 SCIP_RETCODE SCIPparamsetAddBool(
1491 SCIP_PARAMSET* paramset, /**< parameter set */
1492 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1493 BMS_BLKMEM* blkmem, /**< block memory */
1494 const char* name, /**< name of the parameter */
1495 const char* desc, /**< description of the parameter */
1496 SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
1497 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1498 SCIP_Bool defaultvalue, /**< default value of the parameter */
1499 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1500 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1501 )
1502 {
1503 SCIP_PARAM* param;
1504
1505 assert(paramset != NULL);
1506
1507 /* create the parameter */
1508 SCIP_CALL( paramCreateBool(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) );
1509
1510 /* add parameter to the parameter set */
1511 SCIP_CALL( paramsetAdd(paramset, param) );
1512
1513 return SCIP_OKAY;
1514 }
1515
1516 /** creates a int parameter, sets it to its default value, and adds it to the parameter set */
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)1517 SCIP_RETCODE SCIPparamsetAddInt(
1518 SCIP_PARAMSET* paramset, /**< parameter set */
1519 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1520 BMS_BLKMEM* blkmem, /**< block memory */
1521 const char* name, /**< name of the parameter */
1522 const char* desc, /**< description of the parameter */
1523 int* valueptr, /**< pointer to store the current parameter value, or NULL */
1524 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1525 int defaultvalue, /**< default value of the parameter */
1526 int minvalue, /**< minimum value for parameter */
1527 int maxvalue, /**< maximum value for parameter */
1528 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1529 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1530 )
1531 {
1532 SCIP_PARAM* param;
1533
1534 assert(paramset != NULL);
1535
1536 /* create the parameter */
1537 SCIP_CALL( paramCreateInt(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,
1538 paramchgd, paramdata) );
1539
1540 /* add parameter to the parameter set */
1541 SCIP_CALL( paramsetAdd(paramset, param) );
1542
1543 return SCIP_OKAY;
1544 }
1545
1546 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set */
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)1547 SCIP_RETCODE SCIPparamsetAddLongint(
1548 SCIP_PARAMSET* paramset, /**< parameter set */
1549 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1550 BMS_BLKMEM* blkmem, /**< block memory */
1551 const char* name, /**< name of the parameter */
1552 const char* desc, /**< description of the parameter */
1553 SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
1554 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1555 SCIP_Longint defaultvalue, /**< default value of the parameter */
1556 SCIP_Longint minvalue, /**< minimum value for parameter */
1557 SCIP_Longint maxvalue, /**< maximum value for parameter */
1558 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1559 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1560 )
1561 {
1562 SCIP_PARAM* param;
1563
1564 assert(paramset != NULL);
1565
1566 /* create the parameter */
1567 SCIP_CALL( paramCreateLongint(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,
1568 paramchgd, paramdata) );
1569
1570 /* add parameter to the parameter set */
1571 SCIP_CALL( paramsetAdd(paramset, param) );
1572
1573 return SCIP_OKAY;
1574 }
1575
1576 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set */
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)1577 SCIP_RETCODE SCIPparamsetAddReal(
1578 SCIP_PARAMSET* paramset, /**< parameter set */
1579 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1580 BMS_BLKMEM* blkmem, /**< block memory */
1581 const char* name, /**< name of the parameter */
1582 const char* desc, /**< description of the parameter */
1583 SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
1584 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1585 SCIP_Real defaultvalue, /**< default value of the parameter */
1586 SCIP_Real minvalue, /**< minimum value for parameter */
1587 SCIP_Real maxvalue, /**< maximum value for parameter */
1588 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1589 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1590 )
1591 {
1592 SCIP_PARAM* param;
1593
1594 assert(paramset != NULL);
1595
1596 /* create the parameter */
1597 SCIP_CALL( paramCreateReal(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, minvalue, maxvalue,
1598 paramchgd, paramdata) );
1599
1600 /* add parameter to the parameter set */
1601 SCIP_CALL( paramsetAdd(paramset, param) );
1602
1603 return SCIP_OKAY;
1604 }
1605
1606 /** creates a char parameter, sets it to its default value, and adds it to the parameter set */
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)1607 SCIP_RETCODE SCIPparamsetAddChar(
1608 SCIP_PARAMSET* paramset, /**< parameter set */
1609 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1610 BMS_BLKMEM* blkmem, /**< block memory */
1611 const char* name, /**< name of the parameter */
1612 const char* desc, /**< description of the parameter */
1613 char* valueptr, /**< pointer to store the current parameter value, or NULL */
1614 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1615 char defaultvalue, /**< default value of the parameter */
1616 const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
1617 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1618 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1619 )
1620 {
1621 SCIP_PARAM* param;
1622
1623 assert(paramset != NULL);
1624
1625 /* create the parameter */
1626 SCIP_CALL( paramCreateChar(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, allowedvalues,
1627 paramchgd, paramdata) );
1628
1629 /* add parameter to the parameter set */
1630 SCIP_CALL( paramsetAdd(paramset, param) );
1631
1632 return SCIP_OKAY;
1633 }
1634
1635 /** creates a string parameter, sets it to its default value, and adds it to the parameter set */
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)1636 SCIP_RETCODE SCIPparamsetAddString(
1637 SCIP_PARAMSET* paramset, /**< parameter set */
1638 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1639 BMS_BLKMEM* blkmem, /**< block memory */
1640 const char* name, /**< name of the parameter */
1641 const char* desc, /**< description of the parameter */
1642 char** valueptr, /**< pointer to store the current parameter value, or NULL */
1643 SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1644 const char* defaultvalue, /**< default value of the parameter */
1645 SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1646 SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1647 )
1648 {
1649 SCIP_PARAM* param;
1650
1651 assert(paramset != NULL);
1652
1653 /* create the parameter */
1654 SCIP_CALL( paramCreateString(¶m, messagehdlr, blkmem, name, desc, valueptr, isadvanced, defaultvalue, paramchgd, paramdata) );
1655
1656 /* add parameter to the parameter set */
1657 SCIP_CALL( paramsetAdd(paramset, param) );
1658
1659 return SCIP_OKAY;
1660 }
1661
1662 /** returns the name of the given parameter type */
1663 static
paramtypeGetName(SCIP_PARAMTYPE paramtype)1664 const char* paramtypeGetName(
1665 SCIP_PARAMTYPE paramtype /**< type of parameter */
1666 )
1667 {
1668 static const char* paramtypename[] = {
1669 "Bool", /* SCIP_PARAMTYPE_BOOL = 0 */
1670 "int", /* SCIP_PARAMTYPE_INT = 1 */
1671 "Longint", /* SCIP_PARAMTYPE_LONGINT = 2 */
1672 "Real", /* SCIP_PARAMTYPE_REAL = 3 */
1673 "char", /* SCIP_PARAMTYPE_CHAR = 4 */
1674 "string" /* SCIP_PARAMTYPE_STRING = 5 */
1675 };
1676
1677 return paramtypename[(int)paramtype];
1678 }
1679
1680 /** returns whether an existing parameter is fixed */
SCIPparamsetIsFixed(SCIP_PARAMSET * paramset,const char * name)1681 SCIP_Bool SCIPparamsetIsFixed(
1682 SCIP_PARAMSET* paramset, /**< parameter set */
1683 const char* name /**< name of the parameter */
1684 )
1685 {
1686 SCIP_PARAM* param;
1687
1688 assert(paramset != NULL);
1689
1690 /* retrieve parameter from hash table */
1691 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1692 if( param == NULL )
1693 {
1694 SCIPerrorMessage("parameter <%s> unknown\n", name);
1695 SCIPABORT();
1696 return FALSE; /*lint !e527*/
1697 }
1698
1699 return SCIPparamIsFixed(param);
1700 }
1701
1702 /** returns the pointer to an existing SCIP parameter */
SCIPparamsetGetParam(SCIP_PARAMSET * paramset,const char * name)1703 SCIP_PARAM* SCIPparamsetGetParam(
1704 SCIP_PARAMSET* paramset, /**< parameter set */
1705 const char* name /**< name of the parameter */
1706 )
1707 {
1708 assert(paramset != NULL);
1709
1710 /* retrieve parameter from hash table and return it */
1711 return (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1712 }
1713
1714 /** gets the value of an existing SCIP_Bool parameter */
SCIPparamsetGetBool(SCIP_PARAMSET * paramset,const char * name,SCIP_Bool * value)1715 SCIP_RETCODE SCIPparamsetGetBool(
1716 SCIP_PARAMSET* paramset, /**< parameter set */
1717 const char* name, /**< name of the parameter */
1718 SCIP_Bool* value /**< pointer to store the parameter */
1719 )
1720 {
1721 SCIP_PARAM* param;
1722
1723 assert(paramset != NULL);
1724 assert(value != NULL);
1725
1726 /* retrieve parameter from hash table */
1727 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1728 if( param == NULL )
1729 {
1730 SCIPerrorMessage("parameter <%s> unknown\n", name);
1731 return SCIP_PARAMETERUNKNOWN;
1732 }
1733 if( param->paramtype != SCIP_PARAMTYPE_BOOL )
1734 {
1735 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1736 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_BOOL));
1737 return SCIP_PARAMETERWRONGTYPE;
1738 }
1739
1740 /* get the parameter's current value */
1741 *value = SCIPparamGetBool(param);
1742
1743 return SCIP_OKAY;
1744 }
1745
1746 /** gets the value of an existing int parameter */
SCIPparamsetGetInt(SCIP_PARAMSET * paramset,const char * name,int * value)1747 SCIP_RETCODE SCIPparamsetGetInt(
1748 SCIP_PARAMSET* paramset, /**< parameter set */
1749 const char* name, /**< name of the parameter */
1750 int* value /**< pointer to store the parameter */
1751 )
1752 {
1753 SCIP_PARAM* param;
1754
1755 assert(paramset != NULL);
1756 assert(value != NULL);
1757
1758 /* retrieve parameter from hash table */
1759 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1760 if( param == NULL )
1761 {
1762 SCIPerrorMessage("parameter <%s> unknown\n", name);
1763 return SCIP_PARAMETERUNKNOWN;
1764 }
1765 if( param->paramtype != SCIP_PARAMTYPE_INT )
1766 {
1767 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1768 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_INT));
1769 return SCIP_PARAMETERWRONGTYPE;
1770 }
1771
1772 /* get the parameter's current value */
1773 *value = SCIPparamGetInt(param);
1774
1775 return SCIP_OKAY;
1776 }
1777
1778 /** gets the value of an existing SCIP_Longint parameter */
SCIPparamsetGetLongint(SCIP_PARAMSET * paramset,const char * name,SCIP_Longint * value)1779 SCIP_RETCODE SCIPparamsetGetLongint(
1780 SCIP_PARAMSET* paramset, /**< parameter set */
1781 const char* name, /**< name of the parameter */
1782 SCIP_Longint* value /**< pointer to store the parameter */
1783 )
1784 {
1785 SCIP_PARAM* param;
1786
1787 assert(paramset != NULL);
1788 assert(value != NULL);
1789
1790 /* retrieve parameter from hash table */
1791 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1792 if( param == NULL )
1793 {
1794 SCIPerrorMessage("parameter <%s> unknown\n", name);
1795 return SCIP_PARAMETERUNKNOWN;
1796 }
1797 if( param->paramtype != SCIP_PARAMTYPE_LONGINT )
1798 {
1799 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1800 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_LONGINT));
1801 return SCIP_PARAMETERWRONGTYPE;
1802 }
1803
1804 /* get the parameter's current value */
1805 *value = SCIPparamGetLongint(param);
1806
1807 return SCIP_OKAY;
1808 }
1809
1810 /** gets the value of an existing SCIP_Real parameter */
SCIPparamsetGetReal(SCIP_PARAMSET * paramset,const char * name,SCIP_Real * value)1811 SCIP_RETCODE SCIPparamsetGetReal(
1812 SCIP_PARAMSET* paramset, /**< parameter set */
1813 const char* name, /**< name of the parameter */
1814 SCIP_Real* value /**< pointer to store the parameter */
1815 )
1816 {
1817 SCIP_PARAM* param;
1818
1819 assert(paramset != NULL);
1820 assert(value != NULL);
1821
1822 /* retrieve parameter from hash table */
1823 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1824 if( param == NULL )
1825 {
1826 SCIPerrorMessage("parameter <%s> unknown\n", name);
1827 return SCIP_PARAMETERUNKNOWN;
1828 }
1829 if( param->paramtype != SCIP_PARAMTYPE_REAL )
1830 {
1831 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1832 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_REAL));
1833 return SCIP_PARAMETERWRONGTYPE;
1834 }
1835
1836 /* get the parameter's current value */
1837 *value = SCIPparamGetReal(param);
1838
1839 return SCIP_OKAY;
1840 }
1841
1842 /** gets the value of an existing char parameter */
SCIPparamsetGetChar(SCIP_PARAMSET * paramset,const char * name,char * value)1843 SCIP_RETCODE SCIPparamsetGetChar(
1844 SCIP_PARAMSET* paramset, /**< parameter set */
1845 const char* name, /**< name of the parameter */
1846 char* value /**< pointer to store the parameter */
1847 )
1848 {
1849 SCIP_PARAM* param;
1850
1851 assert(paramset != NULL);
1852 assert(value != NULL);
1853
1854 /* retrieve parameter from hash table */
1855 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1856 if( param == NULL )
1857 {
1858 SCIPerrorMessage("parameter <%s> unknown\n", name);
1859 return SCIP_PARAMETERUNKNOWN;
1860 }
1861 if( param->paramtype != SCIP_PARAMTYPE_CHAR )
1862 {
1863 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1864 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_CHAR));
1865 return SCIP_PARAMETERWRONGTYPE;
1866 }
1867
1868 /* get the parameter's current value */
1869 *value = SCIPparamGetChar(param);
1870
1871 return SCIP_OKAY;
1872 }
1873
1874 /** gets the value of an existing string parameter */
SCIPparamsetGetString(SCIP_PARAMSET * paramset,const char * name,char ** value)1875 SCIP_RETCODE SCIPparamsetGetString(
1876 SCIP_PARAMSET* paramset, /**< parameter set */
1877 const char* name, /**< name of the parameter */
1878 char** value /**< pointer to store the parameter */
1879 )
1880 {
1881 SCIP_PARAM* param;
1882
1883 assert(paramset != NULL);
1884 assert(value != NULL);
1885
1886 /* retrieve parameter from hash table */
1887 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1888 if( param == NULL )
1889 {
1890 SCIPerrorMessage("parameter <%s> unknown\n", name);
1891 return SCIP_PARAMETERUNKNOWN;
1892 }
1893 if( param->paramtype != SCIP_PARAMTYPE_STRING )
1894 {
1895 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
1896 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_STRING));
1897 return SCIP_PARAMETERWRONGTYPE;
1898 }
1899
1900 /* get the parameter's current value */
1901 *value = SCIPparamGetString(param);
1902
1903 return SCIP_OKAY;
1904 }
1905
1906 /** changes the fixing status of an existing parameter */
SCIPparamsetFix(SCIP_PARAMSET * paramset,const char * name,SCIP_Bool fixed)1907 SCIP_RETCODE SCIPparamsetFix(
1908 SCIP_PARAMSET* paramset, /**< parameter set */
1909 const char* name, /**< name of the parameter */
1910 SCIP_Bool fixed /**< new fixing status of the parameter */
1911 )
1912 {
1913 SCIP_PARAM* param;
1914
1915 assert(paramset != NULL);
1916
1917 /* retrieve parameter from hash table */
1918 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1919 if( param == NULL )
1920 {
1921 SCIPerrorMessage("parameter <%s> unknown\n", name);
1922 return SCIP_PARAMETERUNKNOWN;
1923 }
1924
1925 SCIPparamSetFixed(param, fixed);
1926
1927 return SCIP_OKAY;
1928 }
1929
1930 /** changes the value of an existing parameter */
SCIPparamsetSet(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * name,void * value)1931 SCIP_RETCODE SCIPparamsetSet(
1932 SCIP_PARAMSET* paramset, /**< parameter set */
1933 SCIP_SET* set, /**< global SCIP settings */
1934 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1935 const char* name, /**< name of the parameter */
1936 void* value /**< new value of the parameter */
1937 )
1938 {
1939 SCIP_PARAM* param;
1940
1941 assert(paramset != NULL);
1942 assert(set != NULL);
1943
1944 /* retrieve parameter from hash table */
1945 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
1946 if( param == NULL )
1947 {
1948 SCIPerrorMessage("parameter <%s> unknown\n", name);
1949 return SCIP_PARAMETERUNKNOWN;
1950 }
1951
1952 switch( param->paramtype )
1953 {
1954 case SCIP_PARAMTYPE_BOOL:
1955 /* set the parameter's current value */
1956 SCIP_CALL( SCIPparamSetBool(param, set, messagehdlr, (SCIP_Bool) (size_t) value, FALSE, TRUE) );
1957 break;
1958
1959 case SCIP_PARAMTYPE_INT:
1960 /* set the parameter's current value */
1961 SCIP_CALL( SCIPparamSetInt(param, set, messagehdlr, (int) (size_t) value, FALSE, TRUE) );
1962 break;
1963
1964 case SCIP_PARAMTYPE_LONGINT:
1965 /* set the parameter's current value */
1966 SCIP_CALL( SCIPparamSetLongint(param, set, messagehdlr, (SCIP_Longint) (size_t) value, FALSE, TRUE) );
1967 break;
1968
1969 case SCIP_PARAMTYPE_REAL:
1970 /* set the parameter's current value */
1971 SCIP_CALL( SCIPparamSetReal(param, set, messagehdlr, (SCIP_Real) (size_t) value, FALSE, TRUE) );
1972 break;
1973
1974 case SCIP_PARAMTYPE_CHAR:
1975 /* set the parameter's current value */
1976 SCIP_CALL( SCIPparamSetChar(param, set, messagehdlr, (char) (size_t) value, FALSE, TRUE) );
1977 break;
1978
1979 case SCIP_PARAMTYPE_STRING:
1980 /* set the parameter's current value */
1981 SCIP_CALL( SCIPparamSetString(param, set, messagehdlr, (char*) value, TRUE) );
1982 break;
1983
1984 default:
1985 SCIPerrorMessage("unknown parameter type\n");
1986 return SCIP_INVALIDDATA;
1987 }
1988
1989 return SCIP_OKAY;
1990 }
1991
1992 /** changes the value of an existing SCIP_Bool parameter */
SCIPparamsetSetBool(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * name,SCIP_Bool value)1993 SCIP_RETCODE SCIPparamsetSetBool(
1994 SCIP_PARAMSET* paramset, /**< parameter set */
1995 SCIP_SET* set, /**< global SCIP settings */
1996 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
1997 const char* name, /**< name of the parameter */
1998 SCIP_Bool value /**< new value of the parameter */
1999 )
2000 {
2001 SCIP_PARAM* param;
2002
2003 assert(paramset != NULL);
2004 assert(set != NULL);
2005
2006 /* retrieve parameter from hash table */
2007 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
2008 if( param == NULL )
2009 {
2010 SCIPerrorMessage("parameter <%s> unknown\n", name);
2011 return SCIP_PARAMETERUNKNOWN;
2012 }
2013 if( param->paramtype != SCIP_PARAMTYPE_BOOL )
2014 {
2015 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2016 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_BOOL));
2017 return SCIP_PARAMETERWRONGTYPE;
2018 }
2019
2020 /* set the parameter's current value */
2021 SCIP_CALL( SCIPparamSetBool(param, set, messagehdlr, value, FALSE, TRUE) );
2022
2023 return SCIP_OKAY;
2024 }
2025
2026 /** changes the default value of an existing SCIP_Bool parameter */
SCIPparamsetSetDefaultBool(SCIP_PARAMSET * paramset,const char * name,SCIP_Bool defaultvalue)2027 SCIP_RETCODE SCIPparamsetSetDefaultBool(
2028 SCIP_PARAMSET* paramset, /**< parameter set */
2029 const char* name, /**< name of the parameter */
2030 SCIP_Bool defaultvalue /**< new default value of the parameter */
2031 )
2032 {
2033 SCIP_PARAM* param;
2034
2035 assert(paramset != NULL);
2036
2037 /* retrieve parameter from hash table */
2038 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
2039 if( param == NULL )
2040 {
2041 SCIPerrorMessage("parameter <%s> unknown\n", name);
2042 return SCIP_PARAMETERUNKNOWN;
2043 }
2044 if( param->paramtype != SCIP_PARAMTYPE_BOOL )
2045 {
2046 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2047 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_BOOL));
2048 return SCIP_PARAMETERWRONGTYPE;
2049 }
2050
2051 /* set the parameter's default value */
2052 SCIPparamSetDefaultBool(param, defaultvalue);
2053
2054 return SCIP_OKAY;
2055 }
2056
2057 /** changes the value of an existing int parameter */
SCIPparamsetSetInt(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * name,int value)2058 SCIP_RETCODE SCIPparamsetSetInt(
2059 SCIP_PARAMSET* paramset, /**< parameter set */
2060 SCIP_SET* set, /**< global SCIP settings */
2061 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2062 const char* name, /**< name of the parameter */
2063 int value /**< new value of the parameter */
2064 )
2065 {
2066 SCIP_PARAM* param;
2067
2068 assert(paramset != NULL);
2069 assert(set != NULL);
2070
2071 /* retrieve parameter from hash table */
2072 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
2073 if( param == NULL )
2074 {
2075 SCIPerrorMessage("parameter <%s> unknown\n", name);
2076 return SCIP_PARAMETERUNKNOWN;
2077 }
2078 if( param->paramtype != SCIP_PARAMTYPE_INT )
2079 {
2080 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2081 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_INT));
2082 return SCIP_PARAMETERWRONGTYPE;
2083 }
2084
2085 /* set the parameter's current value */
2086 SCIP_CALL( SCIPparamSetInt(param, set, messagehdlr, value, FALSE, TRUE) );
2087
2088 return SCIP_OKAY;
2089 }
2090
2091 /** changes the default value of an existing int parameter */
SCIPparamsetSetDefaultInt(SCIP_PARAMSET * paramset,const char * name,int defaultvalue)2092 SCIP_RETCODE SCIPparamsetSetDefaultInt(
2093 SCIP_PARAMSET* paramset, /**< parameter set */
2094 const char* name, /**< name of the parameter */
2095 int defaultvalue /**< new default value of the parameter */
2096 )
2097 {
2098 SCIP_PARAM* param;
2099
2100 assert(paramset != NULL);
2101
2102 /* retrieve parameter from hash table */
2103 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
2104 if( param == NULL )
2105 {
2106 SCIPerrorMessage("parameter <%s> unknown\n", name);
2107 return SCIP_PARAMETERUNKNOWN;
2108 }
2109 if( param->paramtype != SCIP_PARAMTYPE_INT )
2110 {
2111 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2112 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_INT));
2113 return SCIP_PARAMETERWRONGTYPE;
2114 }
2115
2116 /* set the parameter's default value */
2117 SCIPparamSetDefaultInt(param, defaultvalue);
2118
2119 return SCIP_OKAY;
2120 }
2121
2122 /** changes the value of an existing SCIP_Longint parameter */
SCIPparamsetSetLongint(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * name,SCIP_Longint value)2123 SCIP_RETCODE SCIPparamsetSetLongint(
2124 SCIP_PARAMSET* paramset, /**< parameter set */
2125 SCIP_SET* set, /**< global SCIP settings */
2126 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2127 const char* name, /**< name of the parameter */
2128 SCIP_Longint value /**< new value of the parameter */
2129 )
2130 {
2131 SCIP_PARAM* param;
2132
2133 assert(paramset != NULL);
2134 assert(set != NULL);
2135
2136 /* retrieve parameter from hash table */
2137 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
2138 if( param == NULL )
2139 {
2140 SCIPerrorMessage("parameter <%s> unknown\n", name);
2141 return SCIP_PARAMETERUNKNOWN;
2142 }
2143 if( param->paramtype != SCIP_PARAMTYPE_LONGINT )
2144 {
2145 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2146 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_LONGINT));
2147 return SCIP_PARAMETERWRONGTYPE;
2148 }
2149
2150 /* set the parameter's current value */
2151 SCIP_CALL( SCIPparamSetLongint(param, set, messagehdlr, value, FALSE, TRUE) );
2152
2153 return SCIP_OKAY;
2154 }
2155
2156 /** changes the value of an existing SCIP_Real parameter */
SCIPparamsetSetReal(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * name,SCIP_Real value)2157 SCIP_RETCODE SCIPparamsetSetReal(
2158 SCIP_PARAMSET* paramset, /**< parameter set */
2159 SCIP_SET* set, /**< global SCIP settings */
2160 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2161 const char* name, /**< name of the parameter */
2162 SCIP_Real value /**< new value of the parameter */
2163 )
2164 {
2165 SCIP_PARAM* param;
2166
2167 assert(paramset != NULL);
2168 assert(set != NULL);
2169
2170 /* retrieve parameter from hash table */
2171 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
2172 if( param == NULL )
2173 {
2174 SCIPerrorMessage("parameter <%s> unknown\n", name);
2175 return SCIP_PARAMETERUNKNOWN;
2176 }
2177 if( param->paramtype != SCIP_PARAMTYPE_REAL )
2178 {
2179 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2180 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_REAL));
2181 return SCIP_PARAMETERWRONGTYPE;
2182 }
2183
2184 /* set the parameter's current value */
2185 SCIP_CALL( SCIPparamSetReal(param, set, messagehdlr, value, FALSE, TRUE) );
2186
2187 return SCIP_OKAY;
2188 }
2189
2190 /** changes the value of an existing char parameter */
SCIPparamsetSetChar(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * name,char value)2191 SCIP_RETCODE SCIPparamsetSetChar(
2192 SCIP_PARAMSET* paramset, /**< parameter set */
2193 SCIP_SET* set, /**< global SCIP settings */
2194 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2195 const char* name, /**< name of the parameter */
2196 char value /**< new value of the parameter */
2197 )
2198 {
2199 SCIP_PARAM* param;
2200
2201 assert(paramset != NULL);
2202 assert(set != NULL);
2203
2204 /* retrieve parameter from hash table */
2205 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
2206 if( param == NULL )
2207 {
2208 SCIPerrorMessage("parameter <%s> unknown\n", name);
2209 return SCIP_PARAMETERUNKNOWN;
2210 }
2211 if( param->paramtype != SCIP_PARAMTYPE_CHAR )
2212 {
2213 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2214 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_CHAR));
2215 return SCIP_PARAMETERWRONGTYPE;
2216 }
2217
2218 /* set the parameter's current value */
2219 SCIP_CALL( SCIPparamSetChar(param, set, messagehdlr, value, FALSE, TRUE) );
2220
2221 return SCIP_OKAY;
2222 }
2223
2224 /** changes the value of an existing string parameter */
SCIPparamsetSetString(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * name,const char * value)2225 SCIP_RETCODE SCIPparamsetSetString(
2226 SCIP_PARAMSET* paramset, /**< parameter set */
2227 SCIP_SET* set, /**< global SCIP settings */
2228 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2229 const char* name, /**< name of the parameter */
2230 const char* value /**< new value of the parameter */
2231 )
2232 {
2233 SCIP_PARAM* param;
2234
2235 assert(paramset != NULL);
2236 assert(set != NULL);
2237
2238 /* retrieve parameter from hash table */
2239 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)name);
2240 if( param == NULL )
2241 {
2242 SCIPerrorMessage("parameter <%s> unknown\n", name);
2243 return SCIP_PARAMETERUNKNOWN;
2244 }
2245 if( param->paramtype != SCIP_PARAMTYPE_STRING )
2246 {
2247 SCIPerrorMessage("wrong parameter type - parameter <%s> has type <%s> instead of <%s>\n",
2248 name, paramtypeGetName(param->paramtype), paramtypeGetName(SCIP_PARAMTYPE_STRING));
2249 return SCIP_PARAMETERWRONGTYPE;
2250 }
2251
2252 /* set the parameter's current value */
2253 SCIP_CALL( SCIPparamSetString(param, set, messagehdlr, value, TRUE) );
2254
2255 return SCIP_OKAY;
2256 }
2257
2258 /** parses emphasis settings */
2259 static
emphasisParse(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char * line)2260 SCIP_RETCODE emphasisParse(
2261 SCIP_PARAMSET* paramset, /**< parameter set */
2262 SCIP_SET* set, /**< global SCIP settings */
2263 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2264 char* line /**< line to parse (is modified during parse, but not freed) */
2265 )
2266 {
2267 SCIP_PARAMSETTING paramsetting;
2268 SCIP_Bool globalemphasis = FALSE;
2269 char* paramname;
2270 char* paramvaluestr;
2271
2272 assert( paramset != NULL );
2273 assert( line != NULL );
2274
2275 /* find the start of the parameter name */
2276 while ( *line == ' ' || *line == '\t' || *line == '\r' )
2277 line++;
2278 if ( *line == '\0' || *line == '\n' || *line == '#' )
2279 return SCIP_OKAY;
2280 paramname = line;
2281
2282 /* find the end of the parameter name */
2283 while ( *line != ' ' && *line != '\t' && *line != '\r' && *line != '\n' && *line != '#' && *line != '\0' && *line != '=' && *line != ':' )
2284 line++;
2285 *line = '\0';
2286 ++line;
2287
2288 /* check for global emphasis settings */
2289 if ( strcmp(paramname, "default") == 0 )
2290 {
2291 SCIP_CALL( SCIPparamsetSetEmphasis(paramset, set, messagehdlr, SCIP_PARAMEMPHASIS_DEFAULT, FALSE) );
2292 globalemphasis = TRUE;
2293 }
2294 else if ( strcmp(paramname, "counter") == 0 )
2295 {
2296 SCIP_CALL( SCIPparamsetSetEmphasis(paramset, set, messagehdlr, SCIP_PARAMEMPHASIS_COUNTER, FALSE) );
2297 globalemphasis = TRUE;
2298 }
2299 else if ( strcmp(paramname, "cpsolver") == 0 )
2300 {
2301 SCIP_CALL( SCIPparamsetSetEmphasis(paramset, set, messagehdlr, SCIP_PARAMEMPHASIS_CPSOLVER, FALSE) );
2302 globalemphasis = TRUE;
2303 }
2304 else if ( strcmp(paramname, "easycip") == 0 )
2305 {
2306 SCIP_CALL( SCIPparamsetSetEmphasis(paramset, set, messagehdlr, SCIP_PARAMEMPHASIS_EASYCIP, FALSE) );
2307 globalemphasis = TRUE;
2308 }
2309 else if ( strcmp(paramname, "feasibility") == 0 )
2310 {
2311 SCIP_CALL( SCIPparamsetSetEmphasis(paramset, set, messagehdlr, SCIP_PARAMEMPHASIS_FEASIBILITY, FALSE) );
2312 globalemphasis = TRUE;
2313 }
2314 else if ( strcmp(paramname, "hardlp") == 0 )
2315 {
2316 SCIP_CALL( SCIPparamsetSetEmphasis(paramset, set, messagehdlr, SCIP_PARAMEMPHASIS_HARDLP, FALSE) );
2317 globalemphasis = TRUE;
2318 }
2319 else if ( strcmp(paramname, "optimality") == 0 )
2320 {
2321 SCIP_CALL( SCIPparamsetSetEmphasis(paramset, set, messagehdlr, SCIP_PARAMEMPHASIS_OPTIMALITY, FALSE) );
2322 globalemphasis = TRUE;
2323 }
2324 else if ( strcmp(paramname, "numerics") == 0 )
2325 {
2326 SCIP_CALL( SCIPparamsetSetEmphasis(paramset, set, messagehdlr, SCIP_PARAMEMPHASIS_NUMERICS, FALSE) );
2327 globalemphasis = TRUE;
2328 }
2329
2330 /* check whether rest of line is clean */
2331 if ( globalemphasis )
2332 {
2333 /* check, if the rest of the line is clean */
2334 while ( *line == ' ' || *line == '\t' || *line == '\r' )
2335 ++line;
2336 if ( *line != '\0' && *line != '\n' && *line != '#' )
2337 {
2338 SCIPerrorMessage("additional characters after global emphasis setting: %s.\n", line);
2339 return SCIP_READERROR;
2340 }
2341 return SCIP_OKAY;
2342 }
2343
2344 /* find the start of the parameter value string */
2345 while ( *line == ' ' || *line == '\t' || *line == '\r' )
2346 ++line;
2347 if ( *line == '\0' || *line == '\n' || *line == '#' )
2348 {
2349 SCIPerrorMessage("emphasis parameter value is missing\n");
2350 return SCIP_READERROR;
2351 }
2352 paramvaluestr = line;
2353
2354 /* find the end of the parameter value string */
2355 while ( *line != ' ' && *line != '\t' && *line != '\r' && *line != '\n' && *line != '#' && *line != '\0' )
2356 ++line;
2357
2358 if ( *line == '#' )
2359 *line = '\0';
2360 else if ( *line != '\0' )
2361 {
2362 *line = '\0';
2363 ++line;
2364 /* check, if the rest of the line is clean */
2365 while ( *line == ' ' || *line == '\t' || *line == '\r' )
2366 ++line;
2367 if ( *line != '\0' && *line != '\n' && *line != '#' )
2368 {
2369 SCIPerrorMessage("additional characters after emphasis parameter value: %s.\n", line);
2370 return SCIP_READERROR;
2371 }
2372 }
2373
2374 /* determine type of setting */
2375 if ( strcmp(paramvaluestr, "default") == 0 )
2376 paramsetting = SCIP_PARAMSETTING_DEFAULT;
2377 else if ( strcmp(paramvaluestr, "aggressive") == 0 )
2378 paramsetting = SCIP_PARAMSETTING_AGGRESSIVE;
2379 else if ( strcmp(paramvaluestr, "fast") == 0 )
2380 paramsetting = SCIP_PARAMSETTING_FAST;
2381 else if ( strcmp(paramvaluestr, "off") == 0 )
2382 paramsetting = SCIP_PARAMSETTING_OFF;
2383 else
2384 {
2385 SCIPerrorMessage("unkown parameter setting: %s.\n", paramvaluestr);
2386 return SCIP_READERROR;
2387 }
2388
2389 /* check which kind of emphasis we want to set */
2390 if ( strcmp(paramname, "heuristics") == 0 )
2391 {
2392 SCIP_CALL( SCIPsetSetHeuristics(set, messagehdlr, paramsetting, FALSE) );
2393 }
2394 else if ( strcmp(paramname, "presolving") == 0 )
2395 {
2396 SCIP_CALL( SCIPsetSetPresolving(set, messagehdlr, paramsetting, FALSE) );
2397 }
2398 else if ( strcmp(paramname, "separating") == 0 )
2399 {
2400 SCIP_CALL( SCIPsetSetSeparating(set, messagehdlr, paramsetting, FALSE) );
2401 }
2402
2403 return SCIP_OKAY;
2404 }
2405
2406 /** parses a parameter file line "paramname = paramvalue" and sets parameter accordingly */
2407 static
paramsetParse(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char * line,SCIP_Bool * foundnormalparam)2408 SCIP_RETCODE paramsetParse(
2409 SCIP_PARAMSET* paramset, /**< parameter set */
2410 SCIP_SET* set, /**< global SCIP settings */
2411 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2412 char* line, /**< line to parse (is modified during parse, but not freed) */
2413 SCIP_Bool* foundnormalparam /**< pointer to store whether a normal parameter (not emphasis setting) has been found */
2414 )
2415 {
2416 SCIP_PARAM* param;
2417 char* paramname;
2418 char* paramvaluestr;
2419 char* paramend;
2420 char* lastquote;
2421 SCIP_Bool quoted;
2422 SCIP_Bool fix = FALSE;
2423
2424 assert(paramset != NULL);
2425 assert(line != NULL);
2426 assert(foundnormalparam != NULL);
2427
2428 /* find the start of the parameter name */
2429 while( *line == ' ' || *line == '\t' || *line == '\r' )
2430 line++;
2431 if( *line == '\0' || *line == '\n' || *line == '#' )
2432 return SCIP_OKAY;
2433 paramname = line;
2434
2435 /* find the end of the parameter name */
2436 while( *line != ' ' && *line != '\t' && *line != '\r' && *line != '\n' && *line != '#' && *line != '\0' && *line != '=' && *line != ':' )
2437 line++;
2438 paramend = line;
2439
2440 /* skip possible whitespace */
2441 while( *line == ' ' || *line == '\t' || *line == '\r' )
2442 line++;
2443
2444 /* check whether first part consists of "emphasis:" */
2445 if ( *line == ':' )
2446 {
2447 *paramend = '\0'; /* could have paramend == line */
2448 if ( strcmp(paramname, "emphasis") != 0 )
2449 {
2450 SCIPerrorMessage("expected \"emphasis:\" at beginning of line.\n");
2451 return SCIP_READERROR;
2452 }
2453
2454 /* check that emphasis settings only appear at beginning of file */
2455 if ( *foundnormalparam )
2456 {
2457 SCIPerrorMessage("emphasis settings have to appear at top of file.\n");
2458 return SCIP_READERROR;
2459 }
2460
2461 /* parse emphasis line */
2462 SCIP_CALL( emphasisParse(paramset, set, messagehdlr, line+1) ); /* message handler */
2463 return SCIP_OKAY;
2464 }
2465 else if ( *line != '=' )
2466 {
2467 SCIPerrorMessage("expected character '=' after the parameter name.\n");
2468 return SCIP_READERROR;
2469 }
2470 *paramend = '\0'; /* could have paramend == line */
2471 ++line;
2472
2473 /* find the start of the parameter value string */
2474 while( *line == ' ' || *line == '\t' || *line == '\r' )
2475 line++;
2476 if( *line == '\0' || *line == '\n' || *line == '#' )
2477 {
2478 SCIPerrorMessage("parameter value is missing\n");
2479 return SCIP_READERROR;
2480 }
2481 paramvaluestr = line;
2482
2483 /* find the end of the parameter value string */
2484 quoted = (*paramvaluestr == '"');
2485 lastquote = NULL;
2486 while( (quoted || (*line != ' ' && *line != '\t' && *line != '\r' && *line != '\n' && *line != '#')) && *line != '\0' )
2487 {
2488 if( *line == '"' )
2489 lastquote = line;
2490 line++;
2491 }
2492 if( lastquote != NULL )
2493 line = lastquote+1;
2494 if( *line == '#' )
2495 *line = '\0';
2496 else if( *line != '\0' )
2497 {
2498 /* check, if the rest of the line is clean */
2499 *line = '\0';
2500 line++;
2501 while( *line == ' ' || *line == '\t' || *line == '\r' )
2502 line++;
2503 if( *line == 'f' && *(line+1) == 'i' && *(line+2) == 'x' )
2504 {
2505 fix = TRUE;
2506 line += 3;
2507
2508 while( *line == ' ' || *line == '\t' || *line == '\r' )
2509 line++;
2510 }
2511 if( *line != '\0' && *line != '\n' && *line != '#' )
2512 {
2513 SCIPerrorMessage("additional characters <%c> after parameter value (and possible 'fix' keyword)\n", *line);
2514 return SCIP_READERROR;
2515 }
2516 }
2517
2518 /* retrieve parameter from hash table */
2519 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
2520 if( param == NULL )
2521 {
2522 SCIPmessagePrintWarning(messagehdlr, "unknown parameter <%s>\n", paramname);
2523 return SCIP_OKAY;
2524 }
2525
2526 SCIPparamSetFixed(param, FALSE);
2527
2528 /* set parameter's value */
2529 switch( param->paramtype )
2530 {
2531 case SCIP_PARAMTYPE_BOOL:
2532 SCIP_CALL( paramParseBool(param, set, messagehdlr, paramvaluestr) );
2533 break;
2534 case SCIP_PARAMTYPE_INT:
2535 SCIP_CALL( paramParseInt(param, set, messagehdlr, paramvaluestr) );
2536 break;
2537 case SCIP_PARAMTYPE_LONGINT:
2538 SCIP_CALL( paramParseLongint(param, set, messagehdlr, paramvaluestr) );
2539 break;
2540 case SCIP_PARAMTYPE_REAL:
2541 SCIP_CALL( paramParseReal(param, set, messagehdlr, paramvaluestr) );
2542 break;
2543 case SCIP_PARAMTYPE_CHAR:
2544 SCIP_CALL( paramParseChar(param, set, messagehdlr, paramvaluestr) );
2545 break;
2546 case SCIP_PARAMTYPE_STRING:
2547 SCIP_CALL( paramParseString(param, set, messagehdlr, paramvaluestr) );
2548 break;
2549 default:
2550 SCIPerrorMessage("unknown parameter type\n");
2551 return SCIP_INVALIDDATA;
2552 }
2553
2554 if( fix )
2555 SCIPparamSetFixed(param, TRUE);
2556
2557 *foundnormalparam = TRUE;
2558
2559 return SCIP_OKAY;
2560 }
2561
2562 /** reads parameters from a file */
SCIPparamsetRead(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * filename)2563 SCIP_RETCODE SCIPparamsetRead(
2564 SCIP_PARAMSET* paramset, /**< parameter set */
2565 SCIP_SET* set, /**< global SCIP settings */
2566 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2567 const char* filename /**< file name */
2568 )
2569 {
2570 SCIP_RETCODE retcode;
2571 SCIP_Bool foundnormalparam = FALSE;
2572 FILE* file;
2573 char line[1024];
2574 int lineno;
2575
2576 assert(paramset != NULL);
2577 assert(filename != NULL);
2578
2579 /* open the file for reading */
2580 file = fopen(filename, "r");
2581 if( file == NULL )
2582 {
2583 SCIPerrorMessage("cannot open file <%s> for reading\n", filename);
2584 SCIPprintSysError(filename);
2585 return SCIP_NOFILE;
2586 }
2587
2588 /* read the parameters from the file */
2589 lineno = 0;
2590 retcode = SCIP_OKAY;
2591 while( fgets(line, (int) sizeof(line), file) != NULL && retcode == SCIP_OKAY )
2592 {
2593 lineno++;
2594 retcode = paramsetParse(paramset, set, messagehdlr, line, &foundnormalparam);
2595 }
2596
2597 /* close input file */
2598 fclose(file);
2599
2600 if( retcode == SCIP_READERROR )
2601 {
2602 SCIPerrorMessage("input error in file <%s> line %d\n", filename, lineno);
2603 }
2604 else
2605 {
2606 SCIP_CALL( retcode );
2607 }
2608
2609 return SCIP_OKAY;
2610 }
2611
2612 /** writes all parameters in the parameter set to a file */
SCIPparamsetWrite(SCIP_PARAMSET * paramset,SCIP_MESSAGEHDLR * messagehdlr,const char * filename,SCIP_Bool comments,SCIP_Bool onlychanged)2613 SCIP_RETCODE SCIPparamsetWrite(
2614 SCIP_PARAMSET* paramset, /**< parameter set */
2615 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2616 const char* filename, /**< file name, or NULL for stdout */
2617 SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
2618 SCIP_Bool onlychanged /**< should only the parameters been written, that are changed from default? */
2619 )
2620 {
2621 SCIP_RETCODE retcode;
2622 FILE* file;
2623 SCIP_Bool oldquiet = FALSE;
2624 int i;
2625
2626 assert(paramset != NULL);
2627
2628 /* open the file for writing */
2629 if( filename != NULL )
2630 {
2631 file = fopen(filename, "w");
2632 if( file == NULL )
2633 {
2634 SCIPerrorMessage("cannot open file <%s> for writing\n", filename);
2635 SCIPprintSysError(filename);
2636 return SCIP_FILECREATEERROR;
2637 }
2638
2639 /* temporarily set the quiet flag of the message handler to FALSE */
2640 if( messagehdlr != NULL )
2641 {
2642 oldquiet = SCIPmessagehdlrIsQuiet(messagehdlr);
2643 SCIPmessagehdlrSetQuiet(messagehdlr, FALSE);
2644 }
2645 }
2646 else
2647 file = NULL;
2648
2649 if( comments )
2650 {
2651 /* display the SCIP version as comment in the first line */
2652 #if( SCIP_SUBVERSION == 0 )
2653 SCIPmessageFPrintInfo(messagehdlr, file, "# SCIP version %d.%d.%d\n",
2654 SCIP_VERSION/100, (SCIP_VERSION/10) % 10, SCIP_VERSION % 10); /*lint !e778*/
2655 #else
2656 SCIPmessageFPrintInfo(messagehdlr, file, "# SCIP version %d.%d.%d.%d\n",
2657 SCIP_VERSION/100, (SCIP_VERSION/10) % 10, SCIP_VERSION % 10, SCIP_SUBVERSION); /*lint !e778*/
2658 #endif
2659
2660 SCIPmessageFPrintInfo(messagehdlr, file, "\n");
2661 }
2662
2663 /* write the parameters to the file */
2664 for( i = 0; i < paramset->nparams; ++i )
2665 {
2666 retcode = paramWrite(paramset->params[i], messagehdlr, file, comments, onlychanged);
2667 if( retcode != SCIP_OKAY )
2668 {
2669 if( filename != NULL )
2670 {
2671 assert(file != NULL);
2672 fclose(file);
2673 }
2674 SCIP_CALL( retcode );
2675 }
2676 }
2677
2678 /* close output file */
2679 if( filename != NULL )
2680 {
2681 assert(file != NULL); /*lint !e449*/
2682
2683 /* reset the quiet flag of the message handler */
2684 if( messagehdlr != NULL )
2685 {
2686 SCIPmessagehdlrSetQuiet(messagehdlr, oldquiet);
2687 }
2688
2689 fclose(file);
2690 }
2691
2692 return SCIP_OKAY;
2693 }
2694
2695 /** installs default values for all parameters */
SCIPparamsetSetToDefaults(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)2696 SCIP_RETCODE SCIPparamsetSetToDefaults(
2697 SCIP_PARAMSET* paramset, /**< parameter set */
2698 SCIP_SET* set, /**< global SCIP settings */
2699 SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
2700 )
2701 {
2702 int i;
2703
2704 /* set all parameters to their default values */
2705 for( i = 0; i < paramset->nparams; ++i )
2706 {
2707 SCIP_CALL( SCIPparamSetToDefault(paramset->params[i], set, messagehdlr) );
2708 }
2709
2710 return SCIP_OKAY;
2711 }
2712
2713 /** installs default value for a single parameter */
SCIPparamsetSetToDefault(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * paramname)2714 SCIP_RETCODE SCIPparamsetSetToDefault(
2715 SCIP_PARAMSET* paramset, /**< parameter set */
2716 SCIP_SET* set, /**< global SCIP settings */
2717 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2718 const char* paramname /**< name of the parameter */
2719 )
2720 {
2721 SCIP_PARAM* param;
2722
2723 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
2724
2725 if( param != NULL )
2726 {
2727 SCIP_CALL( SCIPparamSetToDefault(param, set, messagehdlr) );
2728 }
2729
2730 return SCIP_OKAY;
2731 }
2732
2733 /** resets parameters changed by SCIPparamsetSetHeuristicsXyz functions to their default values
2734 *
2735 * @note fixed parameters stay as they are; you need to unfix them first if they should be changed, too
2736 */ /*lint --e{715}*/
2737 static
paramsetSetHeuristicsDefault(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)2738 SCIP_RETCODE paramsetSetHeuristicsDefault(
2739 SCIP_PARAMSET* paramset, /**< parameter set */
2740 SCIP_SET* set, /**< global SCIP settings */
2741 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2742 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2743 )
2744 { /*lint --e{715}*/
2745 SCIP_HEUR** heurs;
2746 char paramname[SCIP_MAXSTRLEN];
2747 int nheurs;
2748 int i;
2749
2750 heurs = set->heurs;
2751 nheurs = set->nheurs;
2752
2753 for( i = 0; i < nheurs; ++i )
2754 {
2755 const char* heurname;
2756 heurname = SCIPheurGetName(heurs[i]);
2757
2758 /* set frequency parameter to default */
2759 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/freq", heurname);
2760 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
2761
2762 /* set LP iteration offset to default */
2763 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxlpiterofs", heurname);
2764 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
2765
2766 /* set LP iteration quota to default */
2767 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxlpiterquot", heurname);
2768 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
2769 }
2770
2771 /* set specific parameters for RENS heuristic */
2772 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "heuristics/rens/nodesofs") );
2773 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "heuristics/rens/minfixingrate") );
2774
2775 /* set specific parameters for Crossover heuristic */
2776 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "heuristics/crossover/nwaitingnodes") );
2777 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "heuristics/crossover/dontwaitatroot") );
2778 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "heuristics/crossover/nodesquot") );
2779 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "heuristics/crossover/minfixingrate") );
2780
2781 return SCIP_OKAY;
2782 }
2783
2784 /** sets heuristics to aggressive */
2785 static
paramsetSetHeuristicsAggressive(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)2786 SCIP_RETCODE paramsetSetHeuristicsAggressive(
2787 SCIP_PARAMSET* paramset, /**< parameter set */
2788 SCIP_SET* set, /**< global SCIP settings */
2789 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2790 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2791 )
2792 {
2793 SCIP_HEUR** heurs;
2794 SCIP_PARAM* param;
2795 char paramname[SCIP_MAXSTRLEN];
2796 int nheurs;
2797 int i;
2798
2799 heurs = set->heurs;
2800 nheurs = set->nheurs;
2801
2802 SCIP_CALL( paramsetSetHeuristicsDefault(paramset, set, messagehdlr, quiet) );
2803
2804 for( i = 0; i < nheurs; ++i )
2805 {
2806 const char* heurname;
2807 heurname = SCIPheurGetName(heurs[i]);
2808
2809 /* dualval heuristic should stay disabled */
2810 if( strcmp(heurname, "dualval") == 0 )
2811 continue;
2812
2813 /* the aggressive Benders' decomposition heuristics should remain disabled */
2814 if( strstr(heurname, "benders") != NULL )
2815 continue;
2816
2817 /* get frequency parameter of heuristic */
2818 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/freq", heurname);
2819 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
2820
2821 if( param != NULL )
2822 {
2823 int deffreq;
2824 int newfreq;
2825
2826 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
2827 deffreq = SCIPparamGetIntDefault(param);
2828
2829 /* change frequency to half of the default value, if it is > 0, otherwise set to 20 */
2830 if( deffreq == -1 || deffreq == 0 )
2831 {
2832 newfreq = 20;
2833 }
2834 else
2835 {
2836 newfreq = (int) SCIPsetCeil(set, deffreq/2.0);
2837 newfreq = MAX(newfreq, 1);
2838 }
2839
2840 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, newfreq, quiet) );
2841
2842 /* LP iteration limits only get increased for heuristics which are activated by default */
2843 if( SCIPparamGetIntDefault(param) > -1 )
2844 {
2845 /* construct (possible) parameter name for LP iteration offset */
2846 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxlpiterofs", heurname);
2847 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
2848
2849 if( param != NULL && SCIPparamGetType(param) == SCIP_PARAMTYPE_INT )
2850 {
2851 /* set LP iteration offset to 1.5 time the current value */
2852 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, (int) (1.5 * SCIPparamGetIntDefault(param)), quiet) );
2853 }
2854
2855 /* construct (possible) parameter name for LP iteration quotient parameter */
2856 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/maxlpiterquot", heurname);
2857 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
2858
2859 if( param != NULL && SCIPparamGetType(param) == SCIP_PARAMTYPE_REAL )
2860 {
2861 /* set LP iteration quotient to 1.5 time the current value */
2862 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, paramname, 1.5 * SCIPparamGetRealDefault(param), quiet) );
2863 }
2864 }
2865 }
2866 }
2867
2868 /* set specific parameters for RENS heuristic, if the heuristic is included */
2869 #ifndef NDEBUG
2870 if( SCIPsetFindHeur(set, "rens") != NULL )
2871 #endif
2872 {
2873 SCIP_CALL( paramSetLongint(paramset, set, messagehdlr, "heuristics/rens/nodesofs", (SCIP_Longint)2000, quiet) );
2874 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "heuristics/rens/minfixingrate", 0.3, quiet) );
2875 }
2876
2877 /* set specific parameters for Crossover heuristic, if the heuristic is included */
2878 #ifndef NDEBUG
2879 if( SCIPsetFindHeur(set, "crossover") != NULL )
2880 #endif
2881 {
2882 SCIP_CALL( paramSetLongint(paramset, set, messagehdlr, "heuristics/crossover/nwaitingnodes", (SCIP_Longint)20, quiet) );
2883 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "heuristics/crossover/dontwaitatroot", TRUE, quiet) );
2884 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "heuristics/crossover/nodesquot", 0.15, quiet) );
2885 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "heuristics/crossover/minfixingrate", 0.5, quiet) );
2886 }
2887
2888 /* set specific parameters for Adaptive Large Neighborhood Search heuristic, if the heuristic is included */
2889 #ifndef NDEBUG
2890 if( SCIPsetFindHeur(set, "alns") != NULL )
2891 #endif
2892 {
2893 /* activate all neighborhoods explicitly (keep list in alphabetic order) */
2894 int nneighborhoods = 9;
2895 const char* neighborhoodnames[] = {
2896 "crossover",
2897 "dins",
2898 "localbranching",
2899 "mutation",
2900 "proximity",
2901 "rens",
2902 "rins",
2903 "trustregion",
2904 "zeroobjective"
2905 };
2906 for( i = 0; i < nneighborhoods; ++i )
2907 {
2908 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/alns/%s/active", neighborhoodnames[i]);
2909 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, paramname, TRUE, quiet) );
2910 }
2911 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "heuristics/alns/nodesquot", 0.2, quiet) );
2912 SCIP_CALL( paramSetLongint(paramset, set, messagehdlr, "heuristics/alns/nodesofs", (SCIP_Longint)2000, quiet) );
2913 }
2914
2915 return SCIP_OKAY;
2916 }
2917
2918 /** sets heuristics to fast */
2919 static
paramsetSetHeuristicsFast(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)2920 SCIP_RETCODE paramsetSetHeuristicsFast(
2921 SCIP_PARAMSET* paramset, /**< parameter set */
2922 SCIP_SET* set, /**< global SCIP settings */
2923 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2924 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2925 )
2926 {
2927 int i;
2928
2929 SCIP_HEUR** heurs;
2930 int nheurs;
2931
2932 #define NEXPENSIVEHEURFREQS 12
2933 static const char* const expensiveheurfreqs[NEXPENSIVEHEURFREQS] = {
2934 "heuristics/coefdiving/freq",
2935 "heuristics/distributiondiving/freq",
2936 "heuristics/feaspump/freq",
2937 "heuristics/fracdiving/freq",
2938 "heuristics/guideddiving/freq",
2939 "heuristics/linesearchdiving/freq",
2940 "heuristics/nlpdiving/freq",
2941 "heuristics/subnlp/freq",
2942 "heuristics/objpscostdiving/freq",
2943 "heuristics/pscostdiving/freq",
2944 "heuristics/rootsoldiving/freq",
2945 "heuristics/veclendiving/freq"
2946 };
2947
2948 SCIP_CALL( paramsetSetHeuristicsDefault(paramset, set, messagehdlr, quiet) );
2949
2950 /* disable all heuristics that use subSCIPs */
2951 heurs = SCIPgetHeurs(set->scip);
2952 nheurs = SCIPgetNHeurs(set->scip);
2953 for( i = 0; i < nheurs; ++i )
2954 {
2955 if( SCIPheurUsesSubscip(heurs[i]) )
2956 {
2957 char paramname[SCIP_MAXSTRLEN];
2958 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/freq", SCIPheurGetName(heurs[i]));
2959 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, -1, quiet) );
2960 }
2961 }
2962
2963 /* explicitly turn off further expensive heuristics, if included */
2964 for( i = 0; i < NEXPENSIVEHEURFREQS; ++i )
2965 if( SCIPhashtableRetrieve(paramset->hashtable, (void*)expensiveheurfreqs[i]) != NULL )
2966 {
2967 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, expensiveheurfreqs[i], -1, quiet) );
2968 }
2969
2970 return SCIP_OKAY;
2971 }
2972
2973 /** turns all heuristics off */
2974 static
paramsetSetHeuristicsOff(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)2975 SCIP_RETCODE paramsetSetHeuristicsOff(
2976 SCIP_PARAMSET* paramset, /**< parameter set */
2977 SCIP_SET* set, /**< global SCIP settings */
2978 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
2979 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2980 )
2981 {
2982 SCIP_HEUR** heurs;
2983 char paramname[SCIP_MAXSTRLEN];
2984 int nheurs;
2985 int i;
2986
2987 heurs = set->heurs;
2988 nheurs = set->nheurs;
2989
2990 SCIP_CALL( paramsetSetHeuristicsDefault(paramset, set, messagehdlr, quiet) );
2991
2992 for( i = 0; i < nheurs; ++i )
2993 {
2994 const char* heurname;
2995 heurname = SCIPheurGetName(heurs[i]);
2996
2997 /* get frequency parameter of heuristic */
2998 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/freq", heurname);
2999
3000 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, -1, quiet) );
3001 }
3002
3003 return SCIP_OKAY;
3004 }
3005
3006 /** resets all parameters that start with "presolving" in their name to their default value; additionally set the
3007 * parameters which might have previously been changed by the methods SCIPparamsetSetToPresolving{Off,Fast,Aggressive}
3008 * to their default value
3009 *
3010 * @note fixed parameters stay as they are; you need to unfix them first if they should be changed, too
3011 */
3012 static
paramsetSetPresolvingDefault(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)3013 SCIP_RETCODE paramsetSetPresolvingDefault(
3014 SCIP_PARAMSET* paramset, /**< parameter set */
3015 SCIP_SET* set, /**< global SCIP settings */
3016 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3017 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3018 )
3019 { /*lint --e{715}*/
3020 SCIP_PROP** props;
3021 SCIP_CONSHDLR** conshdlrs;
3022 SCIP_PRESOL** presols;
3023 char paramname[SCIP_MAXSTRLEN];
3024 int nprops;
3025 int nconshdlrs;
3026 int npresols;
3027 int i;
3028
3029 presols = set->presols;
3030 npresols = set->npresols;
3031
3032 /* reset each individual presolver */
3033 for( i = 0; i < npresols; ++i )
3034 {
3035 const char* presolname;
3036 presolname = SCIPpresolGetName(presols[i]);
3037
3038 /* reset maxrounds parameter of presolvers */
3039 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/maxrounds", presolname);
3040
3041 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3042 }
3043
3044 props = set->props;
3045 nprops = set->nprops;
3046
3047 /* reset presolving for each individual propagator */
3048 for( i = 0; i < nprops; ++i )
3049 {
3050 const char* propname;
3051 propname = SCIPpropGetName(props[i]);
3052
3053 /* reset maxprerounds parameter of propagator */
3054 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "propagating/%s/maxprerounds", propname);
3055 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3056 }
3057
3058 conshdlrs = set->conshdlrs;
3059 nconshdlrs = set->nconshdlrs;
3060
3061 /* reset presolving settings for each individual constraint handler */
3062 for( i = 0; i < nconshdlrs; ++i )
3063 {
3064 const char* conshdlrname;
3065 conshdlrname = SCIPconshdlrGetName(conshdlrs[i]);
3066
3067 /* reset maxprerounds parameter of constraint handler */
3068 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/maxprerounds", conshdlrname);
3069 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3070
3071 /* reset presolpairwise parameter of constraint handler */
3072 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/presolpairwise", conshdlrname);
3073 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3074 }
3075
3076 /* explicitly reset parameters of setppc constraint handler, if the constraint handler is included */
3077 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "constraints/setppc/cliquelifting") );
3078
3079 /* explicitly reset parameters of knapsack constraint handler, if the constraint handler is included */
3080 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "constraints/knapsack/disaggregation") );
3081
3082 /* explicitly reset restart and maxrounds parameters */
3083 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "presolving/maxrestarts") );
3084 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "presolving/restartfac") );
3085 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "presolving/restartminred") );
3086 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "presolving/maxrounds") );
3087
3088 /* explicitly reset probing parameters */
3089 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "propagating/probing/maxuseless") );
3090 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "propagating/probing/maxtotaluseless") );
3091 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "propagating/probing/maxprerounds") );
3092
3093 return SCIP_OKAY;
3094 }
3095
3096 /** sets presolving to aggressive */
3097 static
paramsetSetPresolvingAggressive(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)3098 SCIP_RETCODE paramsetSetPresolvingAggressive(
3099 SCIP_PARAMSET* paramset, /**< parameter set */
3100 SCIP_SET* set, /**< global SCIP settings */
3101 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3102 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3103 )
3104 {
3105 SCIP_PARAM* param;
3106 SCIP_PRESOL** presols;
3107 char paramname[SCIP_MAXSTRLEN];
3108 int npresols;
3109 int p;
3110
3111 /* reset previous changes on presolving parameters */
3112 SCIP_CALL( paramsetSetPresolvingDefault(paramset, set, messagehdlr, quiet) );
3113
3114 /* explicitly change restart parameters */
3115 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "presolving/restartfac", 0.0125, quiet) );
3116 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "presolving/restartminred", 0.06, quiet) );
3117
3118 /* explicitly enable clique lifting of setppc constraint handler, if included */
3119 #ifndef NDEBUG
3120 if( SCIPsetFindConshdlr(set, "setppc") != NULL )
3121 #endif
3122 {
3123 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/setppc/cliquelifting", TRUE, quiet) );
3124 }
3125
3126 presols = set->presols;
3127 npresols = set->npresols;
3128
3129 /* enable all presolvers except for convertinttobin */
3130 for( p = 0; p < npresols; ++p )
3131 {
3132 const char* presolname;
3133 presolname = SCIPpresolGetName(presols[p]);
3134
3135 /* convertinttobin alters the problem formulation, which needs to be actively enabled by the user */
3136 if( strcmp(presolname, "convertinttobin") == 0 )
3137 continue;
3138
3139 /* get maxrounds parameter of presolvers */
3140 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/maxrounds", presolname);
3141
3142 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, -1, quiet) );
3143 }
3144
3145 /* explicitly change parameters of probing */
3146 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "propagating/probing/maxuseless");
3147 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
3148 if( param != NULL )
3149 {
3150 int defvalue;
3151
3152 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
3153 defvalue = SCIPparamGetIntDefault(param);
3154
3155 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, (int) (1.5 * defvalue), quiet) );
3156 }
3157 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "propagating/probing/maxtotaluseless");
3158 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
3159 if( param != NULL )
3160 {
3161 int defvalue;
3162
3163 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
3164 defvalue = SCIPparamGetIntDefault(param);
3165
3166 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, (int) (1.5 * defvalue), quiet) );
3167 }
3168
3169 return SCIP_OKAY;
3170 }
3171
3172 /** sets presolving to fast */
3173 static
paramsetSetPresolvingFast(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)3174 SCIP_RETCODE paramsetSetPresolvingFast(
3175 SCIP_PARAMSET* paramset, /**< parameter set */
3176 SCIP_SET* set, /**< global SCIP settings */
3177 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3178 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3179 )
3180 {
3181 SCIP_CONSHDLR** conshdlrs;
3182 SCIP_PARAM* param;
3183 char paramname[SCIP_MAXSTRLEN];
3184 int nconshdlrs;
3185 int i;
3186
3187 /* reset previous changes on presolving parameters */
3188 SCIP_CALL( paramsetSetPresolvingDefault(paramset, set, messagehdlr, quiet) );
3189
3190 conshdlrs = set->conshdlrs;
3191 nconshdlrs = set->nconshdlrs;
3192
3193 /* turn off pairwise comparison for each constraint handler that has this feature */
3194 for( i = 0; i < nconshdlrs; ++i )
3195 {
3196 const char* conshdlrname;
3197 conshdlrname = SCIPconshdlrGetName(conshdlrs[i]);
3198
3199 /* get presolpairwise parameter of constraint handler */
3200 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/presolpairwise", conshdlrname);
3201 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
3202
3203 if( param != NULL && SCIPparamGetType(param) == SCIP_PARAMTYPE_BOOL )
3204 {
3205 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, paramname, FALSE, quiet) );
3206 }
3207 }
3208
3209 /* explicitly turn off restarts */
3210 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/maxrestarts", 0, quiet) );
3211
3212 /* explicitly change parameters of presolver convertinttobin, if included */
3213 #ifndef NDEBUG
3214 if( SCIPsetFindPresol(set, "convertinttobin") != NULL )
3215 #endif
3216 {
3217 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/convertinttobin/maxrounds", 0, quiet) );
3218 }
3219
3220 /* turn off probing, if included */
3221 #ifndef NDEBUG
3222 if( SCIPsetFindProp(set, "probing") != NULL )
3223 #endif
3224 {
3225 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "propagating/probing/maxprerounds", 0, quiet) );
3226 }
3227
3228 /* explicitly disable components constraint handler, if included */
3229 #ifndef NDEBUG
3230 if( SCIPsetFindConshdlr(set, "components") != NULL )
3231 #endif
3232 {
3233 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "constraints/components/maxprerounds", 0, quiet) );
3234 }
3235
3236 /* explicitly disable dominated columns presolver, if included */
3237 #ifndef NDEBUG
3238 if( SCIPsetFindPresol(set, "domcol") != NULL )
3239 #endif
3240 {
3241 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/domcol/maxrounds", 0, quiet) );
3242 }
3243
3244 /* explicitly disable gate extraction presolver, if included */
3245 #ifndef NDEBUG
3246 if( SCIPsetFindPresol(set, "gateextraction") != NULL )
3247 #endif
3248 {
3249 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/gateextraction/maxrounds", 0, quiet) );
3250 }
3251
3252 /* explicitly disable sparsify presolver, if included */
3253 #ifndef NDEBUG
3254 if( SCIPsetFindPresol(set, "sparsify") != NULL )
3255 #endif
3256 {
3257 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/sparsify/maxrounds", 0, quiet) );
3258 }
3259
3260 /* explicitly disable dual sparsify presolver, if included */
3261 #ifndef NDEBUG
3262 if( SCIPsetFindPresol(set, "dualsparsify") != NULL )
3263 #endif
3264 {
3265 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/dualsparsify/maxrounds", 0, quiet) );
3266 }
3267
3268 /* explicitly disable tworowbnd presolver, if included */
3269 #ifndef NDEBUG
3270 if( SCIPsetFindPresol(set, "tworowbnd") != NULL )
3271 #endif
3272 {
3273 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/tworowbnd/maxrounds", 0, quiet) );
3274 }
3275
3276 /* explicitly forbid the use of implications in logicor presolving */
3277 #ifndef NDEBUG
3278 if( SCIPsetFindConshdlr(set, "logicor") != NULL )
3279 #endif
3280 {
3281 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/logicor/implications", 0, quiet) );
3282 }
3283
3284 return SCIP_OKAY;
3285 }
3286
3287 /** turns all presolving off */
3288 static
paramsetSetPresolvingOff(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)3289 SCIP_RETCODE paramsetSetPresolvingOff(
3290 SCIP_PARAMSET* paramset, /**< parameter set */
3291 SCIP_SET* set, /**< global SCIP settings */
3292 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3293 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3294 )
3295 {
3296 SCIP_PRESOL** presols;
3297 SCIP_PROP** props;
3298 SCIP_CONSHDLR** conshdlrs;
3299 char paramname[SCIP_MAXSTRLEN];
3300 int npresols;
3301 int nprops;
3302 int nconshdlrs;
3303 int i;
3304
3305 /* reset previous changes on presolving parameters */
3306 SCIP_CALL( paramsetSetPresolvingDefault(paramset, set, messagehdlr, quiet) );
3307
3308 presols = set->presols;
3309 npresols = set->npresols;
3310
3311 /* turn each individual presolver off */
3312 for( i = 0; i < npresols; ++i )
3313 {
3314 const char* presolname;
3315 presolname = SCIPpresolGetName(presols[i]);
3316
3317 /* get maxrounds parameter of presolvers */
3318 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "presolving/%s/maxrounds", presolname);
3319
3320 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, 0, quiet) );
3321 }
3322
3323 props = set->props;
3324 nprops = set->nprops;
3325
3326 /* turn off presolving for each individual propagator */
3327 for( i = 0; i < nprops; ++i )
3328 {
3329 const char* propname;
3330 propname = SCIPpropGetName(props[i]);
3331
3332 /* get maxrounds parameter of propagator */
3333 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "propagating/%s/maxprerounds", propname);
3334
3335 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, 0, quiet) );
3336 }
3337
3338 conshdlrs = set->conshdlrs;
3339 nconshdlrs = set->nconshdlrs;
3340
3341 /* turn off presolving for each individual constraint handler */
3342 for( i = 0; i < nconshdlrs; ++i )
3343 {
3344 const char* conshdlrname;
3345 conshdlrname = SCIPconshdlrGetName(conshdlrs[i]);
3346
3347 /* get maxprerounds parameter of constraint handler */
3348 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/maxprerounds", conshdlrname);
3349
3350 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, 0, quiet) );
3351 }
3352
3353 /* explicitly turn off restarts */
3354 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/maxrestarts", 0, quiet) );
3355
3356 /* set the maximum number of presolving rounds to zero */
3357 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/maxrounds", 0, quiet) );
3358
3359 return SCIP_OKAY;
3360 }
3361
3362 /** reset parameters that may have been changed by other SCIPparamsetSetSeparatingXyz to their default values
3363 *
3364 * @note fixed parameters stay as they are; you need to unfix them first if they should be changed, too
3365 */ /*lint !e715*/
3366 static
paramsetSetSeparatingDefault(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)3367 SCIP_RETCODE paramsetSetSeparatingDefault(
3368 SCIP_PARAMSET* paramset, /**< parameter set */
3369 SCIP_SET* set, /**< global SCIP settings */
3370 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3371 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3372 )
3373 { /*lint --e{715}*/
3374 SCIP_SEPA** sepas;
3375 SCIP_CONSHDLR** conshdlrs;
3376 char paramname[SCIP_MAXSTRLEN];
3377 int nconshdlrs;
3378 int nsepas;
3379 int i;
3380
3381 sepas = set->sepas;
3382 nsepas = set->nsepas;
3383
3384 /* reset separating parameters of all separators */
3385 for( i = 0; i < nsepas; ++i )
3386 {
3387 const char* sepaname;
3388 sepaname = SCIPsepaGetName(sepas[i]);
3389
3390 /* reset frequency parameter of separator */
3391 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/freq", sepaname);
3392 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3393
3394 /* reset maximum number of rounds in root node */
3395 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/maxroundsroot", sepaname);
3396 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3397
3398 /* reset maximum number of cuts per separation in root node */
3399 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/maxsepacutsroot", sepaname);
3400 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3401 }
3402
3403 conshdlrs = set->conshdlrs;
3404 nconshdlrs = set->nconshdlrs;
3405
3406 /* reset each individual constraint handler separation settings */
3407 for( i = 0; i < nconshdlrs; ++i )
3408 {
3409 const char* conshdlrname;
3410 conshdlrname = SCIPconshdlrGetName(conshdlrs[i]);
3411
3412 /* reset separation frequency parameter of constraint handler, if available */
3413 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/sepafreq", conshdlrname);
3414 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3415
3416 /* reset maximal separated cuts in root node of constraint handler, if available */
3417 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/maxsepacutsroot", conshdlrname);
3418 if( SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname) != NULL )
3419 {
3420 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, paramname) );
3421 }
3422 }
3423
3424 /* explicitly reset individual parameters */
3425 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "constraints/linear/separateall") );
3426 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/minorthoroot") );
3427 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/maxroundsrootsubrun") );
3428 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/maxaddrounds") );
3429 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/maxcutsroot") );
3430 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/poolfreq") );
3431 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/aggregation/maxfailsroot") );
3432 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/mcf/maxtestdelta") );
3433 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/mcf/trynegscaling") );
3434 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/aggregation/maxtriesroot") );
3435 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/aggregation/maxaggrsroot") );
3436 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/maxbounddist") );
3437 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/zerohalf/maxslackroot") );
3438 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/zerohalf/maxslack") );
3439 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/zerohalf/maxsepacutsroot") );
3440 SCIP_CALL( SCIPparamsetSetToDefault(paramset, set, messagehdlr, "separating/zerohalf/maxroundsroot") );
3441
3442 return SCIP_OKAY;
3443 }
3444
3445 /** sets separating to aggressive */
3446 static
paramsetSetSeparatingAggressive(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)3447 SCIP_RETCODE paramsetSetSeparatingAggressive(
3448 SCIP_PARAMSET* paramset, /**< parameter set */
3449 SCIP_SET* set, /**< global SCIP settings */
3450 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3451 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3452 )
3453 {
3454 SCIP_CONSHDLR** conshdlrs;
3455 SCIP_SEPA** sepas;
3456 SCIP_PARAM* param;
3457 char paramname[SCIP_MAXSTRLEN];
3458 int nconshdlrs;
3459 int nsepas;
3460 int i;
3461
3462 sepas = set->sepas;
3463 nsepas = set->nsepas;
3464
3465 /* set all separating parameters to default values */
3466 SCIP_CALL( paramsetSetSeparatingDefault(paramset, set, messagehdlr, quiet) );
3467
3468 /* set separating parameters of all separators */
3469 for( i = 0; i < nsepas; ++i )
3470 {
3471 const char* sepaname;
3472 sepaname = SCIPsepaGetName(sepas[i]);
3473
3474 /* intobj and cgmip separators should stay disabled */
3475 if( strcmp(sepaname, "intobj") == 0 || strcmp(sepaname, "cgmip") == 0 )
3476 continue;
3477
3478 /* get frequency parameter of separator */
3479 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/freq", sepaname);
3480 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
3481
3482 if( param != NULL )
3483 {
3484 int deffreq;
3485 int newfreq;
3486
3487 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
3488 deffreq = SCIPparamGetIntDefault(param);
3489
3490 /* for enabled separators, change frequency to at least every 20th depths and
3491 * enable disabled separators
3492 */
3493 if( deffreq == -1 )
3494 newfreq = 0;
3495 else if( deffreq == 0 )
3496 newfreq = 20;
3497 else
3498 newfreq = MIN(deffreq, 20);
3499
3500 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, newfreq, quiet) );
3501 }
3502
3503 /* get maximum number of rounds in root node */
3504 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/maxroundsroot", sepaname);
3505 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
3506
3507 if( param != NULL )
3508 {
3509 int defrounds;
3510
3511 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
3512 defrounds = SCIPparamGetIntDefault(param);
3513
3514 /* increase the maximum number of rounds in the root node by factor of 1.5 */
3515 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, (int) (1.5 * defrounds), quiet) );
3516 }
3517
3518 /* get maximum number of cuts per separation in root node */
3519 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/maxsepacutsroot", sepaname);
3520 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
3521
3522 if( param != NULL )
3523 {
3524 int defnumber;
3525
3526 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
3527 defnumber = SCIPparamGetIntDefault(param);
3528
3529 /* increase the maximum number of cut per separation rounds in the root node by factor of 2 */
3530 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, 2*defnumber, quiet) );
3531 }
3532 }
3533
3534 conshdlrs = set->conshdlrs;
3535 nconshdlrs = set->nconshdlrs;
3536
3537 /* set separating parameters of all constraint handlers */
3538 for( i = 0; i < nconshdlrs; ++i )
3539 {
3540 const char* conshdlrname;
3541 conshdlrname = SCIPconshdlrGetName(conshdlrs[i]);
3542
3543 /* get separating frequency parameter of constraint handler */
3544 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/sepafreq", conshdlrname);
3545 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
3546
3547 if( param != NULL )
3548 {
3549 int deffreq;
3550 int newfreq;
3551
3552 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
3553 deffreq = SCIPparamGetIntDefault(param);
3554
3555 /* for constraint handlers with enabled separation, change frequency to at least every 10th depths and
3556 * enable disabled separation routines
3557 */
3558 if( deffreq == -1 )
3559 newfreq = 0;
3560 else if( deffreq == 0 )
3561 newfreq = 10;
3562 else
3563 newfreq = MIN(deffreq, 10);
3564
3565 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, newfreq, quiet) );
3566 }
3567
3568 /* get maximal separated cuts in root node of constraint handler */
3569 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/maxsepacutsroot", conshdlrname);
3570 param = (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname);
3571
3572 if( param != NULL )
3573 {
3574 int defnumber;
3575
3576 assert(SCIPparamGetType(param) == SCIP_PARAMTYPE_INT);
3577 defnumber = SCIPparamGetIntDefault(param);
3578
3579 /* change maximal cuts in root node to at least 500 */
3580 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, MAX(defnumber, 500), quiet) );
3581 }
3582 }
3583
3584 /* explicitly change general separating parameters */
3585 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "separating/minorthoroot", 0.1, quiet) );
3586 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/maxroundsrootsubrun", 5, quiet) );
3587 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/maxaddrounds", 5, quiet) );
3588 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/maxcutsroot", 5000, quiet) );
3589 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/poolfreq", 10, quiet) );
3590
3591 /* explicitly change a separating parameter of the linear constraint handler, if included */
3592 #ifndef NDEBUG
3593 if( SCIPsetFindConshdlr(set, "linear") != NULL )
3594 #endif
3595 {
3596 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/linear/separateall", TRUE, quiet) );
3597 }
3598
3599 /* explicitly change a separating parameter of cmir separator, if included */
3600 #ifndef NDEBUG
3601 if( SCIPsetFindSepa(set, "aggregation") != NULL )
3602 #endif
3603 {
3604 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/aggregation/maxfailsroot", 200, quiet) );
3605 }
3606
3607 /* explicitly change separating parameters of mcf separator, if included */
3608 #ifndef NDEBUG
3609 if( SCIPsetFindSepa(set, "mcf") != NULL )
3610 #endif
3611 {
3612 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/mcf/maxtestdelta", -1, quiet) );
3613 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "separating/mcf/trynegscaling", TRUE, quiet) );
3614 }
3615
3616 return SCIP_OKAY;
3617 }
3618
3619 /** sets separating to fast */
3620 static
paramsetSetSeparatingFast(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)3621 SCIP_RETCODE paramsetSetSeparatingFast(
3622 SCIP_PARAMSET* paramset, /**< parameter set */
3623 SCIP_SET* set, /**< global SCIP settings */
3624 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3625 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3626 )
3627 {
3628 /* reset previous changes on separating parameters */
3629 SCIP_CALL( paramsetSetSeparatingDefault(paramset, set, messagehdlr, quiet) );
3630
3631 /* explicitly decrease maxbounddist */
3632 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "separating/maxbounddist", 0.0, quiet) );
3633
3634 /* explicitly turn off expensive separators, if included */
3635 #ifndef NDEBUG
3636 if( SCIPsetFindConshdlr(set, "and") != NULL )
3637 #endif
3638 {
3639 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "constraints/and/sepafreq", 0, quiet) );
3640 }
3641 #ifndef NDEBUG
3642 if( SCIPsetFindSepa(set, "aggregation") != NULL )
3643 #endif
3644 {
3645 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/aggregation/maxroundsroot", 5, quiet) );
3646 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/aggregation/maxtriesroot", 100, quiet) );
3647 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/aggregation/maxaggrsroot", 3, quiet) );
3648 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/aggregation/maxsepacutsroot", 200, quiet) );
3649 }
3650 #ifndef NDEBUG
3651 if( SCIPsetFindSepa(set, "zerohalf") != NULL )
3652 #endif
3653 {
3654 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "separating/zerohalf/maxslackroot", 0.0, quiet) );
3655 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "separating/zerohalf/maxslack", 0.0, quiet) );
3656 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/zerohalf/maxsepacutsroot", 200, quiet) );
3657 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/zerohalf/maxroundsroot", 5, quiet) );
3658 }
3659 #ifndef NDEBUG
3660 if( SCIPsetFindSepa(set, "gomory") != NULL )
3661 #endif
3662 {
3663 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/gomory/maxroundsroot", 20, quiet) );
3664 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/gomory/maxsepacutsroot", 200, quiet) );
3665 }
3666 #ifndef NDEBUG
3667 if( SCIPsetFindSepa(set, "mcf") != NULL )
3668 #endif
3669 {
3670 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/mcf/freq", -1, quiet) );
3671 }
3672 #ifndef NDEBUG
3673 if( SCIPsetFindSepa(set, "strongcg") != NULL )
3674 #endif
3675 {
3676 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/strongcg/maxroundsroot", 10, quiet) );
3677 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/strongcg/maxsepacutsroot", 200, quiet) );
3678 }
3679
3680 return SCIP_OKAY;
3681 }
3682
3683 /** turns all cuts off */
3684 static
paramsetSetSeparatingOff(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)3685 SCIP_RETCODE paramsetSetSeparatingOff(
3686 SCIP_PARAMSET* paramset, /**< parameter set */
3687 SCIP_SET* set, /**< global SCIP settings */
3688 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3689 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3690 )
3691 {
3692 SCIP_SEPA** sepas;
3693 SCIP_CONSHDLR** conshdlrs;
3694 char paramname[SCIP_MAXSTRLEN];
3695 int nsepas;
3696 int nconshdlrs;
3697 int i;
3698
3699 /* reset previous changes on separating parameters */
3700 SCIP_CALL( paramsetSetSeparatingDefault(paramset, set, messagehdlr, quiet) );
3701
3702 sepas = set->sepas;
3703 nsepas = set->nsepas;
3704
3705 /* turn each individual separator off */
3706 for( i = 0; i < nsepas; ++i )
3707 {
3708 const char* sepaname;
3709 sepaname = SCIPsepaGetName(sepas[i]);
3710
3711 /* get frequency parameter of separator */
3712 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/freq", sepaname);
3713 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, -1, quiet) );
3714 }
3715
3716 conshdlrs = set->conshdlrs;
3717 nconshdlrs = set->nconshdlrs;
3718
3719 /* turn off separation for each individual constraint handler */
3720 for( i = 0; i < nconshdlrs; ++i )
3721 {
3722 const char* conshdlrname;
3723 conshdlrname = SCIPconshdlrGetName(conshdlrs[i]);
3724
3725 /* get separation frequency parameter of constraint handler */
3726 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "constraints/%s/sepafreq", conshdlrname);
3727 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, -1, quiet) );
3728 }
3729
3730 return SCIP_OKAY;
3731 }
3732
3733 /** sets parameters to
3734 *
3735 * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPparamsetSetToDefault())
3736 * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
3737 * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
3738 * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
3739 * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
3740 * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
3741 * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
3742 * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
3743 * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
3744 * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
3745 * - \ref SCIP_PARAMEMPHASIS_NUMERICS to solve problems which cause numerical issues
3746 */
SCIPparamsetSetEmphasis(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_PARAMEMPHASIS paramemphasis,SCIP_Bool quiet)3747 SCIP_RETCODE SCIPparamsetSetEmphasis(
3748 SCIP_PARAMSET* paramset, /**< parameter set */
3749 SCIP_SET* set, /**< global SCIP settings */
3750 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
3751 SCIP_PARAMEMPHASIS paramemphasis, /**< parameter emphasis */
3752 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
3753 )
3754 {
3755 /* reset all parameter to default */
3756 SCIP_CALL( SCIPparamsetSetToDefaults(paramset, set, messagehdlr) );
3757
3758 switch( paramemphasis )
3759 {
3760 case SCIP_PARAMEMPHASIS_DEFAULT:
3761 /* the default values are already set */
3762 break;
3763
3764 case SCIP_PARAMEMPHASIS_COUNTER:
3765 /* TODO: should constraints/linear/detectlowerbound and detectcutoffbound be set to FALSE? */
3766 /* avoid logicor upgrade since the logicor constraint handler does not perform full propagation */
3767 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/linear/upgrade/logicor", FALSE, quiet) );
3768
3769 /* set priority for inference branching to highest possible value */
3770 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "branching/inference/priority", INT_MAX/4, quiet) );
3771
3772 /* set priority for depth first search to highest possible value */
3773 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "nodeselection/dfs/stdpriority", INT_MAX/4, quiet) );
3774
3775 /* avoid that the ZIMPL reader transforms the problem before the problem is generated */
3776 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "reading/zplreader/usestartsol", FALSE, quiet) );
3777
3778 /* turn off all heuristics */
3779 SCIP_CALL( paramsetSetHeuristicsOff(paramset, set, messagehdlr, quiet) );
3780
3781 /* turn off all separation */
3782 SCIP_CALL( paramsetSetSeparatingOff(paramset, set, messagehdlr, quiet) );
3783
3784 /* turn off restart */
3785 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/maxrestarts", 0, quiet) );
3786
3787 /* unlimited number of propagation rounds in any branch and bound node */
3788 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "propagating/maxrounds", -1, quiet) );
3789 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "propagating/maxroundsroot", -1, quiet) );
3790
3791 /* adjust conflict analysis for depth first search */
3792 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "conflict/fuiplevels", 1, quiet) );
3793 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "conflict/dynamic", FALSE, quiet) );
3794
3795 /* prefer binary variables for branching */
3796 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "branching/preferbinary", TRUE, quiet) );
3797
3798 /* turn on aggressive constraint aging */
3799 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "constraints/agelimit", 1, quiet) );
3800
3801 /* turn off components presolver since we are currently not able to handle that in case of counting */
3802 #ifndef NDEBUG
3803 if( SCIPsetFindConshdlr(set, "components") != NULL )
3804 #endif
3805 {
3806 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "constraints/components/maxprerounds", 0, quiet) );
3807 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "constraints/components/propfreq", -1, quiet) );
3808 }
3809 break;
3810
3811 case SCIP_PARAMEMPHASIS_CPSOLVER:
3812 /* shrink the minimal maximum value for the conflict length */
3813 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "conflict/minmaxvars", 10, quiet) );
3814
3815 /* use only first unique implication point */
3816 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "conflict/fuiplevels", 1, quiet) );
3817
3818 /* do not use reconversion conflicts */
3819 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "conflict/reconvlevels", 0, quiet) );
3820
3821 /* after 250 conflict we force a restart since then the variable statistics are reasonable initialized */
3822 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "conflict/restartnum", 250, quiet) );
3823
3824 /* increase the number of conflicts which induce a restart */
3825 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "conflict/restartfac", 2.0, quiet) );
3826
3827 /* weight the variable which made into a conflict */
3828 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "conflict/conflictweight", 1.0, quiet) );
3829
3830 /* do not check pseudo solution (for performance reasons) */
3831 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/disableenfops", TRUE, quiet) );
3832
3833 /* use value based history to detect a reasonable branching point */
3834 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "history/valuebased", TRUE, quiet) );
3835
3836 /* turn of LP relaxation */
3837 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "lp/solvefreq", -1, quiet) );
3838
3839 /* prefer the down branch in case the value based history does not suggest something */
3840 SCIP_CALL( paramSetChar(paramset, set, messagehdlr, "nodeselection/childsel", 'd', quiet) );
3841
3842 /* accept any bound change */
3843 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "numerics/boundstreps", 1e-6, quiet) );
3844
3845 /* allow for at most 10 restart, after that the value based history should be reliable */
3846 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "presolving/maxrestarts", 10, quiet) );
3847
3848 /* set priority for depth first search to highest possible value */
3849 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "nodeselection/dfs/stdpriority", INT_MAX/4, quiet) );
3850
3851 break;
3852
3853 case SCIP_PARAMEMPHASIS_EASYCIP:
3854 /* set heuristics to fast, to avoid spending to much time for involved heuristics */
3855 SCIP_CALL( paramsetSetHeuristicsFast(paramset, set, messagehdlr, quiet) );
3856
3857 /* set presolving to fast, to avoid spending to much time for involved presolving */
3858 SCIP_CALL( paramsetSetPresolvingFast(paramset, set, messagehdlr, quiet) );
3859
3860 /* set separating to fast, to avoid spending to much time for involved separators */
3861 SCIP_CALL( paramsetSetSeparatingFast(paramset, set, messagehdlr, quiet) );
3862
3863 break;
3864
3865 case SCIP_PARAMEMPHASIS_FEASIBILITY:
3866 /* set heuristics aggressive */
3867 SCIP_CALL( paramsetSetHeuristicsAggressive(paramset, set, messagehdlr, quiet) );
3868
3869 /* reduce the amount of separation rounds and disable most expensive separators */
3870 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/maxrounds", 1, quiet) );
3871 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/maxroundsroot", 5, quiet) );
3872 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/aggregation/freq", -1, quiet) );
3873 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/mcf/freq", -1, quiet) );
3874
3875 /* set priority for node selection "restartdfs" to be higher as the current used one */
3876 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "nodeselection/restartdfs/stdpriority", INT_MAX/4, quiet) );
3877 break;
3878
3879 case SCIP_PARAMEMPHASIS_HARDLP:
3880 /* set heuristics to fast, to avoid heuristics which solve also an LP */
3881 SCIP_CALL( paramsetSetHeuristicsFast(paramset, set, messagehdlr, quiet) );
3882
3883 /* set presolving to fast, to avoid spending to much time for involved presolving */
3884 SCIP_CALL( paramsetSetPresolvingFast(paramset, set, messagehdlr, quiet) );
3885
3886 /* reduce the amount of strong branching */
3887 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "branching/relpscost/maxreliable", 1.0, quiet) );
3888 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "branching/relpscost/inititer", 10, quiet) );
3889
3890 /* reduce the amount of separation rounds */
3891 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/maxrounds", 1, quiet) );
3892 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "separating/maxroundsroot", 5, quiet) );
3893
3894 break;
3895
3896 case SCIP_PARAMEMPHASIS_OPTIMALITY:
3897 /* set cuts aggressive */
3898 SCIP_CALL( paramsetSetSeparatingAggressive(paramset, set, messagehdlr, quiet) );
3899
3900 /* increase the amount of strong branching */
3901 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "branching/fullstrong/maxdepth", 10, quiet) );
3902 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "branching/fullstrong/priority", INT_MAX / 4, quiet) );
3903 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "branching/fullstrong/maxbounddist", 0.0, quiet) );
3904 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "branching/relpscost/sbiterquot", 1.0, quiet) );
3905 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "branching/relpscost/sbiterofs", 1000000, quiet) );
3906 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "branching/relpscost/maxreliable", 10.0, quiet) );
3907 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "branching/relpscost/usehyptestforreliability",TRUE, quiet) );
3908 break;
3909 case SCIP_PARAMEMPHASIS_PHASEFEAS:
3910
3911 /* enable two phase node selection: UCT will run first, but deactivate itself after a small number of nodes */
3912 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "nodeselection/uct/stdpriority", (INT_MAX / 4) + 1, quiet) );
3913 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "nodeselection/restartdfs/stdpriority", INT_MAX/4, quiet) );
3914
3915 /* enable inference branching */
3916 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "branching/inference/priority", INT_MAX / 4, quiet) );
3917 break;
3918
3919 case SCIP_PARAMEMPHASIS_PHASEIMPROVE:
3920 /* use UCT node selection in all subSCIP heuristics that have this parameter */
3921 {
3922 int h;
3923 SCIP_HEUR** heurs = set->heurs;
3924 int nheurs = set->nheurs;
3925
3926 for( h = 0; h < nheurs; ++h )
3927 {
3928 char paramname[SCIP_MAXSTRLEN];
3929 if( SCIPheurUsesSubscip(heurs[h]) )
3930 {
3931 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/useuct", SCIPheurGetName(heurs[h]));
3932
3933 if( (SCIP_PARAM*)SCIPhashtableRetrieve(paramset->hashtable, (void*)paramname) != NULL )
3934 {
3935 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, paramname, TRUE, quiet) );
3936 }
3937 }
3938 }
3939
3940 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "heuristics/useuctsubscip", TRUE, quiet) );
3941 }
3942 break;
3943 case SCIP_PARAMEMPHASIS_PHASEPROOF:
3944 /* deactivate primal heuristics */
3945 SCIP_CALL( paramsetSetHeuristicsOff(paramset, set, messagehdlr, quiet) );
3946
3947 /* make aggressive use of separators, also locally */
3948 SCIP_CALL( paramsetSetSeparatingAggressive(paramset, set, messagehdlr, quiet) );
3949
3950 /* use depth-first node selection strategy that makes best use of LP warmstarts */
3951 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "nodeselection/dfs/stdpriority", INT_MAX/4, quiet) );
3952
3953 /* enable dynamic weights for reliability pseudo cost branching */
3954 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "branching/relpscost/dynamicweights", TRUE, quiet) );
3955 break;
3956
3957 case SCIP_PARAMEMPHASIS_NUMERICS:
3958
3959 /* huge val is used as a threshold in multiaggregation; decreasing it leads to safer multiaggregations */
3960 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "numerics/hugeval", 1e+10, quiet) );
3961
3962 /* The higher the Markowitz Parameter is, more sparse pivots will be ignored and the numerically
3963 more stable ones will be used as pivot */
3964 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "lp/minmarkowitz", 0.999, quiet) );
3965
3966 /* Added parameters as suggested here: https://git.zib.de/integer/scip/issues/2002#note_92716 */
3967 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "lp/fastmip", 0, quiet) );
3968 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "lp/scaling", 2, quiet) );
3969 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "lp/presolving", FALSE, quiet) );
3970 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "lp/refactorinterval", 40, quiet) );
3971
3972 /* To prevent numerically bad multiaggregations in dualPresolve() and convertLongEquality() set maxmultiaggrqout small*/
3973 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "constraints/linear/maxmultaggrquot", 10.0, quiet) );
3974 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "constraints/linear/maxdualmultaggrquot", 10.0, quiet) );
3975
3976 /* When upgrading constr with knapsack/setppc causes problems */
3977 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/linear/upgrade/knapsack", FALSE, quiet) );
3978 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/linear/upgrade/setppc", FALSE, quiet) );
3979
3980 /* For numerical stability turn rangedrowpropagation, simplifyInequalities and extractCliques off */
3981 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/linear/rangedrowpropagation", FALSE, quiet) );
3982 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/linear/extractcliques", FALSE, quiet) );
3983 SCIP_CALL( paramSetBool(paramset, set, messagehdlr, "constraints/linear/simplifyinequalities", FALSE, quiet) );
3984
3985 /* Reduce the max coefratio to prevent the creation of potentially numerical unstable constraints */
3986 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "separating/maxcoefratio", 100.0, quiet) );
3987 #ifdef SCIP_WITH_PRESOLVELIB
3988 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "presolving/milp/hugebound", 1e6, quiet) );
3989 SCIP_CALL( paramSetReal(paramset, set, messagehdlr, "presolving/milp/markowitztolerance", 0.1, quiet) );
3990 #endif
3991
3992 break;
3993
3994 default:
3995 SCIPerrorMessage("the parameter setting <%d> is not allowed for emphasis call\n", paramemphasis);
3996 return SCIP_INVALIDCALL;
3997 }
3998 return SCIP_OKAY;
3999 }
4000
4001 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
4002 * auxiliary SCIP instances to avoid recursion
4003 */
SCIPparamsetSetToSubscipsOff(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool quiet)4004 SCIP_RETCODE SCIPparamsetSetToSubscipsOff(
4005 SCIP_PARAMSET* paramset, /**< parameter set */
4006 SCIP_SET* set, /**< global SCIP settings */
4007 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4008 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4009 )
4010 {
4011 SCIP_HEUR** heurs;
4012 SCIP_SEPA** sepas;
4013
4014 char paramname[SCIP_MAXSTRLEN];
4015
4016 int nheurs;
4017 int nsepas;
4018 int i;
4019
4020 heurs = set->heurs;
4021 nheurs = set->nheurs;
4022
4023 /* disable all heuristics that use auxiliary SCIP instances */
4024 for( i = 0; i < nheurs; ++i )
4025 {
4026 if( SCIPheurUsesSubscip(heurs[i]) )
4027 {
4028 const char* heurname;
4029 heurname = SCIPheurGetName(heurs[i]);
4030
4031 /* get frequency parameter of heuristic */
4032 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "heuristics/%s/freq", heurname);
4033
4034 /* we have to unfix the parameter if it fixed and not already set to -1 */
4035 if( SCIPparamsetIsFixed(paramset, paramname) )
4036 {
4037 int oldfreq;
4038
4039 SCIP_CALL( SCIPparamsetGetInt(paramset, paramname, &oldfreq) );
4040
4041 /* if the frequency is already set to -1, we do not have to unfix it, but must not try to set it, either */
4042 if( oldfreq == -1 )
4043 continue;
4044
4045 /* unfix parameter */
4046 SCIPmessageFPrintInfo(messagehdlr, NULL, "unfixing parameter %s in order to disable sub-SCIPs in the current (sub-)SCIP instance\n", paramname);
4047 SCIP_CALL( SCIPparamsetFix(paramset, paramname, FALSE) );
4048 }
4049
4050 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, -1, quiet) );
4051 }
4052 }
4053
4054 sepas = set->sepas;
4055 nsepas = set->nsepas;
4056
4057 /* disable all separators that use auxiliary SCIP instances */
4058 for( i = 0; i < nsepas; ++i )
4059 {
4060 if( SCIPsepaUsesSubscip(sepas[i]) )
4061 {
4062 const char* sepaname;
4063 sepaname = SCIPsepaGetName(sepas[i]);
4064
4065 /* get frequency parameter of separator */
4066 (void) SCIPsnprintf(paramname, SCIP_MAXSTRLEN, "separating/%s/freq", sepaname);
4067
4068 /* we have to unfix the parameter if it fixed and not already set to -1 */
4069 if( SCIPparamsetIsFixed(paramset, paramname) )
4070 {
4071 int oldfreq;
4072
4073 SCIP_CALL( SCIPparamsetGetInt(paramset, paramname, &oldfreq) );
4074
4075 /* if the frequency is already set to -1, we do not have to unfix it, but must not try to set it, either */
4076 if( oldfreq == -1 )
4077 continue;
4078
4079 /* unfix parameter */
4080 SCIPmessageFPrintInfo(messagehdlr, NULL, "unfixing parameter %s in order to disable sub-SCIPs in the current (sub-)SCIP instance\n", paramname);
4081 SCIP_CALL( SCIPparamsetFix(paramset, paramname, FALSE) );
4082 }
4083
4084 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, paramname, -1, quiet) );
4085 }
4086 }
4087
4088 /* turn off components constraint handler */
4089 #ifndef NDEBUG
4090 if( SCIPsetFindConshdlr(set, "components") != NULL )
4091 #endif
4092 {
4093 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "constraints/components/maxprerounds", 0, quiet) );
4094 SCIP_CALL( paramSetInt(paramset, set, messagehdlr, "constraints/components/propfreq", -1, quiet) );
4095 }
4096
4097 /* marking that the sub-SCIPs have been deactivated */
4098 set->subscipsoff = TRUE;
4099
4100 return SCIP_OKAY;
4101 }
4102
4103 /** sets heuristic parameters values to
4104 * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
4105 * - SCIP_PARAMSETTING_FAST such that the time spent on heuristics is decreased
4106 * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristics are called more aggressively
4107 * - SCIP_PARAMSETTING_OFF which turn off all heuristics
4108 */
SCIPparamsetSetHeuristics(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_PARAMSETTING paramsetting,SCIP_Bool quiet)4109 SCIP_RETCODE SCIPparamsetSetHeuristics(
4110 SCIP_PARAMSET* paramset, /**< parameter set */
4111 SCIP_SET* set, /**< global SCIP settings */
4112 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4113 SCIP_PARAMSETTING paramsetting, /**< parameter settings */
4114 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4115 )
4116 {
4117 switch( paramsetting )
4118 {
4119 case SCIP_PARAMSETTING_DEFAULT:
4120 SCIP_CALL( paramsetSetHeuristicsDefault(paramset, set, messagehdlr, quiet) );
4121 break;
4122 case SCIP_PARAMSETTING_OFF:
4123 SCIP_CALL( paramsetSetHeuristicsOff(paramset, set, messagehdlr, quiet) );
4124 break;
4125 case SCIP_PARAMSETTING_FAST:
4126 SCIP_CALL( paramsetSetHeuristicsFast(paramset, set, messagehdlr, quiet) );
4127 break;
4128 case SCIP_PARAMSETTING_AGGRESSIVE:
4129 SCIP_CALL( paramsetSetHeuristicsAggressive(paramset, set, messagehdlr, quiet) );
4130 break;
4131 default:
4132 SCIPerrorMessage("the parameter setting <%d> is not allowed for heuristics\n", paramsetting);
4133 return SCIP_INVALIDCALL;
4134 }
4135
4136 return SCIP_OKAY;
4137 }
4138
4139 /** sets presolving parameters to
4140 * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
4141 * - SCIP_PARAMSETTING_FAST such that the time spent on presolving is decreased
4142 * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggressive
4143 * - SCIP_PARAMSETTING_OFF which turn off all presolving
4144 */
SCIPparamsetSetPresolving(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_PARAMSETTING paramsetting,SCIP_Bool quiet)4145 SCIP_RETCODE SCIPparamsetSetPresolving(
4146 SCIP_PARAMSET* paramset, /**< parameter set */
4147 SCIP_SET* set, /**< global SCIP settings */
4148 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4149 SCIP_PARAMSETTING paramsetting, /**< parameter settings */
4150 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4151 )
4152 {
4153 switch( paramsetting )
4154 {
4155 case SCIP_PARAMSETTING_DEFAULT:
4156 SCIP_CALL( paramsetSetPresolvingDefault(paramset, set, messagehdlr, quiet) );
4157 break;
4158 case SCIP_PARAMSETTING_OFF:
4159 SCIP_CALL( paramsetSetPresolvingOff(paramset, set, messagehdlr, quiet) );
4160 break;
4161 case SCIP_PARAMSETTING_FAST:
4162 SCIP_CALL( paramsetSetPresolvingFast(paramset, set, messagehdlr, quiet) );
4163 break;
4164 case SCIP_PARAMSETTING_AGGRESSIVE:
4165 SCIP_CALL( paramsetSetPresolvingAggressive(paramset, set, messagehdlr, quiet) );
4166 break;
4167 default:
4168 SCIPerrorMessage("the parameter setting <%d> is not allowed for presolving\n", paramsetting);
4169 return SCIP_INVALIDCALL;
4170 }
4171
4172 return SCIP_OKAY;
4173 }
4174
4175 /** sets separating parameters to
4176 * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
4177 * - SCIP_PARAMSETTING_FAST such that the time spent on separating is decreased
4178 * - SCIP_PARAMSETTING_AGGRESSIVE such that separating is more aggressive
4179 * - SCIP_PARAMSETTING_OFF which turn off all separating
4180 */
SCIPparamsetSetSeparating(SCIP_PARAMSET * paramset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_PARAMSETTING paramsetting,SCIP_Bool quiet)4181 SCIP_RETCODE SCIPparamsetSetSeparating(
4182 SCIP_PARAMSET* paramset, /**< parameter set */
4183 SCIP_SET* set, /**< global SCIP settings */
4184 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4185 SCIP_PARAMSETTING paramsetting, /**< parameter settings */
4186 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4187 )
4188 {
4189 switch( paramsetting )
4190 {
4191 case SCIP_PARAMSETTING_DEFAULT:
4192 SCIP_CALL( paramsetSetSeparatingDefault(paramset, set, messagehdlr, quiet) );
4193 break;
4194 case SCIP_PARAMSETTING_OFF:
4195 SCIP_CALL( paramsetSetSeparatingOff(paramset, set, messagehdlr, quiet) );
4196 break;
4197 case SCIP_PARAMSETTING_FAST:
4198 SCIP_CALL( paramsetSetSeparatingFast(paramset, set, messagehdlr, quiet) );
4199 break;
4200 case SCIP_PARAMSETTING_AGGRESSIVE:
4201 SCIP_CALL( paramsetSetSeparatingAggressive(paramset, set, messagehdlr, quiet) );
4202 break;
4203 default:
4204 SCIPerrorMessage("the parameter setting <%d> is not allowed for separating\n", paramsetting);
4205 return SCIP_INVALIDCALL;
4206 }
4207
4208 return SCIP_OKAY;
4209 }
4210
4211 /** returns the array of parameters */
SCIPparamsetGetParams(SCIP_PARAMSET * paramset)4212 SCIP_PARAM** SCIPparamsetGetParams(
4213 SCIP_PARAMSET* paramset /**< parameter set */
4214 )
4215 {
4216 assert(paramset != NULL);
4217
4218 return paramset->params;
4219 }
4220
4221 /** returns the number of parameters in the parameter set */
SCIPparamsetGetNParams(SCIP_PARAMSET * paramset)4222 int SCIPparamsetGetNParams(
4223 SCIP_PARAMSET* paramset /**< parameter set */
4224 )
4225 {
4226 assert(paramset != NULL);
4227
4228 return paramset->nparams;
4229 }
4230
4231 /** copies all parameter values of the source parameter set to the corresponding parameters in the target set
4232 *
4233 * by default reoptimization is disabled after copying the parameters. if you want to use reoptimization, you have
4234 * to enable it explicitly.
4235 */
SCIPparamsetCopyParams(SCIP_PARAMSET * sourceparamset,SCIP_PARAMSET * targetparamset,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)4236 SCIP_RETCODE SCIPparamsetCopyParams(
4237 SCIP_PARAMSET* sourceparamset, /**< source parameter set */
4238 SCIP_PARAMSET* targetparamset, /**< target parameter set */
4239 SCIP_SET* set, /**< global SCIP settings of target SCIP */
4240 SCIP_MESSAGEHDLR* messagehdlr /**< message handler of target SCIP */
4241 )
4242 {
4243 int i;
4244
4245 assert(sourceparamset != NULL);
4246 assert(targetparamset != NULL);
4247 assert(sourceparamset != targetparamset);
4248 assert(set != NULL);
4249
4250 assert(sourceparamset->nparams == 0 || sourceparamset->params != NULL);
4251 assert(targetparamset->nparams == 0 || targetparamset->params != NULL);
4252
4253 for( i = 0; i < sourceparamset->nparams; ++i )
4254 {
4255 SCIP_PARAM* sourceparam;
4256 SCIP_PARAM* targetparam;
4257 const char* paramname;
4258
4259 sourceparam = sourceparamset->params[i];
4260 assert(sourceparam != NULL);
4261
4262 /* find parameter of same name in target scip */
4263 paramname = SCIPparamGetName(sourceparam);
4264 targetparam = (SCIP_PARAM*)SCIPhashtableRetrieve(targetparamset->hashtable, (void*)paramname);
4265
4266 /* if a plugin was not copied, the parameter does not exist in the target SCIP */
4267 if( targetparam == NULL )
4268 continue;
4269
4270 assert(SCIPparamGetType(sourceparam) == SCIPparamGetType(targetparam));
4271
4272 /* set value of target parameter to value of source parameter */
4273 switch( SCIPparamGetType(sourceparam) )
4274 {
4275 case SCIP_PARAMTYPE_BOOL:
4276 SCIP_CALL( paramCopyBool(sourceparam, targetparam, set, messagehdlr) );
4277 break;
4278
4279 case SCIP_PARAMTYPE_INT:
4280 SCIP_CALL( paramCopyInt(sourceparam, targetparam, set, messagehdlr) );
4281 break;
4282
4283 case SCIP_PARAMTYPE_LONGINT:
4284 SCIP_CALL( paramCopyLongint(sourceparam, targetparam, set, messagehdlr) );
4285 break;
4286
4287 case SCIP_PARAMTYPE_REAL:
4288 SCIP_CALL( paramCopyReal(sourceparam, targetparam, set, messagehdlr) );
4289 break;
4290
4291 case SCIP_PARAMTYPE_CHAR:
4292 SCIP_CALL( paramCopyChar(sourceparam, targetparam, set, messagehdlr) );
4293 break;
4294
4295 case SCIP_PARAMTYPE_STRING:
4296 /* the visualization parameters are explicitly not copied to avoid that the visualization file of the original SCIP is overwritten;
4297 * to avoid a hard coded comparison, each parameter could get a Bool flag which tells if the value
4298 * of that parameter can be copied
4299 */
4300 if( strncmp(sourceparam->name, "visual/", 7) != 0 )
4301 {
4302 SCIP_CALL( paramCopyString(sourceparam, targetparam, set, messagehdlr) );
4303 }
4304 break;
4305
4306 default:
4307 SCIPerrorMessage("unknown parameter type\n");
4308 return SCIP_INVALIDDATA;
4309 }
4310
4311 /* copy fixing status of parameter */
4312 SCIPparamSetFixed(targetparam, SCIPparamIsFixed(sourceparam));
4313 }
4314
4315 /* disable reoptimization explicitly */
4316 if( set->reopt_enable )
4317 {
4318 if( SCIPsetIsParamFixed(set, "reoptimization/enable") )
4319 {
4320 SCIP_CALL( SCIPsetChgParamFixed(set, "reoptimization/enable", FALSE) );
4321 }
4322 SCIP_CALL( SCIPparamsetSetBool(targetparamset, set, messagehdlr, "reoptimization/enable", FALSE) );
4323 SCIP_CALL( SCIPsetSetReoptimizationParams(set, messagehdlr) );
4324 }
4325
4326 return SCIP_OKAY;
4327 }
4328
4329 /** sets fixing status of given parameter */
SCIPparamSetFixed(SCIP_PARAM * param,SCIP_Bool fixed)4330 void SCIPparamSetFixed(
4331 SCIP_PARAM* param, /**< parameter */
4332 SCIP_Bool fixed /**< new fixing status of the parameter */
4333 )
4334 {
4335 assert(param != NULL);
4336
4337 param->isfixed = fixed;
4338 }
4339
4340 /** checks whether value of bool parameter is valid */
SCIPparamIsValidBool(SCIP_PARAM * param,SCIP_Bool value)4341 SCIP_Bool SCIPparamIsValidBool(
4342 SCIP_PARAM* param, /**< parameter */
4343 SCIP_Bool value /**< value to check */
4344 )
4345 { /*lint --e{715}*/
4346 assert(param != NULL);
4347 return ( value == TRUE || value == FALSE );
4348 }
4349
4350 /** checks whether value of integer parameter is valid */
SCIPparamIsValidInt(SCIP_PARAM * param,int value)4351 SCIP_Bool SCIPparamIsValidInt(
4352 SCIP_PARAM* param, /**< parameter */
4353 int value /**< value to check */
4354 )
4355 {
4356 assert(param != NULL);
4357
4358 return ( value >= param->data.intparam.minvalue && value <= param->data.intparam.maxvalue );
4359 }
4360
4361 /** checks whether value of SCIP_Longint parameter is valid */
SCIPparamIsValidLongint(SCIP_PARAM * param,SCIP_Longint value)4362 SCIP_Bool SCIPparamIsValidLongint(
4363 SCIP_PARAM* param, /**< parameter */
4364 SCIP_Longint value /**< value to check */
4365 )
4366 {
4367 assert( param != NULL );
4368
4369 return ( value >= param->data.longintparam.minvalue && value <= param->data.longintparam.maxvalue );
4370 }
4371
4372 /** checks whether value of SCIP_Real parameter is valid */
SCIPparamIsValidReal(SCIP_PARAM * param,SCIP_Real value)4373 SCIP_Bool SCIPparamIsValidReal(
4374 SCIP_PARAM* param, /**< parameter */
4375 SCIP_Real value /**< value to check */
4376 )
4377 {
4378 assert( param != NULL );
4379
4380 return ( value >= param->data.realparam.minvalue && value <= param->data.realparam.maxvalue );
4381 }
4382
4383 /** checks whether value of char parameter is valid */
SCIPparamIsValidChar(SCIP_PARAM * param,const char value)4384 SCIP_Bool SCIPparamIsValidChar(
4385 SCIP_PARAM* param, /**< parameter */
4386 const char value /**< value to check */
4387 )
4388 {
4389 assert( param != NULL );
4390
4391 if( value == '\b' || value == '\f' || value == '\n' || value == '\r' || value == '\v' )
4392 return FALSE;
4393
4394 if( param->data.charparam.allowedvalues != NULL )
4395 {
4396 char* c;
4397
4398 c = param->data.charparam.allowedvalues;
4399 while( *c != '\0' && *c != value )
4400 c++;
4401
4402 if( *c != value )
4403 return FALSE;
4404 }
4405
4406 return TRUE;
4407 }
4408
4409 /** checks whether value of string parameter is valid */
SCIPparamIsValidString(SCIP_PARAM * param,const char * value)4410 SCIP_Bool SCIPparamIsValidString(
4411 SCIP_PARAM* param, /**< parameter */
4412 const char* value /**< value to check */
4413 )
4414 { /*lint --e{715}*/
4415 unsigned int i;
4416
4417 assert(param != NULL);
4418
4419 for( i = 0; i < (unsigned int) strlen(value); ++i )
4420 {
4421 if( value[i] == '\b' || value[i] == '\f' || value[i] == '\n' || value[i] == '\r' || value[i] == '\v' )
4422 return FALSE;
4423 }
4424 return TRUE;
4425 }
4426
4427 /** sets value of SCIP_Bool parameter */
SCIPparamSetBool(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Bool value,SCIP_Bool initialize,SCIP_Bool quiet)4428 SCIP_RETCODE SCIPparamSetBool(
4429 SCIP_PARAM* param, /**< parameter */
4430 SCIP_SET* set, /**< global SCIP settings, or NULL if param change method should not be called */
4431 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4432 SCIP_Bool value, /**< new value of the parameter */
4433 SCIP_Bool initialize, /**< is this the initialization of the parameter? */
4434 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4435 )
4436 {
4437 assert(param != NULL);
4438
4439 /* check if value is possible for the parameter */
4440 SCIP_CALL_QUIET( paramTestBool(param, messagehdlr, value) );
4441
4442 /* is the value of the parameter changed? */
4443 if( initialize || (param->data.boolparam.valueptr != NULL && *param->data.boolparam.valueptr != value)
4444 || (param->data.boolparam.valueptr == NULL && param->data.boolparam.curvalue != value) )
4445 {
4446 SCIP_Bool oldvalue;
4447
4448 /* check if the parameter is not fixed */
4449 SCIP_CALL_QUIET( paramTestFixed(param, messagehdlr) );
4450
4451 /* set the parameter's current value */
4452 oldvalue = SCIPparamGetBool(param);
4453 if( param->data.boolparam.valueptr != NULL )
4454 *param->data.boolparam.valueptr = value;
4455 else
4456 param->data.boolparam.curvalue = value;
4457
4458 /* call the parameter's change information method */
4459 if( param->paramchgd != NULL && set != NULL )
4460 {
4461 SCIP_RETCODE retcode;
4462
4463 retcode = param->paramchgd(set->scip, param);
4464
4465 if( retcode == SCIP_PARAMETERWRONGVAL )
4466 {
4467 if( param->data.boolparam.valueptr != NULL )
4468 *param->data.boolparam.valueptr = oldvalue;
4469 else
4470 param->data.boolparam.curvalue = oldvalue;
4471 }
4472 else
4473 {
4474 SCIP_CALL( retcode );
4475 }
4476 }
4477 }
4478
4479 if( !quiet )
4480 {
4481 SCIP_CALL( paramWrite(param, messagehdlr, NULL, FALSE, TRUE) );
4482 }
4483
4484 return SCIP_OKAY;
4485 }
4486
4487 /** sets value of int parameter */
SCIPparamSetInt(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,int value,SCIP_Bool initialize,SCIP_Bool quiet)4488 SCIP_RETCODE SCIPparamSetInt(
4489 SCIP_PARAM* param, /**< parameter */
4490 SCIP_SET* set, /**< global SCIP settings, or NULL if param change method should not be called */
4491 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4492 int value, /**< new value of the parameter */
4493 SCIP_Bool initialize, /**< is this the initialization of the parameter? */
4494 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4495 )
4496 {
4497 assert(param != NULL);
4498
4499 /* check if value is possible for the parameter */
4500 SCIP_CALL_QUIET( paramTestInt(param, messagehdlr, value) );
4501
4502 /* is the value of the parameter changed? */
4503 if( initialize || (param->data.intparam.valueptr != NULL && *param->data.intparam.valueptr != value)
4504 || (param->data.intparam.valueptr == NULL && param->data.intparam.curvalue != value) )
4505 {
4506 int oldvalue;
4507
4508 /* check if the parameter is not fixed */
4509 SCIP_CALL_QUIET( paramTestFixed(param, messagehdlr) );
4510
4511 /* set the parameter's current value */
4512 oldvalue = SCIPparamGetInt(param);
4513 if( param->data.intparam.valueptr != NULL )
4514 *param->data.intparam.valueptr = value;
4515 else
4516 param->data.intparam.curvalue = value;
4517
4518 /* call the parameter's change information method */
4519 if( param->paramchgd != NULL && set != NULL )
4520 {
4521 SCIP_RETCODE retcode;
4522
4523 retcode = param->paramchgd(set->scip, param);
4524
4525 if( retcode == SCIP_PARAMETERWRONGVAL )
4526 {
4527 if( param->data.intparam.valueptr != NULL )
4528 *param->data.intparam.valueptr = oldvalue;
4529 else
4530 param->data.intparam.curvalue = oldvalue;
4531 }
4532 else
4533 {
4534 SCIP_CALL( retcode );
4535 }
4536 }
4537 }
4538
4539 if( !quiet )
4540 {
4541 SCIP_CALL( paramWrite(param, messagehdlr, NULL, FALSE, TRUE) );
4542 }
4543
4544 return SCIP_OKAY;
4545 }
4546
4547 /** sets value of SCIP_Longint parameter */
SCIPparamSetLongint(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Longint value,SCIP_Bool initialize,SCIP_Bool quiet)4548 SCIP_RETCODE SCIPparamSetLongint(
4549 SCIP_PARAM* param, /**< parameter */
4550 SCIP_SET* set, /**< global SCIP settings, or NULL if param change method should not be called */
4551 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4552 SCIP_Longint value, /**< new value of the parameter */
4553 SCIP_Bool initialize, /**< is this the initialization of the parameter? */
4554 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4555 )
4556 {
4557 assert(param != NULL);
4558
4559 /* check if value is possible for the parameter */
4560 SCIP_CALL_QUIET( paramTestLongint(param, messagehdlr, value) );
4561
4562 /* is the value of the parameter changed? */
4563 if( initialize || (param->data.longintparam.valueptr != NULL && *param->data.longintparam.valueptr != value)
4564 || (param->data.longintparam.valueptr == NULL && param->data.longintparam.curvalue != value) )
4565 {
4566 SCIP_Longint oldvalue;
4567
4568 /* check if the parameter is not fixed */
4569 SCIP_CALL_QUIET( paramTestFixed(param, messagehdlr) );
4570
4571 /* set the parameter's current value */
4572 oldvalue = SCIPparamGetLongint(param);
4573 if( param->data.longintparam.valueptr != NULL )
4574 *param->data.longintparam.valueptr = value;
4575 else
4576 param->data.longintparam.curvalue = value;
4577
4578 /* call the parameter's change information method */
4579 if( param->paramchgd != NULL && set != NULL )
4580 {
4581 SCIP_RETCODE retcode;
4582
4583 retcode = param->paramchgd(set->scip, param);
4584
4585 if( retcode == SCIP_PARAMETERWRONGVAL )
4586 {
4587 if( param->data.longintparam.valueptr != NULL )
4588 *param->data.longintparam.valueptr = oldvalue;
4589 else
4590 param->data.longintparam.curvalue = oldvalue;
4591 }
4592 else
4593 {
4594 SCIP_CALL( retcode );
4595 }
4596 }
4597 }
4598
4599 if( !quiet )
4600 {
4601 SCIP_CALL( paramWrite(param, messagehdlr, NULL, FALSE, TRUE) );
4602 }
4603
4604 return SCIP_OKAY;
4605 }
4606
4607 /** sets value of SCIP_Real parameter */
SCIPparamSetReal(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,SCIP_Real value,SCIP_Bool initialize,SCIP_Bool quiet)4608 SCIP_RETCODE SCIPparamSetReal(
4609 SCIP_PARAM* param, /**< parameter */
4610 SCIP_SET* set, /**< global SCIP settings, or NULL if param change method should not be called */
4611 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4612 SCIP_Real value, /**< new value of the parameter */
4613 SCIP_Bool initialize, /**< is this the initialization of the parameter? */
4614 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4615 )
4616 {
4617 assert(param != NULL);
4618
4619 /* check if value is possible for the parameter */
4620 value = MAX(value, SCIP_REAL_MIN);
4621 value = MIN(value, SCIP_REAL_MAX);
4622 SCIP_CALL_QUIET( paramTestReal(param, messagehdlr, value) );
4623
4624 /* is the value of the parameter changed? */
4625 if( initialize || (param->data.realparam.valueptr != NULL && *param->data.realparam.valueptr != value) /*lint !e777*/
4626 || (param->data.realparam.valueptr == NULL && param->data.realparam.curvalue != value) ) /*lint !e777*/
4627 {
4628 SCIP_Real oldvalue;
4629
4630 /* check if the parameter is not fixed */
4631 SCIP_CALL_QUIET( paramTestFixed(param, messagehdlr) );
4632
4633 /* set the parameter's current value */
4634 oldvalue = SCIPparamGetReal(param);
4635 if( param->data.realparam.valueptr != NULL )
4636 *param->data.realparam.valueptr = value;
4637 else
4638 param->data.realparam.curvalue = value;
4639
4640 /* call the parameter's change information method */
4641 if( param->paramchgd != NULL && set != NULL )
4642 {
4643 SCIP_RETCODE retcode;
4644
4645 retcode = param->paramchgd(set->scip, param);
4646
4647 if( retcode == SCIP_PARAMETERWRONGVAL )
4648 {
4649 if( param->data.realparam.valueptr != NULL )
4650 *param->data.realparam.valueptr = oldvalue;
4651 else
4652 param->data.realparam.curvalue = oldvalue;
4653 }
4654 else
4655 {
4656 SCIP_CALL( retcode );
4657 }
4658 }
4659 }
4660
4661 if( !quiet )
4662 {
4663 SCIP_CALL( paramWrite(param, messagehdlr, NULL, FALSE, TRUE) );
4664 }
4665
4666 return SCIP_OKAY;
4667 }
4668
4669 /** sets value of char parameter */
SCIPparamSetChar(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,char value,SCIP_Bool initialize,SCIP_Bool quiet)4670 SCIP_RETCODE SCIPparamSetChar(
4671 SCIP_PARAM* param, /**< parameter */
4672 SCIP_SET* set, /**< global SCIP settings, or NULL if param change method should not be called */
4673 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4674 char value, /**< new value of the parameter */
4675 SCIP_Bool initialize, /**< is this the initialization of the parameter? */
4676 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4677 )
4678 {
4679 assert(param != NULL);
4680
4681 /* check, if value is possible for the parameter and the parameter is not fixed */
4682 SCIP_CALL_QUIET( paramTestChar(param, messagehdlr, value) );
4683
4684 /* is the value of the parameter changed? */
4685 if( initialize || (param->data.charparam.valueptr != NULL && *param->data.charparam.valueptr != value)
4686 || (param->data.charparam.valueptr == NULL && param->data.charparam.curvalue != value) )
4687 {
4688 char oldvalue;
4689
4690 SCIP_CALL_QUIET( paramTestFixed(param, messagehdlr) );
4691
4692 /* set the parameter's current value */
4693 oldvalue = SCIPparamGetChar(param);
4694 if( param->data.charparam.valueptr != NULL )
4695 *param->data.charparam.valueptr = value;
4696 else
4697 param->data.charparam.curvalue = value;
4698
4699 /* call the parameter's change information method */
4700 if( param->paramchgd != NULL && set != NULL )
4701 {
4702 SCIP_RETCODE retcode;
4703
4704 retcode = param->paramchgd(set->scip, param);
4705
4706 if( retcode == SCIP_PARAMETERWRONGVAL )
4707 {
4708 if( param->data.charparam.valueptr != NULL )
4709 *param->data.charparam.valueptr = oldvalue;
4710 else
4711 param->data.charparam.curvalue = oldvalue;
4712 }
4713 else
4714 {
4715 SCIP_CALL( retcode );
4716 }
4717 }
4718 }
4719
4720 if( !quiet )
4721 {
4722 SCIP_CALL( paramWrite(param, messagehdlr, NULL, FALSE, TRUE) );
4723 }
4724
4725 return SCIP_OKAY;
4726 }
4727
4728 /** sets value of string parameter */
SCIPparamSetString(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr,const char * value,SCIP_Bool quiet)4729 SCIP_RETCODE SCIPparamSetString(
4730 SCIP_PARAM* param, /**< parameter */
4731 SCIP_SET* set, /**< global SCIP settings, or NULL if param change method should not be called */
4732 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4733 const char* value, /**< new value of the parameter */
4734 SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
4735 )
4736 {
4737 char* oldvalue = NULL;
4738
4739 assert(param != NULL);
4740
4741 /* check if value is possible for the parameter and the parameter is not fixed */
4742 SCIP_CALL_QUIET( paramTestString(param, messagehdlr, value) );
4743 SCIP_CALL_QUIET( paramTestFixed(param, messagehdlr) );
4744
4745 /* set the parameter's current value */
4746 if( param->data.stringparam.valueptr != NULL )
4747 {
4748 oldvalue = *param->data.stringparam.valueptr;
4749 SCIP_ALLOC( BMSduplicateMemoryArray(param->data.stringparam.valueptr, value, strlen(value)+1) );
4750 }
4751 else
4752 {
4753 oldvalue = param->data.stringparam.curvalue;
4754 SCIP_ALLOC( BMSduplicateMemoryArray(¶m->data.stringparam.curvalue, value, strlen(value)+1) );
4755 }
4756
4757 /* call the parameter's change information method */
4758 if( param->paramchgd != NULL && set != NULL )
4759 {
4760 SCIP_RETCODE retcode;
4761
4762 retcode = param->paramchgd(set->scip, param);
4763
4764 if( retcode == SCIP_PARAMETERWRONGVAL )
4765 {
4766 if( param->data.stringparam.valueptr != NULL )
4767 {
4768 BMSfreeMemoryArrayNull(param->data.stringparam.valueptr);
4769 *param->data.stringparam.valueptr = oldvalue;
4770 }
4771 else
4772 {
4773 BMSfreeMemoryArrayNull(¶m->data.stringparam.curvalue);
4774 param->data.stringparam.curvalue = oldvalue;
4775 }
4776 }
4777 else
4778 {
4779 BMSfreeMemoryArrayNull(&oldvalue);
4780 SCIP_CALL( retcode );
4781 }
4782 }
4783 else
4784 {
4785 BMSfreeMemoryArrayNull(&oldvalue);
4786 }
4787
4788 if( !quiet )
4789 {
4790 SCIP_CALL( paramWrite(param, messagehdlr, NULL, FALSE, TRUE) );
4791 }
4792
4793 return SCIP_OKAY;
4794 }
4795
4796
4797 /** changes default value of SCIP_Bool parameter */
SCIPparamSetDefaultBool(SCIP_PARAM * param,SCIP_Bool defaultvalue)4798 void SCIPparamSetDefaultBool(
4799 SCIP_PARAM* param, /**< parameter */
4800 SCIP_Bool defaultvalue /**< new default value */
4801 )
4802 {
4803 assert(param != NULL);
4804 assert(param->paramtype == SCIP_PARAMTYPE_BOOL);
4805
4806 param->data.boolparam.defaultvalue = defaultvalue;
4807 }
4808
4809 /** changes default value of int parameter */
SCIPparamSetDefaultInt(SCIP_PARAM * param,int defaultvalue)4810 void SCIPparamSetDefaultInt(
4811 SCIP_PARAM* param, /**< parameter */
4812 int defaultvalue /**< new default value */
4813 )
4814 {
4815 assert(param != NULL);
4816 assert(param->paramtype == SCIP_PARAMTYPE_INT);
4817
4818 assert(param->data.intparam.minvalue <= defaultvalue && param->data.intparam.maxvalue >= defaultvalue);
4819
4820 param->data.intparam.defaultvalue = defaultvalue;
4821 }
4822
4823 /** sets the parameter to its default setting */
SCIPparamSetToDefault(SCIP_PARAM * param,SCIP_SET * set,SCIP_MESSAGEHDLR * messagehdlr)4824 SCIP_RETCODE SCIPparamSetToDefault(
4825 SCIP_PARAM* param, /**< parameter */
4826 SCIP_SET* set, /**< global SCIP settings */
4827 SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
4828 )
4829 {
4830 assert(param != NULL);
4831
4832 /* do not change the parameter if it is fixed */
4833 if( SCIPparamIsFixed(param) )
4834 {
4835 SCIPsetDebugMsg(set, "parameter <%s> is fixed and is not reset to its default value.\n", param->name);
4836
4837 return SCIP_OKAY;
4838 }
4839
4840 switch( param->paramtype )
4841 {
4842 case SCIP_PARAMTYPE_BOOL:
4843 SCIP_CALL( SCIPparamSetBool(param, set, messagehdlr, SCIPparamGetBoolDefault(param), FALSE, TRUE) );
4844 break;
4845
4846 case SCIP_PARAMTYPE_INT:
4847 SCIP_CALL( SCIPparamSetInt(param, set, messagehdlr, SCIPparamGetIntDefault(param), FALSE, TRUE) );
4848 break;
4849
4850 case SCIP_PARAMTYPE_LONGINT:
4851 SCIP_CALL( SCIPparamSetLongint(param, set, messagehdlr, SCIPparamGetLongintDefault(param), FALSE, TRUE) );
4852 break;
4853
4854 case SCIP_PARAMTYPE_REAL:
4855 SCIP_CALL( SCIPparamSetReal(param, set, messagehdlr, SCIPparamGetRealDefault(param), FALSE, TRUE) );
4856 break;
4857
4858 case SCIP_PARAMTYPE_CHAR:
4859 SCIP_CALL( SCIPparamSetChar(param, set, messagehdlr, SCIPparamGetCharDefault(param), FALSE, TRUE) );
4860 break;
4861
4862 case SCIP_PARAMTYPE_STRING:
4863 SCIP_CALL( SCIPparamSetString(param, set, messagehdlr, SCIPparamGetStringDefault(param), TRUE) );
4864 break;
4865
4866 default:
4867 SCIPerrorMessage("unknown parameter type\n");
4868 return SCIP_INVALIDDATA;
4869 }
4870
4871 return SCIP_OKAY;
4872 }
4873
4874 /** writes a single parameter to a file */
SCIPparamWrite(SCIP_PARAM * param,SCIP_MESSAGEHDLR * messagehdlr,const char * filename,SCIP_Bool comments,SCIP_Bool onlychanged)4875 SCIP_RETCODE SCIPparamWrite(
4876 SCIP_PARAM* param, /**< parameter */
4877 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
4878 const char* filename, /**< file name, or NULL for stdout */
4879 SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
4880 SCIP_Bool onlychanged /**< should only the parameters been written, that are changed from default? */
4881 )
4882 {
4883 SCIP_RETCODE retcode;
4884 FILE* file;
4885
4886 assert(param != NULL);
4887
4888 /* open the file for writing */
4889 if( filename != NULL )
4890 {
4891 file = fopen(filename, "w");
4892 if( file == NULL )
4893 {
4894 SCIPerrorMessage("cannot open file <%s> for writing\n", filename);
4895 SCIPprintSysError(filename);
4896 return SCIP_FILECREATEERROR;
4897 }
4898 }
4899 else
4900 file = NULL;
4901
4902 /* write the parameter to the file */
4903 retcode = paramWrite(param, messagehdlr, file, comments, onlychanged);
4904
4905 /* close output file */
4906 if( filename != NULL )
4907 {
4908 assert(file != NULL); /*lint !e449*/
4909 fclose(file);
4910 }
4911
4912 SCIP_CALL( retcode );
4913
4914 return SCIP_OKAY;
4915 }
4916