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 <ctype.h>
36 #include <stdarg.h>
37 #include <assert.h>
38 #include <string.h>
39 #if defined(_WIN32) || defined(_WIN64)
40 #else
41 #include <strings.h> /*lint --e{766}*/
42 #endif
43 
44 
45 #include "lpi/lpi.h"
46 #include "nlpi/exprinterpret.h"
47 #include "nlpi/nlpi.h"
48 #include "scip/benders.h"
49 #include "scip/benderscut.h"
50 #include "scip/branch.h"
51 #include "scip/branch_nodereopt.h"
52 #include "scip/clock.h"
53 #include "scip/compr.h"
54 #include "scip/concsolver.h"
55 #include "scip/concurrent.h"
56 #include "scip/conflict.h"
57 #include "scip/conflictstore.h"
58 #include "scip/cons.h"
59 #include "scip/cons_linear.h"
60 #include "scip/cutpool.h"
61 #include "scip/cuts.h"
62 #include "scip/debug.h"
63 #include "scip/def.h"
64 #include "scip/dialog.h"
65 #include "scip/dialog_default.h"
66 #include "scip/disp.h"
67 #include "scip/event.h"
68 #include "scip/heur.h"
69 #include "scip/heur_ofins.h"
70 #include "scip/heur_reoptsols.h"
72 #include "scip/heuristics.h"
73 #include "scip/history.h"
74 #include "scip/implics.h"
75 #include "scip/interrupt.h"
76 #include "scip/lp.h"
77 #include "scip/mem.h"
78 #include "scip/message_default.h"
79 #include "scip/misc.h"
80 #include "scip/nlp.h"
81 #include "scip/nodesel.h"
82 #include "scip/paramset.h"
83 #include "scip/presol.h"
84 #include "scip/presolve.h"
85 #include "scip/pricer.h"
86 #include "scip/pricestore.h"
87 #include "scip/primal.h"
88 #include "scip/prob.h"
89 #include "scip/prop.h"
90 #include "scip/reader.h"
91 #include "scip/relax.h"
92 #include "scip/reopt.h"
93 #include "scip/retcode.h"
94 #include "scip/scipbuildflags.h"
95 #include "scip/scipcoreplugins.h"
96 #include "scip/scipgithash.h"
97 #include "scip/sepa.h"
98 #include "scip/sepastore.h"
99 #include "scip/set.h"
100 #include "scip/sol.h"
101 #include "scip/solve.h"
102 #include "scip/stat.h"
103 #include "scip/syncstore.h"
104 #include "scip/table.h"
105 #include "scip/tree.h"
106 #include "scip/var.h"
107 #include "scip/visual.h"
108 #include "xml/xml.h"
109 
110 #include "scip/scip_param.h"
111 
112 #include "scip/pub_message.h"
113 
114 
115 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
116  * this structure except the interface methods in scip.c.
117  * In optimized mode, the structure is included in scip.h, because some of the methods
118  * are implemented as defines for performance reasons (e.g. the numerical comparisons)
119  */
120 #ifndef NDEBUG
121 #include "scip/struct_scip.h"
122 #endif
123 
124 /** creates a SCIP_Bool 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_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
134  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
135  SCIP_Bool defaultvalue, /**< default value of the parameter */
136  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
137  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
138  )
139 {
140  assert(scip != NULL);
141  assert(scip->set != NULL);
142  assert(scip->mem != NULL);
143 
144  SCIP_CALL( SCIPsetAddBoolParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
145  defaultvalue, paramchgd, paramdata) );
146 
147  return SCIP_OKAY;
148 }
149 
150 /** creates a int parameter, sets it to its default value, and adds it to the parameter set
151  *
152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
154  */
156  SCIP* scip, /**< SCIP data structure */
157  const char* name, /**< name of the parameter */
158  const char* desc, /**< description of the parameter */
159  int* valueptr, /**< pointer to store the current parameter value, or NULL */
160  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
161  int defaultvalue, /**< default value of the parameter */
162  int minvalue, /**< minimum value for parameter */
163  int maxvalue, /**< maximum value for parameter */
164  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
165  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
166  )
167 {
168  assert(scip != NULL);
169  assert(scip->set != NULL);
170  assert(scip->mem != NULL);
171 
172  SCIP_CALL( SCIPsetAddIntParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
173  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
174 
175  return SCIP_OKAY;
176 }
177 
178 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
179  *
180  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
181  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
182  */
184  SCIP* scip, /**< SCIP data structure */
185  const char* name, /**< name of the parameter */
186  const char* desc, /**< description of the parameter */
187  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
188  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
189  SCIP_Longint defaultvalue, /**< default value of the parameter */
190  SCIP_Longint minvalue, /**< minimum value for parameter */
191  SCIP_Longint maxvalue, /**< maximum value for 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( SCIPsetAddLongintParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
201  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
202 
203  return SCIP_OKAY;
204 }
205 
206 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
207  *
208  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
209  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
210  */
212  SCIP* scip, /**< SCIP data structure */
213  const char* name, /**< name of the parameter */
214  const char* desc, /**< description of the parameter */
215  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
216  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
217  SCIP_Real defaultvalue, /**< default value of the parameter */
218  SCIP_Real minvalue, /**< minimum value for parameter */
219  SCIP_Real maxvalue, /**< maximum value for parameter */
220  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
221  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
222  )
223 {
224  assert(scip != NULL);
225  assert(scip->set != NULL);
226  assert(scip->mem != NULL);
227 
228  SCIP_CALL( SCIPsetAddRealParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
229  defaultvalue, minvalue, maxvalue, paramchgd, paramdata) );
230 
231  return SCIP_OKAY;
232 }
233 
234 /** creates a char parameter, sets it to its default value, and adds it to the parameter set
235  *
236  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
237  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
238  */
240  SCIP* scip, /**< SCIP data structure */
241  const char* name, /**< name of the parameter */
242  const char* desc, /**< description of the parameter */
243  char* valueptr, /**< pointer to store the current parameter value, or NULL */
244  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
245  char defaultvalue, /**< default value of the parameter */
246  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
247  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
248  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
249  )
250 {
251  assert(scip != NULL);
252  assert(scip->set != NULL);
253  assert(scip->mem != NULL);
254 
255  SCIP_CALL( SCIPsetAddCharParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
256  defaultvalue, allowedvalues, paramchgd, paramdata) );
257 
258  return SCIP_OKAY;
259 }
260 
261 /** creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
262  *
263  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
264  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
265  */
267  SCIP* scip, /**< SCIP data structure */
268  const char* name, /**< name of the parameter */
269  const char* desc, /**< description of the parameter */
270  char** valueptr, /**< pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL */
271  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
272  const char* defaultvalue, /**< default value of the parameter */
273  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
274  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
275  )
276 {
277  assert(scip != NULL);
278  assert(scip->set != NULL);
279  assert(scip->mem != NULL);
280 
281  SCIP_CALL( SCIPsetAddStringParam(scip->set, scip->messagehdlr, scip->mem->setmem, name, desc, valueptr, isadvanced,
282  defaultvalue, paramchgd, paramdata) );
283 
284  return SCIP_OKAY;
285 }
286 
287 /** gets the fixing status of an existing parameter
288  *
289  * @return TRUE if the parameter is fixed to a value, otherwise FALSE.
290  */
292  SCIP* scip, /**< SCIP data structure */
293  const char* name /**< name of the parameter */
294  )
295 {
296  assert(scip != NULL);
297  assert(scip->set != NULL);
298 
299  return SCIPsetIsParamFixed(scip->set, name);
300 }
301 
302 /** returns the pointer to the SCIP parameter with the given name
303  *
304  * @return pointer to the parameter with the given name
305  */
307  SCIP* scip, /**< SCIP data structure */
308  const char* name /**< name of the parameter */
309  )
310 {
311  assert(scip != NULL);
312  assert(scip->set != NULL);
313 
314  return SCIPsetGetParam(scip->set, name);
315 }
316 
317 /** gets the value of an existing SCIP_Bool parameter
318  *
319  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
320  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
321  */
323  SCIP* scip, /**< SCIP data structure */
324  const char* name, /**< name of the parameter */
325  SCIP_Bool* value /**< pointer to store the parameter */
326  )
327 {
328  assert(scip != NULL);
329  assert(scip->set != NULL);
330 
331  SCIP_CALL( SCIPsetGetBoolParam(scip->set, name, value) );
332 
333  return SCIP_OKAY;
334 }
335 
336 /** gets the value of an existing int parameter
337  *
338  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
339  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
340  */
342  SCIP* scip, /**< SCIP data structure */
343  const char* name, /**< name of the parameter */
344  int* value /**< pointer to store the parameter */
345  )
346 {
347  assert(scip != NULL);
348  assert(scip->set != NULL);
349 
350  SCIP_CALL( SCIPsetGetIntParam(scip->set, name, value) );
351 
352  return SCIP_OKAY;
353 }
354 
355 /** gets the value of an existing SCIP_Longint parameter
356  *
357  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
358  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
359  */
361  SCIP* scip, /**< SCIP data structure */
362  const char* name, /**< name of the parameter */
363  SCIP_Longint* value /**< pointer to store the parameter */
364  )
365 {
366  assert(scip != NULL);
367  assert(scip->set != NULL);
368 
369  SCIP_CALL( SCIPsetGetLongintParam(scip->set, name, value) );
370 
371  return SCIP_OKAY;
372 }
373 
374 /** gets the value of an existing SCIP_Real parameter
375  *
376  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
377  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
378  */
380  SCIP* scip, /**< SCIP data structure */
381  const char* name, /**< name of the parameter */
382  SCIP_Real* value /**< pointer to store the parameter */
383  )
384 {
385  assert(scip != NULL);
386  assert(scip->set != NULL);
387 
388  SCIP_CALL( SCIPsetGetRealParam(scip->set, name, value) );
389 
390  return SCIP_OKAY;
391 }
392 
393 /** gets the value of an existing char parameter
394  *
395  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
396  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
397  */
399  SCIP* scip, /**< SCIP data structure */
400  const char* name, /**< name of the parameter */
401  char* value /**< pointer to store the parameter */
402  )
403 {
404  assert(scip != NULL);
405  assert(scip->set != NULL);
406 
407  SCIP_CALL( SCIPsetGetCharParam(scip->set, name, value) );
408 
409  return SCIP_OKAY;
410 }
411 
412 /** gets the value of an existing string(char*) parameter
413  *
414  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
415  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
416  */
418  SCIP* scip, /**< SCIP data structure */
419  const char* name, /**< name of the parameter */
420  char** value /**< pointer to store the parameter */
421  )
422 {
423  assert(scip != NULL);
424  assert(scip->set != NULL);
425 
426  SCIP_CALL( SCIPsetGetStringParam(scip->set, name, value) );
427 
428  return SCIP_OKAY;
429 }
430 
431 /** fixes the value of an existing parameter
432  *
433  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
434  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
435  *
436  * @note: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because
437  * they have to be changed for sub-SCIPs.
438  */
440  SCIP* scip, /**< SCIP data structure */
441  const char* name /**< name of the parameter */
442  )
443 {
444  assert(scip != NULL);
445  assert(scip->set != NULL);
446 
447  SCIP_CALL( SCIPsetChgParamFixed(scip->set, name, TRUE) );
448 
449  return SCIP_OKAY;
450 }
451 
452 /** unfixes the value of an existing parameter
453  *
454  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
455  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
456  */
458  SCIP* scip, /**< SCIP data structure */
459  const char* name /**< name of the parameter */
460  )
461 {
462  assert(scip != NULL);
463  assert(scip->set != NULL);
464 
465  SCIP_CALL( SCIPsetChgParamFixed(scip->set, name, FALSE) );
466 
467  return SCIP_OKAY;
468 }
469 
470 /** changes the value of an existing parameter
471  *
472  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
473  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
474  */
476  SCIP* scip, /**< SCIP data structure */
477  const char* name, /**< name of the parameter */
478  void* value /**< new value of the parameter */
479  )
480 {
481  assert(scip != NULL);
482  assert(scip->set != NULL);
483 
484  SCIP_CALL( SCIPsetSetParam(scip->set, scip->messagehdlr, name, value) );
485 
486  return SCIP_OKAY;
487 }
488 
489 /** changes the value of an existing SCIP_Bool parameter
490  *
491  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
492  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
493  */
495  SCIP* scip, /**< SCIP data structure */
496  SCIP_PARAM* param, /**< parameter */
497  SCIP_Bool value /**< new value of the parameter */
498  )
499 {
500  SCIP_RETCODE retcode;
501 
502  assert(scip != NULL);
503  assert(scip->set != NULL);
504 
505  retcode = SCIPsetChgBoolParam(scip->set, scip->messagehdlr, param, value);
506 
507  if( retcode != SCIP_PARAMETERWRONGVAL )
508  {
509  SCIP_CALL( retcode );
510  }
511 
512  return retcode;
513 }
514 
515 /** changes the value of an existing SCIP_Bool parameter
516  *
517  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
518  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
519  */
521  SCIP* scip, /**< SCIP data structure */
522  const char* name, /**< name of the parameter */
523  SCIP_Bool value /**< new value of the parameter */
524  )
525 {
526  assert(scip != NULL);
527  assert(scip->set != NULL);
528 
529  SCIP_CALL( SCIPsetSetBoolParam(scip->set, scip->messagehdlr, name, value) );
530 
531  return SCIP_OKAY;
532 }
533 
534 /** checks whether the value of an existing SCIP_Bool parameter is valid */
536  SCIP* scip, /**< SCIP data structure */
537  SCIP_PARAM* param, /**< parameter */
538  SCIP_Bool value /**< value to check */
539  )
540 {
541  assert(scip != NULL);
542  assert(param != NULL);
543 
544  return SCIPparamIsValidBool(param, value);
545 }
546 
547 /** changes the value of an existing int parameter
548  *
549  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
550  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
551  */
553  SCIP* scip, /**< SCIP data structure */
554  SCIP_PARAM* param, /**< parameter */
555  int value /**< new value of the parameter */
556  )
557 {
558  SCIP_RETCODE retcode;
559 
560  assert(scip != NULL);
561  assert(scip->set != NULL);
562 
563  retcode = SCIPsetChgIntParam(scip->set, scip->messagehdlr, param, value);
564 
565  if( retcode != SCIP_PARAMETERWRONGVAL )
566  {
567  SCIP_CALL( retcode );
568  }
569 
570  return retcode;
571 }
572 
573 /** changes the value of an existing int parameter
574  *
575  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
576  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
577  */
579  SCIP* scip, /**< SCIP data structure */
580  const char* name, /**< name of the parameter */
581  int value /**< new value of the parameter */
582  )
583 {
584  assert(scip != NULL);
585  assert(scip->set != NULL);
586 
587  SCIP_CALL( SCIPsetSetIntParam(scip->set, scip->messagehdlr, name, value) );
588 
589  return SCIP_OKAY;
590 }
591 
592 /** checks whether parameter value of an existing int paramter is valid */
594  SCIP* scip, /**< SCIP data structure */
595  SCIP_PARAM* param, /**< parameter */
596  int value /**< value to check */
597  )
598 {
599  assert(scip != NULL);
600  assert(param != NULL);
601 
602  return SCIPparamIsValidInt(param, value);
603 }
604 
605 /** changes the value of an existing SCIP_Longint parameter
606  *
607  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
608  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
609  */
611  SCIP* scip, /**< SCIP data structure */
612  SCIP_PARAM* param, /**< parameter */
613  SCIP_Longint value /**< new value of the parameter */
614  )
615 {
616  SCIP_RETCODE retcode;
617 
618  assert(scip != NULL);
619  assert(scip->set != NULL);
620 
621  retcode = SCIPsetChgLongintParam(scip->set, scip->messagehdlr, param, value);
622 
623  if( retcode != SCIP_PARAMETERWRONGVAL )
624  {
625  SCIP_CALL( retcode );
626  }
627 
628  return retcode;
629 }
630 
631 /** changes the value of an existing SCIP_Longint parameter
632  *
633  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
634  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
635  */
637  SCIP* scip, /**< SCIP data structure */
638  const char* name, /**< name of the parameter */
639  SCIP_Longint value /**< new value of the parameter */
640  )
641 {
642  assert(scip != NULL);
643  assert(scip->set != NULL);
644 
645  SCIP_CALL( SCIPsetSetLongintParam(scip->set, scip->messagehdlr, name, value) );
646 
647  return SCIP_OKAY;
648 }
649 
650 /** checks whether parameter value of an existing SCIP_Longint paramter is valid */
652  SCIP* scip, /**< SCIP data structure */
653  SCIP_PARAM* param, /**< parameter */
654  SCIP_Longint value /**< value to check */
655  )
656 {
657  assert(scip != NULL);
658  assert(param != NULL);
659 
660  return SCIPparamIsValidLongint(param, value);
661 }
662 
663 /** changes the value of an existing SCIP_Real parameter
664  *
665  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
666  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
667  */
669  SCIP* scip, /**< SCIP data structure */
670  SCIP_PARAM* param, /**< parameter */
671  SCIP_Real value /**< new value of the parameter */
672  )
673 {
674  SCIP_RETCODE retcode;
675 
676  assert(scip != NULL);
677  assert(scip->set != NULL);
678 
679  retcode = SCIPsetChgRealParam(scip->set, scip->messagehdlr, param, value);
680 
681  if( retcode != SCIP_PARAMETERWRONGVAL )
682  {
683  SCIP_CALL( retcode );
684  }
685 
686  return retcode;
687 }
688 
689 /** changes the value of an existing SCIP_Real parameter
690  *
691  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
692  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
693  */
695  SCIP* scip, /**< SCIP data structure */
696  const char* name, /**< name of the parameter */
697  SCIP_Real value /**< new value of the parameter */
698  )
699 {
700  assert(scip != NULL);
701  assert(scip->set != NULL);
702 
703  SCIP_CALL( SCIPsetSetRealParam(scip->set, scip->messagehdlr, name, value) );
704 
705  return SCIP_OKAY;
706 }
707 
708 /** checks whether parameter value of an existing SCIP_Real paramter is valid */
710  SCIP* scip, /**< SCIP data structure */
711  SCIP_PARAM* param, /**< parameter */
712  SCIP_Real value /**< value to check */
713  )
714 {
715  assert(scip != NULL);
716  assert(param != NULL);
717 
718  return SCIPparamIsValidReal(param, value);
719 }
720 
721 /** changes the value of an existing char parameter
722  *
723  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
724  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
725  */
727  SCIP* scip, /**< SCIP data structure */
728  SCIP_PARAM* param, /**< parameter */
729  char value /**< new value of the parameter */
730  )
731 {
732  SCIP_RETCODE retcode;
733 
734  assert(scip != NULL);
735  assert(scip->set != NULL);
736 
737  retcode = SCIPsetChgCharParam(scip->set, scip->messagehdlr, param, value);
738 
739  if( retcode != SCIP_PARAMETERWRONGVAL )
740  {
741  SCIP_CALL( retcode );
742  }
743 
744  return retcode;
745 }
746 
747 /** changes the value of an existing char parameter
748  *
749  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
750  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
751  */
753  SCIP* scip, /**< SCIP data structure */
754  const char* name, /**< name of the parameter */
755  char value /**< new value of the parameter */
756  )
757 {
758  assert(scip != NULL);
759  assert(scip->set != NULL);
760 
761  SCIP_CALL( SCIPsetSetCharParam(scip->set, scip->messagehdlr, name, value) );
762 
763  return SCIP_OKAY;
764 }
765 
766 /** checks whether parameter value for a given SCIP_Real parameter is valid */
768  SCIP* scip, /**< SCIP data structure */
769  SCIP_PARAM* param, /**< parameter */
770  const char value /**< value to check */
771  )
772 {
773  assert(scip != NULL);
774  assert(param != NULL);
775 
776  return SCIPparamIsValidChar(param, value);
777 }
778 
779 /** changes the value of an existing string(char*) parameter
780  *
781  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
782  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
783  */
785  SCIP* scip, /**< SCIP data structure */
786  SCIP_PARAM* param, /**< parameter */
787  const char* value /**< new value of the parameter */
788  )
789 {
790  SCIP_RETCODE retcode;
791 
792  assert(scip != NULL);
793  assert(scip->set != NULL);
794 
795  retcode = SCIPsetChgStringParam(scip->set, scip->messagehdlr, param, value);
796 
797  if( retcode != SCIP_PARAMETERWRONGVAL )
798  {
799  SCIP_CALL( retcode );
800  }
801 
802  return retcode;
803 }
804 
805 /** changes the value of an existing string(char*) parameter
806  *
807  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
808  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
809  */
811  SCIP* scip, /**< SCIP data structure */
812  const char* name, /**< name of the parameter */
813  const char* value /**< new value of the parameter */
814  )
815 {
816  assert(scip != NULL);
817  assert(scip->set != NULL);
818 
819  SCIP_CALL( SCIPsetSetStringParam(scip->set, scip->messagehdlr, name, value) );
820 
821  return SCIP_OKAY;
822 }
823 
824 /** checks whether parameter value for a given string parameter is valid */
826  SCIP* scip, /**< SCIP data structure */
827  SCIP_PARAM* param, /**< parameter */
828  const char* value /**< value to check */
829  )
830 {
831  assert(scip != NULL);
832  assert(param != NULL);
833 
834  return SCIPparamIsValidString(param, value);
835 }
836 
837 /** reads parameters from a file
838  *
839  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
840  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
841  */
843  SCIP* scip, /**< SCIP data structure */
844  const char* filename /**< file name */
845  )
846 {
847  assert(scip != NULL);
848  assert(scip->set != NULL);
849 
850  SCIP_CALL( SCIPsetReadParams(scip->set, scip->messagehdlr, filename) );
851 
852  return SCIP_OKAY;
853 }
854 
855 /** writes a single parameter to a file
856  *
857  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
858  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
859  */
861  SCIP* scip, /**< SCIP data structure */
862  SCIP_PARAM* param, /**< parameter */
863  const char* filename, /**< file name, or NULL for stdout */
864  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
865  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
866  * default value?
867  */
868  )
869 {
870  assert(scip != NULL);
871  assert(param != NULL);
872 
873  SCIP_CALL( SCIPparamWrite(param, scip->messagehdlr, filename, comments, onlychanged) );
874 
875  return SCIP_OKAY;
876 }
877 
878 /** writes all parameters in the parameter set to a file
879  *
880  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
881  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
882  */
884  SCIP* scip, /**< SCIP data structure */
885  const char* filename, /**< file name, or NULL for stdout */
886  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
887  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
888  * default value?
889  */
890  )
891 {
892  assert(scip != NULL);
893  assert(scip->set != NULL);
894 
895  SCIP_CALL( SCIPsetWriteParams(scip->set, scip->messagehdlr, filename, comments, onlychanged) );
896 
897  return SCIP_OKAY;
898 }
899 
900 /** resets a single parameter to its default value
901  *
902  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
903  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
904  */
906  SCIP* scip, /**< SCIP data structure */
907  const char* name /**< name of the parameter */
908  )
909 {
910  assert(scip != NULL);
911  assert(scip->set != NULL);
912 
913  SCIP_CALL( SCIPsetResetParam(scip->set, scip->messagehdlr, name) );
914 
915  return SCIP_OKAY;
916 }
917 
918 /** resets all parameters to their default values
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  )
926 {
927  assert(scip != NULL);
928  assert(scip->set != NULL);
929 
930  SCIP_CALL( SCIPsetResetParams(scip->set, scip->messagehdlr) );
931 
932  return SCIP_OKAY;
933 }
934 
935 /** sets parameters to
936  *
937  * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
938  * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
939  * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
940  * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
941  * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
942  * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
943  * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
944  * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
945  * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
946  * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
947  *
948  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
949  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
950  */
952  SCIP* scip, /**< SCIP data structure */
953  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
954  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
955  )
956 {
957  assert(scip != NULL);
958  assert(scip->set != NULL);
959 
960  SCIP_CALL( SCIPsetSetEmphasis(scip->set, scip->messagehdlr, paramemphasis, quiet) );
961 
962  return SCIP_OKAY;
963 }
964 
965 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
966  * auxiliary SCIP instances to avoid recursion
967  *
968  * @note only deactivates plugins which could cause recursion, some plugins which use sub-SCIPs stay activated
969  *
970  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
971  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
972  */
974  SCIP* scip, /**< (auxiliary) SCIP data structure */
975  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
976  )
977 {
978  assert(scip != NULL);
979  assert(scip->set != NULL);
980 
981  SCIP_CALL( SCIPsetSetSubscipsOff(scip->set, scip->messagehdlr, quiet) );
982 
983  return SCIP_OKAY;
984 }
985 
986 /** sets heuristic parameters values to
987  *
988  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
989  * - SCIP_PARAMSETTING_FAST such that the time spent on heuristics is decreased
990  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristics are called more aggressively
991  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
992  *
993  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
994  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
995  */
997  SCIP* scip, /**< SCIP data structure */
998  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
999  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1000  )
1001 {
1002  assert(scip != NULL);
1003  assert(scip->set != NULL);
1004  assert(paramsetting == SCIP_PARAMSETTING_DEFAULT || paramsetting == SCIP_PARAMSETTING_FAST
1005  || paramsetting == SCIP_PARAMSETTING_AGGRESSIVE || paramsetting == SCIP_PARAMSETTING_OFF);
1006 
1007  SCIP_CALL( SCIPsetSetHeuristics(scip->set, scip->messagehdlr, paramsetting, quiet) );
1008 
1009  return SCIP_OKAY;
1010 }
1011 
1012 /** sets presolving parameters to
1013  *
1014  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
1015  * - SCIP_PARAMSETTING_FAST such that the time spent on presolving is decreased
1016  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggressive
1017  * - SCIP_PARAMSETTING_OFF which turn off all presolving
1018  *
1019  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1020  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1021  */
1023  SCIP* scip, /**< SCIP data structure */
1024  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1025  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1026  )
1027 {
1028  assert(scip != NULL);
1029  assert(scip->set != NULL);
1030  assert(paramsetting == SCIP_PARAMSETTING_DEFAULT || paramsetting == SCIP_PARAMSETTING_FAST
1031  || paramsetting == SCIP_PARAMSETTING_AGGRESSIVE || paramsetting == SCIP_PARAMSETTING_OFF);
1032 
1033  SCIP_CALL( SCIPsetSetPresolving(scip->set, scip->messagehdlr, paramsetting, quiet) );
1034 
1035  return SCIP_OKAY;
1036 }
1037 
1038 /** sets separating parameters to
1039  *
1040  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
1041  * - SCIP_PARAMSETTING_FAST such that the time spent on separating is decreased
1042  * - SCIP_PARAMSETTING_AGGRESSIVE such that separating is more aggressive
1043  * - SCIP_PARAMSETTING_OFF which turn off all separating
1044  *
1045  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1046  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1047  */
1049  SCIP* scip, /**< SCIP data structure */
1050  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1051  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1052  )
1053 {
1054  assert(scip != NULL);
1055  assert(scip->set != NULL);
1056  assert(paramsetting == SCIP_PARAMSETTING_DEFAULT || paramsetting == SCIP_PARAMSETTING_FAST
1057  || paramsetting == SCIP_PARAMSETTING_AGGRESSIVE || paramsetting == SCIP_PARAMSETTING_OFF);
1058 
1059  SCIP_CALL( SCIPsetSetSeparating(scip->set, scip->messagehdlr, paramsetting, quiet) );
1060 
1061  return SCIP_OKAY;
1062 }
1063 
1064 /** returns the array of all available SCIP parameters
1065  *
1066  * @return SCIP_PARAM* array, containing all SCIP parameters.
1067  */
1069  SCIP* scip /**< SCIP data structure */
1070  )
1071 {
1072  assert(scip != NULL);
1073  assert(scip->set != NULL);
1074 
1075  return SCIPsetGetParams(scip->set);
1076 }
1077 
1078 /** returns the total number of all available SCIP parameters
1079  *
1080  * @return number of all SCIP parameters.
1081  */
1083  SCIP* scip /**< SCIP data structure */
1084  )
1085 {
1086  assert(scip != NULL);
1087  assert(scip->set != NULL);
1088 
1089  return SCIPsetGetNParams(scip->set);
1090 }
internal methods for separators
SCIP_RETCODE SCIPsetSetEmphasis(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: set.c:3452
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
Definition: scip_param.c:1068
SCIP_RETCODE SCIPgetStringParam(SCIP *scip, const char *name, char **value)
Definition: scip_param.c:417
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
Definition: scip_param.c:398
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:1048
#define NULL
Definition: def.h:246
internal methods for managing events
SCIP_Bool SCIPparamIsValidInt(SCIP_PARAM *param, int value)
Definition: paramset.c:4251
default message handler
trivialnegation primal heuristic
internal methods for storing primal CIP solutions
public methods for SCIP parameter handling
methods to interpret (evaluate) an expression tree "fast"
internal methods for branch and bound tree
SCIP_RETCODE SCIPsetSetRealParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Real value)
Definition: set.c:3296
methods for implications, variable bounds, and cliques
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip_param.c:379
internal methods for clocks and timing issues
SCIP_RETCODE SCIPsetParam(SCIP *scip, const char *name, void *value)
Definition: scip_param.c:475
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:76
SCIP_Bool SCIPisStringParamValid(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip_param.c:825
internal methods for NLPI solver interfaces
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
interface methods for specific LP solvers
internal methods for displaying statistics tables
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:996
#define FALSE
Definition: def.h:72
methods for the aggregation rows
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:183
internal methods for Benders&#39; decomposition
SCIP_Bool SCIPisIntParamValid(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip_param.c:593
#define TRUE
Definition: def.h:71
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
methods commonly used by primal heuristics
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:1022
SCIP_RETCODE SCIPsetSetParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, void *value)
Definition: set.c:3116
internal methods for branching rules and branching candidate storage
datastructures for concurrent solvers
SCIP_PARAM ** SCIPsetGetParams(SCIP_SET *set)
Definition: set.c:3533
SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip_param.c:668
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:266
SCIP_RETCODE SCIPwriteParam(SCIP *scip, SCIP_PARAM *param, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip_param.c:860
internal methods for handling parameter settings
methods for creating output for visualization tools (VBC, BAK)
nodereopt branching rule
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
Definition: scip_param.c:694
SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip_param.c:784
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:155
internal methods for LP management
internal methods for branching and inference history
SCIP_RETCODE SCIPsetSetStringParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, const char *value)
Definition: set.c:3372
internal methods for collecting primal CIP solutions and primal informations
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:2951
internal methods for propagators
SCIP_Bool SCIPisCharParamValid(SCIP *scip, SCIP_PARAM *param, const char value)
Definition: scip_param.c:767
SCIP_RETCODE SCIPresetParams(SCIP *scip)
Definition: scip_param.c:923
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_Bool SCIPisBoolParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip_param.c:535
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
git hash methods
SCIP_RETCODE SCIPsetChgBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Bool value)
Definition: set.c:3131
internal methods for storing and manipulating the main problem
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
Definition: scip_param.c:291
SCIP_RETCODE SCIPsetWriteParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: set.c:3401
methods for block memory pools and memory buffers
SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)
Definition: scip_param.c:726
SCIP_RETCODE SCIPsetSetSeparating(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3520
register additional core functionality that is designed as plugins
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
Definition: scip_param.c:520
internal methods for presolvers
SCIP_RETCODE SCIPsetSetIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, int value)
Definition: set.c:3206
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
internal methods for NLP management
#define SCIP_DECL_PARAMCHGD(x)
Definition: type_paramset.h:91
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip_param.c:322
SCIP_RETCODE SCIPsetChgLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, SCIP_Longint value)
Definition: set.c:3235
internal miscellaneous methods
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
Definition: scip_param.c:341
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
Definition: scip_param.c:457
SCIP_Bool SCIPparamIsValidReal(SCIP_PARAM *param, SCIP_Real value)
Definition: paramset.c:4273
SCIP_PARAM * SCIPgetParam(SCIP *scip, const char *name)
Definition: scip_param.c:306
internal methods for node selectors and node priority queues
internal methods for variable pricers
internal methods for global SCIP settings
internal methods for storing conflicts
#define SCIP_CALL(x)
Definition: def.h:358
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:951
SCIP_RETCODE SCIPsetSetPresolving(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3502
internal methods for storing priced variables
internal methods for relaxators
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_Bool SCIPisLongintParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip_param.c:651
SCIP_RETCODE SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)
Definition: scip_param.c:360
internal methods for storing separated cuts
methods commonly used for presolving
methods for catching the user CTRL-C interrupt
SCIP_RETCODE SCIPsetSetLongintParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Longint value)
Definition: set.c:3258
internal methods for problem variables
data structures and methods for collecting reoptimization information
the function declarations for the synchronization store
SCIP_RETCODE SCIPsetSetHeuristics(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: set.c:3484
internal methods for user interface dialog
#define SCIP_Bool
Definition: def.h:69
internal methods for input file readers
SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip_param.c:610
SCIP_RETCODE SCIPsetGetIntParam(SCIP_SET *set, const char *name, int *value)
Definition: set.c:3032
methods for debugging
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
Definition: scip_param.c:578
SCIP_RETCODE SCIPsetStringParam(SCIP *scip, const char *name, const char *value)
Definition: scip_param.c:810
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
SCIP_RETCODE SCIPsetSetCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
Definition: set.c:3334
reoptsols primal heuristic
internal methods for storing cuts in a cut pool
SCIP_RETCODE SCIPfixParam(SCIP *scip, const char *name)
Definition: scip_param.c:439
Constraint handler for linear constraints in their most general form, .
SCIP_Bool SCIPisRealParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip_param.c:709
SCIP_RETCODE SCIPsetGetCharParam(SCIP_SET *set, const char *name, char *value)
Definition: set.c:3074
helper functions for concurrent scip solvers
SCIP_PARAM * SCIPsetGetParam(SCIP_SET *set, const char *name)
Definition: set.c:3007
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
Definition: scip_param.c:752
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
internal methods for return codes for SCIP methods
SCIP_Bool SCIPparamIsValidChar(SCIP_PARAM *param, const char value)
Definition: paramset.c:4284
SCIP_Bool SCIPparamIsValidBool(SCIP_PARAM *param, SCIP_Bool value)
Definition: paramset.c:4242
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:239
internal methods for conflict analysis
internal methods for tree compressions
internal methods for main solving loop and node processing
SCIP_RETCODE SCIPsetResetParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name)
Definition: set.c:3417
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:842
SCIP_SET * set
Definition: struct_scip.h:62
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:2903
SCIP_MESSAGEHDLR * messagehdlr
Definition: struct_scip.h:65
default user interface dialog
#define SCIP_Real
Definition: def.h:157
internal methods for problem statistics
internal methods for constraints and constraint handlers
#define SCIP_Longint
Definition: def.h:142
declarations for XML parsing
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
build flags methods
SCIP_RETCODE SCIPsetChgCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_PARAM *param, char value)
Definition: set.c:3311
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip_param.c:883
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPparamWrite(SCIP_PARAM *param, SCIP_MESSAGEHDLR *messagehdlr, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: paramset.c:4657
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
internal methods for primal heuristics
SCIP_RETCODE SCIPsetGetBoolParam(SCIP_SET *set, const char *name, SCIP_Bool *value)
Definition: set.c:3018
SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip_param.c:552
SCIP_RETCODE SCIPresetParam(SCIP *scip, const char *name)
Definition: scip_param.c:905
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
int SCIPgetNParams(SCIP *scip)
Definition: scip_param.c:1082
SCIP_RETCODE SCIPsetSetBoolParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_Bool value)
Definition: set.c:3153
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip_param.c:494
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:211
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
Definition: scip_param.c:973
internal methods for Benders&#39; decomposition cuts
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
Definition: scip_param.c:636
SCIP_Bool SCIPparamIsValidString(SCIP_PARAM *param, const char *value)
Definition: paramset.c:4310
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:129
internal methods for displaying runtime statistics
OFINS - Objective Function Induced Neighborhood Search - a primal heuristic for reoptimization.