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