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