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