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