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