Scippy

SCIP

Solving Constraint Integer Programs

scip_param.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 2002-2022 Zuse Institute Berlin */
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 scip_param.c
26  * @ingroup OTHER_CFILES
27  * @brief public methods for SCIP parameter handling
28  * @author Tobias Achterberg
29  * @author Timo Berthold
30  * @author Gerald Gamrath
31  * @author Leona Gottwald
32  * @author Stefan Heinz
33  * @author Gregor Hendel
34  * @author Thorsten Koch
35  * @author Alexander Martin
36  * @author Marc Pfetsch
37  * @author Michael Winkler
38  * @author Kati Wolter
39  *
40  * @todo check all SCIP_STAGE_* switches, and include the new stages TRANSFORMED and INITSOLVE
41  */
42 
43 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
44 
45 #include "scip/paramset.h"
46 #include "scip/pub_message.h"
47 #include "scip/scip_param.h"
48 #include "scip/set.h"
49 #include "scip/struct_mem.h"
50 #include "scip/struct_scip.h"
51 
52 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
53  *
54  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
55  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
56  */
58  SCIP* scip, /**< SCIP data structure */
59  const char* name, /**< name of the parameter */
60  const char* desc, /**< description of the parameter */
61  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
62  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
63  SCIP_Bool defaultvalue, /**< default value of the parameter */
64  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
65  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
66  )
67 {
68  assert(scip != NULL);
69  assert(scip->set != NULL);
70  assert(scip->mem != NULL);
71 
72  SCIP_CALL( SCIPsetAddBoolParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
73  defaultvalue, paramchgd, paramdata) );
74 
75  return SCIP_OKAY;
76 }
77 
78 /** creates a int parameter, sets it to its default value, and adds it to the parameter set
79  *
80  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
81  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
82  */
84  SCIP* scip, /**< SCIP data structure */
85  const char* name, /**< name of the parameter */
86  const char* desc, /**< description of the parameter */
87  int* valueptr, /**< pointer to store the current parameter value, or NULL */
88  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
89  int defaultvalue, /**< default value of the parameter */
90  int minvalue, /**< minimum value for parameter */
91  int maxvalue, /**< maximum value for parameter */
92  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
93  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
94  )
95 {
96  assert(scip != NULL);
97  assert(scip->set != NULL);
98  assert(scip->mem != NULL);
99 
100  SCIP_CALL( SCIPsetAddIntParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
101  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
102 
103  return SCIP_OKAY;
104 }
105 
106 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
107  *
108  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
109  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
110  */
112  SCIP* scip, /**< SCIP data structure */
113  const char* name, /**< name of the parameter */
114  const char* desc, /**< description of the parameter */
115  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
116  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
117  SCIP_Longint defaultvalue, /**< default value of the parameter */
118  SCIP_Longint minvalue, /**< minimum value for parameter */
119  SCIP_Longint maxvalue, /**< maximum value for parameter */
120  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
121  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
122  )
123 {
124  assert(scip != NULL);
125  assert(scip->set != NULL);
126  assert(scip->mem != NULL);
127 
128  SCIP_CALL( SCIPsetAddLongintParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
129  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
130 
131  return SCIP_OKAY;
132 }
133 
134 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
135  *
136  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
137  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
138  */
140  SCIP* scip, /**< SCIP data structure */
141  const char* name, /**< name of the parameter */
142  const char* desc, /**< description of the parameter */
143  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
144  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
145  SCIP_Real defaultvalue, /**< default value of the parameter */
146  SCIP_Real minvalue, /**< minimum value for parameter */
147  SCIP_Real maxvalue, /**< maximum value for parameter */
148  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
149  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
150  )
151 {
152  assert(scip != NULL);
153  assert(scip->set != NULL);
154  assert(scip->mem != NULL);
155 
156  SCIP_CALL( SCIPsetAddRealParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
157  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
158 
159  return SCIP_OKAY;
160 }
161 
162 /** creates a char parameter, sets it to its default value, and adds it to the parameter set
163  *
164  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
165  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
166  */
168  SCIP* scip, /**< SCIP data structure */
169  const char* name, /**< name of the parameter */
170  const char* desc, /**< description of the parameter */
171  char* valueptr, /**< pointer to store the current parameter value, or NULL */
172  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
173  char defaultvalue, /**< default value of the parameter */
174  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
175  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
176  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
177  )
178 {
179  assert(scip != NULL);
180  assert(scip->set != NULL);
181  assert(scip->mem != NULL);
182 
183  SCIP_CALL( SCIPsetAddCharParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
184  defaultvalue, allowedvalues, paramchgd, paramdata) );
185 
186  return SCIP_OKAY;
187 }
188 
189 /** creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
190  *
191  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
192  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
193  */
195  SCIP* scip, /**< SCIP data structure */
196  const char* name, /**< name of the parameter */
197  const char* desc, /**< description of the parameter */
198  char** valueptr, /**< pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL */
199  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
200  const char* defaultvalue, /**< default value of the parameter */
201  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
202  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
203  )
204 {
205  assert(scip != NULL);
206  assert(scip->set != NULL);
207  assert(scip->mem != NULL);
208 
209  SCIP_CALL( SCIPsetAddStringParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
210  defaultvalue, paramchgd, paramdata) );
211 
212  return SCIP_OKAY;
213 }
214 
215 /** gets the fixing status of an existing parameter
216  *
217  * @return TRUE if the parameter is fixed to a value, otherwise FALSE.
218  */
220  SCIP* scip, /**< SCIP data structure */
221  const char* name /**< name of the parameter */
222  )
223 {
224  assert(scip != NULL);
225  assert(scip->set != NULL);
226 
227  return SCIPsetIsParamFixed(scip->set, name);
228 }
229 
230 /** returns the pointer to the SCIP parameter with the given name
231  *
232  * @return pointer to the parameter with the given name
233  */
235  SCIP* scip, /**< SCIP data structure */
236  const char* name /**< name of the parameter */
237  )
238 {
239  assert(scip != NULL);
240  assert(scip->set != NULL);
241 
242  return SCIPsetGetParam(scip->set, name);
243 }
244 
245 /** gets the value of an existing SCIP_Bool parameter
246  *
247  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
248  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
249  */
251  SCIP* scip, /**< SCIP data structure */
252  const char* name, /**< name of the parameter */
253  SCIP_Bool* value /**< pointer to store the parameter */
254  )
255 {
256  assert(scip != NULL);
257  assert(scip->set != NULL);
258 
259  SCIP_CALL( SCIPsetGetBoolParam(scip->set, name, value) );
260 
261  return SCIP_OKAY;
262 }
263 
264 /** gets the value of an existing int parameter
265  *
266  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
267  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
268  */
270  SCIP* scip, /**< SCIP data structure */
271  const char* name, /**< name of the parameter */
272  int* value /**< pointer to store the parameter */
273  )
274 {
275  assert(scip != NULL);
276  assert(scip->set != NULL);
277 
278  SCIP_CALL( SCIPsetGetIntParam(scip->set, name, value) );
279 
280  return SCIP_OKAY;
281 }
282 
283 /** gets the value of an existing SCIP_Longint parameter
284  *
285  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
286  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
287  */
289  SCIP* scip, /**< SCIP data structure */
290  const char* name, /**< name of the parameter */
291  SCIP_Longint* value /**< pointer to store the parameter */
292  )
293 {
294  assert(scip != NULL);
295  assert(scip->set != NULL);
296 
297  SCIP_CALL( SCIPsetGetLongintParam(scip->set, name, value) );
298 
299  return SCIP_OKAY;
300 }
301 
302 /** gets the value of an existing SCIP_Real parameter
303  *
304  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
305  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
306  */
308  SCIP* scip, /**< SCIP data structure */
309  const char* name, /**< name of the parameter */
310  SCIP_Real* value /**< pointer to store the parameter */
311  )
312 {
313  assert(scip != NULL);
314  assert(scip->set != NULL);
315 
316  SCIP_CALL( SCIPsetGetRealParam(scip->set, name, value) );
317 
318  return SCIP_OKAY;
319 }
320 
321 /** gets the value of an existing char parameter
322  *
323  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
324  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
325  */
327  SCIP* scip, /**< SCIP data structure */
328  const char* name, /**< name of the parameter */
329  char* value /**< pointer to store the parameter */
330  )
331 {
332  assert(scip != NULL);
333  assert(scip->set != NULL);
334 
335  SCIP_CALL( SCIPsetGetCharParam(scip->set, name, value) );
336 
337  return SCIP_OKAY;
338 }
339 
340 /** gets the value of an existing string(char*) parameter
341  *
342  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
343  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
344  */
346  SCIP* scip, /**< SCIP data structure */
347  const char* name, /**< name of the parameter */
348  char** value /**< pointer to store the parameter */
349  )
350 {
351  assert(scip != NULL);
352  assert(scip->set != NULL);
353 
354  SCIP_CALL( SCIPsetGetStringParam(scip->set, name, value) );
355 
356  return SCIP_OKAY;
357 }
358 
359 /** fixes the value of an existing parameter
360  *
361  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
362  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
363  *
364  * @note: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because
365  * they have to be changed for sub-SCIPs.
366  */
368  SCIP* scip, /**< SCIP data structure */
369  const char* name /**< name of the parameter */
370  )
371 {
372  assert(scip != NULL);
373  assert(scip->set != NULL);
374 
375  SCIP_CALL( SCIPsetChgParamFixed(scip->set, name, TRUE) );
376 
377  return SCIP_OKAY;
378 }
379 
380 /** unfixes the value of an existing parameter
381  *
382  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
383  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
384  */
386  SCIP* scip, /**< SCIP data structure */
387  const char* name /**< name of the parameter */
388  )
389 {
390  assert(scip != NULL);
391  assert(scip->set != NULL);
392 
393  SCIP_CALL( SCIPsetChgParamFixed(scip->set, name, FALSE) );
394 
395  return SCIP_OKAY;
396 }
397 
398 /** changes the value of an existing SCIP_Bool parameter
399  *
400  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
401  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
402  */
404  SCIP* scip, /**< SCIP data structure */
405  SCIP_PARAM* param, /**< parameter */
406  SCIP_Bool value /**< new value of the parameter */
407  )
408 {
409  SCIP_RETCODE retcode;
410 
411  assert(scip != NULL);
412  assert(scip->set != NULL);
413 
414  retcode = SCIPsetChgBoolParam(scip->set, scip->messagehdlr, param, value);
415 
416  if( retcode != SCIP_PARAMETERWRONGVAL )
417  {
418  SCIP_CALL( retcode );
419  }
420 
421  return retcode;
422 }
423 
424 /** changes the value of an existing SCIP_Bool parameter
425  *
426  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
427  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
428  */
430  SCIP* scip, /**< SCIP data structure */
431  const char* name, /**< name of the parameter */
432  SCIP_Bool value /**< new value of the parameter */
433  )
434 {
435  assert(scip != NULL);
436  assert(scip->set != NULL);
437 
438  SCIP_CALL( SCIPsetSetBoolParam(scip->set, scip->messagehdlr, name, value) );
439 
440  return SCIP_OKAY;
441 }
442 
443 /** checks whether the value of an existing SCIP_Bool parameter is valid */
445  SCIP* scip, /**< SCIP data structure */
446  SCIP_PARAM* param, /**< parameter */
447  SCIP_Bool value /**< value to check */
448  )
449 {
450  assert(scip != NULL);
451  assert(param != NULL);
452 
453  return SCIPparamIsValidBool(param, value);
454 }
455 
456 /** changes the value of an existing int parameter
457  *
458  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
459  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
460  */
462  SCIP* scip, /**< SCIP data structure */
463  SCIP_PARAM* param, /**< parameter */
464  int value /**< new value of the parameter */
465  )
466 {
467  SCIP_RETCODE retcode;
468 
469  assert(scip != NULL);
470  assert(scip->set != NULL);
471 
472  retcode = SCIPsetChgIntParam(scip->set, scip->messagehdlr, param, value);
473 
474  if( retcode != SCIP_PARAMETERWRONGVAL )
475  {
476  SCIP_CALL( retcode );
477  }
478 
479  return retcode;
480 }
481 
482 /** changes the value of an existing int parameter
483  *
484  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
485  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
486  */
488  SCIP* scip, /**< SCIP data structure */
489  const char* name, /**< name of the parameter */
490  int value /**< new value of the parameter */
491  )
492 {
493  assert(scip != NULL);
494  assert(scip->set != NULL);
495 
496  SCIP_CALL( SCIPsetSetIntParam(scip->set, scip->messagehdlr, name, value) );
497 
498  return SCIP_OKAY;
499 }
500 
501 /** checks whether parameter value of an existing int paramter is valid */
503  SCIP* scip, /**< SCIP data structure */
504  SCIP_PARAM* param, /**< parameter */
505  int value /**< value to check */
506  )
507 {
508  assert(scip != NULL);
509  assert(param != NULL);
510 
511  return SCIPparamIsValidInt(param, value);
512 }
513 
514 /** changes the value of an existing SCIP_Longint parameter
515  *
516  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
517  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
518  */
520  SCIP* scip, /**< SCIP data structure */
521  SCIP_PARAM* param, /**< parameter */
522  SCIP_Longint value /**< new value of the parameter */
523  )
524 {
525  SCIP_RETCODE retcode;
526 
527  assert(scip != NULL);
528  assert(scip->set != NULL);
529 
530  retcode = SCIPsetChgLongintParam(scip->set, scip->messagehdlr, param, value);
531 
532  if( retcode != SCIP_PARAMETERWRONGVAL )
533  {
534  SCIP_CALL( retcode );
535  }
536 
537  return retcode;
538 }
539 
540 /** changes the value of an existing SCIP_Longint parameter
541  *
542  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
543  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
544  */
546  SCIP* scip, /**< SCIP data structure */
547  const char* name, /**< name of the parameter */
548  SCIP_Longint value /**< new value of the parameter */
549  )
550 {
551  assert(scip != NULL);
552  assert(scip->set != NULL);
553 
554  SCIP_CALL( SCIPsetSetLongintParam(scip->set, scip->messagehdlr, name, value) );
555 
556  return SCIP_OKAY;
557 }
558 
559 /** checks whether parameter value of an existing SCIP_Longint paramter is valid */
561  SCIP* scip, /**< SCIP data structure */
562  SCIP_PARAM* param, /**< parameter */
563  SCIP_Longint value /**< value to check */
564  )
565 {
566  assert(scip != NULL);
567  assert(param != NULL);
568 
569  return SCIPparamIsValidLongint(param, value);
570 }
571 
572 /** changes the value of an existing SCIP_Real parameter
573  *
574  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
575  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
576  */
578  SCIP* scip, /**< SCIP data structure */
579  SCIP_PARAM* param, /**< parameter */
580  SCIP_Real value /**< new value of the parameter */
581  )
582 {
583  SCIP_RETCODE retcode;
584 
585  assert(scip != NULL);
586  assert(scip->set != NULL);
587 
588  retcode = SCIPsetChgRealParam(scip->set, scip->messagehdlr, param, value);
589 
590  if( retcode != SCIP_PARAMETERWRONGVAL )
591  {
592  SCIP_CALL( retcode );
593  }
594 
595  return retcode;
596 }
597 
598 /** changes the value of an existing SCIP_Real parameter
599  *
600  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
601  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
602  */
604  SCIP* scip, /**< SCIP data structure */
605  const char* name, /**< name of the parameter */
606  SCIP_Real value /**< new value of the parameter */
607  )
608 {
609  assert(scip != NULL);
610  assert(scip->set != NULL);
611 
612  SCIP_CALL( SCIPsetSetRealParam(scip->set, scip->messagehdlr, name, value) );
613 
614  return SCIP_OKAY;
615 }
616 
617 /** checks whether parameter value of an existing SCIP_Real paramter is valid */
619  SCIP* scip, /**< SCIP data structure */
620  SCIP_PARAM* param, /**< parameter */
621  SCIP_Real value /**< value to check */
622  )
623 {
624  assert(scip != NULL);
625  assert(param != NULL);
626 
627  return SCIPparamIsValidReal(param, value);
628 }
629 
630 /** changes the value of an existing char parameter
631  *
632  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
633  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
634  */
636  SCIP* scip, /**< SCIP data structure */
637  SCIP_PARAM* param, /**< parameter */
638  char value /**< new value of the parameter */
639  )
640 {
641  SCIP_RETCODE retcode;
642 
643  assert(scip != NULL);
644  assert(scip->set != NULL);
645 
646  retcode = SCIPsetChgCharParam(scip->set, scip->messagehdlr, param, value);
647 
648  if( retcode != SCIP_PARAMETERWRONGVAL )
649  {
650  SCIP_CALL( retcode );
651  }
652 
653  return retcode;
654 }
655 
656 /** changes the value of an existing char parameter
657  *
658  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
659  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
660  */
662  SCIP* scip, /**< SCIP data structure */
663  const char* name, /**< name of the parameter */
664  char value /**< new value of the parameter */
665  )
666 {
667  assert(scip != NULL);
668  assert(scip->set != NULL);
669 
670  SCIP_CALL( SCIPsetSetCharParam(scip->set, scip->messagehdlr, name, value) );
671 
672  return SCIP_OKAY;
673 }
674 
675 /** checks whether parameter value for a given SCIP_Real parameter is valid */
677  SCIP* scip, /**< SCIP data structure */
678  SCIP_PARAM* param, /**< parameter */
679  const char value /**< value to check */
680  )
681 {
682  assert(scip != NULL);
683  assert(param != NULL);
684 
685  return SCIPparamIsValidChar(param, value);
686 }
687 
688 /** changes the value of an existing string(char*) parameter
689  *
690  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
691  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
692  */
694  SCIP* scip, /**< SCIP data structure */
695  SCIP_PARAM* param, /**< parameter */
696  const char* value /**< new value of the parameter */
697  )
698 {
699  SCIP_RETCODE retcode;
700 
701  assert(scip != NULL);
702  assert(scip->set != NULL);
703 
704  retcode = SCIPsetChgStringParam(scip->set, scip->messagehdlr, param, value);
705 
706  if( retcode != SCIP_PARAMETERWRONGVAL )
707  {
708  SCIP_CALL( retcode );
709  }
710 
711  return retcode;
712 }
713 
714 /** changes the value of an existing string(char*) parameter
715  *
716  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
717  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
718  */
720  SCIP* scip, /**< SCIP data structure */
721  const char* name, /**< name of the parameter */
722  const char* value /**< new value of the parameter */
723  )
724 {
725  assert(scip != NULL);
726  assert(scip->set != NULL);
727 
728  SCIP_CALL( SCIPsetSetStringParam(scip->set, scip->messagehdlr, name, value) );
729 
730  return SCIP_OKAY;
731 }
732 
733 /** checks whether parameter value for a given string parameter is valid */
735  SCIP* scip, /**< SCIP data structure */
736  SCIP_PARAM* param, /**< parameter */
737  const char* value /**< value to check */
738  )
739 {
740  assert(scip != NULL);
741  assert(param != NULL);
742 
743  return SCIPparamIsValidString(param, value);
744 }
745 
746 /** reads parameters from a file
747  *
748  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
749  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
750  */
752  SCIP* scip, /**< SCIP data structure */
753  const char* filename /**< file name */
754  )
755 {
756  assert(scip != NULL);
757  assert(scip->set != NULL);
758 
759  SCIP_CALL( SCIPsetReadParams(scip->set, scip->messagehdlr, filename) );
760 
761  return SCIP_OKAY;
762 }
763 
764 /** writes a single parameter to a file
765  *
766  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
767  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
768  */
770  SCIP* scip, /**< SCIP data structure */
771  SCIP_PARAM* param, /**< parameter */
772  const char* filename, /**< file name, or NULL for stdout */
773  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
774  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
775  * default value?
776  */
777  )
778 {
779  assert(scip != NULL);
780  assert(param != NULL);
781 
782  SCIP_CALL( SCIPparamWrite(param, scip->messagehdlr, filename, comments, onlychanged) );
783 
784  return SCIP_OKAY;
785 }
786 
787 /** writes all parameters in the parameter set to a file
788  *
789  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
790  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
791  */
793  SCIP* scip, /**< SCIP data structure */
794  const char* filename, /**< file name, or NULL for stdout */
795  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
796  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
797  * default value?
798  */
799  )
800 {
801  assert(scip != NULL);
802  assert(scip->set != NULL);
803 
804  SCIP_CALL( SCIPsetWriteParams(scip->set, scip->messagehdlr, filename, comments, onlychanged) );
805 
806  return SCIP_OKAY;
807 }
808 
809 /** resets a single parameter to its default value
810  *
811  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
812  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
813  */
815  SCIP* scip, /**< SCIP data structure */
816  const char* name /**< name of the parameter */
817  )
818 {
819  assert(scip != NULL);
820  assert(scip->set != NULL);
821 
822  SCIP_CALL( SCIPsetResetParam(scip->set, scip->messagehdlr, name) );
823 
824  return SCIP_OKAY;
825 }
826 
827 /** resets all parameters to their default values
828  *
829  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
830  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
831  */
833  SCIP* scip /**< SCIP data structure */
834  )
835 {
836  assert(scip != NULL);
837  assert(scip->set != NULL);
838 
839  SCIP_CALL( SCIPsetResetParams(scip->set, scip->messagehdlr) );
840 
841  return SCIP_OKAY;
842 }
843 
844 /** sets parameters to
845  *
846  * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
847  * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
848  * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
849  * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
850  * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
851  * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
852  * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
853  * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
854  * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
855  * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
856  * - \ref SCIP_PARAMEMPHASIS_NUMERICS to solve problems which cause numerical issues
857  *
858  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
859  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
860  */
862  SCIP* scip, /**< SCIP data structure */
863  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
864  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
865  )
866 {
867  assert(scip != NULL);
868  assert(scip->set != NULL);
869 
870  SCIP_CALL( SCIPsetSetEmphasis(scip->set, scip->messagehdlr, paramemphasis, quiet) );
871 
872  return SCIP_OKAY;
873 }
874 
875 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
876  * auxiliary SCIP instances to avoid recursion
877  *
878  * @note only deactivates plugins which could cause recursion, some plugins which use sub-SCIPs stay activated
879  *
880  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
881  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
882  */
884  SCIP* scip, /**< (auxiliary) SCIP data structure */
885  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
886  )
887 {
888  assert(scip != NULL);
889  assert(scip->set != NULL);
890 
891  SCIP_CALL( SCIPsetSetSubscipsOff(scip->set, scip->messagehdlr, quiet) );
892 
893  return SCIP_OKAY;
894 }
895 
896 /** sets heuristic parameters values to
897  *
898  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
899  * - SCIP_PARAMSETTING_FAST such that the time spent on heuristics is decreased
900  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristics are called more aggressively
901  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
902  *
903  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
904  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
905  */
907  SCIP* scip, /**< SCIP data structure */
908  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
909  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
910  )
911 {
912  assert(scip != NULL);
913  assert(scip->set != NULL);
914  assert(paramsetting == SCIP_PARAMSETTING_DEFAULT || paramsetting == SCIP_PARAMSETTING_FAST
915  || paramsetting == SCIP_PARAMSETTING_AGGRESSIVE || paramsetting == SCIP_PARAMSETTING_OFF);
916 
917  SCIP_CALL( SCIPsetSetHeuristics(scip->set, scip->messagehdlr, paramsetting, quiet) );
918 
919  return SCIP_OKAY;
920 }
921 
922 /** sets presolving parameters to
923  *
924  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
925  * - SCIP_PARAMSETTING_FAST such that the time spent on presolving is decreased
926  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggressive
927  * - SCIP_PARAMSETTING_OFF which turn off all presolving
928  *
929  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
930  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
931  */
933  SCIP* scip, /**< SCIP data structure */
934  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
935  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
936  )
937 {
938  assert(scip != NULL);
939  assert(scip->set != NULL);
940  assert(paramsetting == SCIP_PARAMSETTING_DEFAULT || paramsetting == SCIP_PARAMSETTING_FAST
941  || paramsetting == SCIP_PARAMSETTING_AGGRESSIVE || paramsetting == SCIP_PARAMSETTING_OFF);
942 
943  SCIP_CALL( SCIPsetSetPresolving(scip->set, scip->messagehdlr, paramsetting, quiet) );
944 
945  return SCIP_OKAY;
946 }
947 
948 /** sets separating parameters to
949  *
950  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
951  * - SCIP_PARAMSETTING_FAST such that the time spent on separating is decreased
952  * - SCIP_PARAMSETTING_AGGRESSIVE such that separating is more aggressive
953  * - SCIP_PARAMSETTING_OFF which turn off all separating
954  *
955  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
956  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
957  */
959  SCIP* scip, /**< SCIP data structure */
960  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
961  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
962  )
963 {
964  assert(scip != NULL);
965  assert(scip->set != NULL);
966  assert(paramsetting == SCIP_PARAMSETTING_DEFAULT || paramsetting == SCIP_PARAMSETTING_FAST
967  || paramsetting == SCIP_PARAMSETTING_AGGRESSIVE || paramsetting == SCIP_PARAMSETTING_OFF);
968 
969  SCIP_CALL( SCIPsetSetSeparating(scip->set, scip->messagehdlr, paramsetting, quiet) );
970 
971  return SCIP_OKAY;
972 }
973 
974 /** returns the array of all available SCIP parameters
975  *
976  * @return SCIP_PARAM* array, containing all SCIP parameters.
977  */
979  SCIP* scip /**< SCIP data structure */
980  )
981 {
982  assert(scip != NULL);
983  assert(scip->set != NULL);
984 
985  return SCIPsetGetParams(scip->set);
986 }
987 
988 /** returns the total number of all available SCIP parameters
989  *
990  * @return number of all SCIP parameters.
991  */
993  SCIP* scip /**< SCIP data structure */
994  )
995 {
996  assert(scip != NULL);
997  assert(scip->set != NULL);
998 
999  return SCIPsetGetNParams(scip->set);
1000 }
1001 
1002 /** returns whether plugins with sub-SCIPs that could cause recursion have been disabled
1003  *
1004  * @return the value of the variable set->subscipsoff
1005  */
1007  SCIP* scip /**< SCIP data structure */
1008  )
1009 {
1010  assert(scip != NULL);
1011  assert(scip->set != NULL);
1012 
1013  return SCIPsetGetSubscipsOff(scip->set);
1014 }
SCIP_RETCODE SCIPsetSetEmphasis(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: set.c:3587
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
Definition: scip_param.c:978
SCIP_RETCODE SCIPgetStringParam(SCIP *scip, const char *name, char **value)
Definition: scip_param.c:345
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
Definition: scip_param.c:326
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:958
SCIP_Bool SCIPparamIsValidInt(SCIP_PARAM *param, int value)
Definition: paramset.c:4432
public methods for SCIP parameter handling
SCIP_RETCODE SCIPsetSetRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Real value)
Definition: set.c:3431
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip_param.c:307
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:87
SCIP_Bool SCIPisStringParamValid(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip_param.c:734
SCIP_RETCODE SCIPsetGetStringParam(SCIP_SET *set, const char *name, char **value)
Definition: set.c:3238
SCIP_RETCODE SCIPsetResetParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
Definition: set.c:3564
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:906
#define FALSE
Definition: def.h:96
SCIP_RETCODE SCIPaddLongintParam(SCIP *scip, 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: scip_param.c:111
SCIP_Bool SCIPisIntParamValid(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip_param.c:502
SCIP_Bool SCIPgetSubscipsOff(SCIP *scip)
Definition: scip_param.c:1006
#define TRUE
Definition: def.h:95
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:932
SCIP_PARAM ** SCIPsetGetParams(SCIP_SET *set)
Definition: set.c:3668
SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip_param.c:577
SCIP_RETCODE SCIPaddStringParam(SCIP *scip, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:194
SCIP_RETCODE SCIPwriteParam(SCIP *scip, SCIP_PARAM *param, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip_param.c:769
internal methods for handling parameter settings
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
Definition: scip_param.c:603
SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip_param.c:693
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, 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: scip_param.c:83
SCIP_RETCODE SCIPsetSetStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, const char *value)
Definition: set.c:3507
enum SCIP_ParamSetting SCIP_PARAMSETTING
Definition: type_paramset.h:65
SCIP_RETCODE SCIPsetAddCharParam(SCIP_SET *set, 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: set.c:3101
SCIP_Bool SCIPisCharParamValid(SCIP *scip, SCIP_PARAM *param, const char value)
Definition: scip_param.c:676
SCIP_RETCODE SCIPresetParams(SCIP *scip)
Definition: scip_param.c:832
SCIP_RETCODE SCIPsetReadParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename)
Definition: set.c:3522
SCIP_MEM * mem
Definition: struct_scip.h:71
SCIP_Bool SCIPisBoolParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip_param.c:444
SCIP_RETCODE SCIPsetChgIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, int value)
Definition: set.c:3318
SCIP_Bool SCIPsetIsParamFixed(SCIP_SET *set, const char *name)
Definition: set.c:3146
SCIP_RETCODE SCIPsetSetSubscipsOff(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_Bool quiet)
Definition: set.c:3602
SCIP_RETCODE SCIPsetChgBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Bool value)
Definition: set.c:3266
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
Definition: scip_param.c:219
SCIP_RETCODE SCIPsetWriteParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: set.c:3536
SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)
Definition: scip_param.c:635
SCIP_RETCODE SCIPsetSetSeparating(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3655
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
Definition: scip_param.c:429
SCIP_RETCODE SCIPsetSetIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, int value)
Definition: set.c:3341
int SCIPsetGetNParams(SCIP_SET *set)
Definition: set.c:3678
SCIP_RETCODE SCIPsetChgRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Real value)
Definition: set.c:3408
SCIP_Bool SCIPsetGetSubscipsOff(SCIP_SET *set)
Definition: set.c:7312
#define SCIP_DECL_PARAMCHGD(x)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip_param.c:250
SCIP_RETCODE SCIPsetChgLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Longint value)
Definition: set.c:3370
#define NULL
Definition: lpi_spx1.cpp:164
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
Definition: scip_param.c:269
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
Definition: scip_param.c:385
SCIP_Bool SCIPparamIsValidReal(SCIP_PARAM *param, SCIP_Real value)
Definition: paramset.c:4454
SCIP_PARAM * SCIPgetParam(SCIP *scip, const char *name)
Definition: scip_param.c:234
internal methods for global SCIP settings
#define SCIP_CALL(x)
Definition: def.h:393
SCIP main data structure.
BMS_BLKMEM * setmem
Definition: struct_mem.h:48
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: scip_param.c:861
SCIP_RETCODE SCIPsetSetPresolving(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3637
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, 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: set.c:3029
SCIP_Bool SCIPisLongintParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip_param.c:560
SCIP_RETCODE SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)
Definition: scip_param.c:288
SCIP_RETCODE SCIPsetSetLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Longint value)
Definition: set.c:3393
SCIP_RETCODE SCIPsetSetHeuristics(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3619
#define SCIP_Bool
Definition: def.h:93
SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip_param.c:519
SCIP_RETCODE SCIPsetGetIntParam(SCIP_SET *set, const char *name, int *value)
Definition: set.c:3182
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
Definition: scip_param.c:487
datastructures for block memory pools and memory buffers
SCIP_RETCODE SCIPsetStringParam(SCIP *scip, const char *name, const char *value)
Definition: scip_param.c:719
SCIP_RETCODE SCIPsetAddStringParam(SCIP_SET *set, 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: set.c:3124
SCIP_RETCODE SCIPsetSetCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
Definition: set.c:3469
SCIP_RETCODE SCIPfixParam(SCIP *scip, const char *name)
Definition: scip_param.c:367
SCIP_Bool SCIPisRealParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip_param.c:618
SCIP_RETCODE SCIPsetGetCharParam(SCIP_SET *set, const char *name, char *value)
Definition: set.c:3224
SCIP_PARAM * SCIPsetGetParam(SCIP_SET *set, const char *name)
Definition: set.c:3157
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
Definition: scip_param.c:661
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
Definition: type_paramset.h:84
SCIP_RETCODE SCIPsetGetRealParam(SCIP_SET *set, const char *name, SCIP_Real *value)
Definition: set.c:3210
SCIP_Bool SCIPparamIsValidChar(SCIP_PARAM *param, const char value)
Definition: paramset.c:4465
SCIP_Bool SCIPparamIsValidBool(SCIP_PARAM *param, SCIP_Bool value)
Definition: paramset.c:4422
SCIP_RETCODE SCIPaddCharParam(SCIP *scip, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:167
SCIP_RETCODE SCIPsetResetParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name)
Definition: set.c:3552
SCIP_RETCODE SCIPsetChgParamFixed(SCIP_SET *set, const char *name, SCIP_Bool fixed)
Definition: set.c:3252
SCIP_RETCODE SCIPreadParams(SCIP *scip, const char *filename)
Definition: scip_param.c:751
SCIP_SET * set
Definition: struct_scip.h:72
public methods for message output
SCIP_RETCODE SCIPsetAddLongintParam(SCIP_SET *set, 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: set.c:3053
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:75
#define SCIP_Real
Definition: def.h:186
#define SCIP_Longint
Definition: def.h:171
SCIP_RETCODE SCIPsetChgStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, const char *value)
Definition: set.c:3484
SCIP_RETCODE SCIPsetGetLongintParam(SCIP_SET *set, const char *name, SCIP_Longint *value)
Definition: set.c:3196
SCIP_RETCODE SCIPsetChgCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, char value)
Definition: set.c:3446
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip_param.c:792
SCIP_RETCODE SCIPparamWrite(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: paramset.c:5008
SCIP_RETCODE SCIPsetAddRealParam(SCIP_SET *set, 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: set.c:3077
SCIP_RETCODE SCIPsetGetBoolParam(SCIP_SET *set, const char *name, SCIP_Bool *value)
Definition: set.c:3168
SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip_param.c:461
SCIP_RETCODE SCIPresetParam(SCIP *scip, const char *name)
Definition: scip_param.c:814
SCIP_RETCODE SCIPsetAddBoolParam(SCIP_SET *set, 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: set.c:3007
SCIP_Bool SCIPparamIsValidLongint(SCIP_PARAM *param, SCIP_Longint value)
Definition: paramset.c:4443
int SCIPgetNParams(SCIP *scip)
Definition: scip_param.c:992
SCIP_RETCODE SCIPsetSetBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Bool value)
Definition: set.c:3288
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip_param.c:403
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, 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: scip_param.c:139
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
Definition: scip_param.c:883
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
Definition: scip_param.c:545
SCIP_Bool SCIPparamIsValidString(SCIP_PARAM *param, const char *value)
Definition: paramset.c:4491
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:57