Scippy

SCIP

Solving Constraint Integer Programs

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