Scippy

SCIP

Solving Constraint Integer Programs

scip.h
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-2015 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 email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip.h
17  * @ingroup PUBLICMETHODS
18  * @brief SCIP callable library
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  */
26 
27 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
28 
29 #ifndef __SCIP_SCIP_H__
30 #define __SCIP_SCIP_H__
31 
32 
33 #include <stdio.h>
34 
35 #include "scip/def.h"
36 #include "blockmemshell/memory.h"
37 #include "scip/type_retcode.h"
38 #include "scip/type_result.h"
39 #include "scip/type_clock.h"
40 #include "scip/type_misc.h"
41 #include "scip/type_timing.h"
42 #include "scip/type_paramset.h"
43 #include "scip/type_event.h"
44 #include "scip/type_lp.h"
45 #include "scip/type_nlp.h"
46 #include "scip/type_var.h"
47 #include "scip/type_prob.h"
48 #include "scip/type_tree.h"
49 #include "scip/type_scip.h"
50 
51 #include "scip/type_branch.h"
52 #include "scip/type_conflict.h"
53 #include "scip/type_cons.h"
54 #include "scip/type_dialog.h"
55 #include "scip/type_disp.h"
56 #include "scip/type_heur.h"
57 #include "scip/type_compr.h"
58 #include "scip/type_history.h"
59 #include "scip/type_nodesel.h"
60 #include "scip/type_presol.h"
61 #include "scip/type_pricer.h"
62 #include "scip/type_reader.h"
63 #include "scip/type_relax.h"
64 #include "scip/type_sepa.h"
65 #include "scip/type_prop.h"
66 #include "nlpi/type_nlpi.h"
67 
68 /* include public interfaces, s.t. the user only needs to include scip.h */
69 #include "scip/pub_branch.h"
70 #include "scip/pub_conflict.h"
71 #include "scip/pub_cons.h"
72 #include "scip/pub_cutpool.h"
73 #include "scip/pub_dialog.h"
74 #include "scip/pub_disp.h"
75 #include "scip/pub_event.h"
76 #include "scip/pub_fileio.h"
77 #include "scip/pub_heur.h"
78 #include "scip/pub_compr.h"
79 #include "scip/pub_history.h"
80 #include "scip/pub_implics.h"
81 #include "scip/pub_lp.h"
82 #include "scip/pub_nlp.h"
83 #include "scip/pub_message.h"
84 #include "scip/pub_misc.h"
85 #include "scip/pub_nodesel.h"
86 #include "scip/pub_paramset.h"
87 #include "scip/pub_presol.h"
88 #include "scip/pub_pricer.h"
89 #include "scip/pub_reader.h"
90 #include "scip/pub_relax.h"
91 #include "scip/pub_sepa.h"
92 #include "scip/pub_prop.h"
93 #include "scip/pub_sol.h"
94 #include "scip/pub_tree.h"
95 #include "scip/pub_var.h"
96 #include "lpi/lpi.h"
97 #include "nlpi/pub_expr.h"
98 
99 /* include global presolving methods */
100 #include "scip/presolve.h"
101 
102 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
103  * this structure except the interface methods in scip.c.
104  * In optimized mode, the structure is included in scip.h, because some of the methods
105  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
106  * Additionally, the internal "set.h" is included, such that the defines in set.h are
107  * available in optimized mode.
108  */
109 #ifdef NDEBUG
110 #include "scip/struct_scip.h"
111 #include "scip/set.h"
112 #include "scip/tree.h"
113 #include "scip/misc.h"
114 #include "scip/var.h"
115 #endif
116 
117 #ifdef __cplusplus
118 extern "C" {
119 #endif
120 
121 /*
122  * miscellaneous methods
123  */
124 
125 /**@name Miscellaneous Methods */
126 /**@{ */
127 
128 /** returns complete SCIP version number in the format "major . minor tech"
129  *
130  * @return complete SCIP version
131  */
132 extern
134  void
135  );
136 
137 /** returns SCIP major version
138  *
139  * @return major SCIP version
140  */
141 extern
142 int SCIPmajorVersion(
143  void
144  );
145 
146 /** returns SCIP minor version
147  *
148  * @return minor SCIP version
149  */
150 extern
151 int SCIPminorVersion(
152  void
153  );
154 
155 /** returns SCIP technical version
156  *
157  * @return technical SCIP version
158  */
159 extern
160 int SCIPtechVersion(
161  void
162  );
163 
164 /** returns SCIP sub version number
165  *
166  * @return subversion SCIP version
167  */
168 extern
169 int SCIPsubversion(
170  void
171  );
172 
173 /** prints a version information line to a file stream via the message handler system
174  *
175  * @note If the message handler is set to a NULL pointer nothing will be printed
176  */
177 extern
178 void SCIPprintVersion(
179  SCIP* scip, /**< SCIP data structure */
180  FILE* file /**< output file (or NULL for standard output) */
181  );
182 
183 /** prints error message for the given SCIP_RETCODE via the error prints method */
184 extern
185 void SCIPprintError(
186  SCIP_RETCODE retcode /**< SCIP return code causing the error */
187  );
188 
189 /** update statistical information when a new solution was found */
190 extern
192  SCIP* scip /**< SCIP data structure */
193  );
194 
195 /**@} */
196 
197 
198 
199 
200 /*
201  * general SCIP methods
202  */
203 
204 /**@name General SCIP Methods */
205 /**@{ */
206 
207 /** creates and initializes SCIP data structures
208  *
209  * @note The SCIP default message handler is installed. Use the method SCIPsetMessagehdlr() to install your own
210  * message handler or SCIPsetMessagehdlrLogfile() and SCIPsetMessagehdlrQuiet() to write into a log
211  * file and turn off/on the display output, respectively.
212  *
213  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
214  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
215  *
216  * @post After calling this method @p scip reached the solving stage \ref SCIP_STAGE_INIT
217  *
218  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
219  */
220 extern
222  SCIP** scip /**< pointer to SCIP data structure */
223  );
224 
225 /** frees SCIP data structures
226  *
227  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
228  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
229  *
230  * @pre This method can be called if @p scip is in one of the following stages:
231  * - \ref SCIP_STAGE_INIT
232  * - \ref SCIP_STAGE_PROBLEM
233  * - \ref SCIP_STAGE_TRANSFORMED
234  * - \ref SCIP_STAGE_INITPRESOLVE
235  * - \ref SCIP_STAGE_PRESOLVING
236  * - \ref SCIP_STAGE_PRESOLVED
237  * - \ref SCIP_STAGE_EXITPRESOLVE
238  * - \ref SCIP_STAGE_SOLVING
239  * - \ref SCIP_STAGE_SOLVED
240  * - \ref SCIP_STAGE_FREE
241  *
242  * @post After calling this method \SCIP reached the solving stage \ref SCIP_STAGE_FREE
243  *
244  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
245  */
246 extern
248  SCIP** scip /**< pointer to SCIP data structure */
249  );
250 
251 /** returns current stage of SCIP
252  *
253  * @return the current SCIP stage
254  *
255  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
256  */
257 extern
259  SCIP* scip /**< SCIP data structure */
260  );
261 
262 /** outputs SCIP stage and solution status if applicable via the message handler
263  *
264  * @note If the message handler is set to a NULL pointer nothing will be printed
265  *
266  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
267  * thus may to correspond to the original status.
268  *
269  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
270  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
271  *
272  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
273  */
274 extern
276  SCIP* scip, /**< SCIP data structure */
277  FILE* file /**< output file (or NULL for standard output) */
278  );
279 
280 /** gets solution status
281  *
282  * @return SCIP solution status
283  *
284  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
285  */
286 extern
288  SCIP* scip /**< SCIP data structure */
289  );
290 
291 /** outputs solution status
292  *
293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
295  *
296  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
297  */
298 extern
300  SCIP* scip, /**< SCIP data structure */
301  FILE* file /**< output file (or NULL for standard output) */
302  );
303 
304 /** returns whether the current stage belongs to the transformed problem space
305  *
306  * @return Returns TRUE if the \SCIP instance is transformed, otherwise FALSE
307  */
308 extern
310  SCIP* scip /**< SCIP data structure */
311  );
312 
313 /** returns whether the solution process should be probably correct
314  *
315  * @note This feature is not supported yet!
316  *
317  * @return Returns TRUE if \SCIP is exact solving mode, otherwise FALSE
318  */
319 extern
321  SCIP* scip /**< SCIP data structure */
322  );
323 
324 /** returns whether the presolving process would be finished given no more presolving reductions are found in this
325  * presolving round
326  *
327  * Checks whether the number of presolving rounds is not exceeded and the presolving reductions found in the current
328  * presolving round suffice to trigger another presolving round.
329  *
330  * @note if subsequent presolvers find more reductions, presolving might continue even if the method returns FALSE
331  * @note does not check whether infeasibility or unboundedness was already detected in presolving (which would result
332  * in presolving being stopped although the method returns TRUE)
333  *
334  * @return Returns TRUE if presolving is finished if no further reductions are detected
335  */
336 extern
338  SCIP* scip /**< SCIP data structure */
339  );
340 
341 /** returns whether SCIP has performed presolving during the last solve
342  *
343  * @return Returns TRUE if presolving was performed during the last solve
344  */
345 extern
347  SCIP* scip /**< SCIP data structure */
348  );
349 
350 /** returns whether the user pressed CTRL-C to interrupt the solving process
351  *
352  * @return Returns TRUE if Ctrl-C was pressed, otherwise FALSE.
353  */
354 extern
356  SCIP* scip /**< SCIP data structure */
357  );
358 
359 /** returns whether the solving process should be / was stopped before proving optimality;
360  * if the solving process should be / was stopped, the status returned by SCIPgetStatus() yields
361  * the reason for the premature abort
362  *
363  * @return Returns TRUE if solving process is stopped/interrupted, otherwise FALSE.
364  */
365 extern
367  SCIP* scip /**< SCIP data structure */
368  );
369 
370 
371 /**@} */
372 
373 
374 
375 /*
376  * message output methods
377  */
378 
379 /**@name Message Output Methods */
380 /**@{ */
381 
382 /** installs the given message handler, such that all messages are passed to this handler. A messages handler can be
383  * created via SCIPmessagehdlrCreate().
384  *
385  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
386  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
387  *
388  * @pre this method can be called in one of the following stages of the SCIP solving process:
389  * - \ref SCIP_STAGE_INIT
390  * - \ref SCIP_STAGE_PROBLEM
391  *
392  * @note The currently installed messages handler gets freed if this SCIP instance is its last user (w.r.t. capture/release).
393  */
394 extern
396  SCIP* scip, /**< SCIP data structure */
397  SCIP_MESSAGEHDLR* messagehdlr /**< message handler to install, or NULL to suppress all output */
398  );
399 
400 /** returns the currently installed message handler
401  *
402  * @return the currently installed message handler, or NULL if messages are currently suppressed
403  */
404 extern
406  SCIP* scip /**< SCIP data structure */
407  );
408 
409 /** sets the log file name for the currently installed message handler */
410 extern
412  SCIP* scip, /**< SCIP data structure */
413  const char* filename /**< name of log file, or NULL (no log) */
414  );
415 
416 /** sets the currently installed message handler to be quiet (or not) */
417 extern
419  SCIP* scip, /**< SCIP data structure */
420  SCIP_Bool quiet /**< should screen messages be suppressed? */
421  );
422 
423 /** prints a warning message via the message handler */
424 extern
425 void SCIPwarningMessage(
426  SCIP* scip, /**< SCIP data structure */
427  const char* formatstr, /**< format string like in printf() function */
428  ... /**< format arguments line in printf() function */
429  );
430 
431 /** prints a dialog message that requests user interaction or is a direct response to a user interactive command */
432 extern
433 void SCIPdialogMessage(
434  SCIP* scip, /**< SCIP data structure */
435  FILE* file, /**< file stream to print into, or NULL for stdout */
436  const char* formatstr, /**< format string like in printf() function */
437  ... /**< format arguments line in printf() function */
438  );
439 
440 /** prints a message */
441 extern
442 void SCIPinfoMessage(
443  SCIP* scip, /**< SCIP data structure */
444  FILE* file, /**< file stream to print into, or NULL for stdout */
445  const char* formatstr, /**< format string like in printf() function */
446  ... /**< format arguments line in printf() function */
447  );
448 
449 /** prints a message depending on the verbosity level */
450 extern
451 void SCIPverbMessage(
452  SCIP* scip, /**< SCIP data structure */
453  SCIP_VERBLEVEL msgverblevel, /**< verbosity level of this message */
454  FILE* file, /**< file stream to print into, or NULL for stdout */
455  const char* formatstr, /**< format string like in printf() function */
456  ... /**< format arguments line in printf() function */
457  );
458 
459 /** returns the current message verbosity level
460  *
461  * @return message verbosity level of SCIP
462  *
463  * @see \ref SCIP_VerbLevel "SCIP_VERBLEVEL" for a list of all verbosity levels
464  */
465 extern
467  SCIP* scip /**< SCIP data structure */
468  );
469 
470 
471 /**@} */
472 
473 
474 
475 
476 /*
477  * SCIP copy methods
478  */
479 
480 /**@name Copy Methods */
481 /**@{ */
482 
483 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
484  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
485  * copied SCIP instance might not represent the same problem semantics as the original.
486  * Note that in this case dual reductions might be invalid.
487  *
488  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
489  * Also, 'passmessagehdlr' should be set to FALSE.
490  * @note Do not change the source SCIP environment during the copying process
491  *
492  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
493  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
494  *
495  * @pre This method can be called if sourcescip is in one of the following stages:
496  * - \ref SCIP_STAGE_PROBLEM
497  * - \ref SCIP_STAGE_TRANSFORMED
498  * - \ref SCIP_STAGE_INITPRESOLVE
499  * - \ref SCIP_STAGE_PRESOLVING
500  * - \ref SCIP_STAGE_EXITPRESOLVE
501  * - \ref SCIP_STAGE_PRESOLVED
502  * - \ref SCIP_STAGE_INITSOLVE
503  * - \ref SCIP_STAGE_SOLVING
504  * - \ref SCIP_STAGE_SOLVED
505  *
506  * @pre This method can be called if targetscip is in one of the following stages:
507  * - \ref SCIP_STAGE_INIT
508  * - \ref SCIP_STAGE_FREE
509  *
510  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
511  * process was interrupted:
512  * - \ref SCIP_STAGE_PROBLEM
513  *
514  * @note sourcescip stage does not get changed
515  *
516  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
517  */
518 extern
520  SCIP* sourcescip, /**< source SCIP data structure */
521  SCIP* targetscip, /**< target SCIP data structure */
522  SCIP_Bool copyreaders, /**< should the file readers be copied */
523  SCIP_Bool copypricers, /**< should the variable pricers be copied */
524  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
525  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
526  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
527  SCIP_Bool copyrelaxators, /**< should the relaxation handler be copied */
528  SCIP_Bool copyseparators, /**< should the separators be copied */
529  SCIP_Bool copypropagators, /**< should the propagators be copied */
530  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
531  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
532  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
533  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
534  SCIP_Bool copydisplays, /**< should the display columns be copied */
535  SCIP_Bool copydialogs, /**< should the dialogs be copied */
536  SCIP_Bool copynlpis, /**< should the NLPIs be copied */
537  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
538  SCIP_Bool* valid /**< pointer to store whether plugins, in particular all constraint
539  * handlers which do not need constraints were validly copied */
540  );
541 
542 /** create a problem by copying the problem data of the source SCIP
543  *
544  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
545  * @note Do not change the source SCIP environment during the copying process
546  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
547  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
548  *
549  * @pre This method can be called if sourcescip is in one of the following stages:
550  * - \ref SCIP_STAGE_PROBLEM
551  * - \ref SCIP_STAGE_TRANSFORMED
552  * - \ref SCIP_STAGE_INITPRESOLVE
553  * - \ref SCIP_STAGE_PRESOLVING
554  * - \ref SCIP_STAGE_EXITPRESOLVE
555  * - \ref SCIP_STAGE_PRESOLVED
556  * - \ref SCIP_STAGE_INITSOLVE
557  * - \ref SCIP_STAGE_SOLVING
558  * - \ref SCIP_STAGE_SOLVED
559  *
560  * @pre This method can be called if targetscip is in one of the following stages:
561  * - \ref SCIP_STAGE_INIT
562  * - \ref SCIP_STAGE_FREE
563  *
564  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
565  * process was interrupted:
566  * - \ref SCIP_STAGE_PROBLEM
567  *
568  * @note sourcescip stage does not get changed
569  *
570  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
571  */
572 extern
574  SCIP* sourcescip, /**< source SCIP data structure */
575  SCIP* targetscip, /**< target SCIP data structure */
576  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
577  * target variables, or NULL */
578  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
579  * target constraints, or NULL */
580  SCIP_Bool global, /**< create a global or a local copy? */
581  const char* name /**< problem name */
582  );
583 
584 /** create a problem by copying the original problem data of the source SCIP
585  *
586  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
587  * @note Do not change the source SCIP environment during the copying process
588  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
589  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
590  *
591  * @pre This method can be called if sourcescip is in one of the following stages:
592  * - \ref SCIP_STAGE_PROBLEM
593  * - \ref SCIP_STAGE_TRANSFORMED
594  * - \ref SCIP_STAGE_INITPRESOLVE
595  * - \ref SCIP_STAGE_PRESOLVING
596  * - \ref SCIP_STAGE_EXITPRESOLVE
597  * - \ref SCIP_STAGE_PRESOLVED
598  * - \ref SCIP_STAGE_INITSOLVE
599  * - \ref SCIP_STAGE_SOLVING
600  * - \ref SCIP_STAGE_SOLVED
601  *
602  * @pre This method can be called if targetscip is in one of the following stages:
603  * - \ref SCIP_STAGE_INIT
604  * - \ref SCIP_STAGE_FREE
605  *
606  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
607  * process was interrupted:
608  * - \ref SCIP_STAGE_PROBLEM
609  *
610  * @note sourcescip stage does not get changed
611  *
612  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
613  */
614 extern
616  SCIP* sourcescip, /**< source SCIP data structure */
617  SCIP* targetscip, /**< target SCIP data structure */
618  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
619  * target variables, or NULL */
620  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
621  * target constraints, or NULL */
622  const char* name /**< problem name of target */
623  );
624 
625 /** returns copy of the source variable; if there already is a copy of the source variable in the variable hash map,
626  * it is just returned as target variable; elsewise a new variable will be created and added to the target SCIP; this
627  * created variable is added to the variable hash map and returned as target variable
628  *
629  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
630  * @note Do not change the source SCIP environment during the copying process
631  * @note if a new variable was created, this variable will be added to the target-SCIP, but it is not captured
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  *
636  * @pre This method can be called if sourcescip is in one of the following stages:
637  * - \ref SCIP_STAGE_PROBLEM
638  * - \ref SCIP_STAGE_TRANSFORMED
639  * - \ref SCIP_STAGE_INITPRESOLVE
640  * - \ref SCIP_STAGE_PRESOLVING
641  * - \ref SCIP_STAGE_EXITPRESOLVE
642  * - \ref SCIP_STAGE_PRESOLVED
643  * - \ref SCIP_STAGE_INITSOLVE
644  * - \ref SCIP_STAGE_SOLVING
645  * - \ref SCIP_STAGE_SOLVED
646  *
647  * @pre This method can be called if targetscip is in one of the following stages:
648  * - \ref SCIP_STAGE_PROBLEM
649  * - \ref SCIP_STAGE_TRANSFORMED
650  * - \ref SCIP_STAGE_INITPRESOLVE
651  * - \ref SCIP_STAGE_PRESOLVING
652  * - \ref SCIP_STAGE_EXITPRESOLVE
653  * - \ref SCIP_STAGE_SOLVING
654  *
655  * @note targetscip stage does not get changed
656  *
657  * @note sourcescip stage does not get changed
658  *
659  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
660  */
661 extern
663  SCIP* sourcescip, /**< source SCIP data structure */
664  SCIP* targetscip, /**< target SCIP data structure */
665  SCIP_VAR* sourcevar, /**< source variable */
666  SCIP_VAR** targetvar, /**< pointer to store the target variable */
667  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
668  * target variables, or NULL */
669  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
670  * target constraints, or NULL */
671  SCIP_Bool global, /**< should global or local bounds be used? */
672  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
673  );
674 
675 /** copies all active variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
676  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
677  * variables do not get copied
678  *
679  * @note the variables are added to the target-SCIP but not captured
680  *
681  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
682  * @note Do not change the source SCIP environment during the copying process
683  *
684  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
685  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
686  *
687  * @pre This method can be called if sourcescip is in one of the following stages:
688  * - \ref SCIP_STAGE_PROBLEM
689  * - \ref SCIP_STAGE_TRANSFORMED
690  * - \ref SCIP_STAGE_INITPRESOLVE
691  * - \ref SCIP_STAGE_PRESOLVING
692  * - \ref SCIP_STAGE_EXITPRESOLVE
693  * - \ref SCIP_STAGE_PRESOLVED
694  * - \ref SCIP_STAGE_INITSOLVE
695  * - \ref SCIP_STAGE_SOLVING
696  * - \ref SCIP_STAGE_SOLVED
697  *
698  * @pre This method can be called if targetscip is in one of the following stages:
699  * - \ref SCIP_STAGE_PROBLEM
700  *
701  * @note sourcescip stage does not get changed
702  *
703  * @note targetscip stage does not get changed
704  *
705  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
706  */
707 extern
709  SCIP* sourcescip, /**< source SCIP data structure */
710  SCIP* targetscip, /**< target SCIP data structure */
711  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
712  * target variables, or NULL */
713  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
714  * target constraints, or NULL */
715  SCIP_Bool global /**< should global or local bounds be used? */
716  );
717 
718 /** copies all original variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
719  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
720  * variables do not get copied
721  *
722  * @note the variables are added to the target-SCIP but not captured
723  *
724  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
725  * @note Do not change the source SCIP environment during the copying process
726  *
727  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
728  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
729  *
730  * @pre This method can be called if sourcescip is in one of the following stages:
731  * - \ref SCIP_STAGE_PROBLEM
732  * - \ref SCIP_STAGE_TRANSFORMED
733  * - \ref SCIP_STAGE_INITPRESOLVE
734  * - \ref SCIP_STAGE_PRESOLVING
735  * - \ref SCIP_STAGE_EXITPRESOLVE
736  * - \ref SCIP_STAGE_PRESOLVED
737  * - \ref SCIP_STAGE_INITSOLVE
738  * - \ref SCIP_STAGE_SOLVING
739  * - \ref SCIP_STAGE_SOLVED
740  *
741  * @pre This method can be called if targetscip is in one of the following stages:
742  * - \ref SCIP_STAGE_PROBLEM
743  *
744  * @note sourcescip stage does not get changed
745  *
746  * @note targetscip stage does not get changed
747  *
748  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
749  */
750 extern
752  SCIP* sourcescip, /**< source SCIP data structure */
753  SCIP* targetscip, /**< target SCIP data structure */
754  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
755  * target variables, or NULL */
756  SCIP_HASHMAP* consmap /**< a hashmap to store the mapping of source constraints to the corresponding
757  * target constraints, or NULL */
758  );
759 
760 /** merges the histories of variables from a source SCIP into a target SCIP. The two data structures should point to
761  * different SCIP instances.
762  *
763  * @note the notion of source and target is inverted here; \p sourcescip usually denotes a copied SCIP instance, whereas
764  * \p targetscip denotes the original instance
765  */
766 
767 extern
769  SCIP* sourcescip, /**< source SCIP data structure */
770  SCIP* targetscip, /**< target SCIP data structure */
771  SCIP_VAR** sourcevars, /**< source variables for history merge */
772  SCIP_VAR** targetvars, /**< target variables for history merge */
773  int nvars /**< number of variables in both variable arrays */
774  );
775 
776 /** returns copy of the source constraint; if there already is a copy of the source constraint in the constraint hash
777  * map, it is just returned as target constraint; elsewise a new constraint will be created; this created constraint is
778  * added to the constraint hash map and returned as target constraint; the variable map is used to map the variables of
779  * the source SCIP to the variables of the target SCIP
780  *
781  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
782  * be declared feasible even if it violates this particular constraint. This constellation should only be
783  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
784  * to the variable's local bounds.
785  *
786  * @note The constraint is not added to the target SCIP. You can check whether a constraint is added by calling
787  * SCIPconsIsAdded(). (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add
788  * explicitly and what is already added.)
789  *
790  * @note The constraint is always captured, either during the creation of the copy or after finding the copy of the
791  * constraint in the constraint hash map
792  *
793  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
794  * @note Do not change the source SCIP environment during the copying process
795  *
796  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
797  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
798  *
799  * @pre This method can be called if sourcescip is in one of the following stages:
800  * - \ref SCIP_STAGE_PROBLEM
801  * - \ref SCIP_STAGE_TRANSFORMED
802  * - \ref SCIP_STAGE_INITPRESOLVE
803  * - \ref SCIP_STAGE_PRESOLVING
804  * - \ref SCIP_STAGE_EXITPRESOLVE
805  * - \ref SCIP_STAGE_PRESOLVED
806  * - \ref SCIP_STAGE_INITSOLVE
807  * - \ref SCIP_STAGE_SOLVING
808  * - \ref SCIP_STAGE_SOLVED
809  *
810  * @pre This method can be called if targetscip is in one of the following stages:
811  * - \ref SCIP_STAGE_PROBLEM
812  * - \ref SCIP_STAGE_TRANSFORMING
813  * - \ref SCIP_STAGE_INITPRESOLVE
814  * - \ref SCIP_STAGE_PRESOLVING
815  * - \ref SCIP_STAGE_EXITPRESOLVE
816  * - \ref SCIP_STAGE_PRESOLVED
817  * - \ref SCIP_STAGE_SOLVING
818  * - \ref SCIP_STAGE_EXITSOLVE
819  *
820  * @note sourcescip stage does not get changed
821  *
822  * @note targetscip stage does not get changed
823  *
824  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
825  */
826 extern
828  SCIP* sourcescip, /**< source SCIP data structure */
829  SCIP* targetscip, /**< target SCIP data structure */
830  SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
831  SCIP_CONS** targetcons, /**< pointer to store the created target constraint */
832  SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
833  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
834  * variables of the target SCIP, or NULL */
835  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
836  * target constraints, or NULL */
837  const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
838  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
839  SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
840  SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
841  SCIP_Bool check, /**< should the constraint be checked for feasibility? */
842  SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
843  SCIP_Bool local, /**< is constraint only valid locally? */
844  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
845  SCIP_Bool dynamic, /**< is constraint subject to aging? */
846  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
847  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
848  * if it may be moved to a more global node? */
849  SCIP_Bool global, /**< create a global or a local copy? */
850  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
851  );
852 
853 /** copies constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
854  * variables between the source and the target SCIP a hash map can be given; if the variable hash
855  * map is NULL or necessary variable mapping is missing, the required variables are created in the
856  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
857  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
858  * between the constraints of the source and target-SCIP is stored
859  *
860  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
861  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
862  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
863  *
864  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
865  * @note Do not change the source SCIP environment during the copying process
866  *
867  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
868  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
869  *
870  * @pre This method can be called if sourcescip is in one of the following stages:
871  * - \ref SCIP_STAGE_PROBLEM
872  * - \ref SCIP_STAGE_TRANSFORMED
873  * - \ref SCIP_STAGE_INITPRESOLVE
874  * - \ref SCIP_STAGE_PRESOLVING
875  * - \ref SCIP_STAGE_EXITPRESOLVE
876  * - \ref SCIP_STAGE_PRESOLVED
877  * - \ref SCIP_STAGE_INITSOLVE
878  * - \ref SCIP_STAGE_SOLVING
879  * - \ref SCIP_STAGE_SOLVED
880  *
881  * @pre This method can be called if targetscip is in one of the following stages:
882  * - \ref SCIP_STAGE_PROBLEM
883  *
884  * @note sourcescip stage does not get changed
885  *
886  * @note targetscip stage does not get changed
887  *
888  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
889  */
890 extern
892  SCIP* sourcescip, /**< source SCIP data structure */
893  SCIP* targetscip, /**< target SCIP data structure */
894  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
895  * variables of the target SCIP, or NULL */
896  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
897  * target constraints, or NULL */
898  SCIP_Bool global, /**< create a global or a local copy? */
899  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
900  * If TRUE, the modifiable flag of constraints will be copied. */
901  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
902  );
903 
904 /** copies all original constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
905  * variables between the source and the target SCIP a hash map can be given; if the variable hash
906  * map is NULL or necessary variable mapping is missing, the required variables are created in the
907  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
908  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
909  * between the constraints of the source and target-SCIP is stored
910  *
911  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
912  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
913  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
914  *
915  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
916  * @note Do not change the source SCIP environment during the copying process
917  *
918  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
919  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
920  *
921  * @pre This method can be called if sourcescip is in one of the following stages:
922  * - \ref SCIP_STAGE_PROBLEM
923  * - \ref SCIP_STAGE_TRANSFORMED
924  * - \ref SCIP_STAGE_INITPRESOLVE
925  * - \ref SCIP_STAGE_PRESOLVING
926  * - \ref SCIP_STAGE_EXITPRESOLVE
927  * - \ref SCIP_STAGE_PRESOLVED
928  * - \ref SCIP_STAGE_INITSOLVE
929  * - \ref SCIP_STAGE_SOLVING
930  * - \ref SCIP_STAGE_SOLVED
931  *
932  * @pre This method can be called if targetscip is in one of the following stages:
933  * - \ref SCIP_STAGE_PROBLEM
934  *
935  * @note sourcescip stage does not get changed
936  *
937  * @note targetscip stage does not get changed
938  *
939  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
940  */
941 extern
943  SCIP* sourcescip, /**< source SCIP data structure */
944  SCIP* targetscip, /**< target SCIP data structure */
945  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
946  * variables of the target SCIP, or NULL */
947  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
948  * target constraints, or NULL */
949  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
950  * If TRUE, the modifiable flag of constraints will be copied. */
951  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
952  );
953 
954 /** convert all active cuts from cutpool to linear constraints
955  *
956  * @note Do not change the source SCIP environment during the copying process
957  *
958  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
959  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
960  *
961  * @pre This method can be called if SCIP is in one of the following stages:
962  * - \ref SCIP_STAGE_PROBLEM
963  * - \ref SCIP_STAGE_INITPRESOLVE
964  * - \ref SCIP_STAGE_PRESOLVING
965  * - \ref SCIP_STAGE_EXITPRESOLVE
966  * - \ref SCIP_STAGE_PRESOLVED
967  * - \ref SCIP_STAGE_SOLVING
968  * - \ref SCIP_STAGE_EXITSOLVE
969  *
970  * @note SCIP stage does not get changed
971  *
972  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
973  */
974 extern
976  SCIP* scip, /**< SCIP data structure */
977  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
978  * target variables, or NULL */
979  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
980  * target constraints, or NULL */
981  SCIP_Bool global, /**< create a global or a local copy? */
982  int* ncutsadded /**< pointer to store number of added cuts, or NULL */
983  );
984 
985 /** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip
986  *
987  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
988  * @note Do not change the source SCIP environment during the copying process
989  *
990  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
991  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
992  *
993  * @pre This method can be called if sourcescip is in one of the following stages:
994  * - \ref SCIP_STAGE_PROBLEM
995  * - \ref SCIP_STAGE_TRANSFORMED
996  * - \ref SCIP_STAGE_INITPRESOLVE
997  * - \ref SCIP_STAGE_PRESOLVING
998  * - \ref SCIP_STAGE_EXITPRESOLVE
999  * - \ref SCIP_STAGE_PRESOLVED
1000  * - \ref SCIP_STAGE_SOLVING
1001  * - \ref SCIP_STAGE_SOLVED
1002  * - \ref SCIP_STAGE_EXITSOLVE
1003  *
1004  * @pre This method can be called if targetscip is in one of the following stages:
1005  * - \ref SCIP_STAGE_PROBLEM
1006  * - \ref SCIP_STAGE_INITPRESOLVE
1007  * - \ref SCIP_STAGE_PRESOLVING
1008  * - \ref SCIP_STAGE_EXITPRESOLVE
1009  * - \ref SCIP_STAGE_PRESOLVED
1010  * - \ref SCIP_STAGE_SOLVING
1011  * - \ref SCIP_STAGE_EXITSOLVE
1012  *
1013  * @note sourcescip stage does not get changed
1014  *
1015  * @note targetscip stage does not get changed
1016  *
1017  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1018  */
1019 extern
1021  SCIP* sourcescip, /**< source SCIP data structure */
1022  SCIP* targetscip, /**< target SCIP data structure */
1023  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1024  * target variables, or NULL */
1025  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1026  * target constraints, or NULL */
1027  SCIP_Bool global, /**< create a global or a local copy? */
1028  int* ncutsadded /**< pointer to store number of copied cuts, or NULL */
1029  );
1030 
1031 /** copies implications and cliques of sourcescip to targetscip
1032  *
1033  * This function should be called for a targetscip in transformed stage. It can save time in presolving of the
1034  * targetscip, since implications and cliques are copied.
1035  *
1036  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1037  * @note Do not change the source SCIP environment during the copying process
1038  *
1039  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1040  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1041  *
1042  * @pre This method can be called if sourcescip is in one of the following stages:
1043  * - \ref SCIP_STAGE_TRANSFORMED
1044  * - \ref SCIP_STAGE_INITPRESOLVE
1045  * - \ref SCIP_STAGE_PRESOLVING
1046  * - \ref SCIP_STAGE_EXITPRESOLVE
1047  * - \ref SCIP_STAGE_PRESOLVED
1048  * - \ref SCIP_STAGE_SOLVING
1049  * - \ref SCIP_STAGE_SOLVED
1050  * - \ref SCIP_STAGE_EXITSOLVE
1051  *
1052  * @pre This method can be called if targetscip is in one of the following stages:
1053  * - \ref SCIP_STAGE_TRANSFORMED
1054  * - \ref SCIP_STAGE_INITPRESOLVE
1055  * - \ref SCIP_STAGE_PRESOLVING
1056  * - \ref SCIP_STAGE_EXITPRESOLVE
1057  * - \ref SCIP_STAGE_PRESOLVED
1058  * - \ref SCIP_STAGE_INITSOLVE
1059  * - \ref SCIP_STAGE_SOLVING
1060  *
1061  * @note sourcescip stage does not get changed
1062  *
1063  * @note targetscip stage does not get changed
1064  *
1065  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1066  */
1067 extern
1069  SCIP* sourcescip, /**< source SCIP data structure */
1070  SCIP* targetscip, /**< target SCIP data structure */
1071  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1072  * target variables, or NULL */
1073  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1074  * target constraints, or NULL */
1075  SCIP_Bool global, /**< create a global or a local copy? */
1076  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1077  int* nbdchgs, /**< pointer to store the number of performed bound changes, or NULL */
1078  int* ncopied /**< pointer to store number of copied implications and cliques, or NULL */
1079  );
1080 
1081 /** copies parameter settings from sourcescip to targetscip
1082  *
1083  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1084  * @note Do not change the source SCIP environment during the copying process
1085  *
1086  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1087  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1088  *
1089  * @pre This method can be called if sourcescip is in one of the following stages:
1090  * - \ref SCIP_STAGE_PROBLEM
1091  * - \ref SCIP_STAGE_TRANSFORMED
1092  * - \ref SCIP_STAGE_INITPRESOLVE
1093  * - \ref SCIP_STAGE_PRESOLVING
1094  * - \ref SCIP_STAGE_EXITPRESOLVE
1095  * - \ref SCIP_STAGE_PRESOLVED
1096  * - \ref SCIP_STAGE_INITSOLVE
1097  * - \ref SCIP_STAGE_SOLVING
1098  * - \ref SCIP_STAGE_SOLVED
1099  *
1100  * @pre This method can be called if targetscip is in one of the following stages:
1101  * - \ref SCIP_STAGE_INIT
1102  * - \ref SCIP_STAGE_PROBLEM
1103  * - \ref SCIP_STAGE_FREE
1104  *
1105  * @note sourcescip stage does not get changed
1106  *
1107  * @note targetscip stage does not get changed
1108  *
1109  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1110  */
1111 extern
1113  SCIP* sourcescip, /**< source SCIP data structure */
1114  SCIP* targetscip /**< target SCIP data structure */
1115  );
1116 
1117 /** gets depth of current scip instance (increased by each copy call)
1118  *
1119  * @return Depth of subscip of SCIP is returned.
1120  *
1121  * @pre This method can be called if SCIP is in one of the following stages:
1122  * - \ref SCIP_STAGE_PROBLEM
1123  * - \ref SCIP_STAGE_TRANSFORMING
1124  * - \ref SCIP_STAGE_TRANSFORMED
1125  * - \ref SCIP_STAGE_INITPRESOLVE
1126  * - \ref SCIP_STAGE_PRESOLVING
1127  * - \ref SCIP_STAGE_EXITPRESOLVE
1128  * - \ref SCIP_STAGE_PRESOLVED
1129  * - \ref SCIP_STAGE_INITSOLVE
1130  * - \ref SCIP_STAGE_SOLVING
1131  * - \ref SCIP_STAGE_SOLVED
1132  * - \ref SCIP_STAGE_EXITSOLVE
1133  * - \ref SCIP_STAGE_FREETRANS
1134  *
1135  * @note SCIP stage does not get changed
1136  *
1137  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1138  */
1139 extern
1141  SCIP* scip /**< SCIP data structure */
1142  );
1143 
1144 /** copies source SCIP to target SCIP; the copying process is done in the following order:
1145  * 1) copy the plugins
1146  * 2) copy the settings
1147  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1148  * 4) copy all active variables
1149  * 5) copy all constraints
1150  *
1151  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1152  *
1153  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1154  * Also, 'passmessagehdlr' should be set to FALSE.
1155  * @note Do not change the source SCIP environment during the copying process
1156  *
1157  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1158  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1159  *
1160  * @pre This method can be called if sourcescip is in one of the following stages:
1161  * - \ref SCIP_STAGE_PROBLEM
1162  * - \ref SCIP_STAGE_TRANSFORMED
1163  * - \ref SCIP_STAGE_INITPRESOLVE
1164  * - \ref SCIP_STAGE_PRESOLVING
1165  * - \ref SCIP_STAGE_EXITPRESOLVE
1166  * - \ref SCIP_STAGE_PRESOLVED
1167  * - \ref SCIP_STAGE_INITSOLVE
1168  * - \ref SCIP_STAGE_SOLVING
1169  * - \ref SCIP_STAGE_SOLVED
1170  *
1171  * @pre This method can be called if targetscip is in one of the following stages:
1172  * - \ref SCIP_STAGE_INIT
1173  * - \ref SCIP_STAGE_FREE
1174  *
1175  * @note sourcescip stage does not get changed
1176  *
1177  * @note targetscip stage does not get changed
1178  *
1179  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1180  */
1181 extern
1183  SCIP* sourcescip, /**< source SCIP data structure */
1184  SCIP* targetscip, /**< target SCIP data structure */
1185  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1186  * target variables, or NULL */
1187  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1188  * target constraints, or NULL */
1189  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1190  SCIP_Bool global, /**< create a global or a local copy? */
1191  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1192  * plugins will be copied and activated, and the modifiable flag of
1193  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1194  * there are pricers present */
1195  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1196  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
1197  );
1198 
1199 /** copies source SCIP original problem to target SCIP; the copying process is done in the following order:
1200  * 1) copy the plugins
1201  * 2) copy the settings
1202  * 3) create problem data in target-SCIP and copy the original problem data of the source-SCIP
1203  * 4) copy all original variables
1204  * 5) copy all original constraints
1205  *
1206  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1207  *
1208  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1209  * Also, 'passmessagehdlr' should be set to FALSE.
1210  * @note Do not change the source SCIP environment during the copying process
1211  *
1212  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1213  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1214  *
1215  * @pre This method can be called if sourcescip is in one of the following stages:
1216  * - \ref SCIP_STAGE_PROBLEM
1217  * - \ref SCIP_STAGE_TRANSFORMED
1218  * - \ref SCIP_STAGE_INITPRESOLVE
1219  * - \ref SCIP_STAGE_PRESOLVING
1220  * - \ref SCIP_STAGE_EXITPRESOLVE
1221  * - \ref SCIP_STAGE_PRESOLVED
1222  * - \ref SCIP_STAGE_INITSOLVE
1223  * - \ref SCIP_STAGE_SOLVING
1224  * - \ref SCIP_STAGE_SOLVED
1225  *
1226  * @pre This method can be called if targetscip is in one of the following stages:
1227  * - \ref SCIP_STAGE_INIT
1228  * - \ref SCIP_STAGE_FREE
1229  *
1230  * @note sourcescip stage does not get changed
1231  *
1232  * @note targetscip stage does not get changed
1233  *
1234  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1235  */
1236 extern
1238  SCIP* sourcescip, /**< source SCIP data structure */
1239  SCIP* targetscip, /**< target SCIP data structure */
1240  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1241  * target variables, or NULL */
1242  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1243  * target constraints, or NULL */
1244  const char* suffix, /**< suffix which will be added to the names of the target SCIP, might be empty */
1245  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1246  * plugins will be copied and activated, and the modifiable flag of
1247  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1248  * there are pricers present */
1249  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1250  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
1251  );
1252 
1253 /**@} */
1254 
1255 /*
1256  * parameter settings
1257  */
1258 
1259 /**@name Parameter Methods */
1260 /**@{ */
1261 
1262 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
1263  *
1264  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1265  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1266  */
1267 extern
1269  SCIP* scip, /**< SCIP data structure */
1270  const char* name, /**< name of the parameter */
1271  const char* desc, /**< description of the parameter */
1272  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
1273  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1274  SCIP_Bool defaultvalue, /**< default value of the parameter */
1275  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1276  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1277  );
1278 
1279 /** creates a int parameter, sets it to its default value, and adds it to the parameter set
1280  *
1281  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1282  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1283  */
1284 extern
1286  SCIP* scip, /**< SCIP data structure */
1287  const char* name, /**< name of the parameter */
1288  const char* desc, /**< description of the parameter */
1289  int* valueptr, /**< pointer to store the current parameter value, or NULL */
1290  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1291  int defaultvalue, /**< default value of the parameter */
1292  int minvalue, /**< minimum value for parameter */
1293  int maxvalue, /**< maximum value for parameter */
1294  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1295  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1296  );
1297 
1298 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
1299  *
1300  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1301  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1302  */
1303 extern
1305  SCIP* scip, /**< SCIP data structure */
1306  const char* name, /**< name of the parameter */
1307  const char* desc, /**< description of the parameter */
1308  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
1309  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1310  SCIP_Longint defaultvalue, /**< default value of the parameter */
1311  SCIP_Longint minvalue, /**< minimum value for parameter */
1312  SCIP_Longint maxvalue, /**< maximum value for parameter */
1313  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1314  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1315  );
1316 
1317 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
1318  *
1319  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1320  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1321  */
1322 extern
1324  SCIP* scip, /**< SCIP data structure */
1325  const char* name, /**< name of the parameter */
1326  const char* desc, /**< description of the parameter */
1327  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
1328  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1329  SCIP_Real defaultvalue, /**< default value of the parameter */
1330  SCIP_Real minvalue, /**< minimum value for parameter */
1331  SCIP_Real maxvalue, /**< maximum value for parameter */
1332  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1333  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1334  );
1335 
1336 /** creates a char parameter, sets it to its default value, and adds it to the parameter set
1337  *
1338  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1339  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1340  */
1341 extern
1343  SCIP* scip, /**< SCIP data structure */
1344  const char* name, /**< name of the parameter */
1345  const char* desc, /**< description of the parameter */
1346  char* valueptr, /**< pointer to store the current parameter value, or NULL */
1347  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1348  char defaultvalue, /**< default value of the parameter */
1349  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
1350  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1351  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1352  );
1353 
1354 /** creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
1355  *
1356  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1357  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1358  */
1359 extern
1361  SCIP* scip, /**< SCIP data structure */
1362  const char* name, /**< name of the parameter */
1363  const char* desc, /**< description of the parameter */
1364  char** valueptr, /**< pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL */
1365  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1366  const char* defaultvalue, /**< default value of the parameter */
1367  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1368  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1369  );
1370 
1371 /** gets the fixing status of an existing parameter
1372  *
1373  * @return TRUE if the parameter is fixed to a value, otherwise FALSE.
1374  */
1375 extern
1377  SCIP* scip, /**< SCIP data structure */
1378  const char* name /**< name of the parameter */
1379  );
1380 
1381 /** returns the pointer to the SCIP parameter with the given name
1382  *
1383  * @return pointer to the parameter with the given name
1384  */
1385 extern
1387  SCIP* scip, /**< SCIP data structure */
1388  const char* name /**< name of the parameter */
1389  );
1390 
1391 /** gets the value of an existing SCIP_Bool parameter
1392  *
1393  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1394  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1395  */
1396 extern
1398  SCIP* scip, /**< SCIP data structure */
1399  const char* name, /**< name of the parameter */
1400  SCIP_Bool* value /**< pointer to store the parameter */
1401  );
1402 
1403 /** gets the value of an existing int parameter
1404  *
1405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1407  */
1408 extern
1410  SCIP* scip, /**< SCIP data structure */
1411  const char* name, /**< name of the parameter */
1412  int* value /**< pointer to store the parameter */
1413  );
1414 
1415 /** gets the value of an existing SCIP_Longint parameter
1416  *
1417  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1418  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1419  */
1420 extern
1422  SCIP* scip, /**< SCIP data structure */
1423  const char* name, /**< name of the parameter */
1424  SCIP_Longint* value /**< pointer to store the parameter */
1425  );
1426 
1427 /** gets the value of an existing SCIP_Real parameter
1428  *
1429  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1430  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1431  */
1432 extern
1434  SCIP* scip, /**< SCIP data structure */
1435  const char* name, /**< name of the parameter */
1436  SCIP_Real* value /**< pointer to store the parameter */
1437  );
1438 
1439 /** gets the value of an existing char parameter
1440  *
1441  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1442  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1443  */
1444 extern
1446  SCIP* scip, /**< SCIP data structure */
1447  const char* name, /**< name of the parameter */
1448  char* value /**< pointer to store the parameter */
1449  );
1450 
1451 /** gets the value of an existing string(char*) parameter
1452  *
1453  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1454  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1455  */
1456 extern
1458  SCIP* scip, /**< SCIP data structure */
1459  const char* name, /**< name of the parameter */
1460  char** value /**< pointer to store the parameter */
1461  );
1462 
1463 /** fixes the value of an existing parameter
1464  *
1465  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1466  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1467  *
1468  * @note: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because
1469  * they have to be changed for sub-SCIPs.
1470  */
1471 extern
1473  SCIP* scip, /**< SCIP data structure */
1474  const char* name /**< name of the parameter */
1475  );
1476 
1477 /** unfixes the value of an existing parameter
1478  *
1479  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1480  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1481  */
1482 extern
1484  SCIP* scip, /**< SCIP data structure */
1485  const char* name /**< name of the parameter */
1486  );
1487 
1488 /** changes the value of an existing parameter
1489  *
1490  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1491  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1492  */
1493 extern
1495  SCIP* scip, /**< SCIP data structure */
1496  const char* name, /**< name of the parameter */
1497  void* value /**< new value of the parameter */
1498  );
1499 
1500 /** changes the value of an existing SCIP_Bool parameter
1501  *
1502  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1503  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1504  */
1505 extern
1507  SCIP* scip, /**< SCIP data structure */
1508  SCIP_PARAM* param, /**< parameter */
1509  SCIP_Bool value /**< new value of the parameter */
1510  );
1511 
1512 /** changes the value of an existing SCIP_Bool parameter
1513  *
1514  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1515  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1516  */
1517 extern
1519  SCIP* scip, /**< SCIP data structure */
1520  const char* name, /**< name of the parameter */
1521  SCIP_Bool value /**< new value of the parameter */
1522  );
1523 
1524 /** checks the value of an existing SCIP_Bool parameter; issues a warning message if value was invalid
1525  *
1526  * @return \ref SCIP_OKAY is returned if value is valid. Otherwise \ref SCIP_PARAMETERWRONGVAL is returned.
1527  */
1528 extern
1530  SCIP* scip, /**< SCIP data structure */
1531  SCIP_PARAM* param, /**< parameter */
1532  SCIP_Bool value /**< value to check */
1533  );
1534 
1535 /** changes the value of an existing int parameter
1536  *
1537  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1538  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1539  */
1540 extern
1542  SCIP* scip, /**< SCIP data structure */
1543  SCIP_PARAM* param, /**< parameter */
1544  int value /**< new value of the parameter */
1545  );
1546 
1547 /** changes the value of an existing int parameter
1548  *
1549  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1550  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1551  */
1552 extern
1554  SCIP* scip, /**< SCIP data structure */
1555  const char* name, /**< name of the parameter */
1556  int value /**< new value of the parameter */
1557  );
1558 
1559 /** changes the value of an existing SCIP_Longint parameter
1560  *
1561  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1562  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1563  */
1564 extern
1566  SCIP* scip, /**< SCIP data structure */
1567  SCIP_PARAM* param, /**< parameter */
1568  SCIP_Longint value /**< new value of the parameter */
1569  );
1570 
1571 /** changes the value of an existing SCIP_Longint parameter
1572  *
1573  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1574  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1575  */
1576 extern
1578  SCIP* scip, /**< SCIP data structure */
1579  const char* name, /**< name of the parameter */
1580  SCIP_Longint value /**< new value of the parameter */
1581  );
1582 
1583 /** checks parameter value according to the given feasible domain; issues a warning message if value was invalid
1584  *
1585  * @return \ref SCIP_OKAY is returned if value is valid. Otherwise \ref SCIP_PARAMETERWRONGVAL is returned.
1586  */
1587 extern
1589  SCIP* scip, /**< SCIP data structure */
1590  SCIP_PARAM* param, /**< parameter */
1591  SCIP_Longint value /**< value to check */
1592  );
1593 
1594 /** changes the value of an existing SCIP_Real parameter
1595  *
1596  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1597  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1598  */
1599 extern
1601  SCIP* scip, /**< SCIP data structure */
1602  SCIP_PARAM* param, /**< parameter */
1603  SCIP_Real value /**< new value of the parameter */
1604  );
1605 
1606 /** changes the value of an existing SCIP_Real parameter
1607  *
1608  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1609  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1610  */
1611 extern
1613  SCIP* scip, /**< SCIP data structure */
1614  const char* name, /**< name of the parameter */
1615  SCIP_Real value /**< new value of the parameter */
1616  );
1617 
1618 /** changes the value of an existing char parameter
1619  *
1620  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1621  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1622  */
1623 extern
1625  SCIP* scip, /**< SCIP data structure */
1626  SCIP_PARAM* param, /**< parameter */
1627  char value /**< new value of the parameter */
1628  );
1629 
1630 /** changes the value of an existing char parameter
1631  *
1632  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1633  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1634  */
1635 extern
1637  SCIP* scip, /**< SCIP data structure */
1638  const char* name, /**< name of the parameter */
1639  char value /**< new value of the parameter */
1640  );
1641 
1642 /** checks parameter value according to the given feasible domain; issues a warning message if value was invalid
1643  *
1644  * @return \ref SCIP_OKAY is returned if value is valid. Otherwise \ref SCIP_PARAMETERWRONGVAL is returned.
1645  */
1646 extern
1648  SCIP* scip, /**< SCIP data structure */
1649  SCIP_PARAM* param, /**< parameter */
1650  const char value /**< value to check */
1651  );
1652 
1653 /** changes the value of an existing string(char*) parameter
1654  *
1655  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1656  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1657  */
1658 extern
1660  SCIP* scip, /**< SCIP data structure */
1661  SCIP_PARAM* param, /**< parameter */
1662  const char* value /**< new value of the parameter */
1663  );
1664 
1665 /** changes the value of an existing string(char*) parameter
1666  *
1667  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1668  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1669  */
1670 extern
1672  SCIP* scip, /**< SCIP data structure */
1673  const char* name, /**< name of the parameter */
1674  const char* value /**< new value of the parameter */
1675  );
1676 
1677 /** checks parameter value according to the given feasible domain; issues a warning message if value was invalid
1678  *
1679  * @return \ref SCIP_OKAY is returned if value is valid. Otherwise \ref SCIP_PARAMETERWRONGVAL is returned.
1680  */
1681 extern
1683  SCIP* scip, /**< SCIP data structure */
1684  SCIP_PARAM* param, /**< parameter */
1685  const char* value /**< value to check */
1686  );
1687 
1688 /** reads parameters from a file
1689  *
1690  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1691  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1692  */
1693 extern
1695  SCIP* scip, /**< SCIP data structure */
1696  const char* filename /**< file name */
1697  );
1698 
1699 /** writes a single parameter to a file
1700  *
1701  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1702  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1703  */
1704 extern
1706  SCIP* scip, /**< SCIP data structure */
1707  SCIP_PARAM* param, /**< parameter */
1708  const char* filename, /**< file name, or NULL for stdout */
1709  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
1710  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
1711  * default value?
1712  */
1713  );
1714 
1715 /** writes all parameters in the parameter set to a file
1716  *
1717  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1718  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1719  */
1720 extern
1722  SCIP* scip, /**< SCIP data structure */
1723  const char* filename, /**< file name, or NULL for stdout */
1724  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
1725  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
1726  * default value?
1727  */
1728  );
1729 
1730 /** resets a single parameter to its default value
1731  *
1732  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1733  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1734  */
1735 extern
1737  SCIP* scip, /**< SCIP data structure */
1738  const char* name /**< name of the parameter */
1739  );
1740 
1741 /** resets all parameters to their default values
1742  *
1743  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1744  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1745  */
1746 extern
1748  SCIP* scip /**< SCIP data structure */
1749  );
1750 
1751 /** sets parameters to
1752  *
1753  * - SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
1754  * - SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
1755  * - SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
1756  * - SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
1757  * - SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
1758  * - SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
1759  * - SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
1760  *
1761  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1762  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1763  */
1764 extern
1766  SCIP* scip, /**< SCIP data structure */
1767  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
1768  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1769  );
1770 
1771 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
1772  * auxiliary SCIP instances to avoid recursion
1773  *
1774  * @note only deactivates plugins which could cause recursion, some plugins which use sub-SCIPs stay activated
1775  *
1776  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1777  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1778  */
1779 extern
1781  SCIP* scip, /**< (auxiliary) SCIP data structure */
1782  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1783  );
1784 
1785 /** sets heuristic parameters values to
1786  *
1787  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
1788  * - SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
1789  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
1790  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
1791  *
1792  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1793  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1794  */
1795 extern
1797  SCIP* scip, /**< SCIP data structure */
1798  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1799  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1800  );
1801 
1802 /** sets presolving parameters to
1803  *
1804  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
1805  * - SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
1806  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
1807  * - SCIP_PARAMSETTING_OFF which turn off all presolving
1808  *
1809  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1810  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1811  */
1812 extern
1814  SCIP* scip, /**< SCIP data structure */
1815  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1816  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1817  );
1818 
1819 /** sets separating parameters to
1820  *
1821  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
1822  * - SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
1823  * - SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
1824  * - SCIP_PARAMSETTING_OFF which turn off all separating
1825  *
1826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1828  */
1829 extern
1831  SCIP* scip, /**< SCIP data structure */
1832  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1833  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1834  );
1835 
1836 /** returns the array of all available SCIP parameters
1837  *
1838  * @return SCIP_PARAM* array, containing all SCIP parameters.
1839  */
1840 extern
1842  SCIP* scip /**< SCIP data structure */
1843  );
1844 
1845 /** returns the total number of all available SCIP parameters
1846  *
1847  * @return number of all SCIP parameters.
1848  */
1849 extern
1850 int SCIPgetNParams(
1851  SCIP* scip /**< SCIP data structure */
1852  );
1853 
1854 /**@} */
1855 
1856 
1857 /*
1858  * SCIP user functionality methods: managing plugins
1859  */
1860 
1861 /**@name SCIP User Functionality Methods: Managing Plugins */
1862 /**@{ */
1863 
1864 /** creates a reader and includes it in SCIP
1865  *
1866  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1867  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1868  *
1869  * @pre This method can be called if SCIP is in one of the following stages:
1870  * - \ref SCIP_STAGE_INIT
1871  * - \ref SCIP_STAGE_PROBLEM
1872  *
1873  * @note method has all reader callbacks as arguments and is thus changed every time a new callback is added
1874  * in future releases; consider using SCIPincludeReaderBasic() and setter functions
1875  * if you seek for a method which is less likely to change in future releases
1876  */
1877 extern
1879  SCIP* scip, /**< SCIP data structure */
1880  const char* name, /**< name of reader */
1881  const char* desc, /**< description of reader */
1882  const char* extension, /**< file extension that reader processes */
1883  SCIP_DECL_READERCOPY ((*readercopy)), /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
1884  SCIP_DECL_READERFREE ((*readerfree)), /**< destructor of reader */
1885  SCIP_DECL_READERREAD ((*readerread)), /**< read method */
1886  SCIP_DECL_READERWRITE ((*readerwrite)), /**< write method */
1887  SCIP_READERDATA* readerdata /**< reader data */
1888  );
1889 
1890 /** creates a reader and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
1891  * Optional callbacks can be set via specific setter functions, see
1892  * SCIPsetReaderCopy(), SCIPsetReaderFree(), SCIPsetReaderRead(), SCIPsetReaderWrite().
1893  *
1894  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1895  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1896  *
1897  * @pre This method can be called if SCIP is in one of the following stages:
1898  * - \ref SCIP_STAGE_INIT
1899  * - \ref SCIP_STAGE_PROBLEM
1900  *
1901  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeReader() instead
1902  */
1903 extern
1905  SCIP* scip, /**< SCIP data structure */
1906  SCIP_READER** readerptr, /**< reference to reader pointer, or NULL */
1907  const char* name, /**< name of reader */
1908  const char* desc, /**< description of reader */
1909  const char* extension, /**< file extension that reader processes */
1910  SCIP_READERDATA* readerdata /**< reader data */
1911  );
1912 
1913 /** set copy method of reader
1914  *
1915  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1916  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1917  *
1918  * @pre This method can be called if SCIP is in one of the following stages:
1919  * - \ref SCIP_STAGE_INIT
1920  * - \ref SCIP_STAGE_PROBLEM
1921  */
1922 extern
1924  SCIP* scip, /**< SCIP data structure */
1925  SCIP_READER* reader, /**< reader */
1926  SCIP_DECL_READERCOPY ((*readercopy)) /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
1927  );
1928 
1929 /** set deinitialization method of reader
1930  *
1931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1933  *
1934  * @pre This method can be called if SCIP is in one of the following stages:
1935  * - \ref SCIP_STAGE_INIT
1936  * - \ref SCIP_STAGE_PROBLEM
1937  */
1938 extern
1940  SCIP* scip, /**< SCIP data structure */
1941  SCIP_READER* reader, /**< reader */
1942  SCIP_DECL_READERFREE ((*readerfree)) /**< destructor of reader */
1943  );
1944 
1945 /** set read method of reader
1946  *
1947  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1948  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1949  *
1950  * @pre This method can be called if SCIP is in one of the following stages:
1951  * - \ref SCIP_STAGE_INIT
1952  * - \ref SCIP_STAGE_PROBLEM
1953  */
1954 extern
1956  SCIP* scip, /**< SCIP data structure */
1957  SCIP_READER* reader, /**< reader */
1958  SCIP_DECL_READERREAD ((*readerread)) /**< read method of reader */
1959  );
1960 
1961 /** set write method of reader
1962  *
1963  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1964  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1965  *
1966  * @pre This method can be called if SCIP is in one of the following stages:
1967  * - \ref SCIP_STAGE_INIT
1968  * - \ref SCIP_STAGE_PROBLEM
1969  */
1970 extern
1972  SCIP* scip, /**< SCIP data structure */
1973  SCIP_READER* reader, /**< reader */
1974  SCIP_DECL_READERWRITE ((*readerwrite)) /**< write method of reader */
1975  );
1976 
1977 /** returns the reader of the given name, or NULL if not existing */
1978 extern
1980  SCIP* scip, /**< SCIP data structure */
1981  const char* name /**< name of reader */
1982  );
1983 
1984 /** returns the array of currently available readers */
1985 extern
1987  SCIP* scip /**< SCIP data structure */
1988  );
1989 
1990 /** returns the number of currently available readers */
1991 extern
1992 int SCIPgetNReaders(
1993  SCIP* scip /**< SCIP data structure */
1994  );
1995 
1996 /** creates a variable pricer and includes it in SCIP
1997  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
1998  * This should be done during the problem creation stage.
1999  *
2000  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2001  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2002  *
2003  * @pre This method can be called if SCIP is in one of the following stages:
2004  * - \ref SCIP_STAGE_INIT
2005  * - \ref SCIP_STAGE_PROBLEM
2006  *
2007  * @note method has all pricer callbacks as arguments and is thus changed every time a new callback is added
2008  * in future releases; consider using SCIPincludePricerBasic() and setter functions
2009  * if you seek for a method which is less likely to change in future releases
2010  */
2011 extern
2013  SCIP* scip, /**< SCIP data structure */
2014  const char* name, /**< name of variable pricer */
2015  const char* desc, /**< description of variable pricer */
2016  int priority, /**< priority of the variable pricer */
2017  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2018  * problem variables with negative reduced costs are found?
2019  * if this is set to FALSE it may happen that the pricer produces columns
2020  * that already exist in the problem (which are also priced in by the
2021  * default problem variable pricing in the same round) */
2022  SCIP_DECL_PRICERCOPY ((*pricercopy)), /**< copy method of variable pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2023  SCIP_DECL_PRICERFREE ((*pricerfree)), /**< destructor of variable pricer */
2024  SCIP_DECL_PRICERINIT ((*pricerinit)), /**< initialize variable pricer */
2025  SCIP_DECL_PRICEREXIT ((*pricerexit)), /**< deinitialize variable pricer */
2026  SCIP_DECL_PRICERINITSOL((*pricerinitsol)),/**< solving process initialization method of variable pricer */
2027  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)),/**< solving process deinitialization method of variable pricer */
2028  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2029  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2030  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2031  );
2032 
2033 /** creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL;
2034  * if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(),
2035  * SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(),
2036  * SCIPsetPricerFarkas();
2037  *
2038  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2039  * This should be done during the problem creation stage.
2040  *
2041  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2042  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2043  *
2044  * @pre This method can be called if SCIP is in one of the following stages:
2045  * - \ref SCIP_STAGE_INIT
2046  * - \ref SCIP_STAGE_PROBLEM
2047  *
2048  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePricer() instead
2049  */
2050 extern
2052  SCIP* scip, /**< SCIP data structure */
2053  SCIP_PRICER** pricerptr, /**< reference to a pricer, or NULL */
2054  const char* name, /**< name of variable pricer */
2055  const char* desc, /**< description of variable pricer */
2056  int priority, /**< priority of the variable pricer */
2057  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2058  * problem variables with negative reduced costs are found?
2059  * if this is set to FALSE it may happen that the pricer produces columns
2060  * that already exist in the problem (which are also priced in by the
2061  * default problem variable pricing in the same round) */
2062  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2063  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2064  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2065  );
2066 
2067 /** sets copy method of pricer
2068  *
2069  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2070  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2071  *
2072  * @pre This method can be called if SCIP is in one of the following stages:
2073  * - \ref SCIP_STAGE_INIT
2074  * - \ref SCIP_STAGE_PROBLEM
2075  */
2076 extern
2078  SCIP* scip, /**< SCIP data structure */
2079  SCIP_PRICER* pricer, /**< pricer */
2080  SCIP_DECL_PRICERCOPY ((*pricercopy)) /**< copy method of pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2081  );
2082 
2083 /** sets destructor method of pricer
2084  *
2085  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2086  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2087  *
2088  * @pre This method can be called if SCIP is in one of the following stages:
2089  * - \ref SCIP_STAGE_INIT
2090  * - \ref SCIP_STAGE_PROBLEM
2091  */
2092 extern
2094  SCIP* scip, /**< SCIP data structure */
2095  SCIP_PRICER* pricer, /**< pricer */
2096  SCIP_DECL_PRICERFREE ((*pricerfree)) /**< destructor of pricer */
2097  );
2098 
2099 /** sets initialization method of pricer
2100  *
2101  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2102  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2103  *
2104  * @pre This method can be called if SCIP is in one of the following stages:
2105  * - \ref SCIP_STAGE_INIT
2106  * - \ref SCIP_STAGE_PROBLEM
2107  */
2108 extern
2110  SCIP* scip, /**< SCIP data structure */
2111  SCIP_PRICER* pricer, /**< pricer */
2112  SCIP_DECL_PRICERINIT ((*pricerinit)) /**< initialize pricer */
2113  );
2114 
2115 /** sets deinitialization method of pricer
2116  *
2117  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2118  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2119  *
2120  * @pre This method can be called if SCIP is in one of the following stages:
2121  * - \ref SCIP_STAGE_INIT
2122  * - \ref SCIP_STAGE_PROBLEM
2123  */
2124 extern
2126  SCIP* scip, /**< SCIP data structure */
2127  SCIP_PRICER* pricer, /**< pricer */
2128  SCIP_DECL_PRICEREXIT ((*pricerexit)) /**< deinitialize pricer */
2129  );
2130 
2131 /** sets solving process initialization method of pricer
2132  *
2133  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2134  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2135  *
2136  * @pre This method can be called if SCIP is in one of the following stages:
2137  * - \ref SCIP_STAGE_INIT
2138  * - \ref SCIP_STAGE_PROBLEM
2139  */
2140 extern
2142  SCIP* scip, /**< SCIP data structure */
2143  SCIP_PRICER* pricer, /**< pricer */
2144  SCIP_DECL_PRICERINITSOL ((*pricerinitsol))/**< solving process initialization method of pricer */
2145  );
2146 
2147 /** sets solving process deinitialization method of pricer
2148  *
2149  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2150  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2151  *
2152  * @pre This method can be called if SCIP is in one of the following stages:
2153  * - \ref SCIP_STAGE_INIT
2154  * - \ref SCIP_STAGE_PROBLEM
2155  */
2156 extern
2158  SCIP* scip, /**< SCIP data structure */
2159  SCIP_PRICER* pricer, /**< pricer */
2160  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)) /**< solving process deinitialization method of pricer */
2161  );
2162 
2163 /** returns the variable pricer of the given name, or NULL if not existing */
2164 extern
2166  SCIP* scip, /**< SCIP data structure */
2167  const char* name /**< name of variable pricer */
2168  );
2169 
2170 /** returns the array of currently available variable pricers; active pricers are in the first slots of the array */
2171 extern
2173  SCIP* scip /**< SCIP data structure */
2174  );
2175 
2176 /** returns the number of currently available variable pricers */
2177 extern
2178 int SCIPgetNPricers(
2179  SCIP* scip /**< SCIP data structure */
2180  );
2181 
2182 /** returns the number of currently active variable pricers, that are used in the LP solving loop */
2183 extern
2185  SCIP* scip /**< SCIP data structure */
2186  );
2187 
2188 /** sets the priority of a variable pricer */
2189 extern
2191  SCIP* scip, /**< SCIP data structure */
2192  SCIP_PRICER* pricer, /**< variable pricer */
2193  int priority /**< new priority of the variable pricer */
2194  );
2195 
2196 /** activates pricer to be used for the current problem
2197  * This method should be called during the problem creation stage for all pricers that are necessary to solve
2198  * the problem model.
2199  * The pricers are automatically deactivated when the problem is freed.
2200  *
2201  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2202  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2203  *
2204  * @pre This method can be called if SCIP is in one of the following stages:
2205  * - \ref SCIP_STAGE_PROBLEM
2206  */
2207 extern
2209  SCIP* scip, /**< SCIP data structure */
2210  SCIP_PRICER* pricer /**< variable pricer */
2211  );
2212 
2213 /** deactivates pricer
2214  *
2215  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2216  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2217  *
2218  * @pre This method can be called if SCIP is in one of the following stages:
2219  * - \ref SCIP_STAGE_PROBLEM
2220  * - \ref SCIP_STAGE_EXITSOLVE
2221  */
2222 extern
2224  SCIP* scip, /**< SCIP data structure */
2225  SCIP_PRICER* pricer /**< variable pricer */
2226  );
2227 
2228 /** creates a constraint handler and includes it in SCIP.
2229  *
2230  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2231  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2232  *
2233  * @pre This method can be called if SCIP is in one of the following stages:
2234  * - \ref SCIP_STAGE_INIT
2235  * - \ref SCIP_STAGE_PROBLEM
2236  *
2237  * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
2238  * callback is added
2239  * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
2240  * if you seek for a method which is less likely to change in future releases
2241  */
2242 extern
2244  SCIP* scip, /**< SCIP data structure */
2245  const char* name, /**< name of constraint handler */
2246  const char* desc, /**< description of constraint handler */
2247  int sepapriority, /**< priority of the constraint handler for separation */
2248  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2249  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2250  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2251  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2252  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2253  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2254  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2255  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
2256  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2257  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2258  SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
2259  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
2260  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2261  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
2262  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
2263  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
2264  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
2265  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
2266  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
2267  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
2268  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
2269  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
2270  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
2271  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2272  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2273  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2274  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2275  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2276  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2277  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
2278  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
2279  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2280  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
2281  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
2282  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
2283  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
2284  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
2285  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
2286  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
2287  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
2288  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
2289  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
2290  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
2291  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2292  );
2293 
2294 /** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2295  * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
2296  * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
2297  * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
2298  * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
2299  * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
2300  * SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and
2301  * SCIPsetConshdlrGetDiveBdChgs().
2302  *
2303  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2304  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2305  *
2306  * @pre This method can be called if SCIP is in one of the following stages:
2307  * - \ref SCIP_STAGE_INIT
2308  * - \ref SCIP_STAGE_PROBLEM
2309  *
2310  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
2311  */
2312 extern
2314  SCIP* scip, /**< SCIP data structure */
2315  SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
2316  const char* name, /**< name of constraint handler */
2317  const char* desc, /**< description of constraint handler */
2318  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2319  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2320  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2321  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2322  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2323  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2324  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2325  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2326  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2327  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2328  );
2329 
2330 /** sets all separation related callbacks/parameters of the constraint handler
2331  *
2332  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2333  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2334  *
2335  * @pre This method can be called if SCIP is in one of the following stages:
2336  * - \ref SCIP_STAGE_INIT
2337  * - \ref SCIP_STAGE_PROBLEM
2338  */
2339 extern
2341  SCIP* scip, /**< SCIP data structure */
2342  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2343  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2344  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2345  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2346  int sepapriority, /**< priority of the constraint handler for separation */
2347  SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
2348  );
2349 
2350 /** sets both the propagation callback and the propagation frequency of the constraint handler
2351  *
2352  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2353  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2354  *
2355  * @pre This method can be called if SCIP is in one of the following stages:
2356  * - \ref SCIP_STAGE_INIT
2357  * - \ref SCIP_STAGE_PROBLEM
2358  */
2359 extern
2361  SCIP* scip, /**< SCIP data structure */
2362  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2363  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2364  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2365  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2366  SCIP_PROPTIMING proptiming /**< positions in the node solving loop where propagation should be executed */
2367  );
2368 
2369 /** sets copy method of both the constraint handler and each associated constraint
2370  *
2371  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2372  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2373  *
2374  * @pre This method can be called if SCIP is in one of the following stages:
2375  * - \ref SCIP_STAGE_INIT
2376  * - \ref SCIP_STAGE_PROBLEM
2377  */
2378 extern
2380  SCIP* scip, /**< SCIP data structure */
2381  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2382  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2383  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
2384  );
2385 
2386 /** sets destructor method of constraint handler
2387  *
2388  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2389  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2390  *
2391  * @pre This method can be called if SCIP is in one of the following stages:
2392  * - \ref SCIP_STAGE_INIT
2393  * - \ref SCIP_STAGE_PROBLEM
2394  */
2395 extern
2397  SCIP* scip, /**< SCIP data structure */
2398  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2399  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
2400  );
2401 
2402 /** sets initialization method of constraint handler
2403  *
2404  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2405  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2406  *
2407  * @pre This method can be called if SCIP is in one of the following stages:
2408  * - \ref SCIP_STAGE_INIT
2409  * - \ref SCIP_STAGE_PROBLEM
2410  */
2411 extern
2413  SCIP* scip, /**< SCIP data structure */
2414  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2415  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
2416  );
2417 
2418 /** sets deinitialization method of constraint handler
2419  *
2420  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2421  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2422  *
2423  * @pre This method can be called if SCIP is in one of the following stages:
2424  * - \ref SCIP_STAGE_INIT
2425  * - \ref SCIP_STAGE_PROBLEM
2426  */
2427 extern
2429  SCIP* scip, /**< SCIP data structure */
2430  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2431  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
2432  );
2433 
2434 /** sets solving process initialization method of constraint handler
2435  *
2436  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2437  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2438  *
2439  * @pre This method can be called if SCIP is in one of the following stages:
2440  * - \ref SCIP_STAGE_INIT
2441  * - \ref SCIP_STAGE_PROBLEM
2442  */
2443 extern
2445  SCIP* scip, /**< SCIP data structure */
2446  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2447  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
2448  );
2449 
2450 /** sets solving process deinitialization method of constraint handler
2451  *
2452  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2453  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2454  *
2455  * @pre This method can be called if SCIP is in one of the following stages:
2456  * - \ref SCIP_STAGE_INIT
2457  * - \ref SCIP_STAGE_PROBLEM
2458  */
2459 extern
2461  SCIP* scip, /**< SCIP data structure */
2462  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2463  SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
2464  );
2465 
2466 /** sets preprocessing initialization method of constraint handler
2467  *
2468  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2469  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2470  *
2471  * @pre This method can be called if SCIP is in one of the following stages:
2472  * - \ref SCIP_STAGE_INIT
2473  * - \ref SCIP_STAGE_PROBLEM
2474  */
2475 extern
2477  SCIP* scip, /**< SCIP data structure */
2478  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2479  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
2480  );
2481 
2482 /** sets preprocessing deinitialization method of constraint handler
2483  *
2484  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2485  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2486  *
2487  * @pre This method can be called if SCIP is in one of the following stages:
2488  * - \ref SCIP_STAGE_INIT
2489  * - \ref SCIP_STAGE_PROBLEM
2490  */
2491 extern
2493  SCIP* scip, /**< SCIP data structure */
2494  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2495  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
2496  );
2497 
2498 /** sets presolving method of constraint handler
2499  *
2500  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2501  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2502  *
2503  * @pre This method can be called if SCIP is in one of the following stages:
2504  * - \ref SCIP_STAGE_INIT
2505  * - \ref SCIP_STAGE_PROBLEM
2506  */
2507 extern
2509  SCIP* scip, /**< SCIP data structure */
2510  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2511  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
2512  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2513  SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
2514  );
2515 
2516 /** sets method of constraint handler to free specific constraint data
2517  *
2518  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2519  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2520  *
2521  * @pre This method can be called if SCIP is in one of the following stages:
2522  * - \ref SCIP_STAGE_INIT
2523  * - \ref SCIP_STAGE_PROBLEM
2524  */
2525 extern
2527  SCIP* scip, /**< SCIP data structure */
2528  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2529  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
2530  );
2531 
2532 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
2533  *
2534  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2535  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2536  *
2537  * @pre This method can be called if SCIP is in one of the following stages:
2538  * - \ref SCIP_STAGE_INIT
2539  * - \ref SCIP_STAGE_PROBLEM
2540  */
2541 extern
2543  SCIP* scip, /**< SCIP data structure */
2544  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2545  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
2546  );
2547 
2548 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
2549  *
2550  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2551  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2552  *
2553  * @pre This method can be called if SCIP is in one of the following stages:
2554  * - \ref SCIP_STAGE_INIT
2555  * - \ref SCIP_STAGE_PROBLEM
2556  */
2557 extern
2559  SCIP* scip, /**< SCIP data structure */
2560  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2561  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
2562  );
2563 
2564 /** sets propagation conflict resolving method of constraint handler
2565  *
2566  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2567  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2568  *
2569  * @pre This method can be called if SCIP is in one of the following stages:
2570  * - \ref SCIP_STAGE_INIT
2571  * - \ref SCIP_STAGE_PROBLEM
2572  */
2573 extern
2575  SCIP* scip, /**< SCIP data structure */
2576  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2577  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
2578  );
2579 
2580 /** sets activation notification method of constraint handler
2581  *
2582  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2583  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2584  *
2585  * @pre This method can be called if SCIP is in one of the following stages:
2586  * - \ref SCIP_STAGE_INIT
2587  * - \ref SCIP_STAGE_PROBLEM
2588  */
2589 extern
2591  SCIP* scip, /**< SCIP data structure */
2592  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2593  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
2594  );
2595 
2596 /** sets deactivation notification method of constraint handler
2597  *
2598  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2599  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2600  *
2601  * @pre This method can be called if SCIP is in one of the following stages:
2602  * - \ref SCIP_STAGE_INIT
2603  * - \ref SCIP_STAGE_PROBLEM
2604  */
2605 extern
2607  SCIP* scip, /**< SCIP data structure */
2608  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2609  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
2610  );
2611 
2612 /** sets enabling notification method of constraint handler
2613  *
2614  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2615  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2616  *
2617  * @pre This method can be called if SCIP is in one of the following stages:
2618  * - \ref SCIP_STAGE_INIT
2619  * - \ref SCIP_STAGE_PROBLEM
2620  */
2621 extern
2623  SCIP* scip, /**< SCIP data structure */
2624  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2625  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
2626  );
2627 
2628 /** sets disabling notification method of constraint handler
2629  *
2630  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2631  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2632  *
2633  * @pre This method can be called if SCIP is in one of the following stages:
2634  * - \ref SCIP_STAGE_INIT
2635  * - \ref SCIP_STAGE_PROBLEM
2636  */
2637 extern
2639  SCIP* scip, /**< SCIP data structure */
2640  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2641  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
2642  );
2643 
2644 /** sets variable deletion method of constraint handler
2645  *
2646  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2647  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2648  *
2649  * @pre This method can be called if SCIP is in one of the following stages:
2650  * - \ref SCIP_STAGE_INIT
2651  * - \ref SCIP_STAGE_PROBLEM
2652  */
2653 extern
2655  SCIP* scip, /**< SCIP data structure */
2656  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2657  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
2658  );
2659 
2660 /** sets constraint display method of constraint handler
2661  *
2662  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2663  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2664  *
2665  * @pre This method can be called if SCIP is in one of the following stages:
2666  * - \ref SCIP_STAGE_INIT
2667  * - \ref SCIP_STAGE_PROBLEM
2668  */
2669 extern
2671  SCIP* scip, /**< SCIP data structure */
2672  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2673  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
2674  );
2675 
2676 /** sets constraint parsing method of constraint handler
2677  *
2678  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2679  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2680  *
2681  * @pre This method can be called if SCIP is in one of the following stages:
2682  * - \ref SCIP_STAGE_INIT
2683  * - \ref SCIP_STAGE_PROBLEM
2684  */
2685 extern
2687  SCIP* scip, /**< SCIP data structure */
2688  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2689  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
2690  );
2691 
2692 /** sets constraint variable getter method of constraint handler
2693  *
2694  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2695  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2696  *
2697  * @pre This method can be called if SCIP is in one of the following stages:
2698  * - \ref SCIP_STAGE_INIT
2699  * - \ref SCIP_STAGE_PROBLEM
2700  */
2701 extern
2703  SCIP* scip, /**< SCIP data structure */
2704  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2705  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
2706  );
2707 
2708 /** sets constraint variable number getter method of constraint handler
2709  *
2710  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2711  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2712  *
2713  * @pre This method can be called if SCIP is in one of the following stages:
2714  * - \ref SCIP_STAGE_INIT
2715  * - \ref SCIP_STAGE_PROBLEM
2716  */
2717 extern
2719  SCIP* scip, /**< SCIP data structure */
2720  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2721  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
2722  );
2723 
2724 /** sets diving enforcement method of constraint handler
2725  *
2726  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2727  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2728  *
2729  * @pre This method can be called if SCIP is in one of the following stages:
2730  * - \ref SCIP_STAGE_INIT
2731  * - \ref SCIP_STAGE_PROBLEM
2732  */
2733 extern
2735  SCIP* scip, /**< SCIP data structure */
2736  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2737  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
2738  );
2739 
2740 /** returns the constraint handler of the given name, or NULL if not existing */
2741 extern
2743  SCIP* scip, /**< SCIP data structure */
2744  const char* name /**< name of constraint handler */
2745  );
2746 
2747 /** returns the array of currently available constraint handlers */
2748 extern
2750  SCIP* scip /**< SCIP data structure */
2751  );
2752 
2753 /** returns the number of currently available constraint handlers */
2754 extern
2755 int SCIPgetNConshdlrs(
2756  SCIP* scip /**< SCIP data structure */
2757  );
2758 
2759 /** creates a conflict handler and includes it in SCIP
2760  *
2761  * @note method has all conflict handler callbacks as arguments and is thus changed every time a new
2762  * callback is added
2763  * in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions
2764  * if you seek for a method which is less likely to change in future releases
2765  */
2766 extern
2768  SCIP* scip, /**< SCIP data structure */
2769  const char* name, /**< name of conflict handler */
2770  const char* desc, /**< description of conflict handler */
2771  int priority, /**< priority of the conflict handler */
2772  SCIP_DECL_CONFLICTCOPY((*conflictcopy)), /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2773  SCIP_DECL_CONFLICTFREE((*conflictfree)), /**< destructor of conflict handler */
2774  SCIP_DECL_CONFLICTINIT((*conflictinit)), /**< initialize conflict handler */
2775  SCIP_DECL_CONFLICTEXIT((*conflictexit)), /**< deinitialize conflict handler */
2776  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
2777  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
2778  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
2779  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
2780  );
2781 
2782 /** creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental
2783  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
2784  * Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(),
2785  * SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(),
2786  * and SCIPsetConflicthdlrExitsol()
2787  *
2788  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead
2789  */
2790 extern
2792  SCIP* scip, /**< SCIP data structure */
2793  SCIP_CONFLICTHDLR** conflicthdlrptr, /**< reference to a conflict handler pointer, or NULL */
2794  const char* name, /**< name of conflict handler */
2795  const char* desc, /**< description of conflict handler */
2796  int priority, /**< priority of the conflict handler */
2797  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
2798  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
2799  );
2800 
2801 /** set copy method of conflict handler */
2802 extern
2804  SCIP* scip, /**< SCIP data structure */
2805  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2806  SCIP_DECL_CONFLICTCOPY((*conflictcopy)) /**< copy method of conflict handler */
2807  );
2808 
2809 /** set destructor of conflict handler */
2810 extern
2812  SCIP* scip, /**< SCIP data structure */
2813  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2814  SCIP_DECL_CONFLICTFREE((*conflictfree)) /**< destructor of conflict handler */
2815  );
2816 
2817 /** set initialization method of conflict handler */
2818 extern
2820  SCIP* scip, /**< SCIP data structure */
2821  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2822  SCIP_DECL_CONFLICTINIT((*conflictinit)) /**< initialize conflict handler */
2823  );
2824 
2825 /** set deinitialization method of conflict handler */
2826 extern
2828  SCIP* scip, /**< SCIP data structure */
2829  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2830  SCIP_DECL_CONFLICTEXIT((*conflictexit)) /**< deinitialize conflict handler */
2831  );
2832 
2833 /** set solving process initialization method of conflict handler */
2834 extern
2836  SCIP* scip, /**< SCIP data structure */
2837  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2838  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
2839  );
2840 
2841 /** set solving process deinitialization method of conflict handler */
2842 extern
2844  SCIP* scip, /**< SCIP data structure */
2845  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2846  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
2847  );
2848 
2849 /** returns the conflict handler of the given name, or NULL if not existing */
2850 extern
2852  SCIP* scip, /**< SCIP data structure */
2853  const char* name /**< name of conflict handler */
2854  );
2855 
2856 /** returns the array of currently available conflict handlers */
2857 extern
2859  SCIP* scip /**< SCIP data structure */
2860  );
2861 
2862 /** returns the number of currently available conflict handlers */
2863 extern
2865  SCIP* scip /**< SCIP data structure */
2866  );
2867 
2868 /** sets the priority of a conflict handler */
2869 extern
2871  SCIP* scip, /**< SCIP data structure */
2872  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2873  int priority /**< new priority of the conflict handler */
2874  );
2875 
2876 /** creates a presolver and includes it in SCIP
2877  *
2878  * @note method has all presolver callbacks as arguments and is thus changed every time a new
2879  * callback is added
2880  * in future releases; consider using SCIPincludePresolBasic() and setter functions
2881  * if you seek for a method which is less likely to change in future releases
2882  */
2883 extern
2885  SCIP* scip, /**< SCIP data structure */
2886  const char* name, /**< name of presolver */
2887  const char* desc, /**< description of presolver */
2888  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
2889  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
2890  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
2891  SCIP_DECL_PRESOLCOPY ((*presolcopy)), /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
2892  SCIP_DECL_PRESOLFREE ((*presolfree)), /**< destructor of presolver to free user data (called when SCIP is exiting) */
2893  SCIP_DECL_PRESOLINIT ((*presolinit)), /**< initialization method of presolver (called after problem was transformed) */
2894  SCIP_DECL_PRESOLEXIT ((*presolexit)), /**< deinitialization method of presolver (called before transformed problem is freed) */
2895  SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
2896  SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
2897  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
2898  SCIP_PRESOLDATA* presoldata /**< presolver data */
2899  );
2900 
2901 /** Creates a presolver and includes it in SCIP with its fundamental callback. All non-fundamental (or optional)
2902  * callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter
2903  * functions. These are SCIPsetPresolCopy(), SCIPsetPresolFree(), SCIPsetPresolInit(), SCIPsetPresolExit(),
2904  * SCIPsetPresolInitpre(), and SCIPsetPresolExitPre().
2905  *
2906  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePresol() instead
2907  */
2908 extern
2910  SCIP* scip, /**< SCIP data structure */
2911  SCIP_PRESOL** presolptr, /**< reference to presolver, or NULL */
2912  const char* name, /**< name of presolver */
2913  const char* desc, /**< description of presolver */
2914  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
2915  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
2916  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
2917  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
2918  SCIP_PRESOLDATA* presoldata /**< presolver data */
2919  );
2920 
2921 /** sets copy method of presolver */
2922 extern
2924  SCIP* scip, /**< SCIP data structure */
2925  SCIP_PRESOL* presol, /**< presolver */
2926  SCIP_DECL_PRESOLCOPY ((*presolcopy)) /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
2927  );
2928 
2929 /** sets destructor method of presolver */
2930 extern
2932  SCIP* scip, /**< SCIP data structure */
2933  SCIP_PRESOL* presol, /**< presolver */
2934  SCIP_DECL_PRESOLFREE ((*presolfree)) /**< destructor of presolver */
2935  );
2936 
2937 /** sets initialization method of presolver */
2938 extern
2940  SCIP* scip, /**< SCIP data structure */
2941  SCIP_PRESOL* presol, /**< presolver */
2942  SCIP_DECL_PRESOLINIT ((*presolinit)) /**< initialize presolver */
2943  );
2944 
2945 /** sets deinitialization method of presolver */
2946 extern
2948  SCIP* scip, /**< SCIP data structure */
2949  SCIP_PRESOL* presol, /**< presolver */
2950  SCIP_DECL_PRESOLEXIT ((*presolexit)) /**< deinitialize presolver */
2951  );
2952 
2953 /** sets solving process initialization method of presolver */
2954 extern
2956  SCIP* scip, /**< SCIP data structure */
2957  SCIP_PRESOL* presol, /**< presolver */
2958  SCIP_DECL_PRESOLINITPRE ((*presolinitpre))/**< solving process initialization method of presolver */
2959  );
2960 
2961 /** sets solving process deinitialization method of presolver */
2963  SCIP* scip, /**< SCIP data structure */
2964  SCIP_PRESOL* presol, /**< presolver */
2965  SCIP_DECL_PRESOLEXITPRE ((*presolexitpre))/**< solving process deinitialization method of presolver */
2966  );
2967 
2968 /** returns the presolver of the given name, or NULL if not existing */
2969 extern
2971  SCIP* scip, /**< SCIP data structure */
2972  const char* name /**< name of presolver */
2973  );
2974 
2975 /** returns the array of currently available presolvers */
2976 extern
2978  SCIP* scip /**< SCIP data structure */
2979  );
2980 
2981 /** returns the number of currently available presolvers */
2982 extern
2983 int SCIPgetNPresols(
2984  SCIP* scip /**< SCIP data structure */
2985  );
2986 
2987 /** sets the priority of a presolver */
2988 extern
2990  SCIP* scip, /**< SCIP data structure */
2991  SCIP_PRESOL* presol, /**< presolver */
2992  int priority /**< new priority of the presolver */
2993  );
2994 
2995 /** creates a relaxation handler and includes it in SCIP
2996  *
2997  * @note method has all relaxation handler callbacks as arguments and is thus changed every time a new
2998  * callback is added
2999  * in future releases; consider using SCIPincludeRelaxBasic() and setter functions
3000  * if you seek for a method which is less likely to change in future releases
3001  */
3002 extern
3004  SCIP* scip, /**< SCIP data structure */
3005  const char* name, /**< name of relaxation handler */
3006  const char* desc, /**< description of relaxation handler */
3007  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3008  int freq, /**< frequency for calling relaxation handler */
3009  SCIP_DECL_RELAXCOPY ((*relaxcopy)), /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3010  SCIP_DECL_RELAXFREE ((*relaxfree)), /**< destructor of relaxation handler */
3011  SCIP_DECL_RELAXINIT ((*relaxinit)), /**< initialize relaxation handler */
3012  SCIP_DECL_RELAXEXIT ((*relaxexit)), /**< deinitialize relaxation handler */
3013  SCIP_DECL_RELAXINITSOL((*relaxinitsol)), /**< solving process initialization method of relaxation handler */
3014  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), /**< solving process deinitialization method of relaxation handler */
3015  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3016  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3017  );
3018 
3019 /** creates a relaxation handler and includes it in SCIP. All non fundamental
3020  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3021  * Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(),
3022  * SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()
3023  *
3024  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeRelax() instead
3025  */
3026 extern
3028  SCIP* scip, /**< SCIP data structure */
3029  SCIP_RELAX** relaxptr, /**< reference to relaxation pointer, or NULL */
3030  const char* name, /**< name of relaxation handler */
3031  const char* desc, /**< description of relaxation handler */
3032  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3033  int freq, /**< frequency for calling relaxation handler */
3034  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3035  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3036  );
3037 
3038 /** sets copy method of relaxation handler */
3039 extern
3041  SCIP* scip, /**< SCIP data structure */
3042  SCIP_RELAX* relax, /**< relaxation handler */
3043  SCIP_DECL_RELAXCOPY ((*relaxcopy)) /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3044  );
3045 
3046 /** sets destructor method of relaxation handler */
3047 extern
3049  SCIP* scip, /**< SCIP data structure */
3050  SCIP_RELAX* relax, /**< relaxation handler */
3051  SCIP_DECL_RELAXFREE ((*relaxfree)) /**< destructor of relaxation handler */
3052  );
3053 
3054 /** sets initialization method of relaxation handler */
3055 extern
3057  SCIP* scip, /**< SCIP data structure */
3058  SCIP_RELAX* relax, /**< relaxation handler */
3059  SCIP_DECL_RELAXINIT ((*relaxinit)) /**< initialize relaxation handler */
3060  );
3061 
3062 /** sets deinitialization method of relaxation handler */
3063 extern
3065  SCIP* scip, /**< SCIP data structure */
3066  SCIP_RELAX* relax, /**< relaxation handler */
3067  SCIP_DECL_RELAXEXIT ((*relaxexit)) /**< deinitialize relaxation handler */
3068  );
3069 
3070 /** sets solving process initialization method of relaxation handler */
3071 extern
3073  SCIP* scip, /**< SCIP data structure */
3074  SCIP_RELAX* relax, /**< relaxation handler */
3075  SCIP_DECL_RELAXINITSOL((*relaxinitsol)) /**< solving process initialization method of relaxation handler */
3076  );
3077 
3078 /** sets solving process deinitialization method of relaxation handler */
3079 extern
3081  SCIP* scip, /**< SCIP data structure */
3082  SCIP_RELAX* relax, /**< relaxation handler */
3083  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)) /**< solving process deinitialization method of relaxation handler */
3084  );
3085 
3086 /** returns the relaxation handler of the given name, or NULL if not existing */
3087 extern
3089  SCIP* scip, /**< SCIP data structure */
3090  const char* name /**< name of relaxation handler */
3091  );
3092 
3093 /** returns the array of currently available relaxation handlers */
3094 extern
3096  SCIP* scip /**< SCIP data structure */
3097  );
3098 
3099 /** returns the number of currently available relaxation handlers */
3100 extern
3101 int SCIPgetNRelaxs(
3102  SCIP* scip /**< SCIP data structure */
3103  );
3104 
3105 /** sets the priority of a relaxation handler*/
3106 extern
3108  SCIP* scip, /**< SCIP data structure */
3109  SCIP_RELAX* relax, /**< relaxation handler */
3110  int priority /**< new priority of the relaxation handler */
3111  );
3112 
3113 /** creates a separator and includes it in SCIP.
3114  *
3115  * @note method has all separator callbacks as arguments and is thus changed every time a new
3116  * callback is added
3117  * in future releases; consider using SCIPincludeSepaBasic() and setter functions
3118  * if you seek for a method which is less likely to change in future releases
3119  */
3120 extern
3122  SCIP* scip, /**< SCIP data structure */
3123  const char* name, /**< name of separator */
3124  const char* desc, /**< description of separator */
3125  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3126  int freq, /**< frequency for calling separator */
3127  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3128  * to best node's dual bound for applying separation */
3129  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3130  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3131  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3132  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
3133  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
3134  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
3135  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
3136  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
3137  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3138  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3139  SCIP_SEPADATA* sepadata /**< separator data */
3140  );
3141 
3142 /** creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3143  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3144  * Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(),
3145  * SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().
3146  *
3147  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeSepa() instead
3148  */
3149 extern
3151  SCIP* scip, /**< SCIP data structure */
3152  SCIP_SEPA** sepa, /**< reference to a separator, or NULL */
3153  const char* name, /**< name of separator */
3154  const char* desc, /**< description of separator */
3155  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3156  int freq, /**< frequency for calling separator */
3157  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3158  * to best node's dual bound for applying separation */
3159  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3160  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3161  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3162  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3163  SCIP_SEPADATA* sepadata /**< separator data */
3164  );
3165 
3166 /** sets copy method of separator */
3167 extern
3169  SCIP* scip, /**< SCIP data structure */
3170  SCIP_SEPA* sepa, /**< separator */
3171  SCIP_DECL_SEPACOPY ((*sepacopy)) /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3172  );
3173 
3174 /** sets destructor method of separator */
3175 extern
3177  SCIP* scip, /**< SCIP data structure */
3178  SCIP_SEPA* sepa, /**< separator */
3179  SCIP_DECL_SEPAFREE ((*sepafree)) /**< destructor of separator */
3180  );
3181 
3182 /** sets initialization method of separator */
3183 extern
3185  SCIP* scip, /**< SCIP data structure */
3186  SCIP_SEPA* sepa, /**< separator */
3187  SCIP_DECL_SEPAINIT ((*sepainit)) /**< initialize separator */
3188  );
3189 
3190 /** sets deinitialization method of separator */
3191 extern
3193  SCIP* scip, /**< SCIP data structure */
3194  SCIP_SEPA* sepa, /**< separator */
3195  SCIP_DECL_SEPAEXIT ((*sepaexit)) /**< deinitialize separator */
3196  );
3197 
3198 /** sets solving process initialization method of separator */
3199 extern
3201  SCIP* scip, /**< SCIP data structure */
3202  SCIP_SEPA* sepa, /**< separator */
3203  SCIP_DECL_SEPAINITSOL ((*sepainitsol)) /**< solving process initialization method of separator */
3204  );
3205 
3206 /** sets solving process deinitialization method of separator */
3207 extern
3209  SCIP* scip, /**< SCIP data structure */
3210  SCIP_SEPA* sepa, /**< separator */
3211  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)) /**< solving process deinitialization method of separator */
3212  );
3213 
3214 /** returns the separator of the given name, or NULL if not existing */
3215 extern
3217  SCIP* scip, /**< SCIP data structure */
3218  const char* name /**< name of separator */
3219  );
3220 
3221 /** returns the array of currently available separators */
3222 extern
3224  SCIP* scip /**< SCIP data structure */
3225  );
3226 
3227 /** returns the number of currently available separators */
3228 extern
3229 int SCIPgetNSepas(
3230  SCIP* scip /**< SCIP data structure */
3231  );
3232 
3233 /** sets the priority of a separator */
3234 extern
3236  SCIP* scip, /**< SCIP data structure */
3237  SCIP_SEPA* sepa, /**< separator */
3238  int priority /**< new priority of the separator */
3239  );
3240 
3241 /** creates a propagator and includes it in SCIP.
3242  *
3243  * @note method has all propagator callbacks as arguments and is thus changed every time a new
3244  * callback is added in future releases; consider using SCIPincludePropBasic() and setter functions
3245  * if you seek for a method which is less likely to change in future releases
3246  */
3247 extern
3249  SCIP* scip, /**< SCIP data structure */
3250  const char* name, /**< name of propagator */
3251  const char* desc, /**< description of propagator */
3252  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3253  int freq, /**< frequency for calling propagator */
3254  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3255  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagator should be executed */
3256  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3257  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3258  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the propagator's presolving method */
3259  SCIP_DECL_PROPCOPY ((*propcopy)), /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3260  SCIP_DECL_PROPFREE ((*propfree)), /**< destructor of propagator */
3261  SCIP_DECL_PROPINIT ((*propinit)), /**< initialize propagator */
3262  SCIP_DECL_PROPEXIT ((*propexit)), /**< deinitialize propagator */
3263  SCIP_DECL_PROPINITPRE ((*propinitpre)), /**< presolving initialization method of propagator */
3264  SCIP_DECL_PROPEXITPRE ((*propexitpre)), /**< presolving deinitialization method of propagator */
3265  SCIP_DECL_PROPINITSOL ((*propinitsol)), /**< solving process initialization method of propagator */
3266  SCIP_DECL_PROPEXITSOL ((*propexitsol)), /**< solving process deinitialization method of propagator */
3267  SCIP_DECL_PROPPRESOL ((*proppresol)), /**< presolving method */
3268  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3269  SCIP_DECL_PROPRESPROP ((*propresprop)), /**< propagation conflict resolving method */
3270  SCIP_PROPDATA* propdata /**< propagator data */
3271  );
3272 
3273 /** creates a propagator and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
3274  * Optional callbacks can be set via specific setter functions, see SCIPsetPropInit(), SCIPsetPropExit(),
3275  * SCIPsetPropCopy(), SCIPsetPropFree(), SCIPsetPropInitsol(), SCIPsetPropExitsol(),
3276  * SCIPsetPropInitpre(), SCIPsetPropExitpre(), SCIPsetPropPresol(), and SCIPsetPropResprop().
3277  *
3278  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeProp() instead
3279  */
3280 extern
3282  SCIP* scip, /**< SCIP data structure */
3283  SCIP_PROP** propptr, /**< reference to a propagator pointer, or NULL */
3284  const char* name, /**< name of propagator */
3285  const char* desc, /**< description of propagator */
3286  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3287  int freq, /**< frequency for calling propagator */
3288  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3289  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagators should be executed */
3290  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3291  SCIP_PROPDATA* propdata /**< propagator data */
3292  );
3293 
3294 /** sets copy method of propagator */
3295 extern
3297  SCIP* scip, /**< SCIP data structure */
3298  SCIP_PROP* prop, /**< propagator */
3299  SCIP_DECL_PROPCOPY ((*propcopy)) /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3300  );
3301 
3302 /** sets destructor method of propagator */
3303 extern
3305  SCIP* scip, /**< SCIP data structure */
3306  SCIP_PROP* prop, /**< propagator */
3307  SCIP_DECL_PROPFREE ((*propfree)) /**< destructor of propagator */
3308  );
3309 
3310 /** sets initialization method of propagator */
3311 extern
3313  SCIP* scip, /**< SCIP data structure */
3314  SCIP_PROP* prop, /**< propagator */
3315  SCIP_DECL_PROPINIT ((*propinit)) /**< initialize propagator */
3316  );
3317 
3318 /** sets deinitialization method of propagator */
3319 extern
3321  SCIP* scip, /**< SCIP data structure */
3322  SCIP_PROP* prop, /**< propagator */
3323  SCIP_DECL_PROPEXIT ((*propexit)) /**< deinitialize propagator */
3324  );
3325 
3326 /** sets solving process initialization method of propagator */
3327 extern
3329  SCIP* scip, /**< SCIP data structure */
3330  SCIP_PROP* prop, /**< propagator */
3331  SCIP_DECL_PROPINITSOL((*propinitsol)) /**< solving process initialization method of propagator */
3332  );
3333 
3334 /** sets solving process deinitialization method of propagator */
3335 extern
3337  SCIP* scip, /**< SCIP data structure */
3338  SCIP_PROP* prop, /**< propagator */
3339  SCIP_DECL_PROPEXITSOL ((*propexitsol)) /**< solving process deinitialization method of propagator */
3340  );
3341 
3342 /** sets preprocessing initialization method of propagator */
3343 extern
3345  SCIP* scip, /**< SCIP data structure */
3346  SCIP_PROP* prop, /**< propagator */
3347  SCIP_DECL_PROPINITPRE((*propinitpre)) /**< preprocessing initialization method of propagator */
3348  );
3349 
3350 /** sets preprocessing deinitialization method of propagator */
3351 extern
3353  SCIP* scip, /**< SCIP data structure */
3354  SCIP_PROP* prop, /**< propagator */
3355  SCIP_DECL_PROPEXITPRE((*propexitpre)) /**< preprocessing deinitialization method of propagator */
3356  );
3357 
3358 /** sets presolving method of propagator */
3359 extern
3361  SCIP* scip, /**< SCIP data structure */
3362  SCIP_PROP* prop, /**< propagator */
3363  SCIP_DECL_PROPPRESOL((*proppresol)), /**< presolving method of propagator */
3364  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3365  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3366  SCIP_PRESOLTIMING presoltiming /**< timing mask of the propagator's presolving method */
3367  );
3368 
3369 /** sets propagation conflict resolving callback of propagator */
3370 extern
3372  SCIP* scip, /**< SCIP data structure */
3373  SCIP_PROP* prop, /**< propagator */
3374  SCIP_DECL_PROPRESPROP ((*propresprop)) /**< propagation conflict resolving callback */
3375  );
3376 
3377 /** returns the propagator of the given name, or NULL if not existing */
3378 extern
3380  SCIP* scip, /**< SCIP data structure */
3381  const char* name /**< name of propagator */
3382  );
3383 
3384 /** returns the array of currently available propagators */
3385 extern
3387  SCIP* scip /**< SCIP data structure */
3388  );
3389 
3390 /** returns the number of currently available propagators */
3391 extern
3392 int SCIPgetNProps(
3393  SCIP* scip /**< SCIP data structure */
3394  );
3395 
3396 /** sets the priority of a propagator */
3397 extern
3399  SCIP* scip, /**< SCIP data structure */
3400  SCIP_PROP* prop, /**< propagator */
3401  int priority /**< new priority of the propagator */
3402  );
3403 
3404 /** sets the presolving priority of a propagator */
3405 extern
3407  SCIP* scip, /**< SCIP data structure */
3408  SCIP_PROP* prop, /**< propagator */
3409  int presolpriority /**< new presol priority of the propagator */
3410  );
3411 
3412 
3413 /** creates a primal heuristic and includes it in SCIP.
3414  *
3415  * @note method has all heuristic callbacks as arguments and is thus changed every time a new
3416  * callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions
3417  * if you seek for a method which is less likely to change in future releases
3418  *
3419  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3420  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3421  *
3422  * @pre This method can be called if @p scip is in one of the following stages:
3423  * - \ref SCIP_STAGE_INIT
3424  * - \ref SCIP_STAGE_PROBLEM
3425  */
3426 extern
3428  SCIP* scip, /**< SCIP data structure */
3429  const char* name, /**< name of primal heuristic */
3430  const char* desc, /**< description of primal heuristic */
3431  char dispchar, /**< display character of primal heuristic */
3432  int priority, /**< priority of the primal heuristic */
3433  int freq, /**< frequency for calling primal heuristic */
3434  int freqofs, /**< frequency offset for calling primal heuristic */
3435  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3436  unsigned int timingmask, /**< positions in the node solving loop where heuristic should be executed;
3437  * see definition of SCIP_HeurTiming for possible values */
3438  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3439  SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
3440  SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
3441  SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
3442  SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
3443  SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
3444  SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
3445  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
3446  SCIP_HEURDATA* heurdata /**< primal heuristic data */
3447  );
3448 
3449 /** creates a primal heuristic and includes it in SCIP with its most fundamental callbacks.
3450  * All non-fundamental (or optional) callbacks
3451  * as, e. g., init and exit callbacks, will be set to NULL.
3452  * Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(),
3453  * SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
3454  *
3455 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead
3456  */
3457 extern
3459  SCIP* scip, /**< SCIP data structure */
3460  SCIP_HEUR** heur, /**< pointer to the heuristic */
3461  const char* name, /**< name of primal heuristic */
3462  const char* desc, /**< description of primal heuristic */
3463  char dispchar, /**< display character of primal heuristic */
3464  int priority, /**< priority of the primal heuristic */
3465  int freq, /**< frequency for calling primal heuristic */
3466  int freqofs, /**< frequency offset for calling primal heuristic */
3467  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3468  unsigned int timingmask, /**< positions in the node solving loop where heuristic should be executed;
3469  * see definition of SCIP_HeurTiming for possible values */
3470  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3471  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
3472  SCIP_HEURDATA* heurdata /**< primal heuristic data */
3473  );
3474 
3475 /** sets copy method of primal heuristic */
3476 extern
3478  SCIP* scip, /**< SCIP data structure */
3479  SCIP_HEUR* heur, /**< primal heuristic */
3480  SCIP_DECL_HEURCOPY ((*heurcopy)) /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
3481  );
3482 
3483 /** sets destructor method of primal heuristic */
3484 extern
3486  SCIP* scip, /**< SCIP data structure */
3487  SCIP_HEUR* heur, /**< primal heuristic */
3488  SCIP_DECL_HEURFREE ((*heurfree)) /**< destructor of primal heuristic */
3489  );
3490 
3491 /** sets initialization method of primal heuristic */
3492 extern
3494  SCIP* scip, /**< SCIP data structure */
3495  SCIP_HEUR* heur, /**< primal heuristic */
3496  SCIP_DECL_HEURINIT ((*heurinit)) /**< initialize primal heuristic */
3497  );
3498 
3499 /** sets deinitialization method of primal heuristic */
3500 extern
3502  SCIP* scip, /**< SCIP data structure */
3503  SCIP_HEUR* heur, /**< primal heuristic */
3504  SCIP_DECL_HEUREXIT ((*heurexit)) /**< deinitialize primal heuristic */
3505  );
3506 
3507 /** sets solving process initialization method of primal heuristic */
3508 extern
3510  SCIP* scip, /**< SCIP data structure */
3511  SCIP_HEUR* heur, /**< primal heuristic */
3512  SCIP_DECL_HEURINITSOL ((*heurinitsol)) /**< solving process initialization method of primal heuristic */
3513  );
3514 
3515 /** sets solving process deinitialization method of primal heuristic */
3516 extern
3518  SCIP* scip, /**< SCIP data structure */
3519  SCIP_HEUR* heur, /**< primal heuristic */
3520  SCIP_DECL_HEUREXITSOL ((*heurexitsol)) /**< solving process deinitialization method of primal heuristic */
3521  );
3522 
3523 /** returns the primal heuristic of the given name, or NULL if not existing */
3524 extern
3526  SCIP* scip, /**< SCIP data structure */
3527  const char* name /**< name of primal heuristic */
3528  );
3529 
3530 /** returns the array of currently available primal heuristics */
3531 extern
3533  SCIP* scip /**< SCIP data structure */
3534  );
3535 
3536 /** returns the number of currently available primal heuristics */
3537 extern
3538 int SCIPgetNHeurs(
3539  SCIP* scip /**< SCIP data structure */
3540  );
3541 
3542 /** sets the priority of a primal heuristic */
3543 extern
3545  SCIP* scip, /**< SCIP data structure */
3546  SCIP_HEUR* heur, /**< primal heuristic */
3547  int priority /**< new priority of the primal heuristic */
3548  );
3549 
3550 /** creates a tree compression and includes it in SCIP.
3551  *
3552  * @note method has all compression callbacks as arguments and is thus changed every time a new
3553  * callback is added in future releases; consider using SCIPincludeComprBasic() and setter functions
3554  * if you seek for a method which is less likely to change in future releases
3555  */
3556 extern
3558  SCIP* scip, /**< SCIP data structure */
3559  const char* name, /**< name of tree compression */
3560  const char* desc, /**< description of tree compression */
3561  int priority, /**< priority of the tree compression */
3562  int minnnodes, /**< minimal number of nodes to call compression */
3563  SCIP_DECL_COMPRCOPY ((*comprcopy)), /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
3564  SCIP_DECL_COMPRFREE ((*comprfree)), /**< destructor of tree compression */
3565  SCIP_DECL_COMPRINIT ((*comprinit)), /**< initialize tree compression */
3566  SCIP_DECL_COMPREXIT ((*comprexit)), /**< deinitialize tree compression */
3567  SCIP_DECL_COMPRINITSOL ((*comprinitsol)), /**< solving process initialization method of tree compression */
3568  SCIP_DECL_COMPREXITSOL ((*comprexitsol)), /**< solving process deinitialization method of tree compression */
3569  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
3570  SCIP_COMPRDATA* comprdata /**< tree compression data */
3571  );
3572 
3573 /** creates a tree compression and includes it in SCIP with its most fundamental callbacks.
3574  * All non-fundamental (or optional) callbacks
3575  * as, e. g., init and exit callbacks, will be set to NULL.
3576  * Optional callbacks can be set via specific setter functions, see SCIPsetComprCopy(), SCIPsetComprFree(),
3577  * SCIPsetComprInit(), SCIPsetComprExit(), SCIPsetComprInitsol(), and SCIPsetComprExitsol()
3578  *
3579  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeCompr() instead
3580  */
3581 extern
3583  SCIP* scip, /**< SCIP data structure */
3584  SCIP_COMPR** compr, /**< pointer to tree compression */
3585  const char* name, /**< name of tree compression */
3586  const char* desc, /**< description of tree compression */
3587  int priority, /**< priority of the tree compression */
3588  int minnnodes, /**< minimal number of nodes to call the compression */
3589  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
3590  SCIP_COMPRDATA* comprdata /**< tree compression data */
3591  );
3592 
3593 /** sets copy method of tree compression */
3594 extern
3596  SCIP* scip, /**< SCIP data structure */
3597  SCIP_COMPR* compr, /**< tree compression */
3598  SCIP_DECL_COMPRCOPY ((*comprcopy)) /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
3599  );
3600 
3601 /** sets destructor method of tree compression */
3602 extern
3604  SCIP* scip, /**< SCIP data structure */
3605  SCIP_COMPR* compr, /**< tree compression */
3606  SCIP_DECL_COMPRFREE ((*comprfree)) /**< destructor of tree compression */
3607  );
3608 
3609 /** sets initialization method of tree compression */
3610 extern
3612  SCIP* scip, /**< SCIP data structure */
3613  SCIP_COMPR* compr, /**< tree compression */
3614  SCIP_DECL_COMPRINIT ((*comprinit)) /**< initialize tree compression */
3615  );
3616 
3617 /** sets deinitialization method of tree compression */
3618 extern
3620  SCIP* scip, /**< SCIP data structure */
3621  SCIP_COMPR* compr, /**< tree compression */
3622  SCIP_DECL_COMPREXIT ((*comprexit)) /**< deinitialize tree compression */
3623  );
3624 
3625 /** sets solving process initialization method of tree compression */
3626 extern
3628  SCIP* scip, /**< SCIP data structure */
3629  SCIP_COMPR* compr, /**< tree compression */
3630  SCIP_DECL_COMPRINITSOL ((*comprinitsol)) /**< solving process initialization method of tree compression */
3631  );
3632 
3633 /** sets solving process deinitialization method of tree compression */
3634 extern
3636  SCIP* scip, /**< SCIP data structure */
3637  SCIP_COMPR* compr, /**< tree compression */
3638  SCIP_DECL_COMPREXITSOL ((*comprexitsol)) /**< solving process deinitialization method of tree compression */
3639  );
3640 
3641 /** returns the tree compression of the given name, or NULL if not existing */
3642 extern
3644  SCIP* scip, /**< SCIP data structure */
3645  const char* name /**< name of tree compression */
3646  );
3647 
3648 /** returns the array of currently available tree compression */
3649 extern
3651  SCIP* scip /**< SCIP data structure */
3652  );
3653 
3654 /** returns the number of currently available tree compression */
3655 extern
3656 int SCIPgetNCompr(
3657  SCIP* scip /**< SCIP data structure */
3658  );
3659 
3660 /** set the priority of a tree compression method */
3662  SCIP* scip, /**< SCIP data structure */
3663  SCIP_COMPR* compr, /**< compression */
3664  int priority /**< new priority of the tree compression */
3665  );
3666 
3667 /** create a diving set associated with a primal heuristic. The primal heuristic needs to be included
3668  * before this method can be called. The diveset is installed in the array of divesets of the heuristic
3669  * and can be retrieved later by accessing SCIPheurGetDivesets()
3670  *
3671  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3672  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3673  *
3674  * @pre This method can be called if @p scip is in one of the following stages:
3675  * - \ref SCIP_STAGE_INIT
3676  * - \ref SCIP_STAGE_PROBLEM
3677  */
3678 extern
3680  SCIP* scip, /**< SCIP data structure */
3681  SCIP_DIVESET** diveset, /**< pointer to created diving heuristic settings, or NULL if not needed */
3682  SCIP_HEUR* heur, /**< primal heuristic to which the diveset belongs */
3683  const char* name, /**< name for the diveset, or NULL if the name of the heuristic should be used */
3684  SCIP_Real minreldepth, /**< minimal relative depth to start diving */
3685  SCIP_Real maxreldepth, /**< maximal relative depth to start diving */
3686  SCIP_Real maxlpiterquot, /**< maximal fraction of diving LP iterations compared to node LP iterations */
3687  SCIP_Real maxdiveubquot, /**< maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound)
3688  * where diving is performed (0.0: no limit) */
3689  SCIP_Real maxdiveavgquot, /**< maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound)
3690  * where diving is performed (0.0: no limit) */
3691  SCIP_Real maxdiveubquotnosol, /**< maximal UBQUOT when no solution was found yet (0.0: no limit) */
3692  SCIP_Real maxdiveavgquotnosol,/**< maximal AVGQUOT when no solution was found yet (0.0: no limit) */
3693  SCIP_Real lpresolvedomchgquot,/**< percentage of immediate domain changes during probing to trigger LP resolve */
3694  int lpsolvefreq, /**< LP solve frequency for (0: only if enough domain reductions are found by propagation)*/
3695  int maxlpiterofs, /**< additional number of allowed LP iterations */
3696  SCIP_Bool backtrack, /**< use one level of backtracking if infeasibility is encountered? */
3697  SCIP_Bool onlylpbranchcands, /**< should only LP branching candidates be considered instead of the slower but
3698  * more general constraint handler diving variable selection? */
3699  SCIP_Bool specificsos1score, /**< should SOS1 variables be scored by the diving heuristics specific score function;
3700  * otherwise use the score function of the SOS1 constraint handler */
3701  SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)) /**< method for candidate score and rounding direction */
3702 
3703  );
3704 
3705 /** creates an event handler and includes it in SCIP
3706  *
3707  * @note method has all event handler callbacks as arguments and is thus changed every time a new
3708  * callback is added in future releases; consider using SCIPincludeEventhdlrBasic() and setter functions
3709  * if you seek for a method which is less likely to change in future releases
3710  */
3711 extern
3713  SCIP* scip, /**< SCIP data structure */
3714  const char* name, /**< name of event handler */
3715  const char* desc, /**< description of event handler */
3716  SCIP_DECL_EVENTCOPY ((*eventcopy)), /**< copy method of event handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3717  SCIP_DECL_EVENTFREE ((*eventfree)), /**< destructor of event handler */
3718  SCIP_DECL_EVENTINIT ((*eventinit)), /**< initialize event handler */
3719  SCIP_DECL_EVENTEXIT ((*eventexit)), /**< deinitialize event handler */
3720  SCIP_DECL_EVENTINITSOL((*eventinitsol)), /**< solving process initialization method of event handler */
3721  SCIP_DECL_EVENTEXITSOL((*eventexitsol)), /**< solving process deinitialization method of event handler */
3722  SCIP_DECL_EVENTDELETE ((*eventdelete)), /**< free specific event data */
3723  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
3724  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
3725  );
3726 
3727 /** creates an event handler and includes it in SCIP with all its non-fundamental callbacks set
3728  * to NULL; if needed, non-fundamental callbacks can be set afterwards via setter functions
3729  * SCIPsetEventhdlrCopy(), SCIPsetEventhdlrFree(), SCIPsetEventhdlrInit(), SCIPsetEventhdlrExit(),
3730  * SCIPsetEventhdlrInitsol(), SCIPsetEventhdlrExitsol(), and SCIPsetEventhdlrDelete()
3731  *
3732  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeEventhdlr() instead
3733  */
3734 extern
3736  SCIP* scip, /**< SCIP data structure */
3737  SCIP_EVENTHDLR** eventhdlrptr, /**< reference to an event handler, or NULL */
3738  const char* name, /**< name of event handler */
3739  const char* desc, /**< description of event handler */
3740  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
3741  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
3742  );
3743 
3744 /** sets copy callback of the event handler */
3745 extern
3747  SCIP* scip, /**< scip instance */
3748  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3749  SCIP_DECL_EVENTCOPY ((*eventcopy)) /**< copy callback of the event handler */
3750  );
3751 
3752 /** sets deinitialization callback of the event handler */
3753 extern
3755  SCIP* scip, /**< scip instance */
3756  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3757  SCIP_DECL_EVENTFREE ((*eventfree)) /**< deinitialization callback of the event handler */
3758  );
3759 
3760 /** sets initialization callback of the event handler */
3761 extern
3763  SCIP* scip, /**< scip instance */
3764  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3765  SCIP_DECL_EVENTINIT ((*eventinit)) /**< initialize event handler */
3766  );
3767 
3768 /** sets deinitialization callback of the event handler */
3769 extern
3771  SCIP* scip, /**< scip instance */
3772  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3773  SCIP_DECL_EVENTEXIT ((*eventexit)) /**< deinitialize event handler */
3774  );
3775 
3776 /** sets solving process initialization callback of the event handler */
3777 extern
3779  SCIP* scip, /**< scip instance */
3780  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3781  SCIP_DECL_EVENTINITSOL((*eventinitsol)) /**< solving process initialization callback of event handler */
3782  );
3783 
3784 /** sets solving process deinitialization callback of the event handler */
3785 extern
3787  SCIP* scip, /**< scip instance */
3788  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3789  SCIP_DECL_EVENTEXITSOL((*eventexitsol)) /**< solving process deinitialization callback of event handler */
3790  );
3791 
3792 /** sets callback of the event handler to free specific event data */
3793 extern
3795  SCIP* scip, /**< scip instance */
3796  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3797  SCIP_DECL_EVENTDELETE ((*eventdelete)) /**< free specific event data */
3798  );
3799 
3800 /** returns the event handler of the given name, or NULL if not existing */
3801 extern
3803  SCIP* scip, /**< SCIP data structure */
3804  const char* name /**< name of event handler */
3805  );
3806 
3807 /** returns the array of currently available event handlers */
3808 extern
3810  SCIP* scip /**< SCIP data structure */
3811  );
3812 
3813 /** returns the number of currently available event handlers */
3814 extern
3815 int SCIPgetNEventhdlrs(
3816  SCIP* scip /**< SCIP data structure */
3817  );
3818 
3819 /** creates a node selector and includes it in SCIP.
3820  *
3821  * @note method has all node selector callbacks as arguments and is thus changed every time a new
3822  * callback is added in future releases; consider using SCIPincludeNodeselBasic() and setter functions
3823  * if you seek for a method which is less likely to change in future releases
3824  */
3825 extern
3827  SCIP* scip, /**< SCIP data structure */
3828  const char* name, /**< name of node selector */
3829  const char* desc, /**< description of node selector */
3830  int stdpriority, /**< priority of the node selector in standard mode */
3831  int memsavepriority, /**< priority of the node selector in memory saving mode */
3832  SCIP_DECL_NODESELCOPY ((*nodeselcopy)), /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
3833  SCIP_DECL_NODESELFREE ((*nodeselfree)), /**< destructor of node selector */
3834  SCIP_DECL_NODESELINIT ((*nodeselinit)), /**< initialize node selector */
3835  SCIP_DECL_NODESELEXIT ((*nodeselexit)), /**< deinitialize node selector */
3836  SCIP_DECL_NODESELINITSOL((*nodeselinitsol)),/**< solving process initialization method of node selector */
3837  SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)),/**< solving process deinitialization method of node selector */
3838  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
3839  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
3840  SCIP_NODESELDATA* nodeseldata /**< node selector data */
3841  );
3842 
3843 /** Creates a node selector and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3844  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3845  * Optional callbacks can be set via specific setter functions, see SCIPsetNodeselCopy(), SCIPsetNodeselFree(),
3846  * SCIPsetNodeselInit(), SCIPsetNodeselExit(), SCIPsetNodeselInitsol(), and SCIPsetNodeselExitsol()
3847  *
3848  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeNodesel() instead
3849  */
3850 extern
3852  SCIP* scip, /**< SCIP data structure */
3853  SCIP_NODESEL** nodesel, /**< reference to a node selector, or NULL */
3854  const char* name, /**< name of node selector */
3855  const char* desc, /**< description of node selector */
3856  int stdpriority, /**< priority of the node selector in standard mode */
3857  int memsavepriority, /**< priority of the node selector in memory saving mode */
3858  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
3859  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
3860  SCIP_NODESELDATA* nodeseldata /**< node selector data */
3861  );
3862 
3863 /** sets copy method of node selector */
3864 extern
3866  SCIP* scip, /**< SCIP data structure */
3867  SCIP_NODESEL* nodesel, /**< node selector */
3868  SCIP_DECL_NODESELCOPY ((*nodeselcopy)) /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
3869  );
3870 
3871 /** sets destructor method of node selector */
3872 extern
3874  SCIP* scip, /**< SCIP data structure */
3875  SCIP_NODESEL* nodesel, /**< node selector */
3876  SCIP_DECL_NODESELFREE ((*nodeselfree)) /**< destructor of node selector */
3877  );
3878 
3879 /** sets initialization method of node selector */
3880 extern
3882  SCIP* scip, /**< SCIP data structure */
3883  SCIP_NODESEL* nodesel, /**< node selector */
3884  SCIP_DECL_NODESELINIT ((*nodeselinit)) /**< initialize node selector */
3885  );
3886 
3887 /** sets deinitialization method of node selector */
3888 extern
3890  SCIP* scip, /**< SCIP data structure */
3891  SCIP_NODESEL* nodesel, /**< node selector */
3892  SCIP_DECL_NODESELEXIT ((*nodeselexit)) /**< deinitialize node selector */
3893  );
3894 
3895 /** sets solving process initialization method of node selector */
3896 extern
3898  SCIP* scip, /**< SCIP data structure */
3899  SCIP_NODESEL* nodesel, /**< node selector */
3900  SCIP_DECL_NODESELINITSOL ((*nodeselinitsol))/**< solving process initialization method of node selector */
3901  );
3902 
3903 /** sets solving process deinitialization method of node selector */
3904 extern
3906  SCIP* scip, /**< SCIP data structure */
3907  SCIP_NODESEL* nodesel, /**< node selector */
3908  SCIP_DECL_NODESELEXITSOL ((*nodeselexitsol))/**< solving process deinitialization method of node selector */
3909  );
3910 
3911 /** returns the node selector of the given name, or NULL if not existing */
3912 extern
3914  SCIP* scip, /**< SCIP data structure */
3915  const char* name /**< name of node selector */
3916  );
3917 
3918 /** returns the array of currently available node selectors */
3919 extern
3921  SCIP* scip /**< SCIP data structure */
3922  );
3923 
3924 /** returns the number of currently available node selectors */
3925 extern
3926 int SCIPgetNNodesels(
3927  SCIP* scip /**< SCIP data structure */
3928  );
3929 
3930 /** sets the priority of a node selector in standard mode */
3931 extern
3933  SCIP* scip, /**< SCIP data structure */
3934  SCIP_NODESEL* nodesel, /**< node selector */
3935  int priority /**< new standard priority of the node selector */
3936  );
3937 
3938 /** sets the priority of a node selector in memory saving mode */
3939 extern
3941  SCIP* scip, /**< SCIP data structure */
3942  SCIP_NODESEL* nodesel, /**< node selector */
3943  int priority /**< new memory saving priority of the node selector */
3944  );
3945 
3946 /** returns the currently used node selector */
3947 extern
3949  SCIP* scip /**< SCIP data structure */
3950  );
3951 
3952 /** creates a branching rule and includes it in SCIP
3953  *
3954  * @note method has all branching rule callbacks as arguments and is thus changed every time a new
3955  * callback is added in future releases; consider using SCIPincludeBranchruleBasic() and setter functions
3956  * if you seek for a method which is less likely to change in future releases
3957  */
3958 extern
3960  SCIP* scip, /**< SCIP data structure */
3961  const char* name, /**< name of branching rule */
3962  const char* desc, /**< description of branching rule */
3963  int priority, /**< priority of the branching rule */
3964  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
3965  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
3966  * compared to best node's dual bound for applying branching rule
3967  * (0.0: only on current best node, 1.0: on all nodes) */
3968  SCIP_DECL_BRANCHCOPY ((*branchcopy)), /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
3969  SCIP_DECL_BRANCHFREE ((*branchfree)), /**< destructor of branching rule */
3970  SCIP_DECL_BRANCHINIT ((*branchinit)), /**< initialize branching rule */
3971  SCIP_DECL_BRANCHEXIT ((*branchexit)), /**< deinitialize branching rule */
3972  SCIP_DECL_BRANCHINITSOL((*branchinitsol)),/**< solving process initialization method of branching rule */
3973  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)),/**< solving process deinitialization method of branching rule */
3974  SCIP_DECL_BRANCHEXECLP((*branchexeclp)), /**< branching execution method for fractional LP solutions */
3975  SCIP_DECL_BRANCHEXECEXT((*branchexecext)),/**< branching execution method for external candidates */
3976  SCIP_DECL_BRANCHEXECPS((*branchexecps)), /**< branching execution method for not completely fixed pseudo solutions */
3977  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
3978  );
3979 
3980 /** creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
3981  * Optional callbacks can be set via specific setter functions, see SCIPsetBranchruleInit(), SCIPsetBranchruleExit(),
3982  * SCIPsetBranchruleCopy(), SCIPsetBranchruleFree(), SCIPsetBranchruleInitsol(), SCIPsetBranchruleExitsol(),
3983  * SCIPsetBranchruleExecLp(), SCIPsetBranchruleExecExt(), and SCIPsetBranchruleExecPs().
3984  *
3985  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeBranchrule() instead
3986  */
3987 extern
3989  SCIP* scip, /**< SCIP data structure */
3990  SCIP_BRANCHRULE** branchruleptr, /**< pointer to branching rule, or NULL */
3991  const char* name, /**< name of branching rule */
3992  const char* desc, /**< description of branching rule */
3993  int priority, /**< priority of the branching rule */
3994  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
3995  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
3996  * compared to best node's dual bound for applying branching rule
3997  * (0.0: only on current best node, 1.0: on all nodes) */
3998  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
3999  );
4000 
4001 /** sets copy method of branching rule */
4002 extern
4004  SCIP* scip, /**< SCIP data structure */
4005  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4006  SCIP_DECL_BRANCHCOPY ((*branchcopy)) /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
4007  );
4008 
4009 /** sets destructor method of branching rule */
4010 extern
4012  SCIP* scip, /**< SCIP data structure */
4013  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4014  SCIP_DECL_BRANCHFREE ((*branchfree)) /**< destructor of branching rule */
4015  );
4016 
4017 /** sets initialization method of branching rule */
4018 extern
4020  SCIP* scip, /**< SCIP data structure */
4021  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4022  SCIP_DECL_BRANCHINIT ((*branchinit)) /**< initialize branching rule */
4023  );
4024 
4025 /** sets deinitialization method of branching rule */
4026 extern
4028  SCIP* scip, /**< SCIP data structure */
4029  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4030  SCIP_DECL_BRANCHEXIT ((*branchexit)) /**< deinitialize branching rule */
4031  );
4032 
4033 /** sets solving process initialization method of branching rule */
4034 extern
4036  SCIP* scip, /**< SCIP data structure */
4037  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4038  SCIP_DECL_BRANCHINITSOL((*branchinitsol)) /**< solving process initialization method of branching rule */
4039  );
4040 
4041 /** sets solving process deinitialization method of branching rule */
4042 extern
4044  SCIP* scip, /**< SCIP data structure */
4045  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4046  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)) /**< solving process deinitialization method of branching rule */
4047  );
4048 
4049 /** sets branching execution method for fractional LP solutions */
4050 extern
4052  SCIP* scip, /**< SCIP data structure */
4053  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4054  SCIP_DECL_BRANCHEXECLP((*branchexeclp)) /**< branching execution method for fractional LP solutions */
4055  );
4056 
4057 /** sets branching execution method for external candidates */
4058 extern
4060  SCIP* scip, /**< SCIP data structure */
4061  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4062  SCIP_DECL_BRANCHEXECEXT((*branchexecext)) /**< branching execution method for external candidates */
4063  );
4064 
4065 /** sets branching execution method for not completely fixed pseudo solutions */
4066 extern
4068  SCIP* scip, /**< SCIP data structure */
4069  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4070  SCIP_DECL_BRANCHEXECPS((*branchexecps)) /**< branching execution method for not completely fixed pseudo solutions */
4071  );
4072 
4073 /** returns the branching rule of the given name, or NULL if not existing */
4074 extern
4076  SCIP* scip, /**< SCIP data structure */
4077  const char* name /**< name of branching rule */
4078  );
4079 
4080 /** returns the array of currently available branching rules */
4081 extern
4083  SCIP* scip /**< SCIP data structure */
4084  );
4085 
4086 /** returns the number of currently available branching rules */
4087 extern
4089  SCIP* scip /**< SCIP data structure */
4090  );
4091 
4092 /** sets the priority of a branching rule */
4093 extern
4095  SCIP* scip, /**< SCIP data structure */
4096  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4097  int priority /**< new priority of the branching rule */
4098  );
4099 
4100 /** sets maximal depth level, up to which this branching rule should be used (-1 for no limit) */
4101 extern
4103  SCIP* scip, /**< SCIP data structure */
4104  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4105  int maxdepth /**< new maxdepth of the branching rule */
4106  );
4107 
4108 /** sets maximal relative distance from current node's dual bound to primal bound for applying branching rule */
4109 extern
4111  SCIP* scip, /**< SCIP data structure */
4112  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4113  SCIP_Real maxbounddist /**< new maxbounddist of the branching rule */
4114  );
4115 
4116 /** creates a display column and includes it in SCIP */
4117 extern
4119  SCIP* scip, /**< SCIP data structure */
4120  const char* name, /**< name of display column */
4121  const char* desc, /**< description of display column */
4122  const char* header, /**< head line of display column */
4123  SCIP_DISPSTATUS dispstatus, /**< display activation status of display column */
4124  SCIP_DECL_DISPCOPY ((*dispcopy)), /**< copy method of display column or NULL if you don't want to copy your plugin into sub-SCIPs */
4125  SCIP_DECL_DISPFREE ((*dispfree)), /**< destructor of display column */
4126  SCIP_DECL_DISPINIT ((*dispinit)), /**< initialize display column */
4127  SCIP_DECL_DISPEXIT ((*dispexit)), /**< deinitialize display column */
4128  SCIP_DECL_DISPINITSOL ((*dispinitsol)), /**< solving process initialization method of display column */
4129  SCIP_DECL_DISPEXITSOL ((*dispexitsol)), /**< solving process deinitialization method of display column */
4130  SCIP_DECL_DISPOUTPUT ((*dispoutput)), /**< output method */
4131  SCIP_DISPDATA* dispdata, /**< display column data */
4132  int width, /**< width of display column (no. of chars used) */
4133  int priority, /**< priority of display column */
4134  int position, /**< relative position of display column */
4135  SCIP_Bool stripline /**< should the column be separated with a line from its right neighbor? */
4136  );
4137 
4138 /** returns the display column of the given name, or NULL if not existing */
4139 extern
4141  SCIP* scip, /**< SCIP data structure */
4142  const char* name /**< name of display column */
4143  );
4144 
4145 /** returns the array of currently available display columns */
4146 extern
4148  SCIP* scip /**< SCIP data structure */
4149  );
4150 
4151 /** returns the number of currently available display columns */
4152 extern
4153 int SCIPgetNDisps(
4154  SCIP* scip /**< SCIP data structure */
4155  );
4156 
4157 /** automatically selects display columns for being shown w.r.t. the display width parameter */
4158 extern
4160  SCIP* scip /**< SCIP data structure */
4161  );
4162 
4163 /** includes an NLPI in SCIP */
4164 extern
4166  SCIP* scip, /**< SCIP data structure */
4167  SCIP_NLPI* nlpi /**< NLPI data structure */
4168  );
4169 
4170 /** returns the NLPI of the given name, or NULL if not existing */
4171 extern
4173  SCIP* scip, /**< SCIP data structure */
4174  const char* name /**< name of NLPI */
4175  );
4176 
4177 /** returns the array of currently available NLPIs (sorted by priority) */
4178 extern
4180  SCIP* scip /**< SCIP data structure */
4181  );
4182 
4183 /** returns the number of currently available NLPIs */
4184 extern
4185 int SCIPgetNNlpis(
4186  SCIP* scip /**< SCIP data structure */
4187  );
4188 
4189 /** sets the priority of an NLPI */
4190 extern
4192  SCIP* scip, /**< SCIP data structure */
4193  SCIP_NLPI* nlpi, /**< NLPI */
4194  int priority /**< new priority of the NLPI */
4195  );
4196 
4197 /** includes information about an external code linked into the SCIP library */
4198 extern
4200  SCIP* scip, /**< SCIP data structure */
4201  const char* name, /**< name of external code */
4202  const char* description /**< description of external code, or NULL */
4203  );
4204 
4205 /** returns an array of names of currently included external codes */
4206 extern
4208  SCIP* scip /**< SCIP data structure */
4209  );
4210 
4211 /** returns an array of the descriptions of currently included external codes
4212  *
4213  * @note some descriptions may be NULL
4214  */
4215 extern
4217  SCIP* scip /**< SCIP data structure */
4218  );
4219 
4220 /** returns the number of currently included information on external codes */
4221 extern
4223  SCIP* scip /**< SCIP data structure */
4224  );
4225 
4226 /** prints information on external codes to a file stream via the message handler system
4227  *
4228  * @note If the message handler is set to a NULL pointer nothing will be printed
4229  */
4230 extern
4232  SCIP* scip, /**< SCIP data structure */
4233  FILE* file /**< output file (or NULL for standard output) */
4234  );
4235 
4236 /**@} */
4237 
4238 
4239 
4240 
4241 /*
4242  * user interactive dialog methods
4243  */
4244 
4245 /**@name User Interactive Dialog Methods */
4246 /**@{ */
4247 
4248 /** creates and includes dialog
4249  *
4250  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4251  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4252  */
4253 extern
4255  SCIP* scip, /**< SCIP data structure */
4256  SCIP_DIALOG** dialog, /**< pointer to store the dialog */
4257  SCIP_DECL_DIALOGCOPY ((*dialogcopy)), /**< copy method of dialog or NULL if you don't want to copy your plugin into sub-SCIPs */
4258  SCIP_DECL_DIALOGEXEC ((*dialogexec)), /**< execution method of dialog */
4259  SCIP_DECL_DIALOGDESC ((*dialogdesc)), /**< description output method of dialog, or NULL */
4260  SCIP_DECL_DIALOGFREE ((*dialogfree)), /**< destructor of dialog to free user data, or NULL */
4261  const char* name, /**< name of dialog: command name appearing in parent's dialog menu */
4262  const char* desc, /**< description of dialog used if description output method is NULL */
4263  SCIP_Bool issubmenu, /**< is the dialog a submenu? */
4264  SCIP_DIALOGDATA* dialogdata /**< user defined dialog data */
4265  );
4266 
4267 /** returns if the dialog already exists
4268  *
4269  * @return TRUE is returned if the dialog exits, otherwise FALSE.
4270  */
4271 extern
4273  SCIP* scip, /**< SCIP data structure */
4274  SCIP_DIALOG* dialog /**< dialog */
4275  );
4276 
4277 /** captures a dialog
4278  *
4279  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4280  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4281  */
4282 extern
4284  SCIP* scip, /**< SCIP data structure */
4285  SCIP_DIALOG* dialog /**< dialog */
4286  );
4287 
4288 /** releases a dialog
4289  *
4290  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4291  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4292  */
4293 extern
4295  SCIP* scip, /**< SCIP data structure */
4296  SCIP_DIALOG** dialog /**< pointer to the dialog */
4297  );
4298 
4299 /** makes given dialog the root dialog of SCIP's interactive user shell; captures dialog and releases former root dialog
4300  *
4301  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4302  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4303  */
4304 extern
4306  SCIP* scip, /**< SCIP data structure */
4307  SCIP_DIALOG* dialog /**< dialog to be the root */
4308  );
4309 
4310 /** returns the root dialog of SCIP's interactive user shell
4311  *
4312  * @return the root dialog of SCIP's interactive user shell is returned.
4313  */
4314 extern
4316  SCIP* scip /**< SCIP data structure */
4317  );
4318 
4319 /** adds a sub dialog to the given dialog as menu entry and captures it
4320  *
4321  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4322  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4323  */
4324 extern
4326  SCIP* scip, /**< SCIP data structure */
4327  SCIP_DIALOG* dialog, /**< dialog to extend, or NULL for root dialog */
4328  SCIP_DIALOG* subdialog /**< subdialog to add as menu entry in dialog */
4329  );
4330 
4331 /** adds a single line of input which is treated as if the user entered the command line
4332  *
4333  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4334  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4335  */
4336 extern
4338  SCIP* scip, /**< SCIP data structure */
4339  const char* inputline /**< input line to add */
4340  );
4341 
4342 /** adds a single line of input to the command history which can be accessed with the cursor keys
4343  *
4344  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4345  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4346  */
4347 extern
4349  SCIP* scip, /**< SCIP data structure */
4350  const char* inputline /**< input line to add */
4351  );
4352 
4353 /** starts interactive mode of SCIP by executing the root dialog
4354  *
4355  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4356  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4357  *
4358  * @pre This method can be called if @p scip is in one of the following stages:
4359  * - \ref SCIP_STAGE_INIT
4360  * - \ref SCIP_STAGE_FREE
4361  *
4362  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the
4363  * interactive shell was closed:
4364  * - \ref SCIP_STAGE_PROBLEM if the interactive shell was closed after the problem was created
4365  * - \ref SCIP_STAGE_TRANSFORMED if the interactive shell was closed after the problem was transformed
4366  * - \ref SCIP_STAGE_PRESOLVING if the interactive shell was closed during presolving
4367  * - \ref SCIP_STAGE_PRESOLVED if the interactive shell was closed after presolve
4368  * - \ref SCIP_STAGE_SOLVING if the interactive shell was closed during the tree search
4369  * - \ref SCIP_STAGE_SOLVED if the interactive shell was closed after the problem was solved
4370  * - \ref SCIP_STAGE_FREE if the interactive shell was closed after the problem was freed
4371  *
4372  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
4373  */
4374 extern
4376  SCIP* scip /**< SCIP data structure */
4377  );
4378 
4379 /**@} */
4380 
4381 
4382 
4383 
4384 /*
4385  * global problem methods
4386  */
4387 
4388 /**@name Global Problem Methods */
4389 /**@{ */
4390 
4391 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
4392  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
4393  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
4394  *
4395  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4396  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4397  *
4398  * @pre This method can be called if @p scip is in one of the following stages:
4399  * - \ref SCIP_STAGE_INIT
4400  * - \ref SCIP_STAGE_PROBLEM
4401  * - \ref SCIP_STAGE_TRANSFORMED
4402  * - \ref SCIP_STAGE_PRESOLVING
4403  * - \ref SCIP_STAGE_PRESOLVED
4404  * - \ref SCIP_STAGE_SOLVING
4405  * - \ref SCIP_STAGE_SOLVED
4406  * - \ref SCIP_STAGE_FREE
4407  *
4408  * @post After calling this method, \SCIP reaches the following stage:
4409  * - \ref SCIP_STAGE_PROBLEM
4410  */
4411 extern
4413  SCIP* scip, /**< SCIP data structure */
4414  const char* name, /**< problem name */
4415  SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
4416  SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
4417  SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
4418  SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
4419  SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
4420  SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
4421  SCIP_PROBDATA* probdata /**< user problem data set by the reader */
4422  );
4423 
4424 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
4425  * all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(),
4426  * SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and
4427  * SCIPsetProbCopy()
4428  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
4429  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
4430  *
4431  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4432  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4433  *
4434  * @pre This method can be called if @p scip is in one of the following stages:
4435  * - \ref SCIP_STAGE_INIT
4436  * - \ref SCIP_STAGE_PROBLEM
4437  * - \ref SCIP_STAGE_TRANSFORMED
4438  * - \ref SCIP_STAGE_PRESOLVING
4439  * - \ref SCIP_STAGE_PRESOLVED
4440  * - \ref SCIP_STAGE_SOLVING
4441  * - \ref SCIP_STAGE_SOLVED
4442  * - \ref SCIP_STAGE_FREE
4443  *
4444  * @post After calling this method, \SCIP reaches the following stage:
4445  * - \ref SCIP_STAGE_PROBLEM
4446  */
4447 extern
4449  SCIP* scip, /**< SCIP data structure */
4450  const char* name /**< problem name */
4451  );
4452 
4453 /** sets callback to free user data of original problem
4454  *
4455  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4456  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4457  *
4458  * @pre This method can be called if @p scip is in one of the following stages:
4459  * - \ref SCIP_STAGE_PROBLEM
4460  */
4462  SCIP* scip, /**< SCIP data structure */
4463  SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
4464  );
4465 
4466 /** sets callback to create user data of transformed problem by transforming original user data
4467  *
4468  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4469  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4470  *
4471  * @pre This method can be called if @p scip is in one of the following stages:
4472  * - \ref SCIP_STAGE_PROBLEM
4473  */
4474 extern
4476  SCIP* scip, /**< SCIP data structure */
4477  SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
4478  );
4479 
4480 /** sets callback to free user data of transformed problem
4481  *
4482  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4483  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4484  *
4485  * @pre This method can be called if @p scip is in one of the following stages:
4486  * - \ref SCIP_STAGE_PROBLEM
4487  */
4488 extern
4490  SCIP* scip, /**< SCIP data structure */
4491  SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
4492  );
4493 
4494 /** sets solving process initialization callback of transformed data
4495  *
4496  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4497  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4498  *
4499  * @pre This method can be called if @p scip is in one of the following stages:
4500  * - \ref SCIP_STAGE_PROBLEM
4501  */
4502 extern
4504  SCIP* scip, /**< SCIP data structure */
4505  SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization method of transformed data */
4506  );
4507 
4508 /** sets solving process deinitialization callback of transformed data
4509  *
4510  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4511  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4512  *
4513  * @pre This method can be called if @p scip is in one of the following stages:
4514  * - \ref SCIP_STAGE_PROBLEM
4515  */
4516 extern
4518  SCIP* scip, /**< SCIP data structure */
4519  SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization method of transformed data */
4520  );
4521 
4522 /** sets callback to copy user data to a subscip
4523  *
4524  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4525  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4526  *
4527  * @pre This method can be called if @p scip is in one of the following stages:
4528  * - \ref SCIP_STAGE_PROBLEM
4529  */
4530 extern
4532  SCIP* scip, /**< SCIP data structure */
4533  SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
4534  );
4535 
4536 /** reads problem from file and initializes all solving data structures
4537  *
4538  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4539  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4540  *
4541  * @pre This method can be called if @p scip is in one of the following stages:
4542  * - \ref SCIP_STAGE_INIT
4543  * - \ref SCIP_STAGE_PROBLEM
4544  * - \ref SCIP_STAGE_TRANSFORMED
4545  * - \ref SCIP_STAGE_INITPRESOLVE
4546  * - \ref SCIP_STAGE_PRESOLVING
4547  * - \ref SCIP_STAGE_EXITPRESOLVE
4548  * - \ref SCIP_STAGE_PRESOLVED
4549  * - \ref SCIP_STAGE_SOLVING
4550  * - \ref SCIP_STAGE_EXITSOLVE
4551  *
4552  * @post After the method was called, \SCIP is in one of the following stages:
4553  * -\ref SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
4554  * - ref SCIP_STAGE_PROBLEM if the problem file was successfully read
4555  */
4556 extern
4558  SCIP* scip, /**< SCIP data structure */
4559  const char* filename, /**< problem file name */
4560  const char* extension /**< extension of the desired file reader,
4561  * or NULL if file extension should be used */
4562  );
4563 
4564 /** writes original problem to file
4565  *
4566  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4567  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4568  *
4569  * @pre This method can be called if @p scip is in one of the following stages:
4570  * - \ref SCIP_STAGE_PROBLEM
4571  * - \ref SCIP_STAGE_TRANSFORMING
4572  * - \ref SCIP_STAGE_TRANSFORMED
4573  * - \ref SCIP_STAGE_INITPRESOLVE
4574  * - \ref SCIP_STAGE_PRESOLVING
4575  * - \ref SCIP_STAGE_EXITPRESOLVE
4576  * - \ref SCIP_STAGE_PRESOLVED
4577  * - \ref SCIP_STAGE_INITSOLVE
4578  * - \ref SCIP_STAGE_SOLVING
4579  * - \ref SCIP_STAGE_SOLVED
4580  * - \ref SCIP_STAGE_EXITSOLVE
4581  * - \ref SCIP_STAGE_FREETRANS
4582  */
4583 extern
4585  SCIP* scip, /**< SCIP data structure */
4586  const char* filename, /**< output file (or NULL for standard output) */
4587  const char* extension, /**< extension of the desired file reader,
4588  * or NULL if file extension should be used */
4589  SCIP_Bool genericnames /**< use generic variable and constraint names? */
4590  );
4591 
4592 /** writes transformed problem which are valid in the current node to file
4593  *
4594  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4595  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4596  *
4597  * @pre This method can be called if @p scip is in one of the following stages:
4598  * - \ref SCIP_STAGE_TRANSFORMED
4599  * - \ref SCIP_STAGE_INITPRESOLVE
4600  * - \ref SCIP_STAGE_PRESOLVING
4601  * - \ref SCIP_STAGE_EXITPRESOLVE
4602  * - \ref SCIP_STAGE_PRESOLVED
4603  * - \ref SCIP_STAGE_INITSOLVE
4604  * - \ref SCIP_STAGE_SOLVING
4605  * - \ref SCIP_STAGE_SOLVED
4606  * - \ref SCIP_STAGE_EXITSOLVE
4607  *
4608  * @note If you want the write all constraints (including the once which are redundant for example), you need to set
4609  * the parameter <write/allconss> to TRUE
4610  */
4611 extern
4613  SCIP* scip, /**< SCIP data structure */
4614  const char* filename, /**< output file (or NULL for standard output) */
4615  const char* extension, /**< extension of the desired file reader,
4616  * or NULL if file extension should be used */
4617  SCIP_Bool genericnames /**< using generic variable and constraint names? */
4618  );
4619 
4620 /** frees problem and solution process data
4621  *
4622  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4623  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4624  *
4625  * @pre This method can be called if @p scip is in one of the following stages:
4626  * - \ref SCIP_STAGE_INIT
4627  * - \ref SCIP_STAGE_PROBLEM
4628  * - \ref SCIP_STAGE_TRANSFORMED
4629  * - \ref SCIP_STAGE_PRESOLVING
4630  * - \ref SCIP_STAGE_PRESOLVED
4631  * - \ref SCIP_STAGE_SOLVING
4632  * - \ref SCIP_STAGE_SOLVED
4633  * - \ref SCIP_STAGE_FREE
4634  *
4635  * @post After this method was called, SCIP is in the following stage:
4636  * - \ref SCIP_STAGE_INIT
4637  */
4638 extern
4640  SCIP* scip /**< SCIP data structure */
4641  );
4642 
4643 /** permutes parts of the problem data structure
4644  *
4645  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4646  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4647  *
4648  * @pre This method can be called if @p scip is in one of the following stages:
4649  * - \ref SCIP_STAGE_PROBLEM
4650  * - \ref SCIP_STAGE_TRANSFORMED
4651  */
4652 extern
4654  SCIP* scip, /**< SCIP data structure */
4655  unsigned int randseed, /**< seed value for random generator */
4656  SCIP_Bool permuteconss, /**< should the list of constraints in each constraint handler be permuted? */
4657  SCIP_Bool permutebinvars, /**< should the list of binary variables be permuted? */
4658  SCIP_Bool permuteintvars, /**< should the list of integer variables be permuted? */
4659  SCIP_Bool permuteimplvars, /**< should the list of implicit integer variables be permuted? */
4660  SCIP_Bool permutecontvars /**< should the list of continuous integer variables be permuted? */
4661  );
4662 
4663 /** gets user problem data
4664  *
4665  * @return a SCIP_PROBDATA pointer, or NULL if no problem data was allocated
4666  *
4667  * @pre This method can be called if @p scip is in one of the following stages:
4668  * - \ref SCIP_STAGE_PROBLEM
4669  * - \ref SCIP_STAGE_TRANSFORMING
4670  * - \ref SCIP_STAGE_TRANSFORMED
4671  * - \ref SCIP_STAGE_INITPRESOLVE
4672  * - \ref SCIP_STAGE_PRESOLVING
4673  * - \ref SCIP_STAGE_EXITPRESOLVE
4674  * - \ref SCIP_STAGE_PRESOLVED
4675  * - \ref SCIP_STAGE_INITSOLVE
4676  * - \ref SCIP_STAGE_SOLVING
4677  * - \ref SCIP_STAGE_SOLVED
4678  * - \ref SCIP_STAGE_EXITSOLVE
4679  * - \ref SCIP_STAGE_FREETRANS
4680  */
4681 extern
4683  SCIP* scip /**< SCIP data structure */
4684  );
4685 
4686 /** sets user problem data
4687  *
4688  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4689  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4690  *
4691  * @pre This method can be called if @p scip is in one of the following stages:
4692  * - \ref SCIP_STAGE_PROBLEM
4693  * - \ref SCIP_STAGE_TRANSFORMING
4694  * - \ref SCIP_STAGE_TRANSFORMED
4695  * - \ref SCIP_STAGE_INITPRESOLVE
4696  * - \ref SCIP_STAGE_PRESOLVING
4697  * - \ref SCIP_STAGE_EXITPRESOLVE
4698  * - \ref SCIP_STAGE_PRESOLVED
4699  * - \ref SCIP_STAGE_INITSOLVE
4700  * - \ref SCIP_STAGE_SOLVING
4701  * - \ref SCIP_STAGE_SOLVED
4702  * - \ref SCIP_STAGE_EXITSOLVE
4703  * - \ref SCIP_STAGE_FREETRANS
4704  */
4705 extern
4707  SCIP* scip, /**< SCIP data structure */
4708  SCIP_PROBDATA* probdata /**< user problem data to use */
4709  );
4710 
4711 /** returns name of the current problem instance
4712  *
4713  * @return name of the current problem instance
4714  *
4715  * @pre This method can be called if @p scip is in one of the following stages:
4716  * - \ref SCIP_STAGE_PROBLEM
4717  * - \ref SCIP_STAGE_TRANSFORMING
4718  * - \ref SCIP_STAGE_TRANSFORMED
4719  * - \ref SCIP_STAGE_INITPRESOLVE
4720  * - \ref SCIP_STAGE_PRESOLVING
4721  * - \ref SCIP_STAGE_EXITPRESOLVE
4722  * - \ref SCIP_STAGE_PRESOLVED
4723  * - \ref SCIP_STAGE_INITSOLVE
4724  * - \ref SCIP_STAGE_SOLVING
4725  * - \ref SCIP_STAGE_SOLVED
4726  * - \ref SCIP_STAGE_EXITSOLVE
4727  * - \ref SCIP_STAGE_FREETRANS
4728  */
4729 extern
4730 const char* SCIPgetProbName(
4731  SCIP* scip /**< SCIP data structure */
4732  );
4733 
4734 /** sets name of the current problem instance
4735  *
4736  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4737  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4738  *
4739  * @pre This method can be called if @p scip is in one of the following stages:
4740  * - \ref SCIP_STAGE_PROBLEM
4741  * - \ref SCIP_STAGE_TRANSFORMING
4742  * - \ref SCIP_STAGE_TRANSFORMED
4743  * - \ref SCIP_STAGE_INITPRESOLVE
4744  * - \ref SCIP_STAGE_PRESOLVING
4745  * - \ref SCIP_STAGE_EXITPRESOLVE
4746  * - \ref SCIP_STAGE_PRESOLVED
4747  * - \ref SCIP_STAGE_INITSOLVE
4748  * - \ref SCIP_STAGE_SOLVING
4749  * - \ref SCIP_STAGE_SOLVED
4750  * - \ref SCIP_STAGE_EXITSOLVE
4751  * - \ref SCIP_STAGE_FREETRANS
4752  */
4753 extern
4755  SCIP* scip, /**< SCIP data structure */
4756  const char* name /**< name to be set */
4757  );
4758 
4759 /** returns objective sense of original problem
4760  *
4761  * @return objective sense of original problem
4762  *
4763  * @pre This method can be called if @p scip is in one of the following stages:
4764  * - \ref SCIP_STAGE_PROBLEM
4765  * - \ref SCIP_STAGE_TRANSFORMING
4766  * - \ref SCIP_STAGE_TRANSFORMED
4767  * - \ref SCIP_STAGE_INITPRESOLVE
4768  * - \ref SCIP_STAGE_PRESOLVING
4769  * - \ref SCIP_STAGE_EXITPRESOLVE
4770  * - \ref SCIP_STAGE_PRESOLVED
4771  * - \ref SCIP_STAGE_INITSOLVE
4772  * - \ref SCIP_STAGE_SOLVING
4773  * - \ref SCIP_STAGE_SOLVED
4774  * - \ref SCIP_STAGE_EXITSOLVE
4775  * - \ref SCIP_STAGE_FREETRANS
4776  */
4777 extern
4779  SCIP* scip /**< SCIP data structure */
4780  );
4781 
4782 /** sets objective sense of problem
4783  *
4784  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4785  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4786  *
4787  * @pre This method can be called if @p scip is in one of the following stages:
4788  * - \ref SCIP_STAGE_PROBLEM
4789  */
4790 extern
4792  SCIP* scip, /**< SCIP data structure */
4793  SCIP_OBJSENSE objsense /**< new objective sense */
4794  );
4795 
4796 /** adds offset of objective function
4797  *
4798  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4799  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4800  *
4801  * @pre This method can be called if @p scip is in one of the following stages:
4802  * - \ref SCIP_STAGE_PRESOLVING
4803  */
4804 extern
4806  SCIP* scip, /**< SCIP data structure */
4807  SCIP_Real addval /**< value to add to objective offset */
4808  );
4809 
4810 /** adds offset of objective function to original problem and to all existing solution in original space
4811  *
4812  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4813  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4814  *
4815  * @pre This method can be called if @p scip is in one of the following stages:
4816  * - \ref SCIP_STAGE_PROBLEM
4817  */
4818 extern
4820  SCIP* scip, /**< SCIP data structure */
4821  SCIP_Real addval /**< value to add to objective offset */
4822  );
4823 
4824 /** returns the objective offset of the original problem
4825  *
4826  * @return the objective offset of the original problem
4827  *
4828  * @pre This method can be called if @p scip is in one of the following stages:
4829  * - \ref SCIP_STAGE_PROBLEM
4830  * - \ref SCIP_STAGE_TRANSFORMING
4831  * - \ref SCIP_STAGE_TRANSFORMED
4832  * - \ref SCIP_STAGE_INITPRESOLVE
4833  * - \ref SCIP_STAGE_PRESOLVING
4834  * - \ref SCIP_STAGE_EXITPRESOLVE
4835  * - \ref SCIP_STAGE_PRESOLVED
4836  * - \ref SCIP_STAGE_INITSOLVE
4837  * - \ref SCIP_STAGE_SOLVING
4838  * - \ref SCIP_STAGE_SOLVED
4839  */
4840 extern
4842  SCIP* scip /**< SCIP data structure */
4843  );
4844 
4845 /** returns the objective scale of the original problem
4846  *
4847  * @return the objective scale of the original problem
4848  *
4849  * @pre This method can be called if @p scip is in one of the following stages:
4850  * - \ref SCIP_STAGE_PROBLEM
4851  * - \ref SCIP_STAGE_TRANSFORMING
4852  * - \ref SCIP_STAGE_TRANSFORMED
4853  * - \ref SCIP_STAGE_INITPRESOLVE
4854  * - \ref SCIP_STAGE_PRESOLVING
4855  * - \ref SCIP_STAGE_EXITPRESOLVE
4856  * - \ref SCIP_STAGE_PRESOLVED
4857  * - \ref SCIP_STAGE_INITSOLVE
4858  * - \ref SCIP_STAGE_SOLVING
4859  * - \ref SCIP_STAGE_SOLVED
4860  */
4861 extern
4863  SCIP* scip /**< SCIP data structure */
4864  );
4865 
4866 /** returns the objective offset of the transformed problem
4867  *
4868  * @return the objective offset of the transformed problem
4869  *
4870  * @pre This method can be called if @p scip is in one of the following stages:
4871  * - \ref SCIP_STAGE_TRANSFORMED
4872  * - \ref SCIP_STAGE_INITPRESOLVE
4873  * - \ref SCIP_STAGE_PRESOLVING
4874  * - \ref SCIP_STAGE_EXITPRESOLVE
4875  * - \ref SCIP_STAGE_PRESOLVED
4876  * - \ref SCIP_STAGE_INITSOLVE
4877  * - \ref SCIP_STAGE_SOLVING
4878  * - \ref SCIP_STAGE_SOLVED
4879  */
4880 extern
4882  SCIP* scip /**< SCIP data structure */
4883  );
4884 
4885 /** returns the objective scale of the transformed problem
4886  *
4887  * @return the objective scale of the transformed problem
4888  *
4889  * @pre This method can be called if @p scip is in one of the following stages:
4890  * - \ref SCIP_STAGE_TRANSFORMED
4891  * - \ref SCIP_STAGE_INITPRESOLVE
4892  * - \ref SCIP_STAGE_PRESOLVING
4893  * - \ref SCIP_STAGE_EXITPRESOLVE
4894  * - \ref SCIP_STAGE_PRESOLVED
4895  * - \ref SCIP_STAGE_INITSOLVE
4896  * - \ref SCIP_STAGE_SOLVING
4897  * - \ref SCIP_STAGE_SOLVED
4898  */
4899 extern
4901  SCIP* scip /**< SCIP data structure */
4902  );
4903 
4904 /** sets limit on objective function, such that only solutions better than this limit are accepted
4905  *
4906  * @note SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune
4907  * all branch-and-bound nodes with dual bound equal or worse to the objective limit.
4908  * However, SCIP will also collect solutions with objective value worse than the objective limit and
4909  * use them to run improvement heuristics on them.
4910  * @note If SCIP can prove that there exists no solution with a strictly better objective value, the solving status
4911  * will normally be infeasible (the objective limit is interpreted as part of the problem).
4912  * The only exception is that by chance, SCIP found a solution with the same objective value and thus
4913  * proved the optimality of this solution, resulting in solution status optimal.
4914  *
4915  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4916  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4917  *
4918  * @pre This method can be called if @p scip is in one of the following stages:
4919  * - \ref SCIP_STAGE_PROBLEM
4920  * - \ref SCIP_STAGE_TRANSFORMED
4921  * - \ref SCIP_STAGE_INITPRESOLVE
4922  * - \ref SCIP_STAGE_PRESOLVING
4923  * - \ref SCIP_STAGE_EXITPRESOLVE
4924  * - \ref SCIP_STAGE_PRESOLVED
4925  * - \ref SCIP_STAGE_SOLVING
4926  */
4927 extern
4929  SCIP* scip, /**< SCIP data structure */
4930  SCIP_Real objlimit /**< new primal objective limit */
4931  );
4932 
4933 /** returns current limit on objective function
4934  *
4935  * @return the current objective limit of the original problem
4936  *
4937  * @pre This method can be called if @p scip is in one of the following stages:
4938  * - \ref SCIP_STAGE_PROBLEM
4939  * - \ref SCIP_STAGE_TRANSFORMING
4940  * - \ref SCIP_STAGE_TRANSFORMED
4941  * - \ref SCIP_STAGE_INITPRESOLVE
4942  * - \ref SCIP_STAGE_PRESOLVING
4943  * - \ref SCIP_STAGE_EXITPRESOLVE
4944  * - \ref SCIP_STAGE_PRESOLVED
4945  * - \ref SCIP_STAGE_INITSOLVE
4946  * - \ref SCIP_STAGE_SOLVING
4947  * - \ref SCIP_STAGE_SOLVED
4948  */
4949 extern
4951  SCIP* scip /**< SCIP data structure */
4952  );
4953 
4954 /** informs SCIP, that the objective value is always integral in every feasible solution
4955  *
4956  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4957  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4958  *
4959  * @pre This method can be called if @p scip is in one of the following stages:
4960  * - \ref SCIP_STAGE_PROBLEM
4961  * - \ref SCIP_STAGE_TRANSFORMING
4962  * - \ref SCIP_STAGE_INITPRESOLVE
4963  * - \ref SCIP_STAGE_EXITPRESOLVE
4964  * - \ref SCIP_STAGE_SOLVING
4965  */
4966 extern
4968  SCIP* scip /**< SCIP data structure */
4969  );
4970 
4971 /** returns whether the objective value is known to be integral in every feasible solution
4972  *
4973  * @return TRUE, if objective value is known to be always integral, otherwise FALSE
4974  *
4975  * @pre This method can be called if @p scip is in one of the following stages:
4976  * - \ref SCIP_STAGE_PROBLEM
4977  * - \ref SCIP_STAGE_TRANSFORMING
4978  * - \ref SCIP_STAGE_INITPRESOLVE
4979  * - \ref SCIP_STAGE_PRESOLVING
4980  * - \ref SCIP_STAGE_EXITPRESOLVE
4981  * - \ref SCIP_STAGE_PRESOLVED
4982  * - \ref SCIP_STAGE_SOLVING
4983  */
4984 extern
4986  SCIP* scip /**< SCIP data structure */
4987  );
4988 
4989 /** returns the Euclidean norm of the objective function vector (available only for transformed problem)
4990  *
4991  * @return the Euclidean norm of the transformed objective function vector
4992  *
4993  * @pre This method can be called if @p scip is in one of the following stages:
4994  * - \ref SCIP_STAGE_TRANSFORMED
4995  * - \ref SCIP_STAGE_INITPRESOLVE
4996  * - \ref SCIP_STAGE_PRESOLVING
4997  * - \ref SCIP_STAGE_EXITPRESOLVE
4998  * - \ref SCIP_STAGE_PRESOLVED
4999  * - \ref SCIP_STAGE_INITSOLVE
5000  * - \ref SCIP_STAGE_SOLVING
5001  * - \ref SCIP_STAGE_SOLVED
5002  * - \ref SCIP_STAGE_EXITSOLVE
5003  */
5004 extern
5006  SCIP* scip /**< SCIP data structure */
5007  );
5008 
5009 /** adds variable to the problem
5010  *
5011  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5012  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5013  *
5014  * @pre This method can be called if @p scip is in one of the following stages:
5015  * - \ref SCIP_STAGE_PROBLEM
5016  * - \ref SCIP_STAGE_TRANSFORMING
5017  * - \ref SCIP_STAGE_INITPRESOLVE
5018  * - \ref SCIP_STAGE_PRESOLVING
5019  * - \ref SCIP_STAGE_EXITPRESOLVE
5020  * - \ref SCIP_STAGE_PRESOLVED
5021  * - \ref SCIP_STAGE_SOLVING
5022  */
5023 extern
5025  SCIP* scip, /**< SCIP data structure */
5026  SCIP_VAR* var /**< variable to add */
5027  );
5028 
5029 /** adds variable to the problem and uses it as pricing candidate to enter the LP
5030  *
5031  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5032  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5033  *
5034  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
5035  */
5036 extern
5038  SCIP* scip, /**< SCIP data structure */
5039  SCIP_VAR* var, /**< variable to add */
5040  SCIP_Real score /**< pricing score of variable (the larger, the better the variable) */
5041  );
5042 
5043 /** removes variable from the problem
5044  *
5045  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5046  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5047  *
5048  * @pre This method can be called if @p scip is in one of the following stages:
5049  * - \ref SCIP_STAGE_PROBLEM
5050  * - \ref SCIP_STAGE_TRANSFORMING
5051  * - \ref SCIP_STAGE_TRANSFORMED
5052  * - \ref SCIP_STAGE_PRESOLVING
5053  * - \ref SCIP_STAGE_PRESOLVED
5054  * - \ref SCIP_STAGE_SOLVING
5055  * - \ref SCIP_STAGE_EXITSOLVE
5056  * - \ref SCIP_STAGE_FREETRANS
5057  */
5058 extern
5060  SCIP* scip, /**< SCIP data structure */
5061  SCIP_VAR* var, /**< variable to delete */
5062  SCIP_Bool* deleted /**< pointer to store whether variable was successfully marked to be deleted */
5063  );
5064 
5065 /** gets variables of the problem along with the numbers of different variable types; data may become invalid after
5066  * calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5067  *
5068  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5069  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5070  *
5071  * @pre This method can be called if @p scip is in one of the following stages:
5072  * - \ref SCIP_STAGE_PROBLEM
5073  * - \ref SCIP_STAGE_TRANSFORMED
5074  * - \ref SCIP_STAGE_INITPRESOLVE
5075  * - \ref SCIP_STAGE_PRESOLVING
5076  * - \ref SCIP_STAGE_EXITPRESOLVE
5077  * - \ref SCIP_STAGE_PRESOLVED
5078  * - \ref SCIP_STAGE_INITSOLVE
5079  * - \ref SCIP_STAGE_SOLVING
5080  * - \ref SCIP_STAGE_SOLVED
5081  * - \ref SCIP_STAGE_EXITSOLVE
5082  *
5083  * @note Variables in the vars array are ordered: binaries first, then integers, implicit integers and continuous last.
5084  */
5085 extern
5087  SCIP* scip, /**< SCIP data structure */
5088  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5089  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5090  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5091  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5092  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5093  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5094  );
5095 
5096 /** gets array with active problem variables
5097  *
5098  * @return array with active problem variables
5099  *
5100  * @pre This method can be called if @p scip is in one of the following stages:
5101  * - \ref SCIP_STAGE_PROBLEM
5102  * - \ref SCIP_STAGE_TRANSFORMED
5103  * - \ref SCIP_STAGE_INITPRESOLVE
5104  * - \ref SCIP_STAGE_PRESOLVING
5105  * - \ref SCIP_STAGE_EXITPRESOLVE
5106  * - \ref SCIP_STAGE_PRESOLVED
5107  * - \ref SCIP_STAGE_INITSOLVE
5108  * - \ref SCIP_STAGE_SOLVING
5109  * - \ref SCIP_STAGE_SOLVED
5110  * - \ref SCIP_STAGE_EXITSOLVE
5111  *
5112  * @warning If your are using the methods which add or change bound of variables (e.g., SCIPchgVarType(), SCIPfixVar(),
5113  * SCIPaggregateVars(), and SCIPmultiaggregateVar()), it can happen that the internal variable array (which is
5114  * accessed via this method) gets resized and/or resorted. This can invalid the data pointer which is returned
5115  * by this method.
5116  *
5117  * @note Variables in the array are ordered: binaries first, then integers, implicit integers and continuous last.
5118  */
5119 extern
5121  SCIP* scip /**< SCIP data structure */
5122  );
5123 
5124 /** gets number of active problem variables
5125  *
5126  * @return the number of active problem variables
5127  *
5128  * @pre This method can be called if @p scip is in one of the following stages:
5129  * - \ref SCIP_STAGE_PROBLEM
5130  * - \ref SCIP_STAGE_TRANSFORMED
5131  * - \ref SCIP_STAGE_INITPRESOLVE
5132  * - \ref SCIP_STAGE_PRESOLVING
5133  * - \ref SCIP_STAGE_EXITPRESOLVE
5134  * - \ref SCIP_STAGE_PRESOLVED
5135  * - \ref SCIP_STAGE_INITSOLVE
5136  * - \ref SCIP_STAGE_SOLVING
5137  * - \ref SCIP_STAGE_SOLVED
5138  * - \ref SCIP_STAGE_EXITSOLVE
5139  */
5140 extern
5141 int SCIPgetNVars(
5142  SCIP* scip /**< SCIP data structure */
5143  );
5144 
5145 /** gets number of binary active problem variables
5146  *
5147  * @return the number of binary active problem variables
5148  *
5149  * @pre This method can be called if @p scip is in one of the following stages:
5150  * - \ref SCIP_STAGE_PROBLEM
5151  * - \ref SCIP_STAGE_TRANSFORMED
5152  * - \ref SCIP_STAGE_INITPRESOLVE
5153  * - \ref SCIP_STAGE_PRESOLVING
5154  * - \ref SCIP_STAGE_EXITPRESOLVE
5155  * - \ref SCIP_STAGE_PRESOLVED
5156  * - \ref SCIP_STAGE_INITSOLVE
5157  * - \ref SCIP_STAGE_SOLVING
5158  * - \ref SCIP_STAGE_SOLVED
5159  * - \ref SCIP_STAGE_EXITSOLVE
5160  */
5161 extern
5162 int SCIPgetNBinVars(
5163  SCIP* scip /**< SCIP data structure */
5164  );
5165 
5166 /** gets number of integer active problem variables
5167  *
5168  * @return the number of integer active problem variables
5169  *
5170  * @pre This method can be called if @p scip is in one of the following stages:
5171  * - \ref SCIP_STAGE_PROBLEM
5172  * - \ref SCIP_STAGE_TRANSFORMED
5173  * - \ref SCIP_STAGE_INITPRESOLVE
5174  * - \ref SCIP_STAGE_PRESOLVING
5175  * - \ref SCIP_STAGE_EXITPRESOLVE
5176  * - \ref SCIP_STAGE_PRESOLVED
5177  * - \ref SCIP_STAGE_INITSOLVE
5178  * - \ref SCIP_STAGE_SOLVING
5179  * - \ref SCIP_STAGE_SOLVED
5180  * - \ref SCIP_STAGE_EXITSOLVE
5181  */
5182 extern
5183 int SCIPgetNIntVars(
5184  SCIP* scip /**< SCIP data structure */
5185  );
5186 
5187 /** gets number of implicit integer active problem variables
5188  *
5189  * @return the number of implicit integer active problem variables
5190  *
5191  * @pre This method can be called if @p scip is in one of the following stages:
5192  * - \ref SCIP_STAGE_PROBLEM
5193  * - \ref SCIP_STAGE_TRANSFORMED
5194  * - \ref SCIP_STAGE_INITPRESOLVE
5195  * - \ref SCIP_STAGE_PRESOLVING
5196  * - \ref SCIP_STAGE_EXITPRESOLVE
5197  * - \ref SCIP_STAGE_PRESOLVED
5198  * - \ref SCIP_STAGE_INITSOLVE
5199  * - \ref SCIP_STAGE_SOLVING
5200  * - \ref SCIP_STAGE_SOLVED
5201  * - \ref SCIP_STAGE_EXITSOLVE
5202  */
5203 extern
5204 int SCIPgetNImplVars(
5205  SCIP* scip /**< SCIP data structure */
5206  );
5207 
5208 /** gets number of continuous active problem variables
5209  *
5210  * @return the number of continuous active problem variables
5211  *
5212  * @pre This method can be called if @p scip is in one of the following stages:
5213  * - \ref SCIP_STAGE_PROBLEM
5214  * - \ref SCIP_STAGE_TRANSFORMED
5215  * - \ref SCIP_STAGE_INITPRESOLVE
5216  * - \ref SCIP_STAGE_PRESOLVING
5217  * - \ref SCIP_STAGE_EXITPRESOLVE
5218  * - \ref SCIP_STAGE_PRESOLVED
5219  * - \ref SCIP_STAGE_INITSOLVE
5220  * - \ref SCIP_STAGE_SOLVING
5221  * - \ref SCIP_STAGE_SOLVED
5222  * - \ref SCIP_STAGE_EXITSOLVE
5223  */
5224 extern
5225 int SCIPgetNContVars(
5226  SCIP* scip /**< SCIP data structure */
5227  );
5228 
5229 /** gets number of active problem variables with a non-zero objective coefficient
5230  *
5231  * @note In case of the original problem the number of variables is counted. In case of the transformed problem the
5232  * number of variables is just returned since it is stored internally
5233  *
5234  * @return the number of active problem variables with a non-zero objective coefficient
5235  *
5236  * @pre This method can be called if @p scip is in one of the following stages:
5237  * - \ref SCIP_STAGE_PROBLEM
5238  * - \ref SCIP_STAGE_TRANSFORMED
5239  * - \ref SCIP_STAGE_INITPRESOLVE
5240  * - \ref SCIP_STAGE_PRESOLVING
5241  * - \ref SCIP_STAGE_EXITPRESOLVE
5242  * - \ref SCIP_STAGE_PRESOLVED
5243  * - \ref SCIP_STAGE_INITSOLVE
5244  * - \ref SCIP_STAGE_SOLVING
5245  * - \ref SCIP_STAGE_SOLVED
5246  */
5247 extern
5248 int SCIPgetNObjVars(
5249  SCIP* scip /**< SCIP data structure */
5250  );
5251 
5252 /** gets array with fixed and aggregated problem variables; data may become invalid after
5253  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5254  *
5255  * @return an array with fixed and aggregated problem variables; data may become invalid after
5256  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5257  *
5258  * @pre This method can be called if @p scip is in one of the following stages:
5259  * - \ref SCIP_STAGE_PROBLEM
5260  * - \ref SCIP_STAGE_TRANSFORMED
5261  * - \ref SCIP_STAGE_INITPRESOLVE
5262  * - \ref SCIP_STAGE_PRESOLVING
5263  * - \ref SCIP_STAGE_EXITPRESOLVE
5264  * - \ref SCIP_STAGE_PRESOLVED
5265  * - \ref SCIP_STAGE_INITSOLVE
5266  * - \ref SCIP_STAGE_SOLVING
5267  * - \ref SCIP_STAGE_SOLVED
5268  */
5269 extern
5271  SCIP* scip /**< SCIP data structure */
5272  );
5273 
5274 /** gets number of fixed or aggregated problem variables
5275  *
5276  * @return the number of fixed or aggregated problem variables
5277  *
5278  * @pre This method can be called if @p scip is in one of the following stages:
5279  * - \ref SCIP_STAGE_PROBLEM
5280  * - \ref SCIP_STAGE_TRANSFORMED
5281  * - \ref SCIP_STAGE_INITPRESOLVE
5282  * - \ref SCIP_STAGE_PRESOLVING
5283  * - \ref SCIP_STAGE_EXITPRESOLVE
5284  * - \ref SCIP_STAGE_PRESOLVED
5285  * - \ref SCIP_STAGE_INITSOLVE
5286  * - \ref SCIP_STAGE_SOLVING
5287  * - \ref SCIP_STAGE_SOLVED
5288  */
5289 extern
5290 int SCIPgetNFixedVars(
5291  SCIP* scip /**< SCIP data structure */
5292  );
5293 
5294 /** gets variables of the original problem along with the numbers of different variable types; data may become invalid
5295  * after a call to SCIPchgVarType()
5296  *
5297  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5298  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5299  *
5300  * @pre This method can be called if @p scip is in one of the following stages:
5301  * - \ref SCIP_STAGE_PROBLEM
5302  * - \ref SCIP_STAGE_TRANSFORMING
5303  * - \ref SCIP_STAGE_TRANSFORMED
5304  * - \ref SCIP_STAGE_INITPRESOLVE
5305  * - \ref SCIP_STAGE_PRESOLVING
5306  * - \ref SCIP_STAGE_EXITPRESOLVE
5307  * - \ref SCIP_STAGE_PRESOLVED
5308  * - \ref SCIP_STAGE_INITSOLVE
5309  * - \ref SCIP_STAGE_SOLVING
5310  * - \ref SCIP_STAGE_SOLVED
5311  * - \ref SCIP_STAGE_EXITSOLVE
5312  * - \ref SCIP_STAGE_FREETRANS
5313  */
5314 extern
5316  SCIP* scip, /**< SCIP data structure */
5317  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5318  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5319  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5320  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5321  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5322  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5323  );
5324 
5325 /** gets array with original problem variables; data may become invalid after
5326  * a call to SCIPchgVarType()
5327  *
5328  * @return an array with original problem variables; data may become invalid after
5329  * a call to SCIPchgVarType()
5330  *
5331  * @pre This method can be called if @p scip is in one of the following stages:
5332  * - \ref SCIP_STAGE_PROBLEM
5333  * - \ref SCIP_STAGE_TRANSFORMING
5334  * - \ref SCIP_STAGE_TRANSFORMED
5335  * - \ref SCIP_STAGE_INITPRESOLVE
5336  * - \ref SCIP_STAGE_PRESOLVING
5337  * - \ref SCIP_STAGE_EXITPRESOLVE
5338  * - \ref SCIP_STAGE_PRESOLVED
5339  * - \ref SCIP_STAGE_INITSOLVE
5340  * - \ref SCIP_STAGE_SOLVING
5341  * - \ref SCIP_STAGE_SOLVED
5342  * - \ref SCIP_STAGE_EXITSOLVE
5343  * - \ref SCIP_STAGE_FREETRANS
5344  */
5345 extern
5347  SCIP* scip /**< SCIP data structure */
5348  );
5349 
5350 /** gets number of original problem variables
5351  *
5352  * @return the number of original problem variables
5353  *
5354  * @pre This method can be called if @p scip is in one of the following stages:
5355  * - \ref SCIP_STAGE_PROBLEM
5356  * - \ref SCIP_STAGE_TRANSFORMING
5357  * - \ref SCIP_STAGE_TRANSFORMED
5358  * - \ref SCIP_STAGE_INITPRESOLVE
5359  * - \ref SCIP_STAGE_PRESOLVING
5360  * - \ref SCIP_STAGE_EXITPRESOLVE
5361  * - \ref SCIP_STAGE_PRESOLVED
5362  * - \ref SCIP_STAGE_INITSOLVE
5363  * - \ref SCIP_STAGE_SOLVING
5364  * - \ref SCIP_STAGE_SOLVED
5365  * - \ref SCIP_STAGE_EXITSOLVE
5366  * - \ref SCIP_STAGE_FREETRANS
5367  */
5368 extern
5369 int SCIPgetNOrigVars(
5370  SCIP* scip /**< SCIP data structure */
5371  );
5372 
5373 /** gets number of binary variables in the original problem
5374  *
5375  * @return the number of binary variables in the original problem
5376  *
5377  * @pre This method can be called if @p scip is in one of the following stages:
5378  * - \ref SCIP_STAGE_PROBLEM
5379  * - \ref SCIP_STAGE_TRANSFORMING
5380  * - \ref SCIP_STAGE_TRANSFORMED
5381  * - \ref SCIP_STAGE_INITPRESOLVE
5382  * - \ref SCIP_STAGE_PRESOLVING
5383  * - \ref SCIP_STAGE_EXITPRESOLVE
5384  * - \ref SCIP_STAGE_PRESOLVED
5385  * - \ref SCIP_STAGE_INITSOLVE
5386  * - \ref SCIP_STAGE_SOLVING
5387  * - \ref SCIP_STAGE_SOLVED
5388  * - \ref SCIP_STAGE_EXITSOLVE
5389  * - \ref SCIP_STAGE_FREETRANS
5390  */
5391 extern
5393  SCIP* scip /**< SCIP data structure */
5394  );
5395 
5396 /** gets the number of integer variables in the original problem
5397  *
5398  * @return the number of integer variables in the original problem
5399  *
5400  * @pre This method can be called if @p scip is in one of the following stages:
5401  * - \ref SCIP_STAGE_PROBLEM
5402  * - \ref SCIP_STAGE_TRANSFORMING
5403  * - \ref SCIP_STAGE_TRANSFORMED
5404  * - \ref SCIP_STAGE_INITPRESOLVE
5405  * - \ref SCIP_STAGE_PRESOLVING
5406  * - \ref SCIP_STAGE_EXITPRESOLVE
5407  * - \ref SCIP_STAGE_PRESOLVED
5408  * - \ref SCIP_STAGE_INITSOLVE
5409  * - \ref SCIP_STAGE_SOLVING
5410  * - \ref SCIP_STAGE_SOLVED
5411  * - \ref SCIP_STAGE_EXITSOLVE
5412  * - \ref SCIP_STAGE_FREETRANS
5413  */
5414 extern
5416  SCIP* scip /**< SCIP data structure */
5417  );
5418 
5419 /** gets number of implicit integer variables in the original problem
5420  *
5421  * @return the number of implicit integer variables in the original problem
5422  *
5423  * @pre This method can be called if @p scip is in one of the following stages:
5424  * - \ref SCIP_STAGE_PROBLEM
5425  * - \ref SCIP_STAGE_TRANSFORMING
5426  * - \ref SCIP_STAGE_TRANSFORMED
5427  * - \ref SCIP_STAGE_INITPRESOLVE
5428  * - \ref SCIP_STAGE_PRESOLVING
5429  * - \ref SCIP_STAGE_EXITPRESOLVE
5430  * - \ref SCIP_STAGE_PRESOLVED
5431  * - \ref SCIP_STAGE_INITSOLVE
5432  * - \ref SCIP_STAGE_SOLVING
5433  * - \ref SCIP_STAGE_SOLVED
5434  * - \ref SCIP_STAGE_EXITSOLVE
5435  * - \ref SCIP_STAGE_FREETRANS
5436  */
5437 extern
5439  SCIP* scip /**< SCIP data structure */
5440  );
5441 
5442 /** gets number of continuous variables in the original problem
5443  *
5444  * @return the number of continuous variables in the original problem
5445  *
5446  * @pre This method can be called if @p scip is in one of the following stages:
5447  * - \ref SCIP_STAGE_PROBLEM
5448  * - \ref SCIP_STAGE_TRANSFORMING
5449  * - \ref SCIP_STAGE_TRANSFORMED
5450  * - \ref SCIP_STAGE_INITPRESOLVE
5451  * - \ref SCIP_STAGE_PRESOLVING
5452  * - \ref SCIP_STAGE_EXITPRESOLVE
5453  * - \ref SCIP_STAGE_PRESOLVED
5454  * - \ref SCIP_STAGE_INITSOLVE
5455  * - \ref SCIP_STAGE_SOLVING
5456  * - \ref SCIP_STAGE_SOLVED
5457  * - \ref SCIP_STAGE_EXITSOLVE
5458  * - \ref SCIP_STAGE_FREETRANS
5459  */
5460 extern
5462  SCIP* scip /**< SCIP data structure */
5463  );
5464 
5465 /** gets number of all problem variables created during creation and solving of problem;
5466  * this includes also variables that were deleted in the meantime
5467  *
5468  * @return the number of all problem variables created during creation and solving of problem;
5469  * this includes also variables that were deleted in the meantime
5470  *
5471  * @pre This method can be called if @p scip is in one of the following stages:
5472  * - \ref SCIP_STAGE_PROBLEM
5473  * - \ref SCIP_STAGE_TRANSFORMING
5474  * - \ref SCIP_STAGE_TRANSFORMED
5475  * - \ref SCIP_STAGE_INITPRESOLVE
5476  * - \ref SCIP_STAGE_PRESOLVING
5477  * - \ref SCIP_STAGE_EXITPRESOLVE
5478  * - \ref SCIP_STAGE_PRESOLVED
5479  * - \ref SCIP_STAGE_INITSOLVE
5480  * - \ref SCIP_STAGE_SOLVING
5481  * - \ref SCIP_STAGE_SOLVED
5482  * - \ref SCIP_STAGE_EXITSOLVE
5483  * - \ref SCIP_STAGE_FREETRANS
5484  */
5485 extern
5486 int SCIPgetNTotalVars(
5487  SCIP* scip /**< SCIP data structure */
5488  );
5489 
5490 /** gets variables of the original or transformed problem along with the numbers of different variable types;
5491  * the returned problem space (original or transformed) corresponds to the given solution;
5492  * data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and
5493  * SCIPmultiaggregateVar()
5494  *
5495  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5496  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5497  *
5498  * @pre This method can be called if @p scip is in one of the following stages:
5499  * - \ref SCIP_STAGE_PROBLEM
5500  * - \ref SCIP_STAGE_TRANSFORMED
5501  * - \ref SCIP_STAGE_INITPRESOLVE
5502  * - \ref SCIP_STAGE_PRESOLVING
5503  * - \ref SCIP_STAGE_EXITPRESOLVE
5504  * - \ref SCIP_STAGE_PRESOLVED
5505  * - \ref SCIP_STAGE_INITSOLVE
5506  * - \ref SCIP_STAGE_SOLVING
5507  * - \ref SCIP_STAGE_SOLVED
5508  */
5509 extern
5511  SCIP* scip, /**< SCIP data structure */
5512  SCIP_SOL* sol, /**< primal solution that selects the problem space, NULL for current solution */
5513  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5514  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5515  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5516  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5517  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5518  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5519  );
5520 
5521 /** returns variable of given name in the problem, or NULL if not existing
5522  *
5523  * @return variable of given name in the problem, or NULL if not existing
5524  *
5525  * @pre This method can be called if @p scip is in one of the following stages:
5526  * - \ref SCIP_STAGE_PROBLEM
5527  * - \ref SCIP_STAGE_TRANSFORMING
5528  * - \ref SCIP_STAGE_TRANSFORMED
5529  * - \ref SCIP_STAGE_INITPRESOLVE
5530  * - \ref SCIP_STAGE_PRESOLVING
5531  * - \ref SCIP_STAGE_EXITPRESOLVE
5532  * - \ref SCIP_STAGE_PRESOLVED
5533  * - \ref SCIP_STAGE_INITSOLVE
5534  * - \ref SCIP_STAGE_SOLVING
5535  * - \ref SCIP_STAGE_SOLVED
5536  * - \ref SCIP_STAGE_EXITSOLVE
5537  * - \ref SCIP_STAGE_FREETRANS
5538  */
5539 extern
5541  SCIP* scip, /**< SCIP data structure */
5542  const char* name /**< name of variable to find */
5543  );
5544 
5545 /** returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables,
5546  * that will be added in pricing and improve the objective value
5547  *
5548  * @return TRUE, if all potential variables exist in the problem; FALSE, otherwise
5549  *
5550  * @pre This method can be called if @p scip is in one of the following stages:
5551  * - \ref SCIP_STAGE_TRANSFORMING
5552  * - \ref SCIP_STAGE_TRANSFORMED
5553  * - \ref SCIP_STAGE_INITPRESOLVE
5554  * - \ref SCIP_STAGE_PRESOLVING
5555  * - \ref SCIP_STAGE_EXITPRESOLVE
5556  * - \ref SCIP_STAGE_PRESOLVED
5557  * - \ref SCIP_STAGE_INITSOLVE
5558  * - \ref SCIP_STAGE_SOLVING
5559  * - \ref SCIP_STAGE_SOLVED
5560  * - \ref SCIP_STAGE_EXITSOLVE
5561  * - \ref SCIP_STAGE_FREETRANS
5562  */
5563 extern
5565  SCIP* scip /**< SCIP data structure */
5566  );
5567 
5568 /** adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the
5569  * current node (and all of its subnodes); otherwise it is added to the global problem;
5570  * if a local constraint is added at the root node, it is automatically upgraded into a global constraint
5571  *
5572  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5573  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5574  *
5575  * @pre This method can be called if @p scip is in one of the following stages:
5576  * - \ref SCIP_STAGE_PROBLEM
5577  * - \ref SCIP_STAGE_INITPRESOLVE
5578  * - \ref SCIP_STAGE_PRESOLVING
5579  * - \ref SCIP_STAGE_EXITPRESOLVE
5580  * - \ref SCIP_STAGE_PRESOLVED
5581  * - \ref SCIP_STAGE_INITSOLVE
5582  * - \ref SCIP_STAGE_SOLVING
5583  * - \ref SCIP_STAGE_EXITSOLVE
5584  */
5585 extern
5587  SCIP* scip, /**< SCIP data structure */
5588  SCIP_CONS* cons /**< constraint to add */
5589  );
5590 
5591 /** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
5592  * node, where it was added, or from the problem, if it was a problem constraint
5593  *
5594  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5595  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5596  *
5597  * @pre This method can be called if @p scip is in one of the following stages:
5598  * - \ref SCIP_STAGE_PROBLEM
5599  * - \ref SCIP_STAGE_INITPRESOLVE
5600  * - \ref SCIP_STAGE_PRESOLVING
5601  * - \ref SCIP_STAGE_EXITPRESOLVE
5602  * - \ref SCIP_STAGE_INITSOLVE
5603  * - \ref SCIP_STAGE_SOLVING
5604  */
5605 extern
5607  SCIP* scip, /**< SCIP data structure */
5608  SCIP_CONS* cons /**< constraint to delete */
5609  );
5610 
5611 /** returns original constraint of given name in the problem, or NULL if not existing
5612  *
5613  * @return original constraint of given name in the problem, or NULL if not existing
5614  *
5615  * @pre This method can be called if @p scip is in one of the following stages:
5616  * - \ref SCIP_STAGE_PROBLEM
5617  * - \ref SCIP_STAGE_TRANSFORMING
5618  * - \ref SCIP_STAGE_TRANSFORMED
5619  * - \ref SCIP_STAGE_INITPRESOLVE
5620  * - \ref SCIP_STAGE_PRESOLVING
5621  * - \ref SCIP_STAGE_EXITPRESOLVE
5622  * - \ref SCIP_STAGE_INITSOLVE
5623  * - \ref SCIP_STAGE_SOLVING
5624  * - \ref SCIP_STAGE_SOLVED
5625  * - \ref SCIP_STAGE_EXITSOLVE
5626  * - \ref SCIP_STAGE_FREETRANS */
5627 extern
5629  SCIP* scip, /**< SCIP data structure */
5630  const char* name /**< name of constraint to find */
5631  );
5632 
5633 /** returns constraint of given name in the problem, or NULL if not existing
5634  *
5635  * @return constraint of given name in the problem, or NULL if not existing
5636  *
5637  * @pre This method can be called if @p scip is in one of the following stages:
5638  * - \ref SCIP_STAGE_PROBLEM
5639  * - \ref SCIP_STAGE_TRANSFORMING
5640  * - \ref SCIP_STAGE_TRANSFORMED
5641  * - \ref SCIP_STAGE_INITPRESOLVE
5642  * - \ref SCIP_STAGE_PRESOLVING
5643  * - \ref SCIP_STAGE_EXITPRESOLVE
5644  * - \ref SCIP_STAGE_PRESOLVED
5645  * - \ref SCIP_STAGE_INITSOLVE
5646  * - \ref SCIP_STAGE_SOLVING
5647  * - \ref SCIP_STAGE_SOLVED
5648  * - \ref SCIP_STAGE_EXITSOLVE
5649  * - \ref SCIP_STAGE_FREETRANS
5650  */
5651 extern
5653  SCIP* scip, /**< SCIP data structure */
5654  const char* name /**< name of constraint to find */
5655  );
5656 
5657 /** gets number of upgraded constraints
5658  *
5659  * @return number of upgraded constraints
5660  *
5661  * @pre This method can be called if @p scip is in one of the following stages:
5662  * - \ref SCIP_STAGE_PROBLEM
5663  * - \ref SCIP_STAGE_TRANSFORMED
5664  * - \ref SCIP_STAGE_INITPRESOLVE
5665  * - \ref SCIP_STAGE_PRESOLVING
5666  * - \ref SCIP_STAGE_PRESOLVED
5667  * - \ref SCIP_STAGE_EXITPRESOLVE
5668  * - \ref SCIP_STAGE_SOLVING
5669