Scippy

SCIP

Solving Constraint Integer Programs

scip.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2017 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip.h
17  * @ingroup PUBLICCOREAPI
18  * @brief SCIP callable library
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  */
26 
27 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
28 
29 #ifndef __SCIP_SCIP_H__
30 #define __SCIP_SCIP_H__
31 
32 
33 #include <stdio.h>
34 
35 #include "scip/def.h"
36 #include "blockmemshell/memory.h"
37 #include "scip/type_retcode.h"
38 #include "scip/type_result.h"
39 #include "scip/type_clock.h"
40 #include "scip/type_misc.h"
41 #include "scip/type_timing.h"
42 #include "scip/type_paramset.h"
43 #include "scip/type_event.h"
44 #include "scip/type_lp.h"
45 #include "scip/type_nlp.h"
46 #include "scip/type_var.h"
47 #include "scip/type_prob.h"
48 #include "scip/type_tree.h"
49 #include "scip/type_scip.h"
50 
51 #include "scip/type_bandit.h"
52 #include "scip/type_branch.h"
53 #include "scip/type_conflict.h"
54 #include "scip/type_cons.h"
55 #include "scip/type_dialog.h"
56 #include "scip/type_disp.h"
57 #include "scip/type_heur.h"
58 #include "scip/type_compr.h"
59 #include "scip/type_history.h"
60 #include "scip/type_nodesel.h"
61 #include "scip/type_presol.h"
62 #include "scip/type_pricer.h"
63 #include "scip/type_reader.h"
64 #include "scip/type_relax.h"
65 #include "scip/type_sepa.h"
66 #include "scip/type_table.h"
67 #include "scip/type_prop.h"
68 #include "nlpi/type_nlpi.h"
69 #include "scip/type_concsolver.h"
70 #include "scip/type_syncstore.h"
71 
72 /* include public interfaces, s.t. the user only needs to include scip.h */
73 #include "scip/pub_bandit.h"
74 #include "scip/pub_branch.h"
75 #include "scip/pub_conflict.h"
76 #include "scip/pub_cons.h"
77 #include "scip/pub_cutpool.h"
78 #include "scip/pub_dialog.h"
79 #include "scip/pub_disp.h"
80 #include "scip/pub_event.h"
81 #include "scip/pub_fileio.h"
82 #include "scip/pub_heur.h"
83 #include "scip/pub_compr.h"
84 #include "scip/pub_history.h"
85 #include "scip/pub_implics.h"
86 #include "scip/pub_lp.h"
87 #include "scip/pub_nlp.h"
88 #include "scip/pub_message.h"
89 #include "scip/pub_misc.h"
90 #include "scip/pub_nodesel.h"
91 #include "scip/pub_paramset.h"
92 #include "scip/pub_presol.h"
93 #include "scip/pub_pricer.h"
94 #include "scip/pub_reader.h"
95 #include "scip/pub_relax.h"
96 #include "scip/pub_sepa.h"
97 #include "scip/pub_prop.h"
98 #include "scip/pub_sol.h"
99 #include "scip/pub_table.h"
100 #include "scip/pub_tree.h"
101 #include "scip/pub_var.h"
102 #include "lpi/lpi.h"
103 #include "nlpi/pub_expr.h"
104 
105 /* include global presolving, cuts, and heuristics methods */
106 #include "scip/presolve.h"
107 #include "scip/cuts.h"
108 #include "scip/heuristics.h"
109 
110 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
111  * this structure except the interface methods in scip.c.
112  * In optimized mode, the structure is included in scip.h, because some of the methods
113  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
114  * Additionally, the internal "set.h" is included, such that the defines in set.h are
115  * available in optimized mode.
116  */
117 #ifdef NDEBUG
118 #include "scip/struct_scip.h"
119 #include "scip/struct_stat.h"
120 #include "scip/set.h"
121 #include "scip/tree.h"
122 #include "scip/misc.h"
123 #include "scip/var.h"
124 #include "scip/cons.h"
125 #include "scip/solve.h"
126 #include "scip/debug.h"
127 #endif
128 
129 #ifdef __cplusplus
130 extern "C" {
131 #endif
132 
133 /*
134  * miscellaneous methods
135  */
136 
137 /**@addtogroup MiscellaneousMethods
138  *
139  * @{
140  */
141 
142 /** returns complete SCIP version number in the format "major . minor tech"
143  *
144  * @return complete SCIP version
145  */
146 extern
148  void
149  );
150 
151 /** returns SCIP major version
152  *
153  * @return major SCIP version
154  */
155 extern
156 int SCIPmajorVersion(
157  void
158  );
159 
160 /** returns SCIP minor version
161  *
162  * @return minor SCIP version
163  */
164 extern
165 int SCIPminorVersion(
166  void
167  );
168 
169 /** returns SCIP technical version
170  *
171  * @return technical SCIP version
172  */
173 extern
174 int SCIPtechVersion(
175  void
176  );
177 
178 /** returns SCIP sub version number
179  *
180  * @return subversion SCIP version
181  */
182 extern
183 int SCIPsubversion(
184  void
185  );
186 
187 /** prints a version information line to a file stream via the message handler system
188  *
189  * @note If the message handler is set to a NULL pointer nothing will be printed
190  */
191 extern
192 void SCIPprintVersion(
193  SCIP* scip, /**< SCIP data structure */
194  FILE* file /**< output file (or NULL for standard output) */
195  );
196 
197 /** prints detailed information on the compile-time flags
198  *
199  * @note If the message handler is set to a NULL pointer nothing will be printed
200  */
201 extern
203  SCIP* scip, /**< SCIP data structure */
204  FILE* file /**< output file (or NULL for standard output) */
205  );
206 
207 /** prints error message for the given SCIP_RETCODE via the error prints method */
208 extern
209 void SCIPprintError(
210  SCIP_RETCODE retcode /**< SCIP return code causing the error */
211  );
212 
213 /**@} */
214 
215 
216 
217 
218 /*
219  * general SCIP methods
220  */
221 
222 /**@addtogroup GeneralSCIPMethods
223  *
224  * @{
225  */
226 
227 /** creates and initializes SCIP data structures
228  *
229  * @note The SCIP default message handler is installed. Use the method SCIPsetMessagehdlr() to install your own
230  * message handler or SCIPsetMessagehdlrLogfile() and SCIPsetMessagehdlrQuiet() to write into a log
231  * file and turn off/on the display output, respectively.
232  *
233  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
234  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
235  *
236  * @post After calling this method @p scip reached the solving stage \ref SCIP_STAGE_INIT
237  *
238  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
239  */
240 extern
242  SCIP** scip /**< pointer to SCIP data structure */
243  );
244 
245 /** frees SCIP data structures
246  *
247  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
248  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
249  *
250  * @pre This method can be called if @p scip is in one of the following stages:
251  * - \ref SCIP_STAGE_INIT
252  * - \ref SCIP_STAGE_PROBLEM
253  * - \ref SCIP_STAGE_TRANSFORMED
254  * - \ref SCIP_STAGE_INITPRESOLVE
255  * - \ref SCIP_STAGE_PRESOLVING
256  * - \ref SCIP_STAGE_PRESOLVED
257  * - \ref SCIP_STAGE_EXITPRESOLVE
258  * - \ref SCIP_STAGE_SOLVING
259  * - \ref SCIP_STAGE_SOLVED
260  * - \ref SCIP_STAGE_FREE
261  *
262  * @post After calling this method \SCIP reached the solving stage \ref SCIP_STAGE_FREE
263  *
264  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
265  */
266 extern
268  SCIP** scip /**< pointer to SCIP data structure */
269  );
270 
271 /** returns current stage of SCIP
272  *
273  * @return the current SCIP stage
274  *
275  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
276  */
277 extern
279  SCIP* scip /**< SCIP data structure */
280  );
281 
282 /** outputs SCIP stage and solution status if applicable via the message handler
283  *
284  * @note If the message handler is set to a NULL pointer nothing will be printed
285  *
286  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
287  * thus may to correspond to the original status.
288  *
289  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
290  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
291  *
292  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
293  */
294 extern
296  SCIP* scip, /**< SCIP data structure */
297  FILE* file /**< output file (or NULL for standard output) */
298  );
299 
300 /** gets solution status
301  *
302  * @return SCIP solution status
303  *
304  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
305  */
306 extern
308  SCIP* scip /**< SCIP data structure */
309  );
310 
311 /** outputs solution status
312  *
313  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
314  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
315  *
316  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
317  */
318 extern
320  SCIP* scip, /**< SCIP data structure */
321  FILE* file /**< output file (or NULL for standard output) */
322  );
323 
324 /** returns whether the current stage belongs to the transformed problem space
325  *
326  * @return Returns TRUE if the \SCIP instance is transformed, otherwise FALSE
327  */
328 extern
330  SCIP* scip /**< SCIP data structure */
331  );
332 
333 /** returns whether the solution process is arithmetically exact, i.e., not subject to roundoff errors
334  *
335  * @note This feature is not supported yet!
336  *
337  * @return Returns TRUE if \SCIP is exact solving mode, otherwise FALSE
338  */
339 extern
341  SCIP* scip /**< SCIP data structure */
342  );
343 
344 /** returns whether the presolving process would be finished given no more presolving reductions are found in this
345  * presolving round
346  *
347  * Checks whether the number of presolving rounds is not exceeded and the presolving reductions found in the current
348  * presolving round suffice to trigger another presolving round.
349  *
350  * @note if subsequent presolvers find more reductions, presolving might continue even if the method returns FALSE
351  * @note does not check whether infeasibility or unboundedness was already detected in presolving (which would result
352  * in presolving being stopped although the method returns TRUE)
353  *
354  * @return Returns TRUE if presolving is finished if no further reductions are detected
355  */
356 extern
358  SCIP* scip /**< SCIP data structure */
359  );
360 
361 /** returns whether SCIP has performed presolving during the last solve
362  *
363  * @return Returns TRUE if presolving was performed during the last solve
364  */
365 extern
367  SCIP* scip /**< SCIP data structure */
368  );
369 
370 /** returns whether the user pressed CTRL-C to interrupt the solving process
371  *
372  * @return Returns TRUE if Ctrl-C was pressed, otherwise FALSE.
373  */
374 extern
376  SCIP* scip /**< SCIP data structure */
377  );
378 
379 /** returns whether the solving process should be / was stopped before proving optimality;
380  * if the solving process should be / was stopped, the status returned by SCIPgetStatus() yields
381  * the reason for the premature abort
382  *
383  * @return Returns TRUE if solving process is stopped/interrupted, otherwise FALSE.
384  */
385 extern
387  SCIP* scip /**< SCIP data structure */
388  );
389 
390 /**@} */
391 
392 /*
393  * debug solution methods
394  */
395 
396 /**@addtogroup DebugSolutionMethods
397  *
398  * @{
399  */
400 
401 /** enable debug solution mechanism
402  *
403  * the debug solution mechanism allows to trace back the invalidation of
404  * a debug solution during the solution process of SCIP. It must be explicitly
405  * enabled for the SCIP data structure.
406  *
407  * @see debug.h for more information on debug solution mechanism
408  */
409 extern
410 void SCIPenableDebugSol(
411  SCIP* scip /**< SCIP data structure */
412  );
413 
414 /** disable solution debugging mechanism
415  *
416  * @see debug.h for more information on debug solution mechanism
417  */
418 extern
420  SCIP* scip /**< SCIP data structure */
421  );
422 
423 /**@} */
424 
425 
426 /*
427  * message output methods
428  */
429 
430 /**@addtogroup MessageOutputMethods
431  *
432  * @{
433  */
434 
435 /* if we have a C99 compiler */
436 #ifdef SCIP_HAVE_VARIADIC_MACROS
437 
438 /** prints a debugging message if SCIP_DEBUG flag is set */
439 #ifdef SCIP_DEBUG
440 #define SCIPdebugMsg(scip, ...) SCIPprintDebugMessage(scip, __FILE__, __LINE__, __VA_ARGS__)
441 #define SCIPdebugMsgPrint(scip, ...) SCIPdebugMessagePrint(scip, __VA_ARGS__)
442 #else
443 #define SCIPdebugMsg(scip, ...) while ( FALSE ) SCIPprintDebugMessage(scip, __FILE__, __LINE__, __VA_ARGS__)
444 #define SCIPdebugMsgPrint(scip, ...) while ( FALSE ) SCIPdebugMessagePrint(scip, __VA_ARGS__)
445 #endif
446 
447 #else
448 /* if we do not have a C99 compiler, use a workaround that prints a message, but not the file and linenumber */
449 
450 /** prints a debugging message if SCIP_DEBUG flag is set */
451 #ifdef SCIP_DEBUG
452 #define SCIPdebugMsg printf("debug: "), SCIPdebugMessagePrint
453 #define SCIPdebugMsgPrint SCIPdebugMessagePrint
454 #else
455 #define SCIPdebugMsg while ( FALSE ) SCIPdebugMessagePrint
456 #define SCIPdebugMsgPrint while ( FALSE ) SCIPdebugMessagePrint
457 #endif
458 
459 #endif
460 
461 
462 /** installs the given message handler, such that all messages are passed to this handler. A messages handler can be
463  * created via SCIPmessagehdlrCreate().
464  *
465  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
466  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
467  *
468  * @pre this method can be called in one of the following stages of the SCIP solving process:
469  * - \ref SCIP_STAGE_INIT
470  * - \ref SCIP_STAGE_PROBLEM
471  *
472  * @note The currently installed messages handler gets freed if this SCIP instance is its last user (w.r.t. capture/release).
473  */
474 extern
476  SCIP* scip, /**< SCIP data structure */
477  SCIP_MESSAGEHDLR* messagehdlr /**< message handler to install, or NULL to suppress all output */
478  );
479 
480 /** returns the currently installed message handler
481  *
482  * @return the currently installed message handler, or NULL if messages are currently suppressed
483  */
484 extern
486  SCIP* scip /**< SCIP data structure */
487  );
488 
489 /** sets the log file name for the currently installed message handler */
490 extern
492  SCIP* scip, /**< SCIP data structure */
493  const char* filename /**< name of log file, or NULL (no log) */
494  );
495 
496 /** sets the currently installed message handler to be quiet (or not) */
497 extern
499  SCIP* scip, /**< SCIP data structure */
500  SCIP_Bool quiet /**< should screen messages be suppressed? */
501  );
502 
503 /** prints a warning message via the message handler */
504 extern
505 void SCIPwarningMessage(
506  SCIP* scip, /**< SCIP data structure */
507  const char* formatstr, /**< format string like in printf() function */
508  ... /**< format arguments line in printf() function */
509  );
510 
511 /** prints a debug message */
512 extern
514  SCIP* scip, /**< SCIP data structure */
515  const char* sourcefile, /**< name of the source file that called the function */
516  int sourceline, /**< line in the source file where the function was called */
517  const char* formatstr, /**< format string like in printf() function */
518  ... /**< format arguments line in printf() function */
519  );
520 
521 /** prints a debug message without precode */
522 extern
524  SCIP* scip, /**< SCIP data structure */
525  const char* formatstr, /**< format string like in printf() function */
526  ... /**< format arguments line in printf() function */
527  );
528 
529 /** prints a dialog message that requests user interaction or is a direct response to a user interactive command */
530 extern
531 void SCIPdialogMessage(
532  SCIP* scip, /**< SCIP data structure */
533  FILE* file, /**< file stream to print into, or NULL for stdout */
534  const char* formatstr, /**< format string like in printf() function */
535  ... /**< format arguments line in printf() function */
536  );
537 
538 /** prints a message */
539 extern
540 void SCIPinfoMessage(
541  SCIP* scip, /**< SCIP data structure */
542  FILE* file, /**< file stream to print into, or NULL for stdout */
543  const char* formatstr, /**< format string like in printf() function */
544  ... /**< format arguments line in printf() function */
545  );
546 
547 /** prints a message depending on the verbosity level */
548 extern
549 void SCIPverbMessage(
550  SCIP* scip, /**< SCIP data structure */
551  SCIP_VERBLEVEL msgverblevel, /**< verbosity level of this message */
552  FILE* file, /**< file stream to print into, or NULL for stdout */
553  const char* formatstr, /**< format string like in printf() function */
554  ... /**< format arguments line in printf() function */
555  );
556 
557 /** returns the current message verbosity level
558  *
559  * @return message verbosity level of SCIP
560  *
561  * @see \ref SCIP_VerbLevel "SCIP_VERBLEVEL" for a list of all verbosity levels
562  */
563 extern
565  SCIP* scip /**< SCIP data structure */
566  );
567 
568 
569 /**@} */
570 
571 
572 
573 
574 /*
575  * SCIP copy methods
576  */
577 
578 /**@addtogroup CopyMethods
579  *
580  * @{
581  */
582 
583 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
584  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
585  * copied SCIP instance might not represent the same problem semantics as the original.
586  * Note that in this case dual reductions might be invalid.
587  *
588  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
589  * Also, 'passmessagehdlr' should be set to FALSE.
590  * @note Do not change the source SCIP environment during the copying process
591  *
592  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
593  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
594  *
595  * @pre This method can be called if sourcescip is in one of the following stages:
596  * - \ref SCIP_STAGE_PROBLEM
597  * - \ref SCIP_STAGE_TRANSFORMED
598  * - \ref SCIP_STAGE_INITPRESOLVE
599  * - \ref SCIP_STAGE_PRESOLVING
600  * - \ref SCIP_STAGE_EXITPRESOLVE
601  * - \ref SCIP_STAGE_PRESOLVED
602  * - \ref SCIP_STAGE_INITSOLVE
603  * - \ref SCIP_STAGE_SOLVING
604  * - \ref SCIP_STAGE_SOLVED
605  *
606  * @pre This method can be called if targetscip is in one of the following stages:
607  * - \ref SCIP_STAGE_INIT
608  * - \ref SCIP_STAGE_FREE
609  *
610  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
611  * process was interrupted:
612  * - \ref SCIP_STAGE_PROBLEM
613  *
614  * @note sourcescip stage does not get changed
615  *
616  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
617  */
618 extern
620  SCIP* sourcescip, /**< source SCIP data structure */
621  SCIP* targetscip, /**< target SCIP data structure */
622  SCIP_Bool copyreaders, /**< should the file readers be copied */
623  SCIP_Bool copypricers, /**< should the variable pricers be copied */
624  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
625  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
626  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
627  SCIP_Bool copyrelaxators, /**< should the relaxation handler be copied */
628  SCIP_Bool copyseparators, /**< should the separators be copied */
629  SCIP_Bool copypropagators, /**< should the propagators be copied */
630  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
631  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
632  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
633  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
634  SCIP_Bool copydisplays, /**< should the display columns be copied */
635  SCIP_Bool copydialogs, /**< should the dialogs be copied */
636  SCIP_Bool copytables, /**< should the statistics tables be copied */
637  SCIP_Bool copynlpis, /**< should the NLPIs be copied */
638  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
639  SCIP_Bool* valid /**< pointer to store whether plugins, in particular all constraint
640  * handlers which do not need constraints were validly copied */
641  );
642 
643 /** create a problem by copying the problem data of the source SCIP
644  *
645  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
646  * @note Do not change the source SCIP environment during the copying process
647  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
648  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
649  *
650  * @pre This method can be called if sourcescip is in one of the following stages:
651  * - \ref SCIP_STAGE_PROBLEM
652  * - \ref SCIP_STAGE_TRANSFORMED
653  * - \ref SCIP_STAGE_INITPRESOLVE
654  * - \ref SCIP_STAGE_PRESOLVING
655  * - \ref SCIP_STAGE_EXITPRESOLVE
656  * - \ref SCIP_STAGE_PRESOLVED
657  * - \ref SCIP_STAGE_INITSOLVE
658  * - \ref SCIP_STAGE_SOLVING
659  * - \ref SCIP_STAGE_SOLVED
660  *
661  * @pre This method can be called if targetscip is in one of the following stages:
662  * - \ref SCIP_STAGE_INIT
663  * - \ref SCIP_STAGE_PROBLEM
664  * - \ref SCIP_STAGE_TRANSFORMED
665  * - \ref SCIP_STAGE_INITPRESOLVE
666  * - \ref SCIP_STAGE_PRESOLVING
667  * - \ref SCIP_STAGE_EXITPRESOLVE
668  * - \ref SCIP_STAGE_PRESOLVED
669  * - \ref SCIP_STAGE_INITSOLVE
670  * - \ref SCIP_STAGE_SOLVING
671  * - \ref SCIP_STAGE_SOLVED
672  * - \ref SCIP_STAGE_FREE
673  *
674  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
675  * process was interrupted:
676  * - \ref SCIP_STAGE_PROBLEM
677  *
678  * @note sourcescip stage does not get changed
679  *
680  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
681  */
682 extern
684  SCIP* sourcescip, /**< source SCIP data structure */
685  SCIP* targetscip, /**< target SCIP data structure */
686  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
687  * target variables, or NULL */
688  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
689  * target constraints, or NULL */
690  SCIP_Bool global, /**< create a global or a local copy? */
691  const char* name /**< problem name */
692  );
693 
694 /** create a problem by copying the original problem data of the source SCIP
695  *
696  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
697  * @note Do not change the source SCIP environment during the copying process
698  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
699  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
700  *
701  * @pre This method can be called if sourcescip is in one of the following stages:
702  * - \ref SCIP_STAGE_PROBLEM
703  * - \ref SCIP_STAGE_TRANSFORMED
704  * - \ref SCIP_STAGE_INITPRESOLVE
705  * - \ref SCIP_STAGE_PRESOLVING
706  * - \ref SCIP_STAGE_EXITPRESOLVE
707  * - \ref SCIP_STAGE_PRESOLVED
708  * - \ref SCIP_STAGE_INITSOLVE
709  * - \ref SCIP_STAGE_SOLVING
710  * - \ref SCIP_STAGE_SOLVED
711  *
712  * @pre This method can be called if targetscip is in one of the following stages:
713  * - \ref SCIP_STAGE_INIT
714  * - \ref SCIP_STAGE_FREE
715  *
716  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
717  * process was interrupted:
718  * - \ref SCIP_STAGE_PROBLEM
719  *
720  * @note sourcescip stage does not get changed
721  *
722  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
723  */
724 extern
726  SCIP* sourcescip, /**< source SCIP data structure */
727  SCIP* targetscip, /**< target SCIP data structure */
728  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
729  * target variables, or NULL */
730  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
731  * target constraints, or NULL */
732  const char* name /**< problem name of target */
733  );
734 
735 /** enables constraint compression.
736  *
737  * If constraint compression is enabled, fixed variables will be treated as constants
738  * by all constraints that are copied after calling this method.
739  *
740  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
741  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
742  *
743  * @pre This method can be called if scip is in one of the following stages:
744  * - \ref SCIP_STAGE_PROBLEM
745  *
746  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
747  */
748 extern
750  SCIP* scip /**< source SCIP data structure */
751  );
752 
753 /** is constraint compression enabled?
754  *
755  * If constraint compression is enabled, fixed variables can be treated as constants
756  * by all constraints that are copied after calling this method.
757  *
758  * @return TRUE if problem constraint compression is enabled, otherwise FALSE
759  *
760  * @pre This method can be called if scip is in one of the following stages:
761  * - \ref SCIP_STAGE_PROBLEM
762  * - \ref SCIP_STAGE_TRANSFORMING
763  * - \ref SCIP_STAGE_TRANSFORMED
764  * - \ref SCIP_STAGE_INITPRESOLVE
765  * - \ref SCIP_STAGE_PRESOLVING
766  * - \ref SCIP_STAGE_EXITPRESOLVE
767  * - \ref SCIP_STAGE_PRESOLVED
768  * - \ref SCIP_STAGE_INITSOLVE
769  * - \ref SCIP_STAGE_SOLVING
770  * - \ref SCIP_STAGE_SOLVED
771  * - \ref SCIP_STAGE_EXITSOLVE
772  * - \ref SCIP_STAGE_FREETRANS
773  *
774  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
775  */
776 extern
778  SCIP* scip /**< source SCIP data structure */
779  );
780 
781 /** returns copy of the source variable; if there already is a copy of the source variable in the variable hash map,
782  * it is just returned as target variable; elsewise a new variable will be created and added to the target SCIP; this
783  * created variable is added to the variable hash map and returned as target variable
784  *
785  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
786  * @note Do not change the source SCIP environment during the copying process
787  * @note if a new variable was created, this variable will be added to the target-SCIP, but it is not captured
788  *
789  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
790  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
791  *
792  * @pre This method can be called if sourcescip is in one of the following stages:
793  * - \ref SCIP_STAGE_PROBLEM
794  * - \ref SCIP_STAGE_TRANSFORMED
795  * - \ref SCIP_STAGE_INITPRESOLVE
796  * - \ref SCIP_STAGE_PRESOLVING
797  * - \ref SCIP_STAGE_EXITPRESOLVE
798  * - \ref SCIP_STAGE_PRESOLVED
799  * - \ref SCIP_STAGE_INITSOLVE
800  * - \ref SCIP_STAGE_SOLVING
801  * - \ref SCIP_STAGE_SOLVED
802  *
803  * @pre This method can be called if targetscip is in one of the following stages:
804  * - \ref SCIP_STAGE_PROBLEM
805  * - \ref SCIP_STAGE_TRANSFORMED
806  * - \ref SCIP_STAGE_INITPRESOLVE
807  * - \ref SCIP_STAGE_PRESOLVING
808  * - \ref SCIP_STAGE_EXITPRESOLVE
809  * - \ref SCIP_STAGE_SOLVING
810  *
811  * @note targetscip stage does not get changed
812  *
813  * @note sourcescip stage does not get changed
814  *
815  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
816  */
817 extern
819  SCIP* sourcescip, /**< source SCIP data structure */
820  SCIP* targetscip, /**< target SCIP data structure */
821  SCIP_VAR* sourcevar, /**< source variable */
822  SCIP_VAR** targetvar, /**< pointer to store the target variable */
823  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
824  * target variables, or NULL */
825  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
826  * target constraints, or NULL */
827  SCIP_Bool global, /**< should global or local bounds be used? */
828  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
829  );
830 
831 /** copies all active variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
832  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
833  * variables do not get copied
834  *
835  * @note the variables are added to the target-SCIP but not captured
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 hashmap to store the mapping of source variables to the corresponding
868  * target variables, or NULL */
869  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
870  * target constraints, or NULL */
871  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
872  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
873  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
874  SCIP_Bool global /**< should global or local bounds be used? */
875  );
876 
877 /** copies all original variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
878  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
879  * variables do not get copied
880  *
881  * @note the variables are added to the target-SCIP but not captured
882  *
883  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
884  * @note Do not change the source SCIP environment during the copying process
885  *
886  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
887  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
888  *
889  * @pre This method can be called if sourcescip is in one of the following stages:
890  * - \ref SCIP_STAGE_PROBLEM
891  * - \ref SCIP_STAGE_TRANSFORMED
892  * - \ref SCIP_STAGE_INITPRESOLVE
893  * - \ref SCIP_STAGE_PRESOLVING
894  * - \ref SCIP_STAGE_EXITPRESOLVE
895  * - \ref SCIP_STAGE_PRESOLVED
896  * - \ref SCIP_STAGE_INITSOLVE
897  * - \ref SCIP_STAGE_SOLVING
898  * - \ref SCIP_STAGE_SOLVED
899  *
900  * @pre This method can be called if targetscip is in one of the following stages:
901  * - \ref SCIP_STAGE_PROBLEM
902  *
903  * @note sourcescip stage does not get changed
904  *
905  * @note targetscip stage does not get changed
906  *
907  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
908  */
909 extern
911  SCIP* sourcescip, /**< source SCIP data structure */
912  SCIP* targetscip, /**< target SCIP data structure */
913  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
914  * target variables, or NULL */
915  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
916  * target constraints, or NULL */
917  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
918  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
919  int nfixedvars /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
920  );
921 
922 /** merges the histories of variables from a source SCIP into a target SCIP. The two data structures should point to
923  * different SCIP instances.
924  *
925  * @note the notion of source and target is inverted here; \p sourcescip usually denotes a copied SCIP instance, whereas
926  * \p targetscip denotes the original instance
927  */
928 
929 extern
931  SCIP* sourcescip, /**< source SCIP data structure */
932  SCIP* targetscip, /**< target SCIP data structure */
933  SCIP_VAR** sourcevars, /**< source variables for history merge */
934  SCIP_VAR** targetvars, /**< target variables for history merge */
935  int nvars /**< number of variables in both variable arrays */
936  );
937 
938 /** returns copy of the source constraint; if there already is a copy of the source constraint in the constraint hash
939  * map, it is just returned as target constraint; elsewise a new constraint will be created; this created constraint is
940  * added to the constraint hash map and returned as target constraint; the variable map is used to map the variables of
941  * the source SCIP to the variables of the target SCIP
942  *
943  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
944  * be declared feasible even if it violates this particular constraint. This constellation should only be
945  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
946  * to the variable's local bounds.
947  *
948  * @note The constraint is not added to the target SCIP. You can check whether a constraint is added by calling
949  * SCIPconsIsAdded(). (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add
950  * explicitly and what is already added.)
951  *
952  * @note The constraint is always captured, either during the creation of the copy or after finding the copy of the
953  * constraint in the constraint hash map
954  *
955  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
956  * @note Do not change the source SCIP environment during the copying process
957  *
958  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
959  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
960  *
961  * @pre This method can be called if sourcescip is in one of the following stages:
962  * - \ref SCIP_STAGE_PROBLEM
963  * - \ref SCIP_STAGE_TRANSFORMED
964  * - \ref SCIP_STAGE_INITPRESOLVE
965  * - \ref SCIP_STAGE_PRESOLVING
966  * - \ref SCIP_STAGE_EXITPRESOLVE
967  * - \ref SCIP_STAGE_PRESOLVED
968  * - \ref SCIP_STAGE_INITSOLVE
969  * - \ref SCIP_STAGE_SOLVING
970  * - \ref SCIP_STAGE_SOLVED
971  *
972  * @pre This method can be called if targetscip is in one of the following stages:
973  * - \ref SCIP_STAGE_PROBLEM
974  * - \ref SCIP_STAGE_TRANSFORMING
975  * - \ref SCIP_STAGE_INITPRESOLVE
976  * - \ref SCIP_STAGE_PRESOLVING
977  * - \ref SCIP_STAGE_EXITPRESOLVE
978  * - \ref SCIP_STAGE_PRESOLVED
979  * - \ref SCIP_STAGE_SOLVING
980  * - \ref SCIP_STAGE_EXITSOLVE
981  *
982  * @note sourcescip stage does not get changed
983  *
984  * @note targetscip stage does not get changed
985  *
986  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
987  */
988 extern
990  SCIP* sourcescip, /**< source SCIP data structure */
991  SCIP* targetscip, /**< target SCIP data structure */
992  SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
993  SCIP_CONS** targetcons, /**< pointer to store the created target constraint */
994  SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
995  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
996  * variables of the target SCIP, or NULL */
997  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
998  * target constraints, or NULL */
999  const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
1000  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
1001  SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
1002  SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
1003  SCIP_Bool check, /**< should the constraint be checked for feasibility? */
1004  SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
1005  SCIP_Bool local, /**< is constraint only valid locally? */
1006  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
1007  SCIP_Bool dynamic, /**< is constraint subject to aging? */
1008  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
1009  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
1010  * if it may be moved to a more global node? */
1011  SCIP_Bool global, /**< create a global or a local copy? */
1012  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
1013  );
1014 
1015 /** copies constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
1016  * variables between the source and the target SCIP a hash map can be given; if the variable hash
1017  * map is NULL or necessary variable mapping is missing, the required variables are created in the
1018  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
1019  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
1020  * between the constraints of the source and target-SCIP is stored
1021  *
1022  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
1023  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
1024  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
1025  *
1026  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1027  * @note Do not change the source SCIP environment during the copying process
1028  *
1029  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1030  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1031  *
1032  * @pre This method can be called if sourcescip is in one of the following stages:
1033  * - \ref SCIP_STAGE_PROBLEM
1034  * - \ref SCIP_STAGE_TRANSFORMED
1035  * - \ref SCIP_STAGE_INITPRESOLVE
1036  * - \ref SCIP_STAGE_PRESOLVING
1037  * - \ref SCIP_STAGE_EXITPRESOLVE
1038  * - \ref SCIP_STAGE_PRESOLVED
1039  * - \ref SCIP_STAGE_INITSOLVE
1040  * - \ref SCIP_STAGE_SOLVING
1041  * - \ref SCIP_STAGE_SOLVED
1042  *
1043  * @pre This method can be called if targetscip is in one of the following stages:
1044  * - \ref SCIP_STAGE_PROBLEM
1045  *
1046  * @note sourcescip stage does not get changed
1047  *
1048  * @note targetscip stage does not get changed
1049  *
1050  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1051  */
1052 extern
1054  SCIP* sourcescip, /**< source SCIP data structure */
1055  SCIP* targetscip, /**< target SCIP data structure */
1056  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
1057  * variables of the target SCIP, or NULL */
1058  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1059  * target constraints, or NULL */
1060  SCIP_Bool global, /**< create a global or a local copy? */
1061  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
1062  * If TRUE, the modifiable flag of constraints will be copied. */
1063  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
1064  );
1065 
1066 /** copies all original constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
1067  * variables between the source and the target SCIP a hash map can be given; if the variable hash
1068  * map is NULL or necessary variable mapping is missing, the required variables are created in the
1069  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
1070  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
1071  * between the constraints of the source and target-SCIP is stored
1072  *
1073  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
1074  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
1075  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
1076  *
1077  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1078  * @note Do not change the source SCIP environment during the copying process
1079  *
1080  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1081  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1082  *
1083  * @pre This method can be called if sourcescip is in one of the following stages:
1084  * - \ref SCIP_STAGE_PROBLEM
1085  * - \ref SCIP_STAGE_TRANSFORMED
1086  * - \ref SCIP_STAGE_INITPRESOLVE
1087  * - \ref SCIP_STAGE_PRESOLVING
1088  * - \ref SCIP_STAGE_EXITPRESOLVE
1089  * - \ref SCIP_STAGE_PRESOLVED
1090  * - \ref SCIP_STAGE_INITSOLVE
1091  * - \ref SCIP_STAGE_SOLVING
1092  * - \ref SCIP_STAGE_SOLVED
1093  *
1094  * @pre This method can be called if targetscip is in one of the following stages:
1095  * - \ref SCIP_STAGE_PROBLEM
1096  *
1097  * @note sourcescip stage does not get changed
1098  *
1099  * @note targetscip stage does not get changed
1100  *
1101  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1102  */
1103 extern
1105  SCIP* sourcescip, /**< source SCIP data structure */
1106  SCIP* targetscip, /**< target SCIP data structure */
1107  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
1108  * variables of the target SCIP, or NULL */
1109  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1110  * target constraints, or NULL */
1111  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
1112  * If TRUE, the modifiable flag of constraints will be copied. */
1113  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
1114  );
1115 
1116 /** convert all active cuts from cutpool to linear constraints
1117  *
1118  * @note Do not change the source SCIP environment during the copying process
1119  *
1120  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1121  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1122  *
1123  * @pre This method can be called if SCIP is in one of the following stages:
1124  * - \ref SCIP_STAGE_PROBLEM
1125  * - \ref SCIP_STAGE_INITPRESOLVE
1126  * - \ref SCIP_STAGE_PRESOLVING
1127  * - \ref SCIP_STAGE_EXITPRESOLVE
1128  * - \ref SCIP_STAGE_PRESOLVED
1129  * - \ref SCIP_STAGE_SOLVING
1130  * - \ref SCIP_STAGE_EXITSOLVE
1131  *
1132  * @note SCIP stage does not get changed
1133  *
1134  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1135  */
1136 extern
1138  SCIP* scip, /**< SCIP data structure */
1139  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1140  * target variables, or NULL */
1141  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1142  * target constraints, or NULL */
1143  SCIP_Bool global, /**< create a global or a local copy? */
1144  int* ncutsadded /**< pointer to store number of added cuts, or NULL */
1145  );
1146 
1147 /** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip
1148  *
1149  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1150  * @note Do not change the source SCIP environment during the copying process
1151  *
1152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1154  *
1155  * @pre This method can be called if sourcescip is in one of the following stages:
1156  * - \ref SCIP_STAGE_PROBLEM
1157  * - \ref SCIP_STAGE_TRANSFORMED
1158  * - \ref SCIP_STAGE_INITPRESOLVE
1159  * - \ref SCIP_STAGE_PRESOLVING
1160  * - \ref SCIP_STAGE_EXITPRESOLVE
1161  * - \ref SCIP_STAGE_PRESOLVED
1162  * - \ref SCIP_STAGE_SOLVING
1163  * - \ref SCIP_STAGE_SOLVED
1164  * - \ref SCIP_STAGE_EXITSOLVE
1165  *
1166  * @pre This method can be called if targetscip is in one of the following stages:
1167  * - \ref SCIP_STAGE_PROBLEM
1168  * - \ref SCIP_STAGE_INITPRESOLVE
1169  * - \ref SCIP_STAGE_PRESOLVING
1170  * - \ref SCIP_STAGE_EXITPRESOLVE
1171  * - \ref SCIP_STAGE_PRESOLVED
1172  * - \ref SCIP_STAGE_SOLVING
1173  * - \ref SCIP_STAGE_EXITSOLVE
1174  *
1175  * @note sourcescip stage does not get changed
1176  *
1177  * @note targetscip stage does not get changed
1178  *
1179  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1180  */
1181 extern
1183  SCIP* sourcescip, /**< source SCIP data structure */
1184  SCIP* targetscip, /**< target SCIP data structure */
1185  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1186  * target variables, or NULL */
1187  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1188  * target constraints, or NULL */
1189  SCIP_Bool global, /**< create a global or a local copy? */
1190  int* ncutsadded /**< pointer to store number of copied cuts, or NULL */
1191  );
1192 
1193 /** copies all active conflicts from the conflict pool of sourcescip and adds them as linear constraints to targetscip
1194  *
1195  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1196  * @note Do not change the source SCIP environment during the copying process
1197  *
1198  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1199  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1200  *
1201  * @pre This method can be called if sourcescip is in one of the following stages:
1202  * - \ref SCIP_STAGE_PROBLEM
1203  * - \ref SCIP_STAGE_TRANSFORMED
1204  * - \ref SCIP_STAGE_INITPRESOLVE
1205  * - \ref SCIP_STAGE_PRESOLVING
1206  * - \ref SCIP_STAGE_EXITPRESOLVE
1207  * - \ref SCIP_STAGE_PRESOLVED
1208  * - \ref SCIP_STAGE_SOLVING
1209  * - \ref SCIP_STAGE_SOLVED
1210  * - \ref SCIP_STAGE_EXITSOLVE
1211  *
1212  * @pre This method can be called if targetscip is in one of the following stages:
1213  * - \ref SCIP_STAGE_PROBLEM
1214  * - \ref SCIP_STAGE_INITPRESOLVE
1215  * - \ref SCIP_STAGE_PRESOLVING
1216  * - \ref SCIP_STAGE_EXITPRESOLVE
1217  * - \ref SCIP_STAGE_PRESOLVED
1218  * - \ref SCIP_STAGE_SOLVING
1219  * - \ref SCIP_STAGE_EXITSOLVE
1220  *
1221  * @note sourcescip stage does not change
1222  *
1223  * @note targetscip stage does not change
1224  *
1225  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1226  */
1227 extern
1229  SCIP* sourcescip, /**< source SCIP data structure */
1230  SCIP* targetscip, /**< target SCIP data structure */
1231  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1232  * target variables, or NULL */
1233  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1234  * target constraints, or NULL */
1235  SCIP_Bool global, /**< create a global or a local copy? */
1236  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
1237  * If TRUE, the modifiable flag of constraints will be copied. */
1238  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
1239  );
1240 
1241 /** copies implications and cliques of sourcescip to targetscip
1242  *
1243  * This function should be called for a targetscip in transformed stage. It can save time in presolving of the
1244  * targetscip, since implications and cliques are copied.
1245  *
1246  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1247  * @note Do not change the source SCIP environment during the copying process
1248  *
1249  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1250  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1251  *
1252  * @pre This method can be called if sourcescip is in one of the following stages:
1253  * - \ref SCIP_STAGE_TRANSFORMED
1254  * - \ref SCIP_STAGE_INITPRESOLVE
1255  * - \ref SCIP_STAGE_PRESOLVING
1256  * - \ref SCIP_STAGE_EXITPRESOLVE
1257  * - \ref SCIP_STAGE_PRESOLVED
1258  * - \ref SCIP_STAGE_SOLVING
1259  * - \ref SCIP_STAGE_SOLVED
1260  * - \ref SCIP_STAGE_EXITSOLVE
1261  *
1262  * @pre This method can be called if targetscip is in one of the following stages:
1263  * - \ref SCIP_STAGE_TRANSFORMED
1264  * - \ref SCIP_STAGE_INITPRESOLVE
1265  * - \ref SCIP_STAGE_PRESOLVING
1266  * - \ref SCIP_STAGE_EXITPRESOLVE
1267  * - \ref SCIP_STAGE_PRESOLVED
1268  * - \ref SCIP_STAGE_INITSOLVE
1269  * - \ref SCIP_STAGE_SOLVING
1270  *
1271  * @note sourcescip stage does not get changed
1272  *
1273  * @note targetscip stage does not get changed
1274  *
1275  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1276  */
1277 extern
1279  SCIP* sourcescip, /**< source SCIP data structure */
1280  SCIP* targetscip, /**< target SCIP data structure */
1281  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1282  * target variables, or NULL */
1283  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1284  * target constraints, or NULL */
1285  SCIP_Bool global, /**< create a global or a local copy? */
1286  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1287  int* nbdchgs, /**< pointer to store the number of performed bound changes, or NULL */
1288  int* ncopied /**< pointer to store number of copied implications and cliques, or NULL */
1289  );
1290 
1291 /** copies parameter settings from sourcescip to targetscip
1292  *
1293  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1294  * @note Do not change the source SCIP environment during the copying process
1295  *
1296  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1297  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1298  *
1299  * @pre This method can be called if sourcescip is in one of the following stages:
1300  * - \ref SCIP_STAGE_PROBLEM
1301  * - \ref SCIP_STAGE_TRANSFORMED
1302  * - \ref SCIP_STAGE_INITPRESOLVE
1303  * - \ref SCIP_STAGE_PRESOLVING
1304  * - \ref SCIP_STAGE_EXITPRESOLVE
1305  * - \ref SCIP_STAGE_PRESOLVED
1306  * - \ref SCIP_STAGE_INITSOLVE
1307  * - \ref SCIP_STAGE_SOLVING
1308  * - \ref SCIP_STAGE_SOLVED
1309  *
1310  * @pre This method can be called if targetscip is in one of the following stages:
1311  * - \ref SCIP_STAGE_INIT
1312  * - \ref SCIP_STAGE_PROBLEM
1313  * - \ref SCIP_STAGE_FREE
1314  *
1315  * @note sourcescip stage does not get changed
1316  *
1317  * @note targetscip stage does not get changed
1318  *
1319  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1320  */
1321 extern
1323  SCIP* sourcescip, /**< source SCIP data structure */
1324  SCIP* targetscip /**< target SCIP data structure */
1325  );
1326 
1327 /** gets depth of current scip instance (increased by each copy call)
1328  *
1329  * @return Depth of subscip of SCIP is returned.
1330  *
1331  * @pre This method can be called if SCIP is in one of the following stages:
1332  * - \ref SCIP_STAGE_PROBLEM
1333  * - \ref SCIP_STAGE_TRANSFORMING
1334  * - \ref SCIP_STAGE_TRANSFORMED
1335  * - \ref SCIP_STAGE_INITPRESOLVE
1336  * - \ref SCIP_STAGE_PRESOLVING
1337  * - \ref SCIP_STAGE_EXITPRESOLVE
1338  * - \ref SCIP_STAGE_PRESOLVED
1339  * - \ref SCIP_STAGE_INITSOLVE
1340  * - \ref SCIP_STAGE_SOLVING
1341  * - \ref SCIP_STAGE_SOLVED
1342  * - \ref SCIP_STAGE_EXITSOLVE
1343  * - \ref SCIP_STAGE_FREETRANS
1344  *
1345  * @note SCIP stage does not get changed
1346  *
1347  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1348  */
1349 extern
1351  SCIP* scip /**< SCIP data structure */
1352  );
1353 
1354 /** sets depth of scip instance
1355  *
1356  * @pre This method can be called if SCIP is in one of the following stages:
1357  * - \ref SCIP_STAGE_PROBLEM
1358  *
1359  * @note SCIP stage does not get changed
1360  *
1361  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1362  */
1363 extern
1364 void SCIPsetSubscipDepth(
1365  SCIP* scip, /**< SCIP data structure */
1366  int newdepth /**< new subscip depth */
1367  );
1368 
1369 /** copies source SCIP to target SCIP; the copying process is done in the following order:
1370  * 1) copy the plugins
1371  * 2) copy the settings
1372  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1373  * 4) copy all active variables
1374  * 5) copy all constraints
1375  *
1376  * The source problem depends on the stage of the \p sourcescip - In SCIP_STAGE_PROBLEM, the original problem is copied,
1377  * otherwise, the transformed problem is copied. For an explicit copy of the original problem, use SCIPcopyOrig().
1378  *
1379  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1380  *
1381  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1382  * Also, 'passmessagehdlr' should be set to FALSE.
1383  * @note Do not change the source SCIP environment during the copying process
1384  *
1385  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1386  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1387  *
1388  * @pre This method can be called if sourcescip is in one of the following stages:
1389  * - \ref SCIP_STAGE_PROBLEM
1390  * - \ref SCIP_STAGE_TRANSFORMED
1391  * - \ref SCIP_STAGE_INITPRESOLVE
1392  * - \ref SCIP_STAGE_PRESOLVING
1393  * - \ref SCIP_STAGE_EXITPRESOLVE
1394  * - \ref SCIP_STAGE_PRESOLVED
1395  * - \ref SCIP_STAGE_INITSOLVE
1396  * - \ref SCIP_STAGE_SOLVING
1397  * - \ref SCIP_STAGE_SOLVED
1398  *
1399  * @pre This method can be called if targetscip is in one of the following stages:
1400  * - \ref SCIP_STAGE_INIT
1401  * - \ref SCIP_STAGE_FREE
1402  *
1403  * @note sourcescip stage does not get changed
1404  *
1405  * @note targetscip stage does not get changed
1406  *
1407  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1408  */
1409 extern
1411  SCIP* sourcescip, /**< source SCIP data structure */
1412  SCIP* targetscip, /**< target SCIP data structure */
1413  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1414  * target variables, or NULL */
1415  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1416  * target constraints, or NULL */
1417  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1418  SCIP_Bool global, /**< create a global or a local copy? */
1419  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1420  * plugins will be copied and activated, and the modifiable flag of
1421  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1422  * there are pricers present */
1423  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1424  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1425  );
1426 
1427 /** copies source SCIP to target SCIP but compresses constraints
1428  *
1429  * constraint compression is performed by removing fixed variables immediately
1430  * during constraint creation if the involved constraint handlers support
1431  * compression
1432  *
1433  * the copying process is done in the following order:
1434  * 1) copy the plugins
1435  * 2) copy the settings
1436  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1437  * 4) copy all active variables
1438  * a) fix all variable copies specified by \p fixedvars, \p fixedvals, and \p nfixedvars
1439  * b) enable constraint compression
1440  * 5) copy all constraints
1441  *
1442  * The source problem depends on the stage of the \p sourcescip - In SCIP_STAGE_PROBLEM, the original problem is copied,
1443  * otherwise, the transformed problem is copied. For an explicit copy of the original problem, use SCIPcopyOrigConsCompression().
1444  *
1445  * @note: in case that a combination of local bounds and explicit fixing values should be used,
1446  * the fixing value of a variable is preferred if local bounds and fixing value disagree.
1447  *
1448  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1449  *
1450  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1451  * Also, 'passmessagehdlr' should be set to FALSE.
1452  * @note Do not change the source SCIP environment during the copying process
1453  *
1454  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1455  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1456  *
1457  * @pre This method can be called if sourcescip is in one of the following stages:
1458  * - \ref SCIP_STAGE_PROBLEM
1459  * - \ref SCIP_STAGE_TRANSFORMED
1460  * - \ref SCIP_STAGE_INITPRESOLVE
1461  * - \ref SCIP_STAGE_PRESOLVING
1462  * - \ref SCIP_STAGE_EXITPRESOLVE
1463  * - \ref SCIP_STAGE_PRESOLVED
1464  * - \ref SCIP_STAGE_INITSOLVE
1465  * - \ref SCIP_STAGE_SOLVING
1466  * - \ref SCIP_STAGE_SOLVED
1467  *
1468  * @pre This method can be called if targetscip is in one of the following stages:
1469  * - \ref SCIP_STAGE_INIT
1470  * - \ref SCIP_STAGE_FREE
1471  *
1472  * @note sourcescip stage does not get changed
1473  *
1474  * @note targetscip stage does not get changed
1475  *
1476  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1477  */
1478 extern
1480  SCIP* sourcescip, /**< source SCIP data structure */
1481  SCIP* targetscip, /**< target SCIP data structure */
1482  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1483  * target variables, or NULL */
1484  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1485  * target constraints, or NULL */
1486  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1487  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
1488  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
1489  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
1490  SCIP_Bool global, /**< create a global or a local copy? */
1491  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1492  * plugins will be copied and activated, and the modifiable flag of
1493  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1494  * there are pricers present */
1495  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1496  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1497  );
1498 
1499 /** copies source SCIP original problem to target SCIP; the copying process is done in the following order:
1500  * 1) copy the plugins
1501  * 2) copy the settings
1502  * 3) create problem data in target-SCIP and copy the original problem data of the source-SCIP
1503  * 4) copy all original variables
1504  * 5) copy all original constraints
1505  *
1506  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1507  *
1508  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1509  * Also, 'passmessagehdlr' should be set to FALSE.
1510  * @note Do not change the source SCIP environment during the copying process
1511  *
1512  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1513  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1514  *
1515  * @pre This method can be called if sourcescip is in one of the following stages:
1516  * - \ref SCIP_STAGE_PROBLEM
1517  * - \ref SCIP_STAGE_TRANSFORMED
1518  * - \ref SCIP_STAGE_INITPRESOLVE
1519  * - \ref SCIP_STAGE_PRESOLVING
1520  * - \ref SCIP_STAGE_EXITPRESOLVE
1521  * - \ref SCIP_STAGE_PRESOLVED
1522  * - \ref SCIP_STAGE_INITSOLVE
1523  * - \ref SCIP_STAGE_SOLVING
1524  * - \ref SCIP_STAGE_SOLVED
1525  *
1526  * @pre This method can be called if targetscip is in one of the following stages:
1527  * - \ref SCIP_STAGE_INIT
1528  * - \ref SCIP_STAGE_FREE
1529  *
1530  * @note sourcescip stage does not get changed
1531  *
1532  * @note targetscip stage does not get changed
1533  *
1534  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1535  */
1536 extern
1538  SCIP* sourcescip, /**< source SCIP data structure */
1539  SCIP* targetscip, /**< target SCIP data structure */
1540  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1541  * target variables, or NULL */
1542  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1543  * target constraints, or NULL */
1544  const char* suffix, /**< suffix which will be added to the names of the target SCIP, might be empty */
1545  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1546  * plugins will be copied and activated, and the modifiable flag of
1547  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1548  * there are pricers present */
1549  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1550  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1551  );
1552 
1553 /** copies source SCIP original problem to target SCIP but compresses constraints
1554  *
1555  * constraint compression is performed by removing fixed variables immediately
1556  * during constraint creation if the involved constraint handlers support
1557  * compression
1558  *
1559  * the copying process is done in the following order:
1560  * 1) copy the plugins
1561  * 2) copy the settings
1562  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1563  * 4) copy all original variables
1564  * a) fix all variable copies specified by \p fixedvars, \p fixedvals, and \p nfixedvars
1565  * b) enable constraint compression
1566  * 5) copy all constraints
1567  *
1568  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1569  *
1570  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1571  * Also, 'passmessagehdlr' should be set to FALSE.
1572  * @note Do not change the source SCIP environment during the copying process
1573  *
1574  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1575  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1576  *
1577  * @pre This method can be called if sourcescip is in one of the following stages:
1578  * - \ref SCIP_STAGE_PROBLEM
1579  * - \ref SCIP_STAGE_TRANSFORMED
1580  * - \ref SCIP_STAGE_INITPRESOLVE
1581  * - \ref SCIP_STAGE_PRESOLVING
1582  * - \ref SCIP_STAGE_EXITPRESOLVE
1583  * - \ref SCIP_STAGE_PRESOLVED
1584  * - \ref SCIP_STAGE_INITSOLVE
1585  * - \ref SCIP_STAGE_SOLVING
1586  * - \ref SCIP_STAGE_SOLVED
1587  *
1588  * @pre This method can be called if targetscip is in one of the following stages:
1589  * - \ref SCIP_STAGE_INIT
1590  * - \ref SCIP_STAGE_FREE
1591  *
1592  * @note sourcescip stage does not get changed
1593  *
1594  * @note targetscip stage does not get changed
1595  *
1596  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1597  */
1598 extern
1600  SCIP* sourcescip, /**< source SCIP data structure */
1601  SCIP* targetscip, /**< target SCIP data structure */
1602  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1603  * target variables, or NULL */
1604  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1605  * target constraints, or NULL */
1606  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1607  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
1608  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
1609  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
1610  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1611  * plugins will be copied and activated, and the modifiable flag of
1612  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1613  * there are pricers present */
1614  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1615  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1616  );
1617 
1618 /** checks if there is enough time and memory left for copying the sourcescip into a sub-SCIP and solve the sub-SCIP
1619  *
1620  * This is the case if the time and memory limit that would be passed to the sub-SCIP are larger than 0.0
1621  *
1622  * @pre This method can be called if sourcescip is in one of the following stages:
1623  * - \ref SCIP_STAGE_PROBLEM
1624  * - \ref SCIP_STAGE_TRANSFORMED
1625  * - \ref SCIP_STAGE_INITPRESOLVE
1626  * - \ref SCIP_STAGE_PRESOLVING
1627  * - \ref SCIP_STAGE_EXITPRESOLVE
1628  * - \ref SCIP_STAGE_PRESOLVED
1629  * - \ref SCIP_STAGE_INITSOLVE
1630  * - \ref SCIP_STAGE_SOLVING
1631  * - \ref SCIP_STAGE_SOLVED
1632  *
1633  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1634  */
1635 extern
1637  SCIP* sourcescip, /**< source SCIP data structure */
1638  SCIP_Bool* success /**< pointer to store whether there is time and memory left to copy the
1639  * problem and run the sub-SCIP */
1640  );
1641 
1642 /** copies limits from source SCIP to target SCIP
1643  *
1644  * @note time and memory limit are reduced by the amount already spent in the source SCIP before installing the limit
1645  * in the target SCIP
1646  * @note all other limits are disabled and need to be enabled afterwards, if needed
1647  *
1648  * @pre This method can be called if sourcescip is in one of the following stages:
1649  * - \ref SCIP_STAGE_PROBLEM
1650  * - \ref SCIP_STAGE_TRANSFORMED
1651  * - \ref SCIP_STAGE_INITPRESOLVE
1652  * - \ref SCIP_STAGE_PRESOLVING
1653  * - \ref SCIP_STAGE_EXITPRESOLVE
1654  * - \ref SCIP_STAGE_PRESOLVED
1655  * - \ref SCIP_STAGE_INITSOLVE
1656  * - \ref SCIP_STAGE_SOLVING
1657  * - \ref SCIP_STAGE_SOLVED
1658  *
1659  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1660  */
1661 extern
1663  SCIP* sourcescip, /**< source SCIP data structure */
1664  SCIP* targetscip /**< target SCIP data structure */
1665  );
1666 
1667 
1668 /**@} */
1669 
1670 /*
1671  * parameter settings
1672  */
1673 
1674 /**@addtogroup ParameterMethods
1675  *
1676  * @{
1677  */
1678 
1679 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
1680  *
1681  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1682  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1683  */
1684 extern
1686  SCIP* scip, /**< SCIP data structure */
1687  const char* name, /**< name of the parameter */
1688  const char* desc, /**< description of the parameter */
1689  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
1690  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1691  SCIP_Bool defaultvalue, /**< default value of the parameter */
1692  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1693  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1694  );
1695 
1696 /** creates a int parameter, sets it to its default value, and adds it to the parameter set
1697  *
1698  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1699  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1700  */
1701 extern
1703  SCIP* scip, /**< SCIP data structure */
1704  const char* name, /**< name of the parameter */
1705  const char* desc, /**< description of the parameter */
1706  int* valueptr, /**< pointer to store the current parameter value, or NULL */
1707  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1708  int defaultvalue, /**< default value of the parameter */
1709  int minvalue, /**< minimum value for parameter */
1710  int maxvalue, /**< maximum value for parameter */
1711  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1712  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1713  );
1714 
1715 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
1716  *
1717  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1718  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1719  */
1720 extern
1722  SCIP* scip, /**< SCIP data structure */
1723  const char* name, /**< name of the parameter */
1724  const char* desc, /**< description of the parameter */
1725  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
1726  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1727  SCIP_Longint defaultvalue, /**< default value of the parameter */
1728  SCIP_Longint minvalue, /**< minimum value for parameter */
1729  SCIP_Longint maxvalue, /**< maximum value for parameter */
1730  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1731  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1732  );
1733 
1734 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
1735  *
1736  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1737  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1738  */
1739 extern
1741  SCIP* scip, /**< SCIP data structure */
1742  const char* name, /**< name of the parameter */
1743  const char* desc, /**< description of the parameter */
1744  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
1745  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1746  SCIP_Real defaultvalue, /**< default value of the parameter */
1747  SCIP_Real minvalue, /**< minimum value for parameter */
1748  SCIP_Real maxvalue, /**< maximum value for parameter */
1749  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1750  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1751  );
1752 
1753 /** creates a char parameter, sets it to its default value, and adds it to the parameter set
1754  *
1755  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1756  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1757  */
1758 extern
1760  SCIP* scip, /**< SCIP data structure */
1761  const char* name, /**< name of the parameter */
1762  const char* desc, /**< description of the parameter */
1763  char* valueptr, /**< pointer to store the current parameter value, or NULL */
1764  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1765  char defaultvalue, /**< default value of the parameter */
1766  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
1767  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1768  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1769  );
1770 
1771 /** creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
1772  *
1773  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1774  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1775  */
1776 extern
1778  SCIP* scip, /**< SCIP data structure */
1779  const char* name, /**< name of the parameter */
1780  const char* desc, /**< description of the parameter */
1781  char** valueptr, /**< pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL */
1782  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1783  const char* defaultvalue, /**< default value of the parameter */
1784  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1785  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1786  );
1787 
1788 /** gets the fixing status of an existing parameter
1789  *
1790  * @return TRUE if the parameter is fixed to a value, otherwise FALSE.
1791  */
1792 extern
1794  SCIP* scip, /**< SCIP data structure */
1795  const char* name /**< name of the parameter */
1796  );
1797 
1798 /** returns the pointer to the SCIP parameter with the given name
1799  *
1800  * @return pointer to the parameter with the given name
1801  */
1802 extern
1804  SCIP* scip, /**< SCIP data structure */
1805  const char* name /**< name of the parameter */
1806  );
1807 
1808 /** gets the value of an existing SCIP_Bool parameter
1809  *
1810  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1811  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1812  */
1813 extern
1815  SCIP* scip, /**< SCIP data structure */
1816  const char* name, /**< name of the parameter */
1817  SCIP_Bool* value /**< pointer to store the parameter */
1818  );
1819 
1820 /** gets the value of an existing int parameter
1821  *
1822  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1823  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1824  */
1825 extern
1827  SCIP* scip, /**< SCIP data structure */
1828  const char* name, /**< name of the parameter */
1829  int* value /**< pointer to store the parameter */
1830  );
1831 
1832 /** gets the value of an existing SCIP_Longint parameter
1833  *
1834  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1835  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1836  */
1837 extern
1839  SCIP* scip, /**< SCIP data structure */
1840  const char* name, /**< name of the parameter */
1841  SCIP_Longint* value /**< pointer to store the parameter */
1842  );
1843 
1844 /** gets the value of an existing SCIP_Real parameter
1845  *
1846  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1847  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1848  */
1849 extern
1851  SCIP* scip, /**< SCIP data structure */
1852  const char* name, /**< name of the parameter */
1853  SCIP_Real* value /**< pointer to store the parameter */
1854  );
1855 
1856 /** gets the value of an existing char parameter
1857  *
1858  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1859  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1860  */
1861 extern
1863  SCIP* scip, /**< SCIP data structure */
1864  const char* name, /**< name of the parameter */
1865  char* value /**< pointer to store the parameter */
1866  );
1867 
1868 /** gets the value of an existing string(char*) parameter
1869  *
1870  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1871  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1872  */
1873 extern
1875  SCIP* scip, /**< SCIP data structure */
1876  const char* name, /**< name of the parameter */
1877  char** value /**< pointer to store the parameter */
1878  );
1879 
1880 /** fixes the value of an existing parameter
1881  *
1882  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1883  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1884  *
1885  * @note: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because
1886  * they have to be changed for sub-SCIPs.
1887  */
1888 extern
1890  SCIP* scip, /**< SCIP data structure */
1891  const char* name /**< name of the parameter */
1892  );
1893 
1894 /** unfixes the value of an existing parameter
1895  *
1896  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1897  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1898  */
1899 extern
1901  SCIP* scip, /**< SCIP data structure */
1902  const char* name /**< name of the parameter */
1903  );
1904 
1905 /** changes the value of an existing parameter
1906  *
1907  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1908  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1909  */
1910 extern
1912  SCIP* scip, /**< SCIP data structure */
1913  const char* name, /**< name of the parameter */
1914  void* value /**< new value of the parameter */
1915  );
1916 
1917 /** changes the value of an existing SCIP_Bool parameter
1918  *
1919  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1920  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1921  */
1922 extern
1924  SCIP* scip, /**< SCIP data structure */
1925  SCIP_PARAM* param, /**< parameter */
1926  SCIP_Bool value /**< new value of the parameter */
1927  );
1928 
1929 /** changes the value of an existing SCIP_Bool parameter
1930  *
1931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1933  */
1934 extern
1936  SCIP* scip, /**< SCIP data structure */
1937  const char* name, /**< name of the parameter */
1938  SCIP_Bool value /**< new value of the parameter */
1939  );
1940 
1941 /** checks whether the value of an existing SCIP_Bool parameter is valid */
1942 extern
1944  SCIP* scip, /**< SCIP data structure */
1945  SCIP_PARAM* param, /**< parameter */
1946  SCIP_Bool value /**< value to check */
1947  );
1948 
1949 /** changes the value of an existing int parameter
1950  *
1951  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1952  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1953  */
1954 extern
1956  SCIP* scip, /**< SCIP data structure */
1957  SCIP_PARAM* param, /**< parameter */
1958  int value /**< new value of the parameter */
1959  );
1960 
1961 /** changes the value of an existing int parameter
1962  *
1963  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1964  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1965  */
1966 extern
1968  SCIP* scip, /**< SCIP data structure */
1969  const char* name, /**< name of the parameter */
1970  int value /**< new value of the parameter */
1971  );
1972 
1973 /** checks whether the value of an existing int parameter is valid */
1974 extern
1976  SCIP* scip, /**< SCIP data structure */
1977  SCIP_PARAM* param, /**< parameter */
1978  int value /**< value to check */
1979  );
1980 
1981 /** changes the value of an existing SCIP_Longint parameter
1982  *
1983  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1984  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1985  */
1986 extern
1988  SCIP* scip, /**< SCIP data structure */
1989  SCIP_PARAM* param, /**< parameter */
1990  SCIP_Longint value /**< new value of the parameter */
1991  );
1992 
1993 /** changes the value of an existing SCIP_Longint parameter
1994  *
1995  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1996  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1997  */
1998 extern
2000  SCIP* scip, /**< SCIP data structure */
2001  const char* name, /**< name of the parameter */
2002  SCIP_Longint value /**< new value of the parameter */
2003  );
2004 
2005 /** checks whether parameter value of an existing SCIP_Longint paramter is valid */
2006 extern
2008  SCIP* scip, /**< SCIP data structure */
2009  SCIP_PARAM* param, /**< parameter */
2010  SCIP_Longint value /**< value to check */
2011  );
2012 
2013 /** changes the value of an existing SCIP_Real parameter
2014  *
2015  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2016  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2017  */
2018 extern
2020  SCIP* scip, /**< SCIP data structure */
2021  SCIP_PARAM* param, /**< parameter */
2022  SCIP_Real value /**< new value of the parameter */
2023  );
2024 
2025 /** changes the value of an existing SCIP_Real parameter
2026  *
2027  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2028  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2029  */
2030 extern
2032  SCIP* scip, /**< SCIP data structure */
2033  const char* name, /**< name of the parameter */
2034  SCIP_Real value /**< new value of the parameter */
2035  );
2036 
2037 /** checks whether parameter value of an existing SCIP_Real paramter is valid */
2038 extern
2040  SCIP* scip, /**< SCIP data structure */
2041  SCIP_PARAM* param, /**< parameter */
2042  SCIP_Real value /**< value to check */
2043  );
2044 
2045 /** changes the value of an existing char parameter
2046  *
2047  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2048  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2049  */
2050 extern
2052  SCIP* scip, /**< SCIP data structure */
2053  SCIP_PARAM* param, /**< parameter */
2054  char value /**< new value of the parameter */
2055  );
2056 
2057 /** changes the value of an existing char parameter
2058  *
2059  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2060  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2061  */
2062 extern
2064  SCIP* scip, /**< SCIP data structure */
2065  const char* name, /**< name of the parameter */
2066  char value /**< new value of the parameter */
2067  );
2068 
2069 /** checks whether parameter value for a given SCIP_Real parameter is valid */
2070 extern
2072  SCIP* scip, /**< SCIP data structure */
2073  SCIP_PARAM* param, /**< parameter */
2074  const char value /**< value to check */
2075  );
2076 
2077 /** changes the value of an existing string(char*) parameter
2078  *
2079  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2080  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2081  */
2082 extern
2084  SCIP* scip, /**< SCIP data structure */
2085  SCIP_PARAM* param, /**< parameter */
2086  const char* value /**< new value of the parameter */
2087  );
2088 
2089 /** changes the value of an existing string(char*) parameter
2090  *
2091  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2092  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2093  */
2094 extern
2096  SCIP* scip, /**< SCIP data structure */
2097  const char* name, /**< name of the parameter */
2098  const char* value /**< new value of the parameter */
2099  );
2100 
2101 /** checks whether parameter value for a given string parameter is valid */
2102 extern
2104  SCIP* scip, /**< SCIP data structure */
2105  SCIP_PARAM* param, /**< parameter */
2106  const char* value /**< value to check */
2107  );
2108 
2109 /** reads parameters from a file
2110  *
2111  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2112  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2113  */
2114 extern
2116  SCIP* scip, /**< SCIP data structure */
2117  const char* filename /**< file name */
2118  );
2119 
2120 /** writes a single parameter to a file
2121  *
2122  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2123  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2124  */
2125 extern
2127  SCIP* scip, /**< SCIP data structure */
2128  SCIP_PARAM* param, /**< parameter */
2129  const char* filename, /**< file name, or NULL for stdout */
2130  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
2131  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
2132  * default value?
2133  */
2134  );
2135 
2136 /** writes all parameters in the parameter set to a file
2137  *
2138  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2139  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2140  */
2141 extern
2143  SCIP* scip, /**< SCIP data structure */
2144  const char* filename, /**< file name, or NULL for stdout */
2145  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
2146  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
2147  * default value?
2148  */
2149  );
2150 
2151 /** resets a single parameter to its default value
2152  *
2153  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2154  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2155  */
2156 extern
2158  SCIP* scip, /**< SCIP data structure */
2159  const char* name /**< name of the parameter */
2160  );
2161 
2162 /** resets all parameters to their default values
2163  *
2164  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2165  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2166  */
2167 extern
2169  SCIP* scip /**< SCIP data structure */
2170  );
2171 
2172 /** sets parameters to
2173  *
2174  * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
2175  * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
2176  * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
2177  * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
2178  * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
2179  * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
2180  * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
2181  * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
2182  * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
2183  * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
2184  *
2185  *
2186  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2187  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2188  */
2189 extern
2191  SCIP* scip, /**< SCIP data structure */
2192  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
2193  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2194  );
2195 
2196 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
2197  * auxiliary SCIP instances to avoid recursion
2198  *
2199  * @note only deactivates plugins which could cause recursion, some plugins which use sub-SCIPs stay activated
2200  *
2201  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2202  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2203  */
2204 extern
2206  SCIP* scip, /**< (auxiliary) SCIP data structure */
2207  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2208  );
2209 
2210 /** sets heuristic parameters values to
2211  *
2212  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
2213  * - SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
2214  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
2215  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
2216  *
2217  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2218  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2219  */
2220 extern
2222  SCIP* scip, /**< SCIP data structure */
2223  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2224  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2225  );
2226 
2227 /** sets presolving parameters to
2228  *
2229  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
2230  * - SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
2231  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
2232  * - SCIP_PARAMSETTING_OFF which turn off all presolving
2233  *
2234  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2235  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2236  */
2237 extern
2239  SCIP* scip, /**< SCIP data structure */
2240  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2241  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2242  );
2243 
2244 /** sets separating parameters to
2245  *
2246  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
2247  * - SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
2248  * - SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
2249  * - SCIP_PARAMSETTING_OFF which turn off all separating
2250  *
2251  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2252  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2253  */
2254 extern
2256  SCIP* scip, /**< SCIP data structure */
2257  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2258  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2259  );
2260 
2261 /** returns the array of all available SCIP parameters
2262  *
2263  * @return SCIP_PARAM* array, containing all SCIP parameters.
2264  */
2265 extern
2267  SCIP* scip /**< SCIP data structure */
2268  );
2269 
2270 /** returns the total number of all available SCIP parameters
2271  *
2272  * @return number of all SCIP parameters.
2273  */
2274 extern
2275 int SCIPgetNParams(
2276  SCIP* scip /**< SCIP data structure */
2277  );
2278 
2279 /**@} */
2280 
2281 
2282 /*
2283  * SCIP user functionality methods: managing plugins
2284  */
2285 
2286 /**@addtogroup PublicReaderMethods
2287  *
2288  * @{
2289  */
2290 
2291 /** creates a reader and includes it in SCIP
2292  *
2293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2295  *
2296  * @pre This method can be called if SCIP is in one of the following stages:
2297  * - \ref SCIP_STAGE_INIT
2298  * - \ref SCIP_STAGE_PROBLEM
2299  *
2300  * @note method has all reader callbacks as arguments and is thus changed every time a new callback is added
2301  * in future releases; consider using SCIPincludeReaderBasic() and setter functions
2302  * if you seek for a method which is less likely to change in future releases
2303  */
2304 extern
2306  SCIP* scip, /**< SCIP data structure */
2307  const char* name, /**< name of reader */
2308  const char* desc, /**< description of reader */
2309  const char* extension, /**< file extension that reader processes */
2310  SCIP_DECL_READERCOPY ((*readercopy)), /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
2311  SCIP_DECL_READERFREE ((*readerfree)), /**< destructor of reader */
2312  SCIP_DECL_READERREAD ((*readerread)), /**< read method */
2313  SCIP_DECL_READERWRITE ((*readerwrite)), /**< write method */
2314  SCIP_READERDATA* readerdata /**< reader data */
2315  );
2316 
2317 /** creates a reader and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2318  * Optional callbacks can be set via specific setter functions, see
2319  * SCIPsetReaderCopy(), SCIPsetReaderFree(), SCIPsetReaderRead(), SCIPsetReaderWrite().
2320  *
2321  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2322  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2323  *
2324  * @pre This method can be called if SCIP is in one of the following stages:
2325  * - \ref SCIP_STAGE_INIT
2326  * - \ref SCIP_STAGE_PROBLEM
2327  *
2328  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeReader() instead
2329  */
2330 extern
2332  SCIP* scip, /**< SCIP data structure */
2333  SCIP_READER** readerptr, /**< reference to reader pointer, or NULL */
2334  const char* name, /**< name of reader */
2335  const char* desc, /**< description of reader */
2336  const char* extension, /**< file extension that reader processes */
2337  SCIP_READERDATA* readerdata /**< reader data */
2338  );
2339 
2340 /** set copy method of reader
2341  *
2342  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2343  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2344  *
2345  * @pre This method can be called if SCIP is in one of the following stages:
2346  * - \ref SCIP_STAGE_INIT
2347  * - \ref SCIP_STAGE_PROBLEM
2348  */
2349 extern
2351  SCIP* scip, /**< SCIP data structure */
2352  SCIP_READER* reader, /**< reader */
2353  SCIP_DECL_READERCOPY ((*readercopy)) /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
2354  );
2355 
2356 /** set deinitialization method of reader
2357  *
2358  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2359  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2360  *
2361  * @pre This method can be called if SCIP is in one of the following stages:
2362  * - \ref SCIP_STAGE_INIT
2363  * - \ref SCIP_STAGE_PROBLEM
2364  */
2365 extern
2367  SCIP* scip, /**< SCIP data structure */
2368  SCIP_READER* reader, /**< reader */
2369  SCIP_DECL_READERFREE ((*readerfree)) /**< destructor of reader */
2370  );
2371 
2372 /** set read method of reader
2373  *
2374  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2375  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2376  *
2377  * @pre This method can be called if SCIP is in one of the following stages:
2378  * - \ref SCIP_STAGE_INIT
2379  * - \ref SCIP_STAGE_PROBLEM
2380  */
2381 extern
2383  SCIP* scip, /**< SCIP data structure */
2384  SCIP_READER* reader, /**< reader */
2385  SCIP_DECL_READERREAD ((*readerread)) /**< read method of reader */
2386  );
2387 
2388 /** set write method of reader
2389  *
2390  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2391  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2392  *
2393  * @pre This method can be called if SCIP is in one of the following stages:
2394  * - \ref SCIP_STAGE_INIT
2395  * - \ref SCIP_STAGE_PROBLEM
2396  */
2397 extern
2399  SCIP* scip, /**< SCIP data structure */
2400  SCIP_READER* reader, /**< reader */
2401  SCIP_DECL_READERWRITE ((*readerwrite)) /**< write method of reader */
2402  );
2403 
2404 /** returns the reader of the given name, or NULL if not existing */
2405 extern
2407  SCIP* scip, /**< SCIP data structure */
2408  const char* name /**< name of reader */
2409  );
2410 
2411 /** returns the array of currently available readers */
2412 extern
2414  SCIP* scip /**< SCIP data structure */
2415  );
2416 
2417 /** returns the number of currently available readers */
2418 extern
2419 int SCIPgetNReaders(
2420  SCIP* scip /**< SCIP data structure */
2421  );
2422 
2423 /* @} */
2424 
2425 /**@addtogroup PublicPricerMethods
2426  *
2427  * @{
2428  */
2429 
2430 /** creates a variable pricer and includes it in SCIP
2431  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2432  * This should be done during the problem creation stage.
2433  *
2434  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2435  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2436  *
2437  * @pre This method can be called if SCIP is in one of the following stages:
2438  * - \ref SCIP_STAGE_INIT
2439  * - \ref SCIP_STAGE_PROBLEM
2440  *
2441  * @note method has all pricer callbacks as arguments and is thus changed every time a new callback is added
2442  * in future releases; consider using SCIPincludePricerBasic() and setter functions
2443  * if you seek for a method which is less likely to change in future releases
2444  */
2445 extern
2447  SCIP* scip, /**< SCIP data structure */
2448  const char* name, /**< name of variable pricer */
2449  const char* desc, /**< description of variable pricer */
2450  int priority, /**< priority of the variable pricer */
2451  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2452  * problem variables with negative reduced costs are found?
2453  * if this is set to FALSE it may happen that the pricer produces columns
2454  * that already exist in the problem (which are also priced in by the
2455  * default problem variable pricing in the same round) */
2456  SCIP_DECL_PRICERCOPY ((*pricercopy)), /**< copy method of variable pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2457  SCIP_DECL_PRICERFREE ((*pricerfree)), /**< destructor of variable pricer */
2458  SCIP_DECL_PRICERINIT ((*pricerinit)), /**< initialize variable pricer */
2459  SCIP_DECL_PRICEREXIT ((*pricerexit)), /**< deinitialize variable pricer */
2460  SCIP_DECL_PRICERINITSOL((*pricerinitsol)),/**< solving process initialization method of variable pricer */
2461  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)),/**< solving process deinitialization method of variable pricer */
2462  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2463  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2464  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2465  );
2466 
2467 /** creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL;
2468  * if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(),
2469  * SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(),
2470  * SCIPsetPricerFarkas();
2471  *
2472  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2473  * This should be done during the problem creation stage.
2474  *
2475  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2476  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2477  *
2478  * @pre This method can be called if SCIP is in one of the following stages:
2479  * - \ref SCIP_STAGE_INIT
2480  * - \ref SCIP_STAGE_PROBLEM
2481  *
2482  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePricer() instead
2483  */
2484 extern
2486  SCIP* scip, /**< SCIP data structure */
2487  SCIP_PRICER** pricerptr, /**< reference to a pricer, or NULL */
2488  const char* name, /**< name of variable pricer */
2489  const char* desc, /**< description of variable pricer */
2490  int priority, /**< priority of the variable pricer */
2491  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2492  * problem variables with negative reduced costs are found?
2493  * if this is set to FALSE it may happen that the pricer produces columns
2494  * that already exist in the problem (which are also priced in by the
2495  * default problem variable pricing in the same round) */
2496  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2497  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2498  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2499  );
2500 
2501 /** sets copy method of pricer
2502  *
2503  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2504  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2505  *
2506  * @pre This method can be called if SCIP is in one of the following stages:
2507  * - \ref SCIP_STAGE_INIT
2508  * - \ref SCIP_STAGE_PROBLEM
2509  */
2510 extern
2512  SCIP* scip, /**< SCIP data structure */
2513  SCIP_PRICER* pricer, /**< pricer */
2514  SCIP_DECL_PRICERCOPY ((*pricercopy)) /**< copy method of pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2515  );
2516 
2517 /** sets destructor method of pricer
2518  *
2519  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2520  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2521  *
2522  * @pre This method can be called if SCIP is in one of the following stages:
2523  * - \ref SCIP_STAGE_INIT
2524  * - \ref SCIP_STAGE_PROBLEM
2525  */
2526 extern
2528  SCIP* scip, /**< SCIP data structure */
2529  SCIP_PRICER* pricer, /**< pricer */
2530  SCIP_DECL_PRICERFREE ((*pricerfree)) /**< destructor of pricer */
2531  );
2532 
2533 /** sets initialization method of pricer
2534  *
2535  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2537  *
2538  * @pre This method can be called if SCIP is in one of the following stages:
2539  * - \ref SCIP_STAGE_INIT
2540  * - \ref SCIP_STAGE_PROBLEM
2541  */
2542 extern
2544  SCIP* scip, /**< SCIP data structure */
2545  SCIP_PRICER* pricer, /**< pricer */
2546  SCIP_DECL_PRICERINIT ((*pricerinit)) /**< initialize pricer */
2547  );
2548 
2549 /** sets deinitialization method of pricer
2550  *
2551  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2552  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2553  *
2554  * @pre This method can be called if SCIP is in one of the following stages:
2555  * - \ref SCIP_STAGE_INIT
2556  * - \ref SCIP_STAGE_PROBLEM
2557  */
2558 extern
2560  SCIP* scip, /**< SCIP data structure */
2561  SCIP_PRICER* pricer, /**< pricer */
2562  SCIP_DECL_PRICEREXIT ((*pricerexit)) /**< deinitialize pricer */
2563  );
2564 
2565 /** sets solving process initialization method of pricer
2566  *
2567  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2568  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2569  *
2570  * @pre This method can be called if SCIP is in one of the following stages:
2571  * - \ref SCIP_STAGE_INIT
2572  * - \ref SCIP_STAGE_PROBLEM
2573  */
2574 extern
2576  SCIP* scip, /**< SCIP data structure */
2577  SCIP_PRICER* pricer, /**< pricer */
2578  SCIP_DECL_PRICERINITSOL ((*pricerinitsol))/**< solving process initialization method of pricer */
2579  );
2580 
2581 /** sets solving process deinitialization method of pricer
2582  *
2583  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2584  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2585  *
2586  * @pre This method can be called if SCIP is in one of the following stages:
2587  * - \ref SCIP_STAGE_INIT
2588  * - \ref SCIP_STAGE_PROBLEM
2589  */
2590 extern
2592  SCIP* scip, /**< SCIP data structure */
2593  SCIP_PRICER* pricer, /**< pricer */
2594  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)) /**< solving process deinitialization method of pricer */
2595  );
2596 
2597 /** returns the variable pricer of the given name, or NULL if not existing */
2598 extern
2600  SCIP* scip, /**< SCIP data structure */
2601  const char* name /**< name of variable pricer */
2602  );
2603 
2604 /** returns the array of currently available variable pricers; active pricers are in the first slots of the array */
2605 extern
2607  SCIP* scip /**< SCIP data structure */
2608  );
2609 
2610 /** returns the number of currently available variable pricers */
2611 extern
2612 int SCIPgetNPricers(
2613  SCIP* scip /**< SCIP data structure */
2614  );
2615 
2616 /** returns the number of currently active variable pricers, that are used in the LP solving loop */
2617 extern
2619  SCIP* scip /**< SCIP data structure */
2620  );
2621 
2622 /** sets the priority of a variable pricer */
2623 extern
2625  SCIP* scip, /**< SCIP data structure */
2626  SCIP_PRICER* pricer, /**< variable pricer */
2627  int priority /**< new priority of the variable pricer */
2628  );
2629 
2630 /** activates pricer to be used for the current problem
2631  * This method should be called during the problem creation stage for all pricers that are necessary to solve
2632  * the problem model.
2633  * The pricers are automatically deactivated when the problem is freed.
2634  *
2635  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2636  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2637  *
2638  * @pre This method can be called if SCIP is in one of the following stages:
2639  * - \ref SCIP_STAGE_PROBLEM
2640  */
2641 extern
2643  SCIP* scip, /**< SCIP data structure */
2644  SCIP_PRICER* pricer /**< variable pricer */
2645  );
2646 
2647 /** deactivates pricer
2648  *
2649  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2650  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2651  *
2652  * @pre This method can be called if SCIP is in one of the following stages:
2653  * - \ref SCIP_STAGE_PROBLEM
2654  * - \ref SCIP_STAGE_EXITSOLVE
2655  */
2656 extern
2658  SCIP* scip, /**< SCIP data structure */
2659  SCIP_PRICER* pricer /**< variable pricer */
2660  );
2661 
2662 /* @} */
2663 
2664 /**@addtogroup PublicConshdlrMethods
2665  *
2666  * @{
2667  */
2668 
2669 /** creates a constraint handler and includes it in SCIP.
2670  *
2671  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2672  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2673  *
2674  * @pre This method can be called if SCIP is in one of the following stages:
2675  * - \ref SCIP_STAGE_INIT
2676  * - \ref SCIP_STAGE_PROBLEM
2677  *
2678  * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
2679  * callback is added
2680  * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
2681  * if you seek for a method which is less likely to change in future releases
2682  */
2683 extern
2685  SCIP* scip, /**< SCIP data structure */
2686  const char* name, /**< name of constraint handler */
2687  const char* desc, /**< description of constraint handler */
2688  int sepapriority, /**< priority of the constraint handler for separation */
2689  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2690  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2691  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2692  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2693  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2694  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2695  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2696  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
2697  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2698  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2699  SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
2700  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
2701  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2702  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
2703  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
2704  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
2705  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
2706  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
2707  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
2708  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
2709  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
2710  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
2711  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
2712  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2713  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2714  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2715  SCIP_DECL_CONSENFORELAX ((*consenforelax)), /**< enforcing constraints for relaxation solutions */
2716  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2717  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2718  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2719  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
2720  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
2721  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2722  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
2723  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
2724  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
2725  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
2726  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
2727  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
2728  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
2729  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
2730  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
2731  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
2732  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
2733  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2734  );
2735 
2736 /** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2737  * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
2738  * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
2739  * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
2740  * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
2741  * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
2742  * SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and
2743  * SCIPsetConshdlrGetDiveBdChgs().
2744  *
2745  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2746  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2747  *
2748  * @pre This method can be called if SCIP is in one of the following stages:
2749  * - \ref SCIP_STAGE_INIT
2750  * - \ref SCIP_STAGE_PROBLEM
2751  *
2752  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
2753  */
2754 extern
2756  SCIP* scip, /**< SCIP data structure */
2757  SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
2758  const char* name, /**< name of constraint handler */
2759  const char* desc, /**< description of constraint handler */
2760  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2761  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2762  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2763  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2764  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2765  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2766  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2767  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2768  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2769  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2770  );
2771 
2772 /** sets all separation related callbacks/parameters of the constraint handler
2773  *
2774  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2775  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2776  *
2777  * @pre This method can be called if SCIP is in one of the following stages:
2778  * - \ref SCIP_STAGE_INIT
2779  * - \ref SCIP_STAGE_PROBLEM
2780  */
2781 extern
2783  SCIP* scip, /**< SCIP data structure */
2784  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2785  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2786  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2787  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2788  int sepapriority, /**< priority of the constraint handler for separation */
2789  SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
2790  );
2791 
2792 /** sets both the propagation callback and the propagation frequency of the constraint handler
2793  *
2794  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2795  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2796  *
2797  * @pre This method can be called if SCIP is in one of the following stages:
2798  * - \ref SCIP_STAGE_INIT
2799  * - \ref SCIP_STAGE_PROBLEM
2800  */
2801 extern
2803  SCIP* scip, /**< SCIP data structure */
2804  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2805  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2806  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2807  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2808  SCIP_PROPTIMING proptiming /**< positions in the node solving loop where propagation should be executed */
2809  );
2810 
2811 /** sets relaxation enforcement method of the constraint handler
2812  *
2813  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2814  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2815  *
2816  * @pre This method can be called if SCIP is in one of the following stages:
2817  * - \ref SCIP_STAGE_INIT
2818  * - \ref SCIP_STAGE_PROBLEM
2819  */
2820 extern
2822  SCIP* scip, /**< SCIP data structure */
2823  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2824  SCIP_DECL_CONSENFORELAX ((*consenforelax)) /**< enforcement method for relaxation solution of constraint handler (might be NULL) */
2825  );
2826 
2827 /** sets copy method of both the constraint handler and each associated constraint
2828  *
2829  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2830  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2831  *
2832  * @pre This method can be called if SCIP is in one of the following stages:
2833  * - \ref SCIP_STAGE_INIT
2834  * - \ref SCIP_STAGE_PROBLEM
2835  */
2836 extern
2838  SCIP* scip, /**< SCIP data structure */
2839  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2840  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2841  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
2842  );
2843 
2844 /** sets destructor method of constraint handler
2845  *
2846  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2847  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2848  *
2849  * @pre This method can be called if SCIP is in one of the following stages:
2850  * - \ref SCIP_STAGE_INIT
2851  * - \ref SCIP_STAGE_PROBLEM
2852  */
2853 extern
2855  SCIP* scip, /**< SCIP data structure */
2856  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2857  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
2858  );
2859 
2860 /** sets initialization method of constraint handler
2861  *
2862  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2863  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2864  *
2865  * @pre This method can be called if SCIP is in one of the following stages:
2866  * - \ref SCIP_STAGE_INIT
2867  * - \ref SCIP_STAGE_PROBLEM
2868  */
2869 extern
2871  SCIP* scip, /**< SCIP data structure */
2872  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2873  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
2874  );
2875 
2876 /** sets deinitialization method of constraint handler
2877  *
2878  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2879  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2880  *
2881  * @pre This method can be called if SCIP is in one of the following stages:
2882  * - \ref SCIP_STAGE_INIT
2883  * - \ref SCIP_STAGE_PROBLEM
2884  */
2885 extern
2887  SCIP* scip, /**< SCIP data structure */
2888  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2889  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
2890  );
2891 
2892 /** sets solving process initialization method of constraint handler
2893  *
2894  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2895  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2896  *
2897  * @pre This method can be called if SCIP is in one of the following stages:
2898  * - \ref SCIP_STAGE_INIT
2899  * - \ref SCIP_STAGE_PROBLEM
2900  */
2901 extern
2903  SCIP* scip, /**< SCIP data structure */
2904  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2905  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
2906  );
2907 
2908 /** sets solving process deinitialization method of constraint handler
2909  *
2910  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2911  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2912  *
2913  * @pre This method can be called if SCIP is in one of the following stages:
2914  * - \ref SCIP_STAGE_INIT
2915  * - \ref SCIP_STAGE_PROBLEM
2916  */
2917 extern
2919  SCIP* scip, /**< SCIP data structure */
2920  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2921  SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
2922  );
2923 
2924 /** sets preprocessing initialization method of constraint handler
2925  *
2926  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2927  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2928  *
2929  * @pre This method can be called if SCIP is in one of the following stages:
2930  * - \ref SCIP_STAGE_INIT
2931  * - \ref SCIP_STAGE_PROBLEM
2932  */
2933 extern
2935  SCIP* scip, /**< SCIP data structure */
2936  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2937  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
2938  );
2939 
2940 /** sets preprocessing deinitialization method of constraint handler
2941  *
2942  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2943  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2944  *
2945  * @pre This method can be called if SCIP is in one of the following stages:
2946  * - \ref SCIP_STAGE_INIT
2947  * - \ref SCIP_STAGE_PROBLEM
2948  */
2949 extern
2951  SCIP* scip, /**< SCIP data structure */
2952  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2953  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
2954  );
2955 
2956 /** sets presolving method of constraint handler
2957  *
2958  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2959  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2960  *
2961  * @pre This method can be called if SCIP is in one of the following stages:
2962  * - \ref SCIP_STAGE_INIT
2963  * - \ref SCIP_STAGE_PROBLEM
2964  */
2965 extern
2967  SCIP* scip, /**< SCIP data structure */
2968  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2969  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
2970  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2971  SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
2972  );
2973 
2974 /** sets method of constraint handler to free specific constraint data
2975  *
2976  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2977  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2978  *
2979  * @pre This method can be called if SCIP is in one of the following stages:
2980  * - \ref SCIP_STAGE_INIT
2981  * - \ref SCIP_STAGE_PROBLEM
2982  */
2983 extern
2985  SCIP* scip, /**< SCIP data structure */
2986  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2987  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
2988  );
2989 
2990 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
2991  *
2992  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2993  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2994  *
2995  * @pre This method can be called if SCIP is in one of the following stages:
2996  * - \ref SCIP_STAGE_INIT
2997  * - \ref SCIP_STAGE_PROBLEM
2998  */
2999 extern
3001  SCIP* scip, /**< SCIP data structure */
3002  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3003  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
3004  );
3005 
3006 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
3007  *
3008  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3009  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3010  *
3011  * @pre This method can be called if SCIP is in one of the following stages:
3012  * - \ref SCIP_STAGE_INIT
3013  * - \ref SCIP_STAGE_PROBLEM
3014  */
3015 extern
3017  SCIP* scip, /**< SCIP data structure */
3018  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3019  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
3020  );
3021 
3022 /** sets propagation conflict resolving method of constraint handler
3023  *
3024  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3025  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3026  *
3027  * @pre This method can be called if SCIP is in one of the following stages:
3028  * - \ref SCIP_STAGE_INIT
3029  * - \ref SCIP_STAGE_PROBLEM
3030  */
3031 extern
3033  SCIP* scip, /**< SCIP data structure */
3034  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3035  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
3036  );
3037 
3038 /** sets activation notification method of constraint handler
3039  *
3040  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3041  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3042  *
3043  * @pre This method can be called if SCIP is in one of the following stages:
3044  * - \ref SCIP_STAGE_INIT
3045  * - \ref SCIP_STAGE_PROBLEM
3046  */
3047 extern
3049  SCIP* scip, /**< SCIP data structure */
3050  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3051  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
3052  );
3053 
3054 /** sets deactivation notification method of constraint handler
3055  *
3056  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3057  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3058  *
3059  * @pre This method can be called if SCIP is in one of the following stages:
3060  * - \ref SCIP_STAGE_INIT
3061  * - \ref SCIP_STAGE_PROBLEM
3062  */
3063 extern
3065  SCIP* scip, /**< SCIP data structure */
3066  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3067  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
3068  );
3069 
3070 /** sets enabling notification method of constraint handler
3071  *
3072  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3073  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3074  *
3075  * @pre This method can be called if SCIP is in one of the following stages:
3076  * - \ref SCIP_STAGE_INIT
3077  * - \ref SCIP_STAGE_PROBLEM
3078  */
3079 extern
3081  SCIP* scip, /**< SCIP data structure */
3082  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3083  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
3084  );
3085 
3086 /** sets disabling notification method of constraint handler
3087  *
3088  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3089  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3090  *
3091  * @pre This method can be called if SCIP is in one of the following stages:
3092  * - \ref SCIP_STAGE_INIT
3093  * - \ref SCIP_STAGE_PROBLEM
3094  */
3095 extern
3097  SCIP* scip, /**< SCIP data structure */
3098  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3099  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
3100  );
3101 
3102 /** sets variable deletion method of constraint handler
3103  *
3104  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3105  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3106  *
3107  * @pre This method can be called if SCIP is in one of the following stages:
3108  * - \ref SCIP_STAGE_INIT
3109  * - \ref SCIP_STAGE_PROBLEM
3110  */
3111 extern
3113  SCIP* scip, /**< SCIP data structure */
3114  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3115  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
3116  );
3117 
3118 /** sets constraint display method of constraint handler
3119  *
3120  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3121  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3122  *
3123  * @pre This method can be called if SCIP is in one of the following stages:
3124  * - \ref SCIP_STAGE_INIT
3125  * - \ref SCIP_STAGE_PROBLEM
3126  */
3127 extern
3129  SCIP* scip, /**< SCIP data structure */
3130  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3131  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
3132  );
3133 
3134 /** sets constraint parsing method of constraint handler
3135  *
3136  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3137  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3138  *
3139  * @pre This method can be called if SCIP is in one of the following stages:
3140  * - \ref SCIP_STAGE_INIT
3141  * - \ref SCIP_STAGE_PROBLEM
3142  */
3143 extern
3145  SCIP* scip, /**< SCIP data structure */
3146  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3147  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
3148  );
3149 
3150 /** sets constraint variable getter method of constraint handler
3151  *
3152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3154  *
3155  * @pre This method can be called if SCIP is in one of the following stages:
3156  * - \ref SCIP_STAGE_INIT
3157  * - \ref SCIP_STAGE_PROBLEM
3158  */
3159 extern
3161  SCIP* scip, /**< SCIP data structure */
3162  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3163  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
3164  );
3165 
3166 /** sets constraint variable number getter method of constraint handler
3167  *
3168  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3169  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3170  *
3171  * @pre This method can be called if SCIP is in one of the following stages:
3172  * - \ref SCIP_STAGE_INIT
3173  * - \ref SCIP_STAGE_PROBLEM
3174  */
3175 extern
3177  SCIP* scip, /**< SCIP data structure */
3178  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3179  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
3180  );
3181 
3182 /** sets diving enforcement method of constraint handler
3183  *
3184  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3185  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3186  *
3187  * @pre This method can be called if SCIP is in one of the following stages:
3188  * - \ref SCIP_STAGE_INIT
3189  * - \ref SCIP_STAGE_PROBLEM
3190  */
3191 extern
3193  SCIP* scip, /**< SCIP data structure */
3194  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3195  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
3196  );
3197 
3198 /** returns the constraint handler of the given name, or NULL if not existing */
3199 extern
3201  SCIP* scip, /**< SCIP data structure */
3202  const char* name /**< name of constraint handler */
3203  );
3204 
3205 /** returns the array of currently available constraint handlers */
3206 extern
3208  SCIP* scip /**< SCIP data structure */
3209  );
3210 
3211 /** returns the number of currently available constraint handlers */
3212 extern
3213 int SCIPgetNConshdlrs(
3214  SCIP* scip /**< SCIP data structure */
3215  );
3216 
3217 /* @} */
3218 
3219 /**@addtogroup PublicConflictMethods
3220  *
3221  * @{
3222  */
3223 
3224 /** creates a conflict handler and includes it in SCIP
3225  *
3226  * @note method has all conflict handler callbacks as arguments and is thus changed every time a new
3227  * callback is added
3228  * in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions
3229  * if you seek for a method which is less likely to change in future releases
3230  */
3231 extern
3233  SCIP* scip, /**< SCIP data structure */
3234  const char* name, /**< name of conflict handler */
3235  const char* desc, /**< description of conflict handler */
3236  int priority, /**< priority of the conflict handler */
3237  SCIP_DECL_CONFLICTCOPY((*conflictcopy)), /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3238  SCIP_DECL_CONFLICTFREE((*conflictfree)), /**< destructor of conflict handler */
3239  SCIP_DECL_CONFLICTINIT((*conflictinit)), /**< initialize conflict handler */
3240  SCIP_DECL_CONFLICTEXIT((*conflictexit)), /**< deinitialize conflict handler */
3241  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
3242  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
3243  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
3244  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
3245  );
3246 
3247 /** creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3248  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3249  * Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(),
3250  * SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(),
3251  * and SCIPsetConflicthdlrExitsol()
3252  *
3253  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead
3254  */
3255 extern
3257  SCIP* scip, /**< SCIP data structure */
3258  SCIP_CONFLICTHDLR** conflicthdlrptr, /**< reference to a conflict handler pointer, or NULL */
3259  const char* name, /**< name of conflict handler */
3260  const char* desc, /**< description of conflict handler */
3261  int priority, /**< priority of the conflict handler */
3262  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
3263  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
3264  );
3265 
3266 /** set copy method of conflict handler */
3267 extern
3269  SCIP* scip, /**< SCIP data structure */
3270  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3271  SCIP_DECL_CONFLICTCOPY((*conflictcopy)) /**< copy method of conflict handler */
3272  );
3273 
3274 /** set destructor of conflict handler */
3275 extern
3277  SCIP* scip, /**< SCIP data structure */
3278  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3279  SCIP_DECL_CONFLICTFREE((*conflictfree)) /**< destructor of conflict handler */
3280  );
3281 
3282 /** set initialization method of conflict handler */
3283 extern
3285  SCIP* scip, /**< SCIP data structure */
3286  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3287  SCIP_DECL_CONFLICTINIT((*conflictinit)) /**< initialize conflict handler */
3288  );
3289 
3290 /** set deinitialization method of conflict handler */
3291 extern
3293  SCIP* scip, /**< SCIP data structure */
3294  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3295  SCIP_DECL_CONFLICTEXIT((*conflictexit)) /**< deinitialize conflict handler */
3296  );
3297 
3298 /** set solving process initialization method of conflict handler */
3299 extern
3301  SCIP* scip, /**< SCIP data structure */
3302  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3303  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
3304  );
3305 
3306 /** set solving process deinitialization method of conflict handler */
3307 extern
3309  SCIP* scip, /**< SCIP data structure */
3310  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3311  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
3312  );
3313 
3314 /** returns the conflict handler of the given name, or NULL if not existing */
3315 extern
3317  SCIP* scip, /**< SCIP data structure */
3318  const char* name /**< name of conflict handler */
3319  );
3320 
3321 /** returns the array of currently available conflict handlers */
3322 extern
3324  SCIP* scip /**< SCIP data structure */
3325  );
3326 
3327 /** returns the number of currently available conflict handlers */
3328 extern
3330  SCIP* scip /**< SCIP data structure */
3331  );
3332 
3333 /** sets the priority of a conflict handler */
3334 extern
3336  SCIP* scip, /**< SCIP data structure */
3337  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3338  int priority /**< new priority of the conflict handler */
3339  );
3340 
3341 /* @} */
3342 
3343 /**@addtogroup PublicPresolverMethods
3344  *
3345  * @{
3346  */
3347 
3348 /** creates a presolver and includes it in SCIP
3349  *
3350  * @note method has all presolver callbacks as arguments and is thus changed every time a new
3351  * callback is added
3352  * in future releases; consider using SCIPincludePresolBasic() and setter functions
3353  * if you seek for a method which is less likely to change in future releases
3354  */
3355 extern
3357  SCIP* scip, /**< SCIP data structure */
3358  const char* name, /**< name of presolver */
3359  const char* desc, /**< description of presolver */
3360  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
3361  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
3362  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
3363  SCIP_DECL_PRESOLCOPY ((*presolcopy)), /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
3364  SCIP_DECL_PRESOLFREE ((*presolfree)), /**< destructor of presolver to free user data (called when SCIP is exiting) */
3365  SCIP_DECL_PRESOLINIT ((*presolinit)), /**< initialization method of presolver (called after problem was transformed) */
3366  SCIP_DECL_PRESOLEXIT ((*presolexit)), /**< deinitialization method of presolver (called before transformed problem is freed) */
3367  SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
3368  SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
3369  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
3370  SCIP_PRESOLDATA* presoldata /**< presolver data */
3371  );
3372 
3373 /** Creates a presolver and includes it in SCIP with its fundamental callback. All non-fundamental (or optional)
3374  * callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter
3375  * functions. These are SCIPsetPresolCopy(), SCIPsetPresolFree(), SCIPsetPresolInit(), SCIPsetPresolExit(),
3376  * SCIPsetPresolInitpre(), and SCIPsetPresolExitPre().
3377  *
3378  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePresol() instead
3379  */
3380 extern
3382  SCIP* scip, /**< SCIP data structure */
3383  SCIP_PRESOL** presolptr, /**< reference to presolver, or NULL */
3384  const char* name, /**< name of presolver */
3385  const char* desc, /**< description of presolver */
3386  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
3387  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
3388  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
3389  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
3390  SCIP_PRESOLDATA* presoldata /**< presolver data */
3391  );
3392 
3393 /** sets copy method of presolver */
3394 extern
3396  SCIP* scip, /**< SCIP data structure */
3397  SCIP_PRESOL* presol, /**< presolver */
3398  SCIP_DECL_PRESOLCOPY ((*presolcopy)) /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
3399  );
3400 
3401 /** sets destructor method of presolver */
3402 extern
3404  SCIP* scip, /**< SCIP data structure */
3405  SCIP_PRESOL* presol, /**< presolver */
3406  SCIP_DECL_PRESOLFREE ((*presolfree)) /**< destructor of presolver */
3407  );
3408 
3409 /** sets initialization method of presolver */
3410 extern
3412  SCIP* scip, /**< SCIP data structure */
3413  SCIP_PRESOL* presol, /**< presolver */
3414  SCIP_DECL_PRESOLINIT ((*presolinit)) /**< initialize presolver */
3415  );
3416 
3417 /** sets deinitialization method of presolver */
3418 extern
3420  SCIP* scip, /**< SCIP data structure */
3421  SCIP_PRESOL* presol, /**< presolver */
3422  SCIP_DECL_PRESOLEXIT ((*presolexit)) /**< deinitialize presolver */
3423  );
3424 
3425 /** sets solving process initialization method of presolver */
3426 extern
3428  SCIP* scip, /**< SCIP data structure */
3429  SCIP_PRESOL* presol, /**< presolver */
3430  SCIP_DECL_PRESOLINITPRE ((*presolinitpre))/**< solving process initialization method of presolver */
3431  );
3432 
3433 /** sets solving process deinitialization method of presolver */
3435  SCIP* scip, /**< SCIP data structure */
3436  SCIP_PRESOL* presol, /**< presolver */
3437  SCIP_DECL_PRESOLEXITPRE ((*presolexitpre))/**< solving process deinitialization method of presolver */
3438  );
3439 
3440 /** returns the presolver of the given name, or NULL if not existing */
3441 extern
3443  SCIP* scip, /**< SCIP data structure */
3444  const char* name /**< name of presolver */
3445  );
3446 
3447 /** returns the array of currently available presolvers */
3448 extern
3450  SCIP* scip /**< SCIP data structure */
3451  );
3452 
3453 /** returns the number of currently available presolvers */
3454 extern
3455 int SCIPgetNPresols(
3456  SCIP* scip /**< SCIP data structure */
3457  );
3458 
3459 /** sets the priority of a presolver */
3460 extern
3462  SCIP* scip, /**< SCIP data structure */
3463  SCIP_PRESOL* presol, /**< presolver */
3464  int priority /**< new priority of the presolver */
3465  );
3466 
3467 /* @} */
3468 
3469 /**@addtogroup PublicRelaxatorMethods
3470  *
3471  * @{
3472  */
3473 
3474 /** creates a relaxation handler and includes it in SCIP
3475  *
3476  * @note method has all relaxation handler callbacks as arguments and is thus changed every time a new
3477  * callback is added
3478  * in future releases; consider using SCIPincludeRelaxBasic() and setter functions
3479  * if you seek for a method which is less likely to change in future releases
3480  */
3481 extern
3483  SCIP* scip, /**< SCIP data structure */
3484  const char* name, /**< name of relaxation handler */
3485  const char* desc, /**< description of relaxation handler */
3486  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3487  int freq, /**< frequency for calling relaxation handler */
3488  SCIP_DECL_RELAXCOPY ((*relaxcopy)), /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3489  SCIP_DECL_RELAXFREE ((*relaxfree)), /**< destructor of relaxation handler */
3490  SCIP_DECL_RELAXINIT ((*relaxinit)), /**< initialize relaxation handler */
3491  SCIP_DECL_RELAXEXIT ((*relaxexit)), /**< deinitialize relaxation handler */
3492  SCIP_DECL_RELAXINITSOL((*relaxinitsol)), /**< solving process initialization method of relaxation handler */
3493  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), /**< solving process deinitialization method of relaxation handler */
3494  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3495  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3496  );
3497 
3498 /** creates a relaxation handler and includes it in SCIP. All non fundamental
3499  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3500  * Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(),
3501  * SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()
3502  *
3503  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeRelax() instead
3504  */
3505 extern
3507  SCIP* scip, /**< SCIP data structure */
3508  SCIP_RELAX** relaxptr, /**< reference to relaxation pointer, or NULL */
3509  const char* name, /**< name of relaxation handler */
3510  const char* desc, /**< description of relaxation handler */
3511  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3512  int freq, /**< frequency for calling relaxation handler */
3513  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3514  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3515  );
3516 
3517 /** sets copy method of relaxation handler */
3518 extern
3520  SCIP* scip, /**< SCIP data structure */
3521  SCIP_RELAX* relax, /**< relaxation handler */
3522  SCIP_DECL_RELAXCOPY ((*relaxcopy)) /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3523  );
3524 
3525 /** sets destructor method of relaxation handler */
3526 extern
3528  SCIP* scip, /**< SCIP data structure */
3529  SCIP_RELAX* relax, /**< relaxation handler */
3530  SCIP_DECL_RELAXFREE ((*relaxfree)) /**< destructor of relaxation handler */
3531  );
3532 
3533 /** sets initialization method of relaxation handler */
3534 extern
3536  SCIP* scip, /**< SCIP data structure */
3537  SCIP_RELAX* relax, /**< relaxation handler */
3538  SCIP_DECL_RELAXINIT ((*relaxinit)) /**< initialize relaxation handler */
3539  );
3540 
3541 /** sets deinitialization method of relaxation handler */
3542 extern
3544  SCIP* scip, /**< SCIP data structure */
3545  SCIP_RELAX* relax, /**< relaxation handler */
3546  SCIP_DECL_RELAXEXIT ((*relaxexit)) /**< deinitialize relaxation handler */
3547  );
3548 
3549 /** sets solving process initialization method of relaxation handler */
3550 extern
3552  SCIP* scip, /**< SCIP data structure */
3553  SCIP_RELAX* relax, /**< relaxation handler */
3554  SCIP_DECL_RELAXINITSOL((*relaxinitsol)) /**< solving process initialization method of relaxation handler */
3555  );
3556 
3557 /** sets solving process deinitialization method of relaxation handler */
3558 extern
3560  SCIP* scip, /**< SCIP data structure */
3561  SCIP_RELAX* relax, /**< relaxation handler */
3562  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)) /**< solving process deinitialization method of relaxation handler */
3563  );
3564 
3565 /** returns the relaxation handler of the given name, or NULL if not existing */
3566 extern
3568  SCIP* scip, /**< SCIP data structure */
3569  const char* name /**< name of relaxation handler */
3570  );
3571 
3572 /** returns the array of currently available relaxation handlers */
3573 extern
3575  SCIP* scip /**< SCIP data structure */
3576  );
3577 
3578 /** returns the number of currently available relaxation handlers */
3579 extern
3580 int SCIPgetNRelaxs(
3581  SCIP* scip /**< SCIP data structure */
3582  );
3583 
3584 /** sets the priority of a relaxation handler*/
3585 extern
3587  SCIP* scip, /**< SCIP data structure */
3588  SCIP_RELAX* relax, /**< relaxation handler */
3589  int priority /**< new priority of the relaxation handler */
3590  );
3591 
3592 /* @} */
3593 
3594 /**@addtogroup PublicSeparatorMethods
3595  *
3596  * @{
3597  */
3598 
3599 /** creates a separator and includes it in SCIP.
3600  *
3601  * @note method has all separator callbacks as arguments and is thus changed every time a new
3602  * callback is added
3603  * in future releases; consider using SCIPincludeSepaBasic() and setter functions
3604  * if you seek for a method which is less likely to change in future releases
3605  */
3606 extern
3608  SCIP* scip, /**< SCIP data structure */
3609  const char* name, /**< name of separator */
3610  const char* desc, /**< description of separator */
3611  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3612  int freq, /**< frequency for calling separator */
3613  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3614  * to best node's dual bound for applying separation */
3615  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3616  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3617  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3618  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
3619  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
3620  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
3621  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
3622  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
3623  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3624  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3625  SCIP_SEPADATA* sepadata /**< separator data */
3626  );
3627 
3628 /** creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3629  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3630  * Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(),
3631  * SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().
3632  *
3633  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeSepa() instead
3634  */
3635 extern
3637  SCIP* scip, /**< SCIP data structure */
3638  SCIP_SEPA** sepa, /**< reference to a separator, or NULL */
3639  const char* name, /**< name of separator */
3640  const char* desc, /**< description of separator */
3641  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3642  int freq, /**< frequency for calling separator */
3643  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3644  * to best node's dual bound for applying separation */
3645  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3646  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3647  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3648  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3649  SCIP_SEPADATA* sepadata /**< separator data */
3650  );
3651 
3652 /** sets copy method of separator */
3653 extern
3655  SCIP* scip, /**< SCIP data structure */
3656  SCIP_SEPA* sepa, /**< separator */
3657  SCIP_DECL_SEPACOPY ((*sepacopy)) /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3658  );
3659 
3660 /** sets destructor method of separator */
3661 extern
3663  SCIP* scip, /**< SCIP data structure */
3664  SCIP_SEPA* sepa, /**< separator */
3665  SCIP_DECL_SEPAFREE ((*sepafree)) /**< destructor of separator */
3666  );
3667 
3668 /** sets initialization method of separator */
3669 extern
3671  SCIP* scip, /**< SCIP data structure */
3672  SCIP_SEPA* sepa, /**< separator */
3673  SCIP_DECL_SEPAINIT ((*sepainit)) /**< initialize separator */
3674  );
3675 
3676 /** sets deinitialization method of separator */
3677 extern
3679  SCIP* scip, /**< SCIP data structure */
3680  SCIP_SEPA* sepa, /**< separator */
3681  SCIP_DECL_SEPAEXIT ((*sepaexit)) /**< deinitialize separator */
3682  );
3683 
3684 /** sets solving process initialization method of separator */
3685 extern
3687  SCIP* scip, /**< SCIP data structure */
3688  SCIP_SEPA* sepa, /**< separator */
3689  SCIP_DECL_SEPAINITSOL ((*sepainitsol)) /**< solving process initialization method of separator */
3690  );
3691 
3692 /** sets solving process deinitialization method of separator */
3693 extern
3695  SCIP* scip, /**< SCIP data structure */
3696  SCIP_SEPA* sepa, /**< separator */
3697  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)) /**< solving process deinitialization method of separator */
3698  );
3699 
3700 /** returns the separator of the given name, or NULL if not existing */
3701 extern
3703  SCIP* scip, /**< SCIP data structure */
3704  const char* name /**< name of separator */
3705  );
3706 
3707 /** returns the array of currently available separators */
3708 extern
3710  SCIP* scip /**< SCIP data structure */
3711  );
3712 
3713 /** returns the number of currently available separators */
3714 extern
3715 int SCIPgetNSepas(
3716  SCIP* scip /**< SCIP data structure */
3717  );
3718 
3719 /** sets the priority of a separator */
3720 extern
3722  SCIP* scip, /**< SCIP data structure */
3723  SCIP_SEPA* sepa, /**< separator */
3724  int priority /**< new priority of the separator */
3725  );
3726 
3727 /** gets value of minimal efficacy for a cut to enter the LP
3728  *
3729  * @pre This method can be called if @p scip is in one of the following stages:
3730  * - \ref SCIP_STAGE_SOLVING
3731  *
3732  * @return value of "separating/minefficacyroot" if at root node, otherwise value of "separating/minefficacy"
3733  */
3734 extern
3736  SCIP* scip /**< SCIP data structure */
3737  );
3738 
3739 #ifdef NDEBUG
3740 #define SCIPgetSepaMinEfficacy(scip) (SCIPtreeGetCurrentDepth((scip)->tree) == 0 ? (scip)->set->sepa_minefficacyroot : (scip)->set->sepa_minefficacy)
3741 #endif
3742 
3743 /* @} */
3744 
3745 /**@addtogroup PublicPropagatorMethods
3746  *
3747  * @{
3748  */
3749 
3750 /** creates a propagator and includes it in SCIP.
3751  *
3752 
3753  * @note method has all propagator callbacks as arguments and is thus changed every time a new
3754  * callback is added in future releases; consider using SCIPincludePropBasic() and setter functions
3755  * if you seek for a method which is less likely to change in future releases
3756  */
3757 extern
3759  SCIP* scip, /**< SCIP data structure */
3760  const char* name, /**< name of propagator */
3761  const char* desc, /**< description of propagator */
3762  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3763  int freq, /**< frequency for calling propagator */
3764  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3765  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagator should be executed */
3766  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3767  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3768  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the propagator's presolving method */
3769  SCIP_DECL_PROPCOPY ((*propcopy)), /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3770  SCIP_DECL_PROPFREE ((*propfree)), /**< destructor of propagator */
3771  SCIP_DECL_PROPINIT ((*propinit)), /**< initialize propagator */
3772  SCIP_DECL_PROPEXIT ((*propexit)), /**< deinitialize propagator */
3773  SCIP_DECL_PROPINITPRE ((*propinitpre)), /**< presolving initialization method of propagator */
3774  SCIP_DECL_PROPEXITPRE ((*propexitpre)), /**< presolving deinitialization method of propagator */
3775  SCIP_DECL_PROPINITSOL ((*propinitsol)), /**< solving process initialization method of propagator */
3776  SCIP_DECL_PROPEXITSOL ((*propexitsol)), /**< solving process deinitialization method of propagator */
3777  SCIP_DECL_PROPPRESOL ((*proppresol)), /**< presolving method */
3778  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3779  SCIP_DECL_PROPRESPROP ((*propresprop)), /**< propagation conflict resolving method */
3780  SCIP_PROPDATA* propdata /**< propagator data */
3781  );
3782 
3783 /** creates a propagator and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
3784  * Optional callbacks can be set via specific setter functions, see SCIPsetPropInit(), SCIPsetPropExit(),
3785  * SCIPsetPropCopy(), SCIPsetPropFree(), SCIPsetPropInitsol(), SCIPsetPropExitsol(),
3786  * SCIPsetPropInitpre(), SCIPsetPropExitpre(), SCIPsetPropPresol(), and SCIPsetPropResprop().
3787  *
3788  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeProp() instead
3789  */
3790 extern
3792  SCIP* scip, /**< SCIP data structure */
3793  SCIP_PROP** propptr, /**< reference to a propagator pointer, or NULL */
3794  const char* name, /**< name of propagator */
3795  const char* desc, /**< description of propagator */
3796  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3797  int freq, /**< frequency for calling propagator */
3798  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3799  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagators should be executed */
3800  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3801  SCIP_PROPDATA* propdata /**< propagator data */
3802  );
3803 
3804 /** sets copy method of propagator */
3805 extern
3807  SCIP* scip, /**< SCIP data structure */
3808  SCIP_PROP* prop, /**< propagator */
3809  SCIP_DECL_PROPCOPY ((*propcopy)) /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3810  );
3811 
3812 /** sets destructor method of propagator */
3813 extern
3815  SCIP* scip, /**< SCIP data structure */
3816  SCIP_PROP* prop, /**< propagator */
3817  SCIP_DECL_PROPFREE ((*propfree)) /**< destructor of propagator */
3818  );
3819 
3820 /** sets initialization method of propagator */
3821 extern
3823  SCIP* scip, /**< SCIP data structure */
3824  SCIP_PROP* prop, /**< propagator */
3825  SCIP_DECL_PROPINIT ((*propinit)) /**< initialize propagator */
3826  );
3827 
3828 /** sets deinitialization method of propagator */
3829 extern
3831  SCIP* scip, /**< SCIP data structure */
3832  SCIP_PROP* prop, /**< propagator */
3833  SCIP_DECL_PROPEXIT ((*propexit)) /**< deinitialize propagator */
3834  );
3835 
3836 /** sets solving process initialization method of propagator */
3837 extern
3839  SCIP* scip, /**< SCIP data structure */
3840  SCIP_PROP* prop, /**< propagator */
3841  SCIP_DECL_PROPINITSOL((*propinitsol)) /**< solving process initialization method of propagator */
3842  );
3843 
3844 /** sets solving process deinitialization method of propagator */
3845 extern
3847  SCIP* scip, /**< SCIP data structure */
3848  SCIP_PROP* prop, /**< propagator */
3849  SCIP_DECL_PROPEXITSOL ((*propexitsol)) /**< solving process deinitialization method of propagator */
3850  );
3851 
3852 /** sets preprocessing initialization method of propagator */
3853 extern
3855  SCIP* scip, /**< SCIP data structure */
3856  SCIP_PROP* prop, /**< propagator */
3857  SCIP_DECL_PROPINITPRE((*propinitpre)) /**< preprocessing initialization method of propagator */
3858  );
3859 
3860 /** sets preprocessing deinitialization method of propagator */
3861 extern
3863  SCIP* scip, /**< SCIP data structure */
3864  SCIP_PROP* prop, /**< propagator */
3865  SCIP_DECL_PROPEXITPRE((*propexitpre)) /**< preprocessing deinitialization method of propagator */
3866  );
3867 
3868 /** sets presolving method of propagator */
3869 extern
3871  SCIP* scip, /**< SCIP data structure */
3872  SCIP_PROP* prop, /**< propagator */
3873  SCIP_DECL_PROPPRESOL((*proppresol)), /**< presolving method of propagator */
3874  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3875  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3876  SCIP_PRESOLTIMING presoltiming /**< timing mask of the propagator's presolving method */
3877  );
3878 
3879 /** sets propagation conflict resolving callback of propagator */
3880 extern
3882  SCIP* scip, /**< SCIP data structure */
3883  SCIP_PROP* prop, /**< propagator */
3884  SCIP_DECL_PROPRESPROP ((*propresprop)) /**< propagation conflict resolving callback */
3885  );
3886 
3887 /** returns the propagator of the given name, or NULL if not existing */
3888 extern
3890  SCIP* scip, /**< SCIP data structure */
3891  const char* name /**< name of propagator */
3892  );
3893 
3894 /** returns the array of currently available propagators */
3895 extern
3897  SCIP* scip /**< SCIP data structure */
3898  );
3899 
3900 /** returns the number of currently available propagators */
3901 extern
3902 int SCIPgetNProps(
3903  SCIP* scip /**< SCIP data structure */
3904  );
3905 
3906 /** sets the priority of a propagator */
3907 extern
3909  SCIP* scip, /**< SCIP data structure */
3910  SCIP_PROP* prop, /**< propagator */
3911  int priority /**< new priority of the propagator */
3912  );
3913 
3914 /** sets the presolving priority of a propagator */
3915 extern
3917  SCIP* scip, /**< SCIP data structure */
3918  SCIP_PROP* prop, /**< propagator */
3919  int presolpriority /**< new presol priority of the propagator */
3920  );
3921 
3922 /* @} */
3923 
3924 /**@addtogroup PublicConcsolverTypeMethods
3925  *
3926  * @{
3927  */
3928 
3929 /** creates a concurrent solver type and includes it in SCIP.
3930  *
3931  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3933  *
3934  * @pre This method can be called if @p scip is in one of the following stages:
3935  * - \ref SCIP_STAGE_INIT
3936  * - \ref SCIP_STAGE_PROBLEM
3937  */
3938 extern
3940  SCIP* scip, /**< SCIP data structure */
3941  const char* name, /**< name of concurrent_solver */
3942  SCIP_Real prefpriodefault, /**< the default preferred priority of this concurrent solver type */
3943  SCIP_DECL_CONCSOLVERCREATEINST ((*concsolvercreateinst)), /**< data copy method of concurrent solver */
3944  SCIP_DECL_CONCSOLVERDESTROYINST ((*concsolverdestroyinst)), /**< data copy method of concurrent solver */
3945  SCIP_DECL_CONCSOLVERINITSEEDS ((*concsolverinitseeds)), /**< initialize random seeds of concurrent solver */
3946  SCIP_DECL_CONCSOLVEREXEC ((*concsolverexec)), /**< execution method of concurrent solver */
3947  SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA ((*concsolvercopysolvdata)),/**< method to copy solving data */
3948  SCIP_DECL_CONCSOLVERSTOP ((*concsolverstop)), /**< terminate solving in concurrent solver */
3949  SCIP_DECL_CONCSOLVERSYNCWRITE ((*concsolversyncwrite)), /**< synchronization method of concurrent solver */
3950  SCIP_DECL_CONCSOLVERSYNCREAD ((*concsolversyncread)), /**< synchronization method of concurrent solver */
3951  SCIP_DECL_CONCSOLVERTYPEFREEDATA ((*concsolvertypefreedata)),/**< method to free data of concurrent solver type */
3952  SCIP_CONCSOLVERTYPEDATA* data /**< the concurent solver type's data */
3953  );
3954 
3955 /** returns the concurrent solver type with the given name, or NULL if not existing */
3956 extern
3958  SCIP* scip, /**< SCIP data structure */
3959  const char* name /**< name of concurrent_solver */
3960  );
3961 
3962 /** returns the array of included concurrent solver types */
3963 extern
3965  SCIP* scip /**< SCIP data structure */
3966  );
3967 
3968 /** returns the number of included concurrent solver types */
3969 extern
3971  SCIP* scip /**< SCIP data structure */
3972  );
3973 
3974 /* @} */
3975 
3976 /**@addtogroup PublicHeuristicMethods
3977  *
3978  * @{
3979  */
3980 
3981 /** creates a primal heuristic and includes it in SCIP.
3982  *
3983  * @note method has all heuristic callbacks as arguments and is thus changed every time a new
3984  * callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions
3985  * if you seek for a method which is less likely to change in future releases
3986  *
3987  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3988  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3989  *
3990  * @pre This method can be called if @p scip is in one of the following stages:
3991  * - \ref SCIP_STAGE_INIT
3992  * - \ref SCIP_STAGE_PROBLEM
3993  */
3994 extern
3996  SCIP* scip, /**< SCIP data structure */
3997  const char* name, /**< name of primal heuristic */
3998  const char* desc, /**< description of primal heuristic */
3999  char dispchar, /**< display character of primal heuristic */
4000  int priority, /**< priority of the primal heuristic */
4001  int freq, /**< frequency for calling primal heuristic */
4002  int freqofs, /**< frequency offset for calling primal heuristic */
4003  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
4004  SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
4005  * see definition of SCIP_HEURTIMING for possible values */
4006  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
4007  SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
4008  SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
4009  SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
4010  SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
4011  SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
4012  SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
4013  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
4014  SCIP_HEURDATA* heurdata /**< primal heuristic data */
4015  );
4016 
4017 /** creates a primal heuristic and includes it in SCIP with its most fundamental callbacks.
4018  * All non-fundamental (or optional) callbacks
4019  * as, e. g., init and exit callbacks, will be set to NULL.
4020  * Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(),
4021  * SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
4022  *
4023 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead
4024  */
4025 extern
4027  SCIP* scip, /**< SCIP data structure */
4028  SCIP_HEUR** heur, /**< pointer to the heuristic */
4029  const char* name, /**< name of primal heuristic */
4030  const char* desc, /**< description of primal heuristic */
4031  char dispchar, /**< display character of primal heuristic */
4032  int priority, /**< priority of the primal heuristic */
4033  int freq, /**< frequency for calling primal heuristic */
4034  int freqofs, /**< frequency offset for calling primal heuristic */
4035  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
4036  SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
4037  * see definition of SCIP_HEURTIMING for possible values */
4038  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
4039  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
4040  SCIP_HEURDATA* heurdata /**< primal heuristic data */
4041  );
4042 
4043 /** sets copy method of primal heuristic */
4044 extern
4046  SCIP* scip, /**< SCIP data structure */
4047  SCIP_HEUR* heur, /**< primal heuristic */
4048  SCIP_DECL_HEURCOPY ((*heurcopy)) /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
4049  );
4050 
4051 /** sets destructor method of primal heuristic */
4052 extern
4054  SCIP* scip, /**< SCIP data structure */
4055  SCIP_HEUR* heur, /**< primal heuristic */
4056  SCIP_DECL_HEURFREE ((*heurfree)) /**< destructor of primal heuristic */
4057  );
4058 
4059 /** sets initialization method of primal heuristic */
4060 extern
4062  SCIP* scip, /**< SCIP data structure */
4063  SCIP_HEUR* heur, /**< primal heuristic */
4064  SCIP_DECL_HEURINIT ((*heurinit)) /**< initialize primal heuristic */
4065  );
4066 
4067 /** sets deinitialization method of primal heuristic */
4068 extern
4070  SCIP* scip, /**< SCIP data structure */
4071  SCIP_HEUR* heur, /**< primal heuristic */
4072  SCIP_DECL_HEUREXIT ((*heurexit)) /**< deinitialize primal heuristic */
4073  );
4074 
4075 /** sets solving process initialization method of primal heuristic */
4076 extern
4078  SCIP* scip, /**< SCIP data structure */
4079  SCIP_HEUR* heur, /**< primal heuristic */
4080  SCIP_DECL_HEURINITSOL ((*heurinitsol)) /**< solving process initialization method of primal heuristic */
4081  );
4082 
4083 /** sets solving process deinitialization method of primal heuristic */
4084 extern
4086  SCIP* scip, /**< SCIP data structure */
4087  SCIP_HEUR* heur, /**< primal heuristic */
4088  SCIP_DECL_HEUREXITSOL ((*heurexitsol)) /**< solving process deinitialization method of primal heuristic */
4089  );
4090 
4091 /** returns the primal heuristic of the given name, or NULL if not existing */
4092 extern
4094  SCIP* scip, /**< SCIP data structure */
4095  const char* name /**< name of primal heuristic */
4096  );
4097 
4098 /** returns the array of currently available primal heuristics */
4099 extern
4101  SCIP* scip /**< SCIP data structure */
4102  );
4103 
4104 /** returns the number of currently available primal heuristics */
4105 extern
4106 int SCIPgetNHeurs(
4107  SCIP* scip /**< SCIP data structure */
4108  );
4109 
4110 /** sets the priority of a primal heuristic */
4111 extern
4113  SCIP* scip, /**< SCIP data structure */
4114  SCIP_HEUR* heur, /**< primal heuristic */
4115  int priority /**< new priority of the primal heuristic */
4116  );
4117 
4118 /* @} */
4119 
4120 /**@addtogroup PublicCompressionMethods
4121  *
4122  * @{
4123  */
4124 /** creates a tree compression and includes it in SCIP.
4125  *
4126  * @note method has all compression callbacks as arguments and is thus changed every time a new
4127  * callback is added in future releases; consider using SCIPincludeComprBasic() and setter functions
4128  * if you seek for a method which is less likely to change in future releases
4129  */
4130 extern
4132  SCIP* scip, /**< SCIP data structure */
4133  const char* name, /**< name of tree compression */
4134  const char* desc, /**< description of tree compression */
4135  int priority, /**< priority of the tree compression */
4136  int minnnodes, /**< minimal number of nodes to call compression */
4137  SCIP_DECL_COMPRCOPY ((*comprcopy)), /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
4138  SCIP_DECL_COMPRFREE ((*comprfree)), /**< destructor of tree compression */
4139  SCIP_DECL_COMPRINIT ((*comprinit)), /**< initialize tree compression */
4140  SCIP_DECL_COMPREXIT ((*comprexit)), /**< deinitialize tree compression */
4141  SCIP_DECL_COMPRINITSOL ((*comprinitsol)), /**< solving process initialization method of tree compression */
4142  SCIP_DECL_COMPREXITSOL ((*comprexitsol)), /**< solving process deinitialization method of tree compression */
4143  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
4144  SCIP_COMPRDATA* comprdata /**< tree compression data */
4145  );
4146 
4147 /** creates a tree compression and includes it in SCIP with its most fundamental callbacks.
4148  * All non-fundamental (or optional) callbacks
4149  * as, e. g., init and exit callbacks, will be set to NULL.
4150  * Optional callbacks can be set via specific setter functions, see SCIPsetComprCopy(), SCIPsetComprFree(),
4151  * SCIPsetComprInit(), SCIPsetComprExit(), SCIPsetComprInitsol(), and SCIPsetComprExitsol()
4152  *
4153  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeCompr() instead
4154  */
4155 extern
4157  SCIP* scip, /**< SCIP data structure */
4158  SCIP_COMPR** compr, /**< pointer to tree compression */
4159  const char* name, /**< name of tree compression */
4160  const char* desc, /**< description of tree compression */
4161  int priority, /**< priority of the tree compression */
4162  int minnnodes, /**< minimal number of nodes to call the compression */
4163  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
4164  SCIP_COMPRDATA* comprdata /**< tree compression data */
4165  );
4166 
4167 /** sets copy method of tree compression */
4168 extern
4170  SCIP* scip, /**< SCIP data structure */
4171  SCIP_COMPR* compr, /**< tree compression */
4172  SCIP_DECL_COMPRCOPY ((*comprcopy)) /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
4173  );
4174 
4175 /** sets destructor method of tree compression */
4176 extern
4178  SCIP* scip, /**< SCIP data structure */
4179  SCIP_COMPR* compr, /**< tree compression */
4180  SCIP_DECL_COMPRFREE ((*comprfree)) /**< destructor of tree compression */
4181  );
4182 
4183 /** sets initialization method of tree compression */
4184 extern
4186  SCIP* scip, /**< SCIP data structure */
4187  SCIP_COMPR* compr, /**< tree compression */
4188  SCIP_DECL_COMPRINIT ((*comprinit)) /**< initialize tree compression */
4189  );
4190 
4191 /** sets deinitialization method of tree compression */
4192 extern
4194  SCIP* scip, /**< SCIP data structure */
4195  SCIP_COMPR* compr, /**< tree compression */
4196  SCIP_DECL_COMPREXIT ((*comprexit)) /**< deinitialize tree compression */
4197  );
4198 
4199 /** sets solving process initialization method of tree compression */
4200 extern
4202  SCIP* scip, /**< SCIP data structure */
4203  SCIP_COMPR* compr, /**< tree compression */
4204  SCIP_DECL_COMPRINITSOL ((*comprinitsol)) /**< solving process initialization method of tree compression */
4205  );
4206 
4207 /** sets solving process deinitialization method of tree compression */
4208 extern
4210  SCIP* scip, /**< SCIP data structure */
4211  SCIP_COMPR* compr, /**< tree compression */
4212  SCIP_DECL_COMPREXITSOL ((*comprexitsol)) /**< solving process deinitialization method of tree compression */
4213  );
4214 
4215 /** returns the tree compression of the given name, or NULL if not existing */
4216 extern
4218  SCIP* scip, /**< SCIP data structure */
4219  const char* name /**< name of tree compression */
4220  );
4221 
4222 /** returns the array of currently available tree compression */
4223 extern
4225  SCIP* scip /**< SCIP data structure */
4226  );
4227 
4228 /** returns the number of currently available tree compression */
4229 extern
4230 int SCIPgetNCompr(
4231  SCIP* scip /**< SCIP data structure */
4232  );
4233 
4234 /** set the priority of a tree compression method */
4236  SCIP* scip, /**< SCIP data structure */
4237  SCIP_COMPR* compr, /**< compression */
4238  int priority /**< new priority of the tree compression */
4239  );
4240 
4241 /* @} */
4242 
4243 /**@addtogroup PublicDivesetMethods
4244  *
4245  * @{
4246  */
4247 
4248 /** create a diving set associated with a primal heuristic. The primal heuristic needs to be included
4249  * before this method can be called. The diveset is installed in the array of divesets of the heuristic
4250  * and can be retrieved later by accessing SCIPheurGetDivesets()
4251  *
4252  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4253  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4254  *
4255  * @pre This method can be called if @p scip is in one of the following stages:
4256  * - \ref SCIP_STAGE_INIT
4257  * - \ref SCIP_STAGE_PROBLEM
4258  */
4259 extern
4261  SCIP* scip, /**< SCIP data structure */
4262  SCIP_DIVESET** diveset, /**< pointer to created diving heuristic settings, or NULL if not needed */
4263  SCIP_HEUR* heur, /**< primal heuristic to which the diveset belongs */
4264  const char* name, /**< name for the diveset, or NULL if the name of the heuristic should be used */
4265  SCIP_Real minreldepth, /**< minimal relative depth to start diving */
4266  SCIP_Real maxreldepth, /**< maximal relative depth to start diving */
4267  SCIP_Real maxlpiterquot, /**< maximal fraction of diving LP iterations compared to node LP iterations */
4268  SCIP_Real maxdiveubquot, /**< maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound)
4269  * where diving is performed (0.0: no limit) */
4270  SCIP_Real maxdiveavgquot, /**< maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound)
4271  * where diving is performed (0.0: no limit) */
4272  SCIP_Real maxdiveubquotnosol, /**< maximal UBQUOT when no solution was found yet (0.0: no limit) */
4273  SCIP_Real maxdiveavgquotnosol,/**< maximal AVGQUOT when no solution was found yet (0.0: no limit) */
4274  SCIP_Real lpresolvedomchgquot,/**< percentage of immediate domain changes during probing to trigger LP resolve */
4275  int lpsolvefreq, /**< LP solve frequency for (0: only if enough domain reductions are found by propagation)*/
4276  int maxlpiterofs, /**< additional number of allowed LP iterations */
4277  unsigned int initialseed, /**< initial seed for random number generation */
4278  SCIP_Bool backtrack, /**< use one level of backtracking if infeasibility is encountered? */
4279  SCIP_Bool onlylpbranchcands, /**< should only LP branching candidates be considered instead of the slower but
4280  * more general constraint handler diving variable selection? */
4281  SCIP_Bool specificsos1score, /**< should SOS1 variables be scored by the diving heuristics specific score function;
4282  * otherwise use the score function of the SOS1 constraint handler */
4283  SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)) /**< method for candidate score and rounding direction */
4284 
4285  );
4286 
4287 /* @} */
4288 
4289 /**@addtogroup PublicEventHandlerMethods
4290  *
4291  * @{
4292  */
4293 
4294 /** creates an event handler and includes it in SCIP
4295  *
4296  * @note method has all event handler callbacks as arguments and is thus changed every time a new
4297  * callback is added in future releases; consider using SCIPincludeEventhdlrBasic() and setter functions
4298  * if you seek for a method which is less likely to change in future releases
4299  */
4300 extern
4302  SCIP* scip, /**< SCIP data structure */
4303  const char* name, /**< name of event handler */
4304  const char* desc, /**< description of event handler */
4305  SCIP_DECL_EVENTCOPY ((*eventcopy)), /**< copy method of event handler or NULL if you don't want to copy your plugin into sub-SCIPs */
4306  SCIP_DECL_EVENTFREE ((*eventfree)), /**< destructor of event handler */
4307  SCIP_DECL_EVENTINIT ((*eventinit)), /**< initialize event handler */
4308  SCIP_DECL_EVENTEXIT ((*eventexit)), /**< deinitialize event handler */
4309  SCIP_DECL_EVENTINITSOL((*eventinitsol)), /**< solving process initialization method of event handler */
4310  SCIP_DECL_EVENTEXITSOL((*eventexitsol)), /**< solving process deinitialization method of event handler */
4311  SCIP_DECL_EVENTDELETE ((*eventdelete)), /**< free specific event data */
4312  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
4313  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
4314  );
4315 
4316 /** creates an event handler and includes it in SCIP with all its non-fundamental callbacks set
4317  * to NULL; if needed, non-fundamental callbacks can be set afterwards via setter functions
4318  * SCIPsetEventhdlrCopy(), SCIPsetEventhdlrFree(), SCIPsetEventhdlrInit(), SCIPsetEventhdlrExit(),
4319  * SCIPsetEventhdlrInitsol(), SCIPsetEventhdlrExitsol(), and SCIPsetEventhdlrDelete()
4320  *
4321  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeEventhdlr() instead
4322  */
4323 extern
4325  SCIP* scip, /**< SCIP data structure */
4326  SCIP_EVENTHDLR** eventhdlrptr, /**< reference to an event handler, or NULL */
4327  const char* name, /**< name of event handler */
4328  const char* desc, /**< description of event handler */
4329  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
4330  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
4331  );
4332 
4333 /** sets copy callback of the event handler */
4334 extern
4336  SCIP* scip, /**< scip instance */
4337  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4338  SCIP_DECL_EVENTCOPY ((*eventcopy)) /**< copy callback of the event handler */
4339  );
4340 
4341 /** sets deinitialization callback of the event handler */
4342 extern
4344  SCIP* scip, /**< scip instance */
4345  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4346  SCIP_DECL_EVENTFREE ((*eventfree)) /**< deinitialization callback of the event handler */
4347  );
4348 
4349 /** sets initialization callback of the event handler */
4350 extern
4352  SCIP* scip, /**< scip instance */
4353  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4354  SCIP_DECL_EVENTINIT ((*eventinit)) /**< initialize event handler */
4355  );
4356 
4357 /** sets deinitialization callback of the event handler */
4358 extern
4360  SCIP* scip, /**< scip instance */
4361  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4362  SCIP_DECL_EVENTEXIT ((*eventexit)) /**< deinitialize event handler */
4363  );
4364 
4365 /** sets solving process initialization callback of the event handler */
4366 extern
4368  SCIP* scip, /**< scip instance */
4369  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4370  SCIP_DECL_EVENTINITSOL((*eventinitsol)) /**< solving process initialization callback of event handler */
4371  );
4372 
4373 /** sets solving process deinitialization callback of the event handler */
4374 extern
4376  SCIP* scip, /**< scip instance */
4377  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4378  SCIP_DECL_EVENTEXITSOL((*eventexitsol)) /**< solving process deinitialization callback of event handler */
4379  );
4380 
4381 /** sets callback of the event handler to free specific event data */
4382 extern
4384  SCIP* scip, /**< scip instance */
4385  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4386  SCIP_DECL_EVENTDELETE ((*eventdelete)) /**< free specific event data */
4387  );
4388 
4389 /** returns the event handler of the given name, or NULL if not existing */
4390 extern
4392  SCIP* scip, /**< SCIP data structure */
4393  const char* name /**< name of event handler */
4394  );
4395 
4396 /** returns the array of currently available event handlers */
4397 extern
4399  SCIP* scip /**< SCIP data structure */
4400  );
4401 
4402 /** returns the number of currently available event handlers */
4403 extern
4404 int SCIPgetNEventhdlrs(
4405  SCIP* scip /**< SCIP data structure */
4406  );
4407 
4408 /* @} */
4409 
4410 /**@addtogroup PublicNodeSelectorMethods
4411  *
4412  * @{
4413  */
4414 
4415 /** creates a node selector and includes it in SCIP.
4416  *
4417  * @note method has all node selector callbacks as arguments and is thus changed every time a new
4418  * callback is added in future releases; consider using SCIPincludeNodeselBasic() and setter functions
4419  * if you seek for a method which is less likely to change in future releases
4420  */
4421 extern
4423  SCIP* scip, /**< SCIP data structure */
4424  const char* name, /**< name of node selector */
4425  const char* desc, /**< description of node selector */
4426  int stdpriority, /**< priority of the node selector in standard mode */
4427  int memsavepriority, /**< priority of the node selector in memory saving mode */
4428  SCIP_DECL_NODESELCOPY ((*nodeselcopy)), /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
4429  SCIP_DECL_NODESELFREE ((*nodeselfree)), /**< destructor of node selector */
4430  SCIP_DECL_NODESELINIT ((*nodeselinit)), /**< initialize node selector */
4431  SCIP_DECL_NODESELEXIT ((*nodeselexit)), /**< deinitialize node selector */
4432  SCIP_DECL_NODESELINITSOL((*nodeselinitsol)),/**< solving process initialization method of node selector */
4433  SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)),/**< solving process deinitialization method of node selector */
4434  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
4435  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
4436  SCIP_NODESELDATA* nodeseldata /**< node selector data */
4437  );
4438 
4439 /** Creates a node selector and includes it in SCIP with its most fundamental callbacks. All non-fundamental
4440  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
4441  * Optional callbacks can be set via specific setter functions, see SCIPsetNodeselCopy(), SCIPsetNodeselFree(),
4442  * SCIPsetNodeselInit(), SCIPsetNodeselExit(), SCIPsetNodeselInitsol(), and SCIPsetNodeselExitsol()
4443  *
4444  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeNodesel() instead
4445  */
4446 extern
4448  SCIP* scip, /**< SCIP data structure */
4449  SCIP_NODESEL** nodesel, /**< reference to a node selector, or NULL */
4450  const char* name, /**< name of node selector */
4451  const char* desc, /**< description of node selector */
4452  int stdpriority, /**< priority of the node selector in standard mode */
4453  int memsavepriority, /**< priority of the node selector in memory saving mode */
4454  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
4455  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
4456  SCIP_NODESELDATA* nodeseldata /**< node selector data */
4457  );
4458 
4459 /** sets copy method of node selector */
4460 extern
4462  SCIP* scip, /**< SCIP data structure */
4463  SCIP_NODESEL* nodesel, /**< node selector */
4464  SCIP_DECL_NODESELCOPY ((*nodeselcopy)) /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
4465  );
4466 
4467 /** sets destructor method of node selector */
4468 extern
4470  SCIP* scip, /**< SCIP data structure */
4471  SCIP_NODESEL* nodesel, /**< node selector */
4472  SCIP_DECL_NODESELFREE ((*nodeselfree)) /**< destructor of node selector */
4473  );
4474 
4475 /** sets initialization method of node selector */
4476 extern
4478  SCIP* scip, /**< SCIP data structure */
4479  SCIP_NODESEL* nodesel, /**< node selector */
4480  SCIP_DECL_NODESELINIT ((*nodeselinit)) /**< initialize node selector */
4481  );
4482 
4483 /** sets deinitialization method of node selector */
4484 extern
4486  SCIP* scip, /**< SCIP data structure */
4487  SCIP_NODESEL* nodesel, /**< node selector */
4488  SCIP_DECL_NODESELEXIT ((*nodeselexit)) /**< deinitialize node selector */
4489  );
4490 
4491 /** sets solving process initialization method of node selector */
4492 extern
4494  SCIP* scip, /**< SCIP data structure */
4495  SCIP_NODESEL* nodesel, /**< node selector */
4496  SCIP_DECL_NODESELINITSOL ((*nodeselinitsol))/**< solving process initialization method of node selector */
4497  );
4498 
4499 /** sets solving process deinitialization method of node selector */
4500 extern
4502  SCIP* scip, /**< SCIP data structure */
4503  SCIP_NODESEL* nodesel, /**< node selector */
4504  SCIP_DECL_NODESELEXITSOL ((*nodeselexitsol))/**< solving process deinitialization method of node selector */
4505  );
4506 
4507 /** returns the node selector of the given name, or NULL if not existing */
4508 extern
4510  SCIP* scip, /**< SCIP data structure */
4511  const char* name /**< name of node selector */
4512  );
4513 
4514 /** returns the array of currently available node selectors */
4515 extern
4517  SCIP* scip /**< SCIP data structure */
4518  );
4519 
4520 /** returns the number of currently available node selectors */
4521 extern
4522 int SCIPgetNNodesels(
4523  SCIP* scip /**< SCIP data structure */
4524  );
4525 
4526 /** sets the priority of a node selector in standard mode */
4527 extern
4529  SCIP* scip, /**< SCIP data structure */
4530  SCIP_NODESEL* nodesel, /**< node selector */
4531  int priority /**< new standard priority of the node selector */
4532  );
4533 
4534 /** sets the priority of a node selector in memory saving mode */
4535 extern
4537  SCIP* scip, /**< SCIP data structure */
4538  SCIP_NODESEL* nodesel, /**< node selector */
4539  int priority /**< new memory saving priority of the node selector */
4540  );
4541 
4542 /** returns the currently used node selector */
4543 extern
4545  SCIP* scip /**< SCIP data structure */
4546  );
4547 
4548 /**@addtogroup PublicBanditAlgorithms
4549  *
4550  * @{
4551  */
4552 
4553 /** includes a bandit algorithm virtual function table */
4554 extern
4556  SCIP* scip, /**< SCIP data structure */
4557  SCIP_BANDITVTABLE** banditvtable, /**< bandit algorithm virtual function table */
4558  const char* name, /**< a name for the algorithm represented by this vtable */
4559  SCIP_DECL_BANDITFREE ((*banditfree)), /**< callback to free bandit specific data structures */
4560  SCIP_DECL_BANDITSELECT((*banditselect)), /**< selection callback for bandit selector */
4561  SCIP_DECL_BANDITUPDATE((*banditupdate)), /**< update callback for bandit algorithms */
4562  SCIP_DECL_BANDITRESET ((*banditreset)) /**< update callback for bandit algorithms */
4563  );
4564 
4565 /** returns the bandit virtual function table of the given name, or NULL if not existing */
4566 extern
4568  SCIP* scip, /**< SCIP data structure */
4569  const char* name /**< name of bandit algorithm virtual function table */
4570  );
4571 
4572 /** calls destructor and frees memory of bandit algorithm */
4573 extern
4575  SCIP* scip, /**< SCIP data structure */
4576  SCIP_BANDIT** bandit /**< pointer to bandit algorithm data structure */
4577  );
4578 
4579 /** reset the bandit algorithm */
4580 extern
4582  SCIP* scip, /**< SCIP data structure */
4583  SCIP_BANDIT* bandit, /**< pointer to bandit algorithm data structure */
4584  SCIP_Real* priorities, /**< priorities for every action, or NULL if not needed */
4585  unsigned int seed /**< initial random seed for bandit selection */
4586  );
4587 
4588 /* @} */
4589 
4590 
4591 
4592 /* @} */
4593 
4594 /**@addtogroup PublicBranchRuleMethods
4595  *
4596  * @{
4597  */
4598 
4599 /** creates a branching rule and includes it in SCIP
4600  *
4601  * @note method has all branching rule callbacks as arguments and is thus changed every time a new
4602  * callback is added in future releases; consider using SCIPincludeBranchruleBasic() and setter functions
4603  * if you seek for a method which is less likely to change in future releases
4604  */
4605 extern
4607  SCIP* scip, /**< SCIP data structure */
4608  const char* name, /**< name of branching rule */
4609  const char* desc, /**< description of branching rule */
4610  int priority, /**< priority of the branching rule */
4611  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
4612  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
4613  * compared to best node's dual bound for applying branching rule
4614  * (0.0: only on current best node, 1.0: on all nodes) */
4615  SCIP_DECL_BRANCHCOPY ((*branchcopy)), /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
4616  SCIP_DECL_BRANCHFREE ((*branchfree)), /**< destructor of branching rule */
4617  SCIP_DECL_BRANCHINIT ((*branchinit)), /**< initialize branching rule */
4618  SCIP_DECL_BRANCHEXIT ((*branchexit)), /**< deinitialize branching rule */
4619  SCIP_DECL_BRANCHINITSOL((*branchinitsol)),/**< solving process initialization method of branching rule */
4620  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)),/**< solving process deinitialization method of branching rule */
4621  SCIP_DECL_BRANCHEXECLP((*branchexeclp)), /**< branching execution method for fractional LP solutions */
4622  SCIP_DECL_BRANCHEXECEXT((*branchexecext)),/**< branching execution method for external candidates */
4623  SCIP_DECL_BRANCHEXECPS((*branchexecps)), /**< branching execution method for not completely fixed pseudo solutions */
4624  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
4625  );
4626 
4627 /** creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
4628  * Optional callbacks can be set via specific setter functions, see SCIPsetBranchruleInit(), SCIPsetBranchruleExit(),
4629  * SCIPsetBranchruleCopy(), SCIPsetBranchruleFree(), SCIPsetBranchruleInitsol(), SCIPsetBranchruleExitsol(),
4630  * SCIPsetBranchruleExecLp(), SCIPsetBranchruleExecExt(), and SCIPsetBranchruleExecPs().
4631  *
4632  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeBranchrule() instead
4633  */
4634 extern
4636  SCIP* scip, /**< SCIP data structure */
4637  SCIP_BRANCHRULE** branchruleptr, /**< pointer to branching rule, or NULL */
4638  const char* name, /**< name of branching rule */
4639  const char* desc, /**< description of branching rule */
4640  int priority, /**< priority of the branching rule */
4641  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
4642  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
4643  * compared to best node's dual bound for applying branching rule
4644  * (0.0: only on current best node, 1.0: on all nodes) */
4645  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
4646  );
4647 
4648 /** sets copy method of branching rule */
4649 extern
4651  SCIP* scip, /**< SCIP data structure */
4652  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4653  SCIP_DECL_BRANCHCOPY ((*branchcopy)) /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
4654  );
4655 
4656 /** sets destructor method of branching rule */
4657 extern
4659  SCIP* scip, /**< SCIP data structure */
4660  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4661  SCIP_DECL_BRANCHFREE ((*branchfree)) /**< destructor of branching rule */
4662  );
4663 
4664 /** sets initialization method of branching rule */
4665 extern
4667  SCIP* scip, /**< SCIP data structure */
4668  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4669  SCIP_DECL_BRANCHINIT ((*branchinit)) /**< initialize branching rule */
4670  );
4671 
4672 /** sets deinitialization method of branching rule */
4673 extern
4675  SCIP* scip, /**< SCIP data structure */
4676  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4677  SCIP_DECL_BRANCHEXIT ((*branchexit)) /**< deinitialize branching rule */
4678  );
4679 
4680 /** sets solving process initialization method of branching rule */
4681 extern
4683  SCIP* scip, /**< SCIP data structure */
4684  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4685  SCIP_DECL_BRANCHINITSOL((*branchinitsol)) /**< solving process initialization method of branching rule */
4686  );
4687 
4688 /** sets solving process deinitialization method of branching rule */
4689 extern
4691  SCIP* scip, /**< SCIP data structure */
4692  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4693  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)) /**< solving process deinitialization method of branching rule */
4694  );
4695 
4696 /** sets branching execution method for fractional LP solutions */
4697 extern
4699  SCIP* scip, /**< SCIP data structure */
4700  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4701  SCIP_DECL_BRANCHEXECLP((*branchexeclp)) /**< branching execution method for fractional LP solutions */
4702  );
4703 
4704 /** sets branching execution method for external candidates */
4705 extern
4707  SCIP* scip, /**< SCIP data structure */
4708  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4709  SCIP_DECL_BRANCHEXECEXT((*branchexecext)) /**< branching execution method for external candidates */
4710  );
4711 
4712 /** sets branching execution method for not completely fixed pseudo solutions */
4713 extern
4715  SCIP* scip, /**< SCIP data structure */
4716  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4717  SCIP_DECL_BRANCHEXECPS((*branchexecps)) /**< branching execution method for not completely fixed pseudo solutions */
4718  );
4719 
4720 /** returns the branching rule of the given name, or NULL if not existing */
4721 extern
4723  SCIP* scip, /**< SCIP data structure */
4724  const char* name /**< name of branching rule */
4725  );
4726 
4727 /** returns the array of currently available branching rules */
4728 extern
4730  SCIP* scip /**< SCIP data structure */
4731  );
4732 
4733 /** returns the number of currently available branching rules */
4734 extern
4736  SCIP* scip /**< SCIP data structure */
4737  );
4738 
4739 /** sets the priority of a branching rule */
4740 extern
4742  SCIP* scip, /**< SCIP data structure */
4743  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4744  int priority /**< new priority of the branching rule */
4745  );
4746 
4747 /** sets maximal depth level, up to which this branching rule should be used (-1 for no limit) */
4748 extern
4750  SCIP* scip, /**< SCIP data structure */
4751  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4752  int maxdepth /**< new maxdepth of the branching rule */
4753  );
4754 
4755 /** sets maximal relative distance from current node's dual bound to primal bound for applying branching rule */
4756 extern
4758  SCIP* scip, /**< SCIP data structure */
4759  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4760  SCIP_Real maxbounddist /**< new maxbounddist of the branching rule */
4761  );
4762 
4763 /* @} */
4764 
4765 /**@addtogroup PublicDisplayMethods
4766  *
4767  * @{
4768  */
4769 
4770 /** creates a display column and includes it in SCIP */
4771 extern
4773  SCIP* scip, /**< SCIP data structure */
4774  const char* name, /**< name of display column */
4775  const char* desc, /**< description of display column */
4776  const char* header, /**< head line of display column */
4777  SCIP_DISPSTATUS dispstatus, /**< display activation status of display column */
4778  SCIP_DECL_DISPCOPY ((*dispcopy)), /**< copy method of display column or NULL if you don't want to copy your plugin into sub-SCIPs */
4779  SCIP_DECL_DISPFREE ((*dispfree)), /**< destructor of display column */
4780  SCIP_DECL_DISPINIT ((*dispinit)), /**< initialize display column */
4781  SCIP_DECL_DISPEXIT ((*dispexit)), /**< deinitialize display column */
4782  SCIP_DECL_DISPINITSOL ((*dispinitsol)), /**< solving process initialization method of display column */
4783  SCIP_DECL_DISPEXITSOL ((*dispexitsol)), /**< solving process deinitialization method of display column */
4784  SCIP_DECL_DISPOUTPUT ((*dispoutput)), /**< output method */
4785  SCIP_DISPDATA* dispdata, /**< display column data */
4786  int width, /**< width of display column (no. of chars used) */
4787  int priority, /**< priority of display column */
4788  int position, /**< relative position of display column */
4789  SCIP_Bool stripline /**< should the column be separated with a line from its right neighbor? */
4790  );
4791 
4792 /** returns the display column of the given name, or NULL if not existing */
4793 extern
4795  SCIP* scip, /**< SCIP data structure */
4796  const char* name /**< name of display column */
4797  );
4798 
4799 /** returns the array of currently available display columns */
4800 extern
4802  SCIP* scip /**< SCIP data structure */
4803  );
4804 
4805 /** returns the number of currently available display columns */
4806 extern
4807 int SCIPgetNDisps(
4808  SCIP* scip /**< SCIP data structure */
4809  );
4810 
4811 /** automatically selects display columns for being shown w.r.t. the display width parameter */
4812 extern
4814  SCIP* scip /**< SCIP data structure */
4815  );
4816 
4817 /** changes the display column mode */
4818 extern
4819 void SCIPchgDispMode(
4820  SCIP_DISP* disp, /**< display column */
4821  SCIP_DISPMODE mode /**< the display column mode */
4822  );
4823 
4824 /* @} */
4825 
4826 /**@addtogroup PublicTableMethods
4827  *
4828  * @{
4829  */
4830 
4831 /** creates a statistics table and includes it in SCIP */
4832 extern
4834  SCIP* scip, /**< SCIP data structure */
4835  const char* name, /**< name of statistics table */
4836  const char* desc, /**< description of statistics table */
4837  SCIP_Bool active, /**< should the table be activated by default? */
4838  SCIP_DECL_TABLECOPY ((*tablecopy)), /**< copy method of statistics table or NULL if you don't want to copy your plugin into sub-SCIPs */
4839  SCIP_DECL_TABLEFREE ((*tablefree)), /**< destructor of statistics table */
4840  SCIP_DECL_TABLEINIT ((*tableinit)), /**< initialize statistics table */
4841  SCIP_DECL_TABLEEXIT ((*tableexit)), /**< deinitialize statistics table */
4842  SCIP_DECL_TABLEINITSOL ((*tableinitsol)), /**< solving process initialization method of statistics table */
4843  SCIP_DECL_TABLEEXITSOL ((*tableexitsol)), /**< solving process deinitialization method of statistics table */
4844  SCIP_DECL_TABLEOUTPUT ((*tableoutput)), /**< output method */
4845  SCIP_TABLEDATA* tabledata, /**< statistics table data */
4846  int position, /**< position of statistics table */
4847  SCIP_STAGE earlieststage /**< output of the statistics table is only printed from this stage onwards */
4848  );
4849 
4850 /** returns the statistics table of the given name, or NULL if not existing */
4851 extern
4853  SCIP* scip, /**< SCIP data structure */
4854  const char* name /**< name of statistics table */
4855  );
4856 
4857 /** returns the array of currently available statistics tables */
4858 extern
4860  SCIP* scip /**< SCIP data structure */
4861  );
4862 
4863 /** returns the number of currently available statistics tables */
4864 extern
4865 int SCIPgetNTables(
4866  SCIP* scip /**< SCIP data structure */
4867  );
4868 
4869 /* @} */
4870 
4871 /**@addtogroup PublicNLPInterfaceMethods
4872  *
4873  * @{
4874  */
4875 
4876 /** includes an NLPI in SCIP */
4877 extern
4879  SCIP* scip, /**< SCIP data structure */
4880  SCIP_NLPI* nlpi /**< NLPI data structure */
4881  );
4882 
4883 /** returns the NLPI of the given name, or NULL if not existing */
4884 extern
4886  SCIP* scip, /**< SCIP data structure */
4887  const char* name /**< name of NLPI */
4888  );
4889 
4890 /** returns the array of currently available NLPIs (sorted by priority) */
4891 extern
4893  SCIP* scip /**< SCIP data structure */
4894  );
4895 
4896 /** returns the number of currently available NLPIs */
4897 extern
4898 int SCIPgetNNlpis(
4899  SCIP* scip /**< SCIP data structure */
4900  );
4901 
4902 /** sets the priority of an NLPI */
4903 extern
4905  SCIP* scip, /**< SCIP data structure */
4906  SCIP_NLPI* nlpi, /**< NLPI */
4907  int priority /**< new priority of the NLPI */
4908  );
4909 
4910 /* @} */
4911 
4912 /**@addtogroup PublicExternalCodeMethods
4913  *
4914  * @{
4915  */
4916 
4917 
4918 
4919 /** includes information about an external code linked into the SCIP library */
4920 extern
4922  SCIP* scip, /**< SCIP data structure */
4923  const char* name, /**< name of external code */
4924  const char* description /**< description of external code, or NULL */
4925  );
4926 
4927 /** returns an array of names of currently included external codes */
4928 extern
4930  SCIP* scip /**< SCIP data structure */
4931  );
4932 
4933 /** returns an array of the descriptions of currently included external codes
4934  *
4935  * @note some descriptions may be NULL
4936  */
4937 extern
4939  SCIP* scip /**< SCIP data structure */
4940  );
4941 
4942 /** returns the number of currently included information on external codes */
4943 extern
4945  SCIP* scip /**< SCIP data structure */
4946  );
4947 
4948 /** prints information on external codes to a file stream via the message handler system
4949  *
4950  * @note If the message handler is set to a NULL pointer nothing will be printed
4951  */
4952 extern
4954  SCIP* scip, /**< SCIP data structure */
4955  FILE* file /**< output file (or NULL for standard output) */
4956  );
4957 
4958 /* @} */
4959 
4960 /*
4961  * user interactive dialog methods
4962  */
4963 
4964 /**@addtogroup PublicDialogMethods
4965  *
4966  * @{
4967  */
4968 
4969 /** creates and includes dialog
4970  *
4971  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4972  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4973  */
4974 extern
4976  SCIP* scip, /**< SCIP data structure */
4977  SCIP_DIALOG** dialog, /**< pointer to store the dialog */
4978  SCIP_DECL_DIALOGCOPY ((*dialogcopy)), /**< copy method of dialog or NULL if you don't want to copy your plugin into sub-SCIPs */
4979  SCIP_DECL_DIALOGEXEC ((*dialogexec)), /**< execution method of dialog */
4980  SCIP_DECL_DIALOGDESC ((*dialogdesc)), /**< description output method of dialog, or NULL */
4981  SCIP_DECL_DIALOGFREE ((*dialogfree)), /**< destructor of dialog to free user data, or NULL */
4982  const char* name, /**< name of dialog: command name appearing in parent's dialog menu */
4983  const char* desc, /**< description of dialog used if description output method is NULL */
4984  SCIP_Bool issubmenu, /**< is the dialog a submenu? */
4985  SCIP_DIALOGDATA* dialogdata /**< user defined dialog data */
4986  );
4987 
4988 /** returns if the dialog already exists
4989  *
4990  * @return TRUE is returned if the dialog exists, otherwise FALSE.
4991  */
4992 extern
4994  SCIP* scip, /**< SCIP data structure */
4995  SCIP_DIALOG* dialog /**< dialog */
4996  );
4997 
4998 /** captures a dialog
4999  *
5000  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5001  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5002  */
5003 extern
5005  SCIP* scip, /**< SCIP data structure */
5006  SCIP_DIALOG* dialog /**< dialog */
5007  );
5008 
5009 /** releases a dialog
5010  *
5011  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5012  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5013  */
5014 extern
5016  SCIP* scip, /**< SCIP data structure */
5017  SCIP_DIALOG** dialog /**< pointer to the dialog */
5018  );
5019 
5020 /** makes given dialog the root dialog of SCIP's interactive user shell; captures dialog and releases former root dialog
5021  *
5022  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5023  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5024  */
5025 extern
5027  SCIP* scip, /**< SCIP data structure */
5028  SCIP_DIALOG* dialog /**< dialog to be the root */
5029  );
5030 
5031 /** returns the root dialog of SCIP's interactive user shell
5032  *
5033  * @return the root dialog of SCIP's interactive user shell is returned.
5034  */
5035 extern
5037  SCIP* scip /**< SCIP data structure */
5038  );
5039 
5040 /** adds a sub dialog to the given dialog as menu entry and captures it
5041  *
5042  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5043  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5044  */
5045 extern
5047  SCIP* scip, /**< SCIP data structure */
5048  SCIP_DIALOG* dialog, /**< dialog to extend, or NULL for root dialog */
5049  SCIP_DIALOG* subdialog /**< subdialog to add as menu entry in dialog */
5050  );
5051 
5052 /** adds a single line of input which is treated as if the user entered the command line
5053  *
5054  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5055  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5056  */
5057 extern
5059  SCIP* scip, /**< SCIP data structure */
5060  const char* inputline /**< input line to add */
5061  );
5062 
5063 /** adds a single line of input to the command history which can be accessed with the cursor keys
5064  *
5065  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5066  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5067  */
5068 extern
5070  SCIP* scip, /**< SCIP data structure */
5071  const char* inputline /**< input line to add */
5072  );
5073 
5074 /** starts interactive mode of SCIP by executing the root dialog
5075  *
5076  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5077  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5078  *
5079  * @pre This method can be called if @p scip is in one of the following stages:
5080  * - \ref SCIP_STAGE_INIT
5081  * - \ref SCIP_STAGE_FREE
5082  *
5083  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the
5084  * interactive shell was closed:
5085  * - \ref SCIP_STAGE_PROBLEM if the interactive shell was closed after the problem was created
5086  * - \ref SCIP_STAGE_TRANSFORMED if the interactive shell was closed after the problem was transformed
5087  * - \ref SCIP_STAGE_PRESOLVING if the interactive shell was closed during presolving
5088  * - \ref SCIP_STAGE_PRESOLVED if the interactive shell was closed after presolve
5089  * - \ref SCIP_STAGE_SOLVING if the interactive shell was closed during the tree search
5090  * - \ref SCIP_STAGE_SOLVED if the interactive shell was closed after the problem was solved
5091  * - \ref SCIP_STAGE_FREE if the interactive shell was closed after the problem was freed
5092  *
5093  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
5094  */
5095 extern
5097  SCIP* scip /**< SCIP data structure */
5098  );
5099 
5100 /**@} */
5101 
5102 /*
5103  * global problem methods
5104  */
5105 
5106 /**@addtogroup GlobalProblemMethods
5107  *
5108  * @{
5109  */
5110 
5111 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
5112  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
5113  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
5114  *
5115  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5116  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5117  *
5118  * @pre This method can be called if @p scip is in one of the following stages:
5119  * - \ref SCIP_STAGE_INIT
5120  * - \ref SCIP_STAGE_PROBLEM
5121  * - \ref SCIP_STAGE_TRANSFORMED
5122  * - \ref SCIP_STAGE_PRESOLVING
5123  * - \ref SCIP_STAGE_PRESOLVED
5124  * - \ref SCIP_STAGE_SOLVING
5125  * - \ref SCIP_STAGE_SOLVED
5126  * - \ref SCIP_STAGE_FREE
5127  *
5128  * @post After calling this method, \SCIP reaches the following stage:
5129  * - \ref SCIP_STAGE_PROBLEM
5130  */
5131 extern
5133  SCIP* scip, /**< SCIP data structure */
5134  const char* name, /**< problem name */
5135  SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
5136  SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
5137  SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
5138  SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
5139  SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
5140  SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
5141  SCIP_PROBDATA* probdata /**< user problem data set by the reader */
5142  );
5143 
5144 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
5145  * all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(),
5146  * SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and
5147  * SCIPsetProbCopy()
5148  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
5149  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
5150  *
5151  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5152  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5153  *
5154  * @pre This method can be called if @p scip is in one of the following stages:
5155  * - \ref SCIP_STAGE_INIT
5156  * - \ref SCIP_STAGE_PROBLEM
5157  * - \ref SCIP_STAGE_TRANSFORMED
5158  * - \ref SCIP_STAGE_PRESOLVING
5159  * - \ref SCIP_STAGE_PRESOLVED
5160  * - \ref SCIP_STAGE_SOLVING
5161  * - \ref SCIP_STAGE_SOLVED
5162  * - \ref SCIP_STAGE_FREE
5163  *
5164  * @post After calling this method, \SCIP reaches the following stage:
5165  * - \ref SCIP_STAGE_PROBLEM
5166  */
5167 extern
5169  SCIP* scip, /**< SCIP data structure */
5170  const char* name /**< problem name */
5171  );
5172 
5173 /** sets callback to free user data of original problem
5174  *
5175  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5176  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5177  *
5178  * @pre This method can be called if @p scip is in one of the following stages:
5179  * - \ref SCIP_STAGE_PROBLEM
5180  */
5181 extern
5183  SCIP* scip, /**< SCIP data structure */
5184  SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
5185  );
5186 
5187 /** sets callback to create user data of transformed problem by transforming original user data
5188  *
5189  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5190  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5191  *
5192  * @pre This method can be called if @p scip is in one of the following stages:
5193  * - \ref SCIP_STAGE_PROBLEM
5194  */
5195 extern
5197  SCIP* scip, /**< SCIP data structure */
5198  SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
5199  );
5200 
5201 /** sets callback to free user data of transformed problem
5202  *
5203  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5204  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5205  *
5206  * @pre This method can be called if @p scip is in one of the following stages:
5207  * - \ref SCIP_STAGE_PROBLEM
5208  */
5209 extern
5211  SCIP* scip, /**< SCIP data structure */
5212  SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
5213  );
5214 
5215 /** sets solving process initialization callback of transformed data
5216  *
5217  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5218  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5219  *
5220  * @pre This method can be called if @p scip is in one of the following stages:
5221  * - \ref SCIP_STAGE_PROBLEM
5222  */
5223 extern
5225  SCIP* scip, /**< SCIP data structure */
5226  SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization method of transformed data */
5227  );
5228 
5229 /** sets solving process deinitialization callback of transformed data
5230  *
5231  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5232  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5233  *
5234  * @pre This method can be called if @p scip is in one of the following stages:
5235  * - \ref SCIP_STAGE_PROBLEM
5236  */
5237 extern
5239  SCIP* scip, /**< SCIP data structure */
5240  SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization method of transformed data */
5241  );
5242 
5243 /** sets callback to copy user data to a subscip
5244  *
5245  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5246  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5247  *
5248  * @pre This method can be called if @p scip is in one of the following stages:
5249  * - \ref SCIP_STAGE_PROBLEM
5250  */
5251 extern
5253  SCIP* scip, /**< SCIP data structure */
5254  SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
5255  );
5256 
5257 /** reads problem from file and initializes all solving data structures
5258  *
5259  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5260  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5261  *
5262  * @pre This method can be called if @p scip is in one of the following stages:
5263  * - \ref SCIP_STAGE_INIT
5264  * - \ref SCIP_STAGE_PROBLEM
5265  * - \ref SCIP_STAGE_TRANSFORMED
5266  * - \ref SCIP_STAGE_INITPRESOLVE
5267  * - \ref SCIP_STAGE_PRESOLVING
5268  * - \ref SCIP_STAGE_EXITPRESOLVE
5269  * - \ref SCIP_STAGE_PRESOLVED
5270  * - \ref SCIP_STAGE_SOLVING
5271  * - \ref SCIP_STAGE_EXITSOLVE
5272  *
5273  * @post After the method was called, \SCIP is in one of the following stages:
5274  * - \ref SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
5275  * - \ref SCIP_STAGE_PROBLEM if the problem file was successfully read
5276  */
5277 extern
5279  SCIP* scip, /**< SCIP data structure */
5280  const char* filename, /**< problem file name */
5281  const char* extension /**< extension of the desired file reader,
5282  * or NULL if file extension should be used */
5283  );
5284 
5285 /** writes original problem to file
5286  *
5287  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5288  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5289  *
5290  * @pre This method can be called if @p scip is in one of the following stages:
5291  * - \ref SCIP_STAGE_PROBLEM
5292  * - \ref SCIP_STAGE_TRANSFORMING
5293  * - \ref SCIP_STAGE_TRANSFORMED
5294  * - \ref SCIP_STAGE_INITPRESOLVE
5295  * - \ref SCIP_STAGE_PRESOLVING
5296  * - \ref SCIP_STAGE_EXITPRESOLVE
5297  * - \ref SCIP_STAGE_PRESOLVED
5298  * - \ref SCIP_STAGE_INITSOLVE
5299  * - \ref SCIP_STAGE_SOLVING
5300  * - \ref SCIP_STAGE_SOLVED
5301  * - \ref SCIP_STAGE_EXITSOLVE
5302  * - \ref SCIP_STAGE_FREETRANS
5303  */
5304 extern
5306  SCIP* scip, /**< SCIP data structure */
5307  const char* filename, /**< output file (or NULL for standard output) */
5308  const char* extension, /**< extension of the desired file reader,
5309  * or NULL if file extension should be used */
5310  SCIP_Bool genericnames /**< use generic variable and constraint names? */
5311  );
5312 
5313 /** writes transformed problem which are valid in the current node to file
5314  *
5315  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5316  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5317  *
5318  * @pre This method can be called if @p scip is in one of the following stages:
5319  * - \ref SCIP_STAGE_TRANSFORMED
5320  * - \ref SCIP_STAGE_INITPRESOLVE
5321  * - \ref SCIP_STAGE_PRESOLVING
5322  * - \ref SCIP_STAGE_EXITPRESOLVE
5323  * - \ref SCIP_STAGE_PRESOLVED
5324  * - \ref SCIP_STAGE_INITSOLVE
5325  * - \ref SCIP_STAGE_SOLVING
5326  * - \ref SCIP_STAGE_SOLVED
5327  * - \ref SCIP_STAGE_EXITSOLVE
5328  *
5329  * @note If you want the write all constraints (including the once which are redundant for example), you need to set
5330  * the parameter <write/allconss> to TRUE
5331  */
5332 extern
5334  SCIP* scip, /**< SCIP data structure */
5335  const char* filename, /**< output file (or NULL for standard output) */
5336  const char* extension, /**< extension of the desired file reader,
5337  * or NULL if file extension should be used */
5338  SCIP_Bool genericnames /**< using generic variable and constraint names? */
5339  );
5340 
5341 /** frees problem and solution process data
5342  *
5343  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5344  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5345  *
5346  * @pre This method can be called if @p scip is in one of the following stages:
5347  * - \ref SCIP_STAGE_INIT
5348  * - \ref SCIP_STAGE_PROBLEM
5349  * - \ref SCIP_STAGE_TRANSFORMED
5350  * - \ref SCIP_STAGE_PRESOLVING
5351  * - \ref SCIP_STAGE_PRESOLVED
5352  * - \ref SCIP_STAGE_SOLVING
5353  * - \ref SCIP_STAGE_SOLVED
5354  * - \ref SCIP_STAGE_FREE
5355  *
5356  * @post After this method was called, SCIP is in the following stage:
5357  * - \ref SCIP_STAGE_INIT
5358  */
5359 extern
5361  SCIP* scip /**< SCIP data structure */
5362  );
5363 
5364 /** permutes parts of the problem data structure
5365  *
5366  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5367  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5368  *
5369  * @pre This method can be called if @p scip is in one of the following stages:
5370  * - \ref SCIP_STAGE_PROBLEM
5371  * - \ref SCIP_STAGE_TRANSFORMED
5372  */
5373 extern
5375  SCIP* scip, /**< SCIP data structure */
5376  unsigned int randseed, /**< seed value for random generator */
5377  SCIP_Bool permuteconss, /**< should the list of constraints in each constraint handler be permuted? */
5378  SCIP_Bool permutebinvars, /**< should the list of binary variables be permuted? */
5379  SCIP_Bool permuteintvars, /**< should the list of integer variables be permuted? */
5380  SCIP_Bool permuteimplvars, /**< should the list of implicit integer variables be permuted? */
5381  SCIP_Bool permutecontvars /**< should the list of continuous integer variables be permuted? */
5382  );
5383 
5384 /** gets user problem data
5385  *
5386  * @return a SCIP_PROBDATA pointer, or NULL if no problem data was allocated
5387  *
5388  * @pre This method can be called if @p scip is in one of the following stages:
5389  * - \ref SCIP_STAGE_PROBLEM
5390  * - \ref SCIP_STAGE_TRANSFORMING
5391  * - \ref SCIP_STAGE_TRANSFORMED
5392  * - \ref SCIP_STAGE_INITPRESOLVE
5393  * - \ref SCIP_STAGE_PRESOLVING
5394  * - \ref SCIP_STAGE_EXITPRESOLVE
5395  * - \ref SCIP_STAGE_PRESOLVED
5396  * - \ref SCIP_STAGE_INITSOLVE
5397  * - \ref SCIP_STAGE_SOLVING
5398  * - \ref SCIP_STAGE_SOLVED
5399  * - \ref SCIP_STAGE_EXITSOLVE
5400  * - \ref SCIP_STAGE_FREETRANS
5401  */
5402 extern
5404  SCIP* scip /**< SCIP data structure */
5405  );
5406 
5407 /** sets user problem data
5408  *
5409  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5410  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5411  *
5412  * @pre This method can be called if @p scip is in one of the following stages:
5413  * - \ref SCIP_STAGE_PROBLEM
5414  * - \ref SCIP_STAGE_TRANSFORMING
5415  * - \ref SCIP_STAGE_TRANSFORMED
5416  * - \ref SCIP_STAGE_INITPRESOLVE
5417  * - \ref SCIP_STAGE_PRESOLVING
5418  * - \ref SCIP_STAGE_EXITPRESOLVE
5419  * - \ref SCIP_STAGE_PRESOLVED
5420  * - \ref SCIP_STAGE_INITSOLVE
5421  * - \ref SCIP_STAGE_SOLVING
5422  * - \ref SCIP_STAGE_SOLVED
5423  * - \ref SCIP_STAGE_EXITSOLVE
5424  * - \ref SCIP_STAGE_FREETRANS
5425  */
5426 extern
5428  SCIP* scip, /**< SCIP data structure */
5429  SCIP_PROBDATA* probdata /**< user problem data to use */
5430  );
5431 
5432 /** returns name of the current problem instance
5433  *
5434  * @return name of the current problem instance
5435  *
5436  * @pre This method can be called if @p scip is in one of the following stages:
5437  * - \ref SCIP_STAGE_PROBLEM
5438  * - \ref SCIP_STAGE_TRANSFORMING
5439  * - \ref SCIP_STAGE_TRANSFORMED
5440  * - \ref SCIP_STAGE_INITPRESOLVE
5441  * - \ref SCIP_STAGE_PRESOLVING
5442  * - \ref SCIP_STAGE_EXITPRESOLVE
5443  * - \ref SCIP_STAGE_PRESOLVED
5444  * - \ref SCIP_STAGE_INITSOLVE
5445  * - \ref SCIP_STAGE_SOLVING
5446  * - \ref SCIP_STAGE_SOLVED
5447  * - \ref SCIP_STAGE_EXITSOLVE
5448  * - \ref SCIP_STAGE_FREETRANS
5449  */
5450 extern
5451 const char* SCIPgetProbName(
5452  SCIP* scip /**< SCIP data structure */
5453  );
5454 
5455 /** sets name of the current problem instance
5456  *
5457  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5458  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5459  *
5460  * @pre This method can be called if @p scip is in one of the following stages:
5461  * - \ref SCIP_STAGE_PROBLEM
5462  * - \ref SCIP_STAGE_TRANSFORMING
5463  * - \ref SCIP_STAGE_TRANSFORMED
5464  * - \ref SCIP_STAGE_INITPRESOLVE
5465  * - \ref SCIP_STAGE_PRESOLVING
5466  * - \ref SCIP_STAGE_EXITPRESOLVE
5467  * - \ref SCIP_STAGE_PRESOLVED
5468  * - \ref SCIP_STAGE_INITSOLVE
5469  * - \ref SCIP_STAGE_SOLVING
5470  * - \ref SCIP_STAGE_SOLVED
5471  * - \ref SCIP_STAGE_EXITSOLVE
5472  * - \ref SCIP_STAGE_FREETRANS
5473  */
5474 extern
5476  SCIP* scip, /**< SCIP data structure */
5477  const char* name /**< name to be set */
5478  );
5479 
5480 /** changes the objective function
5481  *
5482  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5483  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5484  *
5485  * @pre This method can be called if @p scip is in one of the following stages:
5486  * - \ref SCIP_STAGE_PROBLEM
5487  * - \ref SCIP_STAGE_PRESOLVED
5488  *
5489  * @note This method should be only used to change the objective function during two reoptimization runs and is only
5490  * recommended to an experienced user.
5491  *
5492  * @note All variables not given in \p vars array are assumed to have an objective coefficient of zero.
5493  */
5494 extern
5496  SCIP* scip, /**< SCIP data structure */
5497  SCIP_OBJSENSE objsense, /**< new objective function */
5498  SCIP_VAR** vars, /**< problem variables */
5499  SCIP_Real* coefs, /**< objective coefficients */
5500  int nvars /**< variables in vars array */
5501  );
5502 
5503 /** returns objective sense of original problem
5504  *
5505  * @return objective sense of original problem
5506  *
5507  * @pre This method can be called if @p scip is in one of the following stages:
5508  * - \ref SCIP_STAGE_PROBLEM
5509  * - \ref SCIP_STAGE_TRANSFORMING
5510  * - \ref SCIP_STAGE_TRANSFORMED
5511  * - \ref SCIP_STAGE_INITPRESOLVE
5512  * - \ref SCIP_STAGE_PRESOLVING
5513  * - \ref SCIP_STAGE_EXITPRESOLVE
5514  * - \ref SCIP_STAGE_PRESOLVED
5515  * - \ref SCIP_STAGE_INITSOLVE
5516  * - \ref SCIP_STAGE_SOLVING
5517  * - \ref SCIP_STAGE_SOLVED
5518  * - \ref SCIP_STAGE_EXITSOLVE
5519  * - \ref SCIP_STAGE_FREETRANS
5520  */
5521 extern
5523  SCIP* scip /**< SCIP data structure */
5524  );
5525 
5526 /** sets objective sense of problem
5527  *
5528  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5529  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5530  *
5531  * @pre This method can be called if @p scip is in one of the following stages:
5532  * - \ref SCIP_STAGE_PROBLEM
5533  */
5534 extern
5536  SCIP* scip, /**< SCIP data structure */
5537  SCIP_OBJSENSE objsense /**< new objective sense */
5538  );
5539 
5540 /** adds offset of objective function
5541  *
5542  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5543  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5544  *
5545  * @pre This method can be called if @p scip is in one of the following stages:
5546  * - \ref SCIP_STAGE_PRESOLVING
5547  */
5548 extern
5550  SCIP* scip, /**< SCIP data structure */
5551  SCIP_Real addval /**< value to add to objective offset */
5552  );
5553 
5554 /** adds offset of objective function to original problem and to all existing solution in original space
5555  *
5556  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5557  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5558  *
5559  * @pre This method can be called if @p scip is in one of the following stages:
5560  * - \ref SCIP_STAGE_PROBLEM
5561  */
5562 extern
5564  SCIP* scip, /**< SCIP data structure */
5565  SCIP_Real addval /**< value to add to objective offset */
5566  );
5567 
5568 /** returns the objective offset of the original problem
5569  *
5570  * @return the objective offset of the original problem
5571  *
5572  * @pre This method can be called if @p scip is in one of the following stages:
5573  * - \ref SCIP_STAGE_PROBLEM
5574  * - \ref SCIP_STAGE_TRANSFORMING
5575  * - \ref SCIP_STAGE_TRANSFORMED
5576  * - \ref SCIP_STAGE_INITPRESOLVE
5577  * - \ref SCIP_STAGE_PRESOLVING
5578  * - \ref SCIP_STAGE_EXITPRESOLVE
5579  * - \ref SCIP_STAGE_PRESOLVED
5580  * - \ref SCIP_STAGE_INITSOLVE
5581  * - \ref SCIP_STAGE_SOLVING
5582  * - \ref SCIP_STAGE_SOLVED
5583  */
5584 extern
5586  SCIP* scip /**< SCIP data structure */
5587  );
5588 
5589 /** returns the objective scale of the original problem
5590  *
5591  * @return the objective scale of the original problem
5592  *
5593  * @pre This method can be called if @p scip is in one of the following stages:
5594  * - \ref SCIP_STAGE_PROBLEM
5595  * - \ref SCIP_STAGE_TRANSFORMING
5596  * - \ref SCIP_STAGE_TRANSFORMED
5597  * - \ref SCIP_STAGE_INITPRESOLVE
5598  * - \ref SCIP_STAGE_PRESOLVING
5599  * - \ref SCIP_STAGE_EXITPRESOLVE
5600  * - \ref SCIP_STAGE_PRESOLVED
5601  * - \ref SCIP_STAGE_INITSOLVE
5602  * - \ref SCIP_STAGE_SOLVING
5603  * - \ref SCIP_STAGE_SOLVED
5604  */
5605 extern
5607  SCIP* scip /**< SCIP data structure */
5608  );
5609 
5610 /** returns the objective offset of the transformed problem
5611  *
5612  * @return the objective offset of the transformed problem
5613  *
5614  * @pre This method can be called if @p scip is in one of the following stages:
5615  * - \ref SCIP_STAGE_TRANSFORMED
5616  * - \ref SCIP_STAGE_INITPRESOLVE
5617  * - \ref SCIP_STAGE_PRESOLVING
5618  * - \ref SCIP_STAGE_EXITPRESOLVE
5619  * - \ref SCIP_STAGE_PRESOLVED
5620  * - \ref SCIP_STAGE_INITSOLVE
5621  * - \ref SCIP_STAGE_SOLVING
5622  * - \ref SCIP_STAGE_SOLVED
5623  */
5624 extern
5626  SCIP* scip /**< SCIP data structure */
5627  );
5628 
5629 /** returns the objective scale of the transformed problem
5630  *
5631  * @return the objective scale of the transformed problem
5632  *
5633  * @pre This method can be called if @p scip is in one of the following stages:
5634  * - \ref SCIP_STAGE_TRANSFORMED
5635  * - \ref SCIP_STAGE_INITPRESOLVE
5636  * - \ref SCIP_STAGE_PRESOLVING
5637  * - \ref SCIP_STAGE_EXITPRESOLVE
5638  * - \ref SCIP_STAGE_PRESOLVED
5639  * - \ref SCIP_STAGE_INITSOLVE
5640  * - \ref SCIP_STAGE_SOLVING
5641  * - \ref SCIP_STAGE_SOLVED
5642  */
5643 extern
5645  SCIP* scip /**< SCIP data structure */
5646  );
5647 
5648 /** sets limit on objective function, such that only solutions better than this limit are accepted
5649  *
5650  * @note SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune
5651  * all branch-and-bound nodes with dual bound equal or worse to the objective limit.
5652  * However, SCIP will also collect solutions with objective value worse than the objective limit and
5653  * use them to run improvement heuristics on them.
5654  * @note If SCIP can prove that there exists no solution with a strictly better objective value, the solving status
5655  * will normally be infeasible (the objective limit is interpreted as part of the problem).
5656  * The only exception is that by chance, SCIP found a solution with the same objective value and thus
5657  * proved the optimality of this solution, resulting in solution status optimal.
5658  *
5659  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5660  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5661  *
5662  * @pre This method can be called if @p scip is in one of the following stages:
5663  * - \ref SCIP_STAGE_PROBLEM
5664  * - \ref SCIP_STAGE_TRANSFORMED
5665  * - \ref SCIP_STAGE_INITPRESOLVE
5666  * - \ref SCIP_STAGE_PRESOLVING
5667  * - \ref SCIP_STAGE_EXITPRESOLVE
5668  * - \ref SCIP_STAGE_PRESOLVED
5669  * - \ref SCIP_STAGE_SOLVING
5670  */
5671 extern
5673  SCIP* scip, /**< SCIP data structure */
5674  SCIP_Real objlimit /**< new primal objective limit */
5675  );
5676 
5677 /** returns current limit on objective function
5678  *
5679  * @return the current objective limit of the original problem
5680  *
5681  * @pre This method can be called if @p scip is in one of the following stages:
5682  * - \ref SCIP_STAGE_PROBLEM
5683  * - \ref SCIP_STAGE_TRANSFORMING
5684  * - \ref SCIP_STAGE_TRANSFORMED
5685  * - \ref SCIP_STAGE_INITPRESOLVE
5686  * - \ref SCIP_STAGE_PRESOLVING
5687  * - \ref SCIP_STAGE_EXITPRESOLVE
5688  * - \ref SCIP_STAGE_PRESOLVED
5689  * - \ref SCIP_STAGE_INITSOLVE
5690  * - \ref SCIP_STAGE_SOLVING
5691  * - \ref SCIP_STAGE_SOLVED
5692  */
5693 extern
5695  SCIP* scip /**< SCIP data structure */
5696  );
5697 
5698 /** informs SCIP, that the objective value is always integral in every feasible solution
5699  *
5700  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5701  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5702  *
5703  * @pre This method can be called if @p scip is in one of the following stages:
5704  * - \ref SCIP_STAGE_PROBLEM
5705  * - \ref SCIP_STAGE_TRANSFORMING
5706  * - \ref SCIP_STAGE_INITPRESOLVE
5707  * - \ref SCIP_STAGE_EXITPRESOLVE
5708  * - \ref SCIP_STAGE_SOLVING
5709  *
5710  * @note This function should be used to inform SCIP that the objective function is integral, helping to improve the
5711  * performance. This is useful when using column generation. If no column generation (pricing) is used, SCIP
5712  * automatically detects whether the objective function is integral or can be scaled to be integral. However, in
5713  * any case, the user has to make sure that no variable is added during the solving process that destroys this
5714  * property.
5715  */
5716 extern
5718  SCIP* scip /**< SCIP data structure */
5719  );
5720 
5721 /** returns whether the objective value is known to be integral in every feasible solution
5722  *
5723  * @return TRUE, if objective value is known to be always integral, otherwise FALSE
5724  *
5725  * @pre This method can be called if @p scip is in one of the following stages:
5726  * - \ref SCIP_STAGE_PROBLEM
5727  * - \ref SCIP_STAGE_TRANSFORMING
5728  * - \ref SCIP_STAGE_INITPRESOLVE
5729  * - \ref SCIP_STAGE_PRESOLVING
5730  * - \ref SCIP_STAGE_EXITPRESOLVE
5731  * - \ref SCIP_STAGE_PRESOLVED
5732  * - \ref SCIP_STAGE_SOLVING
5733  *
5734  * @note If no pricing is performed, SCIP automatically detects whether the objective function is integral or can be
5735  * scaled to be integral, helping to improve performance. This function returns the result. Otherwise
5736  * SCIPsetObjIntegral() can be used to inform SCIP. However, in any case, the user has to make sure that no
5737  * variable is added during the solving process that destroys this property.
5738  */
5739 extern
5741  SCIP* scip /**< SCIP data structure */
5742  );
5743 
5744 /** returns the Euclidean norm of the objective function vector (available only for transformed problem)
5745  *
5746  * @return the Euclidean norm of the transformed objective function vector
5747  *
5748  * @pre This method can be called if @p scip is in one of the following stages:
5749  * - \ref SCIP_STAGE_TRANSFORMED
5750  * - \ref SCIP_STAGE_INITPRESOLVE
5751  * - \ref SCIP_STAGE_PRESOLVING
5752  * - \ref SCIP_STAGE_EXITPRESOLVE
5753  * - \ref SCIP_STAGE_PRESOLVED
5754  * - \ref SCIP_STAGE_INITSOLVE
5755  * - \ref SCIP_STAGE_SOLVING
5756  * - \ref SCIP_STAGE_SOLVED
5757  * - \ref SCIP_STAGE_EXITSOLVE
5758  */
5759 extern
5761  SCIP* scip /**< SCIP data structure */
5762  );
5763 
5764 /** adds variable to the problem
5765  *
5766  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5767  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5768  *
5769  * @pre This method can be called if @p scip is in one of the following stages:
5770  * - \ref SCIP_STAGE_PROBLEM
5771  * - \ref SCIP_STAGE_TRANSFORMING
5772  * - \ref SCIP_STAGE_INITPRESOLVE
5773  * - \ref SCIP_STAGE_PRESOLVING
5774  * - \ref SCIP_STAGE_EXITPRESOLVE
5775  * - \ref SCIP_STAGE_PRESOLVED
5776  * - \ref SCIP_STAGE_SOLVING
5777  */
5778 extern
5780  SCIP* scip, /**< SCIP data structure */
5781  SCIP_VAR* var /**< variable to add */
5782  );
5783 
5784 /** adds variable to the problem and uses it as pricing candidate to enter the LP
5785  *
5786  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5787  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5788  *
5789  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
5790  */
5791 extern
5793  SCIP* scip, /**< SCIP data structure */
5794  SCIP_VAR* var, /**< variable to add */
5795  SCIP_Real score /**< pricing score of variable (the larger, the better the variable) */
5796  );
5797 
5798 /** removes variable from the problem
5799  *
5800  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5801  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5802  *
5803  * @pre This method can be called if @p scip is in one of the following stages:
5804  * - \ref SCIP_STAGE_PROBLEM
5805  * - \ref SCIP_STAGE_TRANSFORMING
5806  * - \ref SCIP_STAGE_TRANSFORMED
5807  * - \ref SCIP_STAGE_PRESOLVING
5808  * - \ref SCIP_STAGE_FREETRANS
5809  */
5810 extern
5812  SCIP* scip, /**< SCIP data structure */
5813  SCIP_VAR* var, /**< variable to delete */
5814  SCIP_Bool* deleted /**< pointer to store whether variable was successfully marked to be deleted */
5815  );
5816 
5817 /** gets variables of the problem along with the numbers of different variable types; data may become invalid after
5818  * calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5819  *
5820  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5821  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5822  *
5823  * @pre This method can be called if @p scip is in one of the following stages:
5824  * - \ref SCIP_STAGE_PROBLEM
5825  * - \ref SCIP_STAGE_TRANSFORMED
5826  * - \ref SCIP_STAGE_INITPRESOLVE
5827  * - \ref SCIP_STAGE_PRESOLVING
5828  * - \ref SCIP_STAGE_EXITPRESOLVE
5829  * - \ref SCIP_STAGE_PRESOLVED
5830  * - \ref SCIP_STAGE_INITSOLVE
5831  * - \ref SCIP_STAGE_SOLVING
5832  * - \ref SCIP_STAGE_SOLVED
5833  * - \ref SCIP_STAGE_EXITSOLVE
5834  *
5835  * @note Variables in the vars array are ordered: binaries first, then integers, implicit integers and continuous last.
5836  */
5837 extern
5839  SCIP* scip, /**< SCIP data structure */
5840  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5841  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5842  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5843  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5844  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5845  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5846  );
5847 
5848 /** gets array with active problem variables
5849  *
5850  * @return array with active problem variables
5851  *
5852  * @pre This method can be called if @p scip is in one of the following stages:
5853  * - \ref SCIP_STAGE_PROBLEM
5854  * - \ref SCIP_STAGE_TRANSFORMED
5855  * - \ref SCIP_STAGE_INITPRESOLVE
5856  * - \ref SCIP_STAGE_PRESOLVING
5857  * - \ref SCIP_STAGE_EXITPRESOLVE
5858  * - \ref SCIP_STAGE_PRESOLVED
5859  * - \ref SCIP_STAGE_INITSOLVE
5860  * - \ref SCIP_STAGE_SOLVING
5861  * - \ref SCIP_STAGE_SOLVED
5862  * - \ref SCIP_STAGE_EXITSOLVE
5863  *
5864  * @warning If your are using the methods which add or change bound of variables (e.g., SCIPchgVarType(), SCIPfixVar(),
5865  * SCIPaggregateVars(), and SCIPmultiaggregateVar()), it can happen that the internal variable array (which is
5866  * accessed via this method) gets resized and/or resorted. This can invalid the data pointer which is returned
5867  * by this method.
5868  *
5869  * @note Variables in the array are ordered: binaries first, then integers, implicit integers and continuous last.
5870  */
5871 extern
5873  SCIP* scip /**< SCIP data structure */
5874  );
5875 
5876 /** gets number of active problem variables
5877  *
5878  * @return the number of active problem variables
5879  *
5880  * @pre This method can be called if @p scip is in one of the following stages:
5881  * - \ref SCIP_STAGE_PROBLEM
5882  * - \ref SCIP_STAGE_TRANSFORMED
5883  * - \ref SCIP_STAGE_INITPRESOLVE
5884  * - \ref SCIP_STAGE_PRESOLVING
5885  * - \ref SCIP_STAGE_EXITPRESOLVE
5886  * - \ref SCIP_STAGE_PRESOLVED
5887  * - \ref SCIP_STAGE_INITSOLVE
5888  * - \ref SCIP_STAGE_SOLVING
5889  * - \ref SCIP_STAGE_SOLVED
5890  * - \ref SCIP_STAGE_EXITSOLVE
5891  */
5892 extern
5893 int SCIPgetNVars(
5894  SCIP* scip /**< SCIP data structure */
5895  );
5896 
5897 /** gets number of binary active problem variables
5898  *
5899  * @return the number of binary active problem variables
5900  *
5901  * @pre This method can be called if @p scip is in one of the following stages:
5902  * - \ref SCIP_STAGE_PROBLEM
5903  * - \ref SCIP_STAGE_TRANSFORMED
5904  * - \ref SCIP_STAGE_INITPRESOLVE
5905  * - \ref SCIP_STAGE_PRESOLVING
5906  * - \ref SCIP_STAGE_EXITPRESOLVE
5907  * - \ref SCIP_STAGE_PRESOLVED
5908  * - \ref SCIP_STAGE_INITSOLVE
5909  * - \ref SCIP_STAGE_SOLVING
5910  * - \ref SCIP_STAGE_SOLVED
5911  * - \ref SCIP_STAGE_EXITSOLVE
5912  */
5913 extern
5914 int SCIPgetNBinVars(
5915  SCIP* scip /**< SCIP data structure */
5916  );
5917 
5918 /** gets number of integer active problem variables
5919  *
5920  * @return the number of integer active problem variables
5921  *
5922  * @pre This method can be called if @p scip is in one of the following stages:
5923  * - \ref SCIP_STAGE_PROBLEM
5924  * - \ref SCIP_STAGE_TRANSFORMED
5925  * - \ref SCIP_STAGE_INITPRESOLVE
5926  * - \ref SCIP_STAGE_PRESOLVING
5927  * - \ref SCIP_STAGE_EXITPRESOLVE
5928  * - \ref SCIP_STAGE_PRESOLVED
5929  * - \ref SCIP_STAGE_INITSOLVE
5930  * - \ref SCIP_STAGE_SOLVING
5931  * - \ref SCIP_STAGE_SOLVED
5932  * - \ref SCIP_STAGE_EXITSOLVE
5933  */
5934 extern
5935 int SCIPgetNIntVars(
5936  SCIP* scip /**< SCIP data structure */
5937  );
5938 
5939 /** gets number of implicit integer active problem variables
5940  *
5941  * @return the number of implicit integer active problem variables
5942  *
5943  * @pre This method can be called if @p scip is in one of the following stages:
5944  * - \ref SCIP_STAGE_PROBLEM
5945  * - \ref SCIP_STAGE_TRANSFORMED
5946  * - \ref SCIP_STAGE_INITPRESOLVE
5947  * - \ref SCIP_STAGE_PRESOLVING
5948  * - \ref SCIP_STAGE_EXITPRESOLVE
5949  * - \ref SCIP_STAGE_PRESOLVED
5950  * - \ref SCIP_STAGE_INITSOLVE
5951  * - \ref SCIP_STAGE_SOLVING
5952  * - \ref SCIP_STAGE_SOLVED
5953  * - \ref SCIP_STAGE_EXITSOLVE
5954  */
5955 extern
5956 int SCIPgetNImplVars(
5957  SCIP* scip /**< SCIP data structure */
5958  );
5959 
5960 /** gets number of continuous active problem variables
5961  *
5962  * @return the number of continuous active problem variables
5963  *
5964  * @pre This method can be called if @p scip is in one of the following stages:
5965  * - \ref SCIP_STAGE_PROBLEM
5966  * - \ref SCIP_STAGE_TRANSFORMED
5967  * - \ref SCIP_STAGE_INITPRESOLVE
5968  * - \ref SCIP_STAGE_PRESOLVING
5969  * - \ref SCIP_STAGE_EXITPRESOLVE
5970  * - \ref SCIP_STAGE_PRESOLVED
5971  * - \ref SCIP_STAGE_INITSOLVE
5972  * - \ref SCIP_STAGE_SOLVING
5973  * - \ref SCIP_STAGE_SOLVED
5974  * - \ref SCIP_STAGE_EXITSOLVE
5975  */
5976 extern
5977 int SCIPgetNContVars(
5978  SCIP* scip /**< SCIP data structure */
5979  );
5980 
5981 /** gets number of active problem variables with a non-zero objective coefficient
5982  *
5983  * @note In case of the original problem the number of variables is counted. In case of the transformed problem the
5984  * number of variables is just returned since it is stored internally
5985  *
5986  * @return the number of active problem variables with a non-zero objective coefficient
5987  *
5988  * @pre This method can be called if @p scip is in one of the following stages:
5989  * - \ref SCIP_STAGE_PROBLEM
5990  * - \ref SCIP_STAGE_TRANSFORMED
5991  * - \ref SCIP_STAGE_INITPRESOLVE
5992  * - \ref SCIP_STAGE_PRESOLVING
5993  * - \ref SCIP_STAGE_EXITPRESOLVE
5994  * - \ref SCIP_STAGE_PRESOLVED
5995  * - \ref SCIP_STAGE_INITSOLVE
5996  * - \ref SCIP_STAGE_SOLVING
5997  * - \ref SCIP_STAGE_SOLVED
5998  */
5999 extern
6000 int SCIPgetNObjVars(
6001  SCIP* scip /**< SCIP data structure */
6002  );
6003 
6004 /** gets array with fixed and aggregated problem variables; data may become invalid after
6005  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
6006  *
6007  * @return an array with fixed and aggregated problem variables; data may become invalid after
6008  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
6009  *
6010  * @pre This method can be called if @p scip is in one of the following stages:
6011  * - \ref SCIP_STAGE_PROBLEM
6012  * - \ref SCIP_STAGE_TRANSFORMED
6013  * - \ref SCIP_STAGE_INITPRESOLVE
6014  * - \ref SCIP_STAGE_PRESOLVING
6015  * - \ref SCIP_STAGE_EXITPRESOLVE
6016  * - \ref SCIP_STAGE_PRESOLVED
6017  * - \ref SCIP_STAGE_INITSOLVE
6018  * - \ref SCIP_STAGE_SOLVING
6019  * - \ref SCIP_STAGE_SOLVED
6020  */
6021 extern
6023  SCIP* scip /**< SCIP data structure */
6024  );
6025 
6026 /** gets number of fixed or aggregated problem variables
6027  *
6028  * @return the number of fixed or aggregated problem variables
6029  *
6030  * @pre This method can be called if @p scip is in one of the following stages:
6031  * - \ref SCIP_STAGE_PROBLEM
6032  * - \ref SCIP_STAGE_TRANSFORMED
6033  * - \ref SCIP_STAGE_INITPRESOLVE
6034  * - \ref SCIP_STAGE_PRESOLVING
6035  * - \ref SCIP_STAGE_EXITPRESOLVE
6036  * - \ref SCIP_STAGE_PRESOLVED
6037  * - \ref SCIP_STAGE_INITSOLVE
6038  * - \ref SCIP_STAGE_SOLVING
6039  * - \ref SCIP_STAGE_SOLVED
6040  */
6041 extern
6042 int SCIPgetNFixedVars(
6043  SCIP* scip /**< SCIP data structure */
6044  );
6045 
6046 /** gets variables of the original problem along with the numbers of different variable types; data may become invalid
6047  * after a call to SCIPchgVarType()
6048  *
6049  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6050  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6051  *
6052  * @pre This method can be called if @p scip is in one of the following stages:
6053  * - \ref SCIP_STAGE_PROBLEM
6054  * - \ref SCIP_STAGE_TRANSFORMING
6055  * - \ref SCIP_STAGE_TRANSFORMED
6056  * - \ref SCIP_STAGE_INITPRESOLVE
6057  * - \ref SCIP_STAGE_PRESOLVING
6058  * - \ref SCIP_STAGE_EXITPRESOLVE
6059  * - \ref SCIP_STAGE_PRESOLVED
6060  * - \ref SCIP_STAGE_INITSOLVE
6061  * - \ref SCIP_STAGE_SOLVING
6062  * - \ref SCIP_STAGE_SOLVED
6063  * - \ref SCIP_STAGE_EXITSOLVE
6064  * - \ref SCIP_STAGE_FREETRANS
6065  */
6066 extern
6068  SCIP* scip, /**< SCIP data structure */
6069  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
6070  int* nvars, /**< pointer to store number of variables or NULL if not needed */
6071  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
6072  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
6073  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
6074  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
6075  );
6076 
6077 /** gets array with original problem variables; data may become invalid after
6078  * a call to SCIPchgVarType()
6079  *
6080  * @return an array with original problem variables; data may become invalid after
6081  * a call to SCIPchgVarType()
6082  *
6083  * @pre This method can be called if @p scip is in one of the following stages:
6084  * - \ref SCIP_STAGE_PROBLEM
6085  * - \ref SCIP_STAGE_TRANSFORMING
6086  * - \ref SCIP_STAGE_TRANSFORMED
6087  * - \ref SCIP_STAGE_INITPRESOLVE
6088  * - \ref SCIP_STAGE_PRESOLVING
6089  * - \ref SCIP_STAGE_EXITPRESOLVE
6090  * - \ref SCIP_STAGE_PRESOLVED
6091  * - \ref SCIP_STAGE_INITSOLVE
6092  * - \ref SCIP_STAGE_SOLVING
6093  * - \ref SCIP_STAGE_SOLVED
6094  * - \ref SCIP_STAGE_EXITSOLVE
6095  * - \ref SCIP_STAGE_FREETRANS
6096  */
6097 extern
6099  SCIP* scip /**< SCIP data structure */
6100  );
6101 
6102 /** gets number of original problem variables
6103  *
6104  * @return the number of original problem variables
6105  *
6106  * @pre This method can be called if @p scip is in one of the following stages:
6107  * - \ref SCIP_STAGE_PROBLEM
6108  * - \ref SCIP_STAGE_TRANSFORMING
6109  * - \ref SCIP_STAGE_TRANSFORMED
6110  * - \ref SCIP_STAGE_INITPRESOLVE
6111  * - \ref SCIP_STAGE_PRESOLVING
6112  * - \ref SCIP_STAGE_EXITPRESOLVE
6113  * - \ref SCIP_STAGE_PRESOLVED
6114  * - \ref SCIP_STAGE_INITSOLVE
6115  * - \ref SCIP_STAGE_SOLVING
6116  * - \ref SCIP_STAGE_SOLVED
6117  * - \ref SCIP_STAGE_EXITSOLVE
6118  * - \ref SCIP_STAGE_FREETRANS
6119  */
6120 extern
6121 int SCIPgetNOrigVars(
6122  SCIP* scip /**< SCIP data structure */
6123  );
6124 
6125 /** gets number of binary variables in the original problem
6126  *
6127  * @return the number of binary variables in the original problem
6128  *
6129  * @pre This method can be called if @p scip is in one of the following stages:
6130  * - \ref SCIP_STAGE_PROBLEM
6131  * - \ref SCIP_STAGE_TRANSFORMING
6132  * - \ref SCIP_STAGE_TRANSFORMED
6133  * - \ref SCIP_STAGE_INITPRESOLVE
6134  * - \ref SCIP_STAGE_PRESOLVING
6135  * - \ref SCIP_STAGE_EXITPRESOLVE
6136  * - \ref SCIP_STAGE_PRESOLVED
6137  * - \ref SCIP_STAGE_INITSOLVE
6138  * - \ref SCIP_STAGE_SOLVING
6139  * - \ref SCIP_STAGE_SOLVED
6140  * - \ref SCIP_STAGE_EXITSOLVE
6141  * - \ref SCIP_STAGE_FREETRANS
6142  */
6143 extern
6145  SCIP* scip /**< SCIP data structure */
6146  );
6147 
6148 /** gets the number of integer variables in the original problem
6149  *
6150  * @return the number of integer variables in the original problem
6151  *
6152  * @pre This method can be called if @p scip is in one of the following stages:
6153  * - \ref SCIP_STAGE_PROBLEM
6154  * - \ref SCIP_STAGE_TRANSFORMING
6155  * - \ref SCIP_STAGE_TRANSFORMED
6156  * - \ref SCIP_STAGE_INITPRESOLVE
6157  * - \ref SCIP_STAGE_PRESOLVING
6158  * - \ref SCIP_STAGE_EXITPRESOLVE
6159  * - \ref SCIP_STAGE_PRESOLVED
6160  * - \ref SCIP_STAGE_INITSOLVE
6161  * - \ref SCIP_STAGE_SOLVING
6162  * - \ref SCIP_STAGE_SOLVED
6163  * - \ref SCIP_STAGE_EXITSOLVE
6164  * - \ref SCIP_STAGE_FREETRANS
6165  */
6166 extern
6168  SCIP* scip /**< SCIP data structure */
6169  );
6170 
6171 /** gets number of implicit integer variables in the original problem
6172  *
6173  * @return the number of implicit integer variables in the original problem
6174  *
6175  * @pre This method can be called if @p scip is in one of the following stages:
6176  * - \ref SCIP_STAGE_PROBLEM
6177  * - \ref SCIP_STAGE_TRANSFORMING
6178  * - \ref SCIP_STAGE_TRANSFORMED
6179  * - \ref SCIP_STAGE_INITPRESOLVE
6180  * - \ref SCIP_STAGE_PRESOLVING
6181  * - \ref SCIP_STAGE_EXITPRESOLVE
6182  * - \ref SCIP_STAGE_PRESOLVED
6183  * - \ref SCIP_STAGE_INITSOLVE
6184  * - \ref SCIP_STAGE_SOLVING
6185  * - \ref SCIP_STAGE_SOLVED
6186  * - \ref SCIP_STAGE_EXITSOLVE
6187  * - \ref SCIP_STAGE_FREETRANS
6188  */
6189 extern
6191  SCIP* scip /**< SCIP data structure */
6192  );
6193 
6194 /** gets number of continuous variables in the original problem
6195  *
6196  * @return the number of continuous variables in the original problem
6197  *
6198  * @pre This method can be called if @p scip is in one of the following stages:
6199  * - \ref SCIP_STAGE_PROBLEM
6200  * - \ref SCIP_STAGE_TRANSFORMING
6201  * - \ref SCIP_STAGE_TRANSFORMED
6202  * - \ref SCIP_STAGE_INITPRESOLVE
6203  * - \ref SCIP_STAGE_PRESOLVING
6204  * - \ref SCIP_STAGE_EXITPRESOLVE
6205  * - \ref SCIP_STAGE_PRESOLVED
6206  * - \ref SCIP_STAGE_INITSOLVE
6207  * - \ref SCIP_STAGE_SOLVING
6208  * - \ref SCIP_STAGE_SOLVED
6209  * - \ref SCIP_STAGE_EXITSOLVE
6210  * - \ref SCIP_STAGE_FREETRANS
6211  */
6212 extern
6214  SCIP* scip /**< SCIP data structure */
6215  );
6216 
6217 /** gets number of all problem variables created during creation and solving of problem;
6218  * this includes also variables that were deleted in the meantime
6219  *
6220  * @return the number of all problem variables created during creation and solving of problem;
6221  * this includes also variables that were deleted in the meantime
6222  *
6223  * @pre This method can be called if @p scip is in one of the following stages:
6224  * - \ref SCIP_STAGE_PROBLEM
6225  * - \ref SCIP_STAGE_TRANSFORMING
6226  * - \ref SCIP_STAGE_TRANSFORMED
6227  * - \ref SCIP_STAGE_INITPRESOLVE
6228  * - \ref SCIP_STAGE_PRESOLVING
6229  * - \ref SCIP_STAGE_EXITPRESOLVE
6230  * - \ref SCIP_STAGE_PRESOLVED
6231  * - \ref SCIP_STAGE_INITSOLVE
6232  * - \ref SCIP_STAGE_SOLVING
6233  * - \ref SCIP_STAGE_SOLVED
6234  * - \ref SCIP_STAGE_EXITSOLVE
6235  * - \ref SCIP_STAGE_FREETRANS
6236  */
6237 extern
6238 int SCIPgetNTotalVars(
6239  SCIP* scip /**< SCIP data structure */
6240  );
6241 
6242 /** gets variables of the original or transformed problem along with the numbers of different variable types;
6243  * the returned problem space (original or transformed) corresponds to the given solution;
6244  * data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and
6245  * SCIPmultiaggregateVar()
6246  *
6247  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6248  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6249  *
6250  * @pre This method can be called if @p scip is in one of the following stages:
6251  * - \ref SCIP_STAGE_PROBLEM
6252  * - \ref SCIP_STAGE_TRANSFORMED
6253  * - \ref SCIP_STAGE_INITPRESOLVE
6254  * - \ref SCIP_STAGE_PRESOLVING
6255  * - \ref SCIP_STAGE_EXITPRESOLVE
6256  * - \ref SCIP_STAGE_PRESOLVED
6257  * - \ref SCIP_STAGE_INITSOLVE
6258  * - \ref SCIP_STAGE_SOLVING
6259  * - \ref SCIP_STAGE_SOLVED
6260  */
6261 extern
6263  SCIP* scip, /**< SCIP data structure */
6264  SCIP_SOL* sol, /**< primal solution that selects the problem space, NULL for current solution */
6265  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
6266  int* nvars, /**< pointer to store number of variables or NULL if not needed */
6267  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
6268  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
6269  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
6270  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
6271  );
6272 
6273 /** returns variable of given name in the problem, or NULL if not existing
6274  *
6275  * @return variable of given name in the problem, or NULL if not existing
6276  *
6277  * @pre This method can be called if @p scip is in one of the following stages:
6278  * - \ref SCIP_STAGE_PROBLEM
6279  * - \ref SCIP_STAGE_TRANSFORMING
6280  * - \ref SCIP_STAGE_TRANSFORMED
6281  * - \ref SCIP_STAGE_INITPRESOLVE
6282  * - \ref SCIP_STAGE_PRESOLVING
6283  * - \ref SCIP_STAGE_EXITPRESOLVE
6284  * - \ref SCIP_STAGE_PRESOLVED
6285  * - \ref SCIP_STAGE_INITSOLVE
6286  * - \ref SCIP_STAGE_SOLVING
6287  * - \ref SCIP_STAGE_SOLVED
6288  * - \ref SCIP_STAGE_EXITSOLVE
6289  * - \ref SCIP_STAGE_FREETRANS
6290  */
6291 extern
6293  SCIP* scip, /**< SCIP data structure */
6294  const char* name /**< name of variable to find */
6295  );
6296 
6297 /** returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables,
6298  * that will be added in pricing and improve the objective value
6299  *
6300  * @return TRUE, if all potential variables exist in the problem; FALSE, otherwise
6301  *
6302  * @pre This method can be called if @p scip is in one of the following stages:
6303  * - \ref SCIP_STAGE_TRANSFORMING
6304  * - \ref SCIP_STAGE_TRANSFORMED
6305  * - \ref SCIP_STAGE_INITPRESOLVE
6306  * - \ref SCIP_STAGE_PRESOLVING
6307  * - \ref SCIP_STAGE_EXITPRESOLVE
6308  * - \ref SCIP_STAGE_PRESOLVED
6309  * - \ref SCIP_STAGE_INITSOLVE
6310  * - \ref SCIP_STAGE_SOLVING
6311  * - \ref SCIP_STAGE_SOLVED
6312  * - \ref SCIP_STAGE_EXITSOLVE
6313  * - \ref SCIP_STAGE_FREETRANS
6314  */
6315 extern
6317  SCIP* scip /**< SCIP data structure */
6318  );
6319 
6320 /** adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the
6321  * current node (and all of its subnodes); otherwise it is added to the global problem;
6322  * if a local constraint is added at the root node, it is automatically upgraded into a global constraint
6323  *
6324  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6325  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6326  *
6327  * @pre This method can be called if @p scip is in one of the following stages:
6328  * - \ref SCIP_STAGE_PROBLEM
6329  * - \ref SCIP_STAGE_INITPRESOLVE
6330  * - \ref SCIP_STAGE_PRESOLVING
6331  * - \ref SCIP_STAGE_EXITPRESOLVE
6332  * - \ref SCIP_STAGE_PRESOLVED
6333  * - \ref SCIP_STAGE_INITSOLVE
6334  * - \ref SCIP_STAGE_SOLVING
6335  * - \ref SCIP_STAGE_EXITSOLVE
6336  */
6337 extern
6339  SCIP* scip, /**< SCIP data structure */
6340  SCIP_CONS* cons /**< constraint to add */
6341  );
6342 
6343 /** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
6344  * node, where it was added, or from the problem, if it was a problem constraint
6345  *
6346  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6347  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6348  *
6349  * @pre This method can be called if @p scip is in one of the following stages:
6350  * - \ref SCIP_STAGE_PROBLEM
6351  * - \ref SCIP_STAGE_INITPRESOLVE
6352  * - \ref SCIP_STAGE_PRESOLVING
6353  * - \ref SCIP_STAGE_EXITPRESOLVE
6354  * - \ref SCIP_STAGE_INITSOLVE
6355  * - \ref SCIP_STAGE_SOLVING
6356  * - \ref SCIP_STAGE_EXITSOLVE
6357  */
6358 extern
6360  SCIP* scip, /**< SCIP data structure */
6361  SCIP_CONS* cons /**< constraint to delete */
6362  );
6363 
6364 /** returns original constraint of given name in the problem, or NULL if not existing
6365  *
6366  * @return original constraint of given name in the problem, or NULL if not existing
6367  *
6368  * @pre This method can be called if @p scip is in one of the following stages:
6369  * - \ref SCIP_STAGE_PROBLEM
6370  * - \ref SCIP_STAGE_TRANSFORMING
6371  * - \ref SCIP_STAGE_TRANSFORMED
6372  * - \ref SCIP_STAGE_INITPRESOLVE
6373  * - \ref SCIP_STAGE_PRESOLVING
6374  * - \ref SCIP_STAGE_EXITPRESOLVE
6375  * - \ref SCIP_STAGE_INITSOLVE
6376  * - \ref SCIP_STAGE_SOLVING
6377  * - \ref SCIP_STAGE_SOLVED
6378  * - \ref SCIP_STAGE_EXITSOLVE
6379  * - \ref SCIP_STAGE_FREETRANS */
6380 extern
6382  SCIP* scip, /**< SCIP data structure */
6383  const char* name /**< name of constraint to find */
6384  );
6385 
6386 /** returns constraint of given name in the problem, or NULL if not existing
6387  *
6388  * @return constraint of given name in the problem, or NULL if not existing
6389  *
6390  * @pre This method can be called if @p scip is in one of the following stages:
6391  * - \ref SCIP_STAGE_PROBLEM
6392  * - \ref SCIP_STAGE_TRANSFORMING
6393  * - \ref SCIP_STAGE_TRANSFORMED
6394  * - \ref SCIP_STAGE_INITPRESOLVE
6395  * - \ref SCIP_STAGE_PRESOLVING
6396  * - \ref SCIP_STAGE_EXITPRESOLVE
6397  * - \ref SCIP_STAGE_PRESOLVED
6398  * - \ref SCIP_STAGE_INITSOLVE
6399  * - \ref SCIP_STAGE_SOLVING
6400  * - \ref SCIP_STAGE_SOLVED
6401  * - \ref SCIP_STAGE_EXITSOLVE
6402  * - \ref SCIP_STAGE_FREETRANS
6403  */
6404 extern
6406  SCIP* scip, /**< SCIP data structure */
6407  const char* name /**< name of constraint to find */
6408  );
6409 
6410 /** gets number of upgraded constraints
6411  *
6412  * @return number of upgraded constraints
6413  *
6414  * @pre This method can be called if @p scip is in one of the following stages:
6415  * - \ref SCIP_STAGE_PROBLEM
6416  * - \ref SCIP_STAGE_TRANSFORMED
6417  * - \ref SCIP_STAGE_INITPRESOLVE
6418  * - \ref SCIP_STAGE_PRESOLVING
6419  * - \ref SCIP_STAGE_PRESOLVED
6420  * - \ref SCIP_STAGE_EXITPRESOLVE
6421  * - \ref SCIP_STAGE_SOLVING
6422  * - \ref SCIP_STAGE_SOLVED
6423  */
6424 extern
6425 int SCIPgetNUpgrConss(
6426  SCIP* scip /**< SCIP data structure */
6427  );
6428 
6429 /** gets total number of globally valid constraints currently in the problem
6430  *
6431  * @return total number of globally valid constraints currently in the problem
6432  *
6433  * @pre This method can be called if @p scip is in one of the following stages:
6434  * - \ref SCIP_STAGE_PROBLEM
6435  * - \ref SCIP_STAGE_TRANSFORMED
6436  * - \ref SCIP_STAGE_INITPRESOLVE
6437  * - \ref SCIP_STAGE_PRESOLVING
6438  * - \ref SCIP_STAGE_EXITPRESOLVE
6439  * - \ref SCIP_STAGE_PRESOLVED
6440  * - \ref SCIP_STAGE_INITSOLVE
6441  * - \ref SCIP_STAGE_SOLVING
6442  * - \ref SCIP_STAGE_SOLVED
6443  */
6444 extern
6445 int SCIPgetNConss(
6446  SCIP* scip /**< SCIP data structure */
6447  );
6448 
6449 /** gets array of globally valid constraints currently in the problem
6450  *
6451  * @return array of globally valid constraints currently in the problem
6452  *
6453  * @pre This method can be called if @p scip is in one of the following stages:
6454  * - \ref SCIP_STAGE_PROBLEM
6455  * - \ref SCIP_STAGE_TRANSFORMED
6456  * - \ref SCIP_STAGE_INITPRESOLVE
6457  * - \ref SCIP_STAGE_PRESOLVING
6458  * - \ref SCIP_STAGE_EXITPRESOLVE
6459  * - \ref SCIP_STAGE_PRESOLVED
6460  * - \ref SCIP_STAGE_INITSOLVE
6461  * - \ref SCIP_STAGE_SOLVING
6462  * - \ref SCIP_STAGE_SOLVED
6463  *
6464  * @warning If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is
6465  * accessed via this method) gets resized. This can invalid the pointer which is returned by this method.
6466  */
6467 extern
6469  SCIP* scip /**< SCIP data structure */
6470  );
6471 
6472 /** gets total number of constraints in the original problem
6473  *
6474  * @return total number of constraints in the original problem
6475  *
6476  * @pre This method can be called if @p scip is in one of the following stages:
6477  * - \ref SCIP_STAGE_PROBLEM
6478  * - \ref SCIP_STAGE_TRANSFORMING
6479  * - \ref SCIP_STAGE_TRANSFORMED
6480  * - \ref SCIP_STAGE_INITPRESOLVE
6481  * - \ref SCIP_STAGE_PRESOLVING
6482  * - \ref SCIP_STAGE_EXITPRESOLVE
6483  * - \ref SCIP_STAGE_PRESOLVED
6484  * - \ref SCIP_STAGE_INITSOLVE
6485  * - \ref SCIP_STAGE_SOLVING
6486  * - \ref SCIP_STAGE_SOLVED
6487  * - \ref SCIP_STAGE_EXITSOLVE
6488  * - \ref SCIP_STAGE_FREETRANS
6489  */
6490 extern
6491 int SCIPgetNOrigConss(
6492  SCIP* scip /**< SCIP data structure */
6493  );
6494 
6495 /** gets array of constraints in the original problem
6496  *
6497  * @return array of constraints in the original problem
6498  *
6499  * @pre This method can be called if @p scip is in one of the following stages:
6500  * - \ref SCIP_STAGE_PROBLEM
6501  * - \ref SCIP_STAGE_TRANSFORMING
6502  * - \ref SCIP_STAGE_TRANSFORMED
6503  * - \ref SCIP_STAGE_INITPRESOLVE
6504  * - \ref SCIP_STAGE_PRESOLVING
6505  * - \ref SCIP_STAGE_EXITPRESOLVE
6506  * - \ref SCIP_STAGE_PRESOLVED
6507  * - \ref SCIP_STAGE_INITSOLVE
6508  * - \ref SCIP_STAGE_SOLVING
6509  * - \ref SCIP_STAGE_SOLVED
6510  * - \ref SCIP_STAGE_EXITSOLVE
6511  * - \ref SCIP_STAGE_FREETRANS
6512  */
6513 extern
6515  SCIP* scip /**< SCIP data structure */
6516  );
6517 
6518 /** computes the number of check constraint in the current node (loop over all constraint handler and cumulates the
6519  * number of check constraints)
6520  *
6521  * @return returns the number of check constraints
6522  *
6523  * @pre This method can be called if @p scip is in one of the following stages:
6524  * - \ref SCIP_STAGE_TRANSFORMED
6525  * - \ref SCIP_STAGE_INITPRESOLVE
6526  * - \ref SCIP_STAGE_PRESOLVING
6527  * - \ref SCIP_STAGE_EXITPRESOLVE
6528  * - \ref SCIP_STAGE_PRESOLVED
6529  * - \ref SCIP_STAGE_INITSOLVE
6530  * - \ref SCIP_STAGE_SOLVING
6531  */
6532 extern
6533 int SCIPgetNCheckConss(
6534  SCIP* scip /**< SCIP data structure */
6535  );
6536 
6537 /**@} */
6538 
6539 
6540 
6541 
6542 /*
6543  * local subproblem methods
6544  */
6545 
6546 /**@addtogroup LocalSubproblemMethods
6547  *
6548  * @{
6549  */
6550 
6551 /** adds a conflict to a given node or globally to the problem if @p node == NULL.
6552  *
6553  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6554  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6555  *
6556  * @pre this method can be called in one of the following stages of the SCIP solving process:
6557  * - \ref SCIP_STAGE_INITPRESOLVE
6558  * - \ref SCIP_STAGE_PRESOLVING
6559  * - \ref SCIP_STAGE_EXITPRESOLVE
6560  * - \ref SCIP_STAGE_SOLVING
6561  *
6562  * @note this method will release the constraint
6563  */
6564 extern
6566  SCIP* scip, /**< SCIP data structure */
6567  SCIP_NODE* node, /**< node to add conflict (or NULL if global) */
6568  SCIP_CONS* cons, /**< constraint representing the conflict */
6569  SCIP_NODE* validnode, /**< node at which the constraint is valid (or NULL) */
6570  SCIP_CONFTYPE conftype, /**< type of the conflict */
6571  SCIP_Bool iscutoffinvolved /**< is a cutoff bound involved in this conflict */
6572  );
6573 
6574 /** removes all conflicts depending on an old cutoff bound if the improvement of the incumbent is good enough
6575  *
6576  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6577  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6578  *
6579  * @pre this method can be called in one of the following stages of the SCIP solving process:
6580  * - \ref SCIP_STAGE_PRESOLVING
6581  * - \ref SCIP_STAGE_SOLVING
6582  */
6583 extern
6585  SCIP* scip, /**< SCIP data structure */
6586  SCIP_EVENT* event /**< event data */
6587  );
6588 
6589 /** adds constraint to the given node (and all of its subnodes), even if it is a global constraint;
6590  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
6591  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
6592  * only active in a small part of the tree although it is valid in a larger part.
6593  * In this case, one should pass the more global node where the constraint is valid as "validnode".
6594  * Note that the same constraint cannot be added twice to the branching tree with different "validnode" parameters.
6595  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
6596  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
6597  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
6598  *
6599  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6600  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6601  *
6602  * @pre this method can be called in one of the following stages of the SCIP solving process:
6603  * - \ref SCIP_STAGE_INITPRESOLVE
6604  * - \ref SCIP_STAGE_PRESOLVING
6605  * - \ref SCIP_STAGE_EXITPRESOLVE
6606  * - \ref SCIP_STAGE_SOLVING
6607  */
6608 extern
6610  SCIP* scip, /**< SCIP data structure */
6611  SCIP_NODE* node, /**< node to add constraint to */
6612  SCIP_CONS* cons, /**< constraint to add */
6613  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
6614  );
6615 
6616 /** adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint;
6617  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
6618  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
6619  * only active in a small part of the tree although it is valid in a larger part.
6620  *
6621  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
6622  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
6623  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
6624  *
6625  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6626  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6627  *
6628  * @pre this method can be called in one of the following stages of the SCIP solving process:
6629  * - \ref SCIP_STAGE_INITPRESOLVE
6630  * - \ref SCIP_STAGE_PRESOLVING
6631  * - \ref SCIP_STAGE_EXITPRESOLVE
6632  * - \ref SCIP_STAGE_SOLVING
6633  *
6634  * @note The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is
6635  * the case due internal data structures and performance issues. In such a case you should try to realize your
6636  * issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.
6637  */
6638 extern
6640  SCIP* scip, /**< SCIP data structure */
6641  SCIP_CONS* cons, /**< constraint to add */
6642  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
6643  );
6644 
6645 /** disables constraint's separation, enforcing, and propagation capabilities at the given node (and all subnodes);
6646  * if the method is called at the root node, the constraint is globally deleted from the problem;
6647  * the constraint deletion is being remembered at the given node, s.t. after leaving the node's subtree, the constraint
6648  * is automatically enabled again, and after entering the node's subtree, it is automatically disabled;
6649  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
6650  * alternatively, use SCIPdisableCons()
6651  *
6652  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6653  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6654  *
6655  * @pre this method can be called in one of the following stages of the SCIP solving process:
6656  * - \ref SCIP_STAGE_INITPRESOLVE
6657  * - \ref SCIP_STAGE_PRESOLVING
6658  * - \ref SCIP_STAGE_EXITPRESOLVE
6659  * - \ref SCIP_STAGE_SOLVING
6660  */
6661 extern
6663  SCIP* scip, /**< SCIP data structure */
6664  SCIP_NODE* node, /**< node to disable constraint in */
6665  SCIP_CONS* cons /**< constraint to locally delete */
6666  );
6667 
6668 /** disables constraint's separation, enforcing, and propagation capabilities at the current node (and all subnodes);
6669  * if the method is called during problem modification or at the root node, the constraint is globally deleted from
6670  * the problem;
6671  * the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the
6672  * constraint is automatically enabled again, and after reentering the current node's subtree, it is automatically
6673  * disabled again;
6674  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
6675  * alternatively, use SCIPdisableCons()
6676  *
6677  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6678  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6679  *
6680  * @pre this method can be called in one of the following stages of the SCIP solving process:
6681  * - \ref SCIP_STAGE_PROBLEM
6682  * - \ref SCIP_STAGE_INITPRESOLVE
6683  * - \ref SCIP_STAGE_PRESOLVING
6684  * - \ref SCIP_STAGE_EXITPRESOLVE
6685  * - \ref SCIP_STAGE_SOLVING
6686  */
6687 extern
6689  SCIP* scip, /**< SCIP data structure */
6690  SCIP_CONS* cons /**< constraint to locally delete */
6691  );
6692 
6693 /** gets estimate of best primal solution w.r.t. original problem contained in current subtree
6694  *
6695  * @return estimate of best primal solution w.r.t. original problem contained in current subtree
6696  *
6697  * @pre this method can be called in one of the following stages of the SCIP solving process:
6698  * - \ref SCIP_STAGE_SOLVING
6699  */
6700 extern
6702  SCIP* scip /**< SCIP data structure */
6703  );
6704 
6705 /** gets estimate of best primal solution w.r.t. transformed problem contained in current subtree
6706  *
6707  * @return estimate of best primal solution w.r.t. transformed problem contained in current subtree
6708  *
6709  * @pre this method can be called in one of the following stages of the SCIP solving process:
6710  * - \ref SCIP_STAGE_SOLVING
6711  */
6712 extern
6714  SCIP* scip /**< SCIP data structure */
6715  );
6716 
6717 /** gets dual bound of current node
6718  *
6719  * @return dual bound of current node
6720  *
6721  * @pre this method can be called in one of the following stages of the SCIP solving process:
6722  * - \ref SCIP_STAGE_SOLVING
6723  */
6724 extern
6726  SCIP* scip /**< SCIP data structure */
6727  );
6728 
6729 /** gets lower bound of current node in transformed problem
6730  *
6731  * @return lower bound of current node in transformed problem
6732  *
6733  * @pre this method can be called in one of the following stages of the SCIP solving process:
6734  * - \ref SCIP_STAGE_SOLVING
6735  */
6736 extern
6738  SCIP* scip /**< SCIP data structure */
6739  );
6740 
6741 /** gets dual bound of given node
6742  *
6743  * @return dual bound of a given node
6744  *
6745  * @pre this method can be called in one of the following stages of the SCIP solving process:
6746  * - \ref SCIP_STAGE_SOLVING
6747  */
6748 extern
6750  SCIP* scip, /**< SCIP data structure */
6751  SCIP_NODE* node /**< node to get dual bound for */
6752  );
6753 
6754 /** gets lower bound of given node in transformed problem
6755  *
6756  * @return lower bound of given node in transformed problem
6757  *
6758  * @pre this method can be called in one of the following stages of the SCIP solving process:
6759  * - \ref SCIP_STAGE_SOLVING
6760  */
6761 extern
6763  SCIP* scip, /**< SCIP data structure */
6764  SCIP_NODE* node /**< node to get dual bound for */
6765  );
6766 
6767 /** if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in
6768  * original problem space), sets the current node's dual bound to the new value
6769  *
6770  * @note the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.
6771  *
6772  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6773  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6774  *
6775  * @pre this method can be called in one of the following stages of the SCIP solving process:
6776  * - \ref SCIP_STAGE_PROBLEM
6777  * - \ref SCIP_STAGE_PRESOLVING
6778  * - \ref SCIP_STAGE_PRESOLVED
6779  * - \ref SCIP_STAGE_SOLVING
6780  */
6781 extern
6783  SCIP* scip, /**< SCIP data structure */
6784  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
6785  );
6786 
6787 /** if given value is larger than the current node's lower bound (in transformed problem), sets the current node's
6788  * lower bound to the new value
6789  *
6790  * @note the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.
6791  *
6792  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6793  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6794  *
6795  * @pre this method can be called in one of the following stages of the SCIP solving process:
6796  * - \ref SCIP_STAGE_PRESOLVING
6797  * - \ref SCIP_STAGE_PRESOLVED
6798  * - \ref SCIP_STAGE_SOLVING
6799  */
6800 extern
6802  SCIP* scip, /**< SCIP data structure */
6803  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
6804  );
6805 
6806 /** if given value is tighter (larger for minimization, smaller for maximization) than the node's dual bound,
6807  * sets the node's dual bound to the new value
6808  *
6809  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6810  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6811  *
6812  * @pre this method can be called in one of the following stages of the SCIP solving process:
6813  * - \ref SCIP_STAGE_SOLVING
6814  */
6815 extern
6817  SCIP* scip, /**< SCIP data structure */
6818  SCIP_NODE* node, /**< node to update dual bound for */
6819  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
6820  );
6821 
6822 /** if given value is larger than the node's lower bound (in transformed problem), sets the node's lower bound
6823  * to the new value
6824  *
6825  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6826  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6827  *
6828  * @pre this method can be called in one of the following stages of the SCIP solving process:
6829  * - \ref SCIP_STAGE_SOLVING
6830  */
6831 extern
6833  SCIP* scip, /**< SCIP data structure */
6834  SCIP_NODE* node, /**< node to update lower bound for */
6835  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
6836  );
6837 
6838 /** change the node selection priority of the given child
6839  *
6840  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6841  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6842  *
6843  * @pre this method can be called in one of the following stages of the SCIP solving process:
6844  * - \ref SCIP_STAGE_SOLVING
6845  */
6846 extern
6848  SCIP* scip, /**< SCIP data structure */
6849  SCIP_NODE* child, /**< child to update the node selection priority */
6850  SCIP_Real priority /**< node selection priority value */
6851  );
6852 
6853 /**@} */
6854 
6855 
6856 
6857 
6858 /*
6859  * solve methods
6860  */
6861 
6862 /**@addtogroup PublicSolveMethods
6863  *
6864  * @{
6865  */
6866 
6867 /** initializes solving data structures and transforms problem
6868  *
6869  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6870  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6871  *
6872  * @pre This method can be called if @p scip is in one of the following stages:
6873  * - \ref SCIP_STAGE_PROBLEM
6874  * - \ref SCIP_STAGE_TRANSFORMED
6875  * - \ref SCIP_STAGE_INITPRESOLVE
6876  * - \ref SCIP_STAGE_PRESOLVING
6877  * - \ref SCIP_STAGE_EXITPRESOLVE
6878  * - \ref SCIP_STAGE_PRESOLVED
6879  * - \ref SCIP_STAGE_INITSOLVE
6880  * - \ref SCIP_STAGE_SOLVING
6881  * - \ref SCIP_STAGE_SOLVED
6882  * - \ref SCIP_STAGE_EXITSOLVE
6883  * - \ref SCIP_STAGE_FREETRANS
6884  * - \ref SCIP_STAGE_FREE
6885  *
6886  * @post When calling this method in the \ref SCIP_STAGE_PROBLEM stage, the \SCIP stage is changed to \ref
6887  * SCIP_STAGE_TRANSFORMED; otherwise, the stage is not changed
6888  *
6889  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6890  */
6891 extern
6893  SCIP* scip /**< SCIP data structure */
6894  );
6895 
6896 /** transforms and presolves problem
6897  *
6898  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6899  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6900  *
6901  * @pre This method can be called if @p scip is in one of the following stages:
6902  * - \ref SCIP_STAGE_PROBLEM
6903  * - \ref SCIP_STAGE_TRANSFORMED
6904  * - \ref SCIP_STAGE_PRESOLVING
6905  * - \ref SCIP_STAGE_PRESOLVED
6906  *
6907  * @post After calling this method \SCIP reaches one of the following stages:
6908  * - \ref SCIP_STAGE_PRESOLVING if the presolving process was interrupted
6909  * - \ref SCIP_STAGE_PRESOLVED if the presolving process was finished and did not solve the problem
6910  * - \ref SCIP_STAGE_SOLVED if the problem was solved during presolving
6911  *
6912  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6913  */
6914 extern
6916  SCIP* scip /**< SCIP data structure */
6917  );
6918 
6919 /** transforms, presolves, and solves problem
6920  *
6921  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6922  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6923  *
6924  * @pre This method can be called if @p scip is in one of the following stages:
6925  * - \ref SCIP_STAGE_PROBLEM
6926  * - \ref SCIP_STAGE_TRANSFORMED
6927  * - \ref SCIP_STAGE_PRESOLVING
6928  * - \ref SCIP_STAGE_PRESOLVED
6929  * - \ref SCIP_STAGE_SOLVING
6930  * - \ref SCIP_STAGE_SOLVED
6931  *
6932  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
6933  * process was interrupted:
6934 
6935  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
6936  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
6937  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
6938  *
6939  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6940  */
6941 extern
6943  SCIP* scip /**< SCIP data structure */
6944  );
6945 
6946 /** transforms, presolves, and solves problem using additional solvers which emphasize on
6947  * finding solutions.
6948  *
6949  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6950  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6951  *
6952  * @pre This method can be called if @p scip is in one of the following stages:
6953  * - \ref SCIP_STAGE_PROBLEM
6954  * - \ref SCIP_STAGE_TRANSFORMED
6955  * - \ref SCIP_STAGE_PRESOLVING
6956  * - \ref SCIP_STAGE_PRESOLVED
6957  * - \ref SCIP_STAGE_SOLVING
6958  * - \ref SCIP_STAGE_SOLVED
6959  *
6960  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
6961  * process was interrupted:
6962  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
6963  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
6964  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
6965  *
6966  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6967  *
6968  * @deprecated Please use SCIPsolveConcurrent() instead.
6969  */
6970 extern
6972  SCIP* scip /**< SCIP data structure */
6973  );
6974 
6975 /** transforms, presolves, and solves problem using additional solvers which emphasize on
6976  * finding solutions.
6977  *
6978  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6979  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6980  *
6981  * @pre This method can be called if @p scip is in one of the following stages:
6982  * - \ref SCIP_STAGE_PROBLEM
6983  * - \ref SCIP_STAGE_TRANSFORMED
6984  * - \ref SCIP_STAGE_PRESOLVING
6985  * - \ref SCIP_STAGE_PRESOLVED
6986  * - \ref SCIP_STAGE_SOLVING
6987  * - \ref SCIP_STAGE_SOLVED
6988  *
6989  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
6990  * process was interrupted:
6991  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
6992  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
6993  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
6994  *
6995  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6996  */
6997 extern
6999  SCIP* scip /**< SCIP data structure */
7000  );
7001 
7002 /** frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is
7003  * preserved
7004  *
7005  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7006  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7007  *
7008  * @pre This method can be called if @p scip is in one of the following stages:
7009  * - \ref SCIP_STAGE_INIT
7010  * - \ref SCIP_STAGE_PROBLEM
7011  * - \ref SCIP_STAGE_TRANSFORMED
7012  * - \ref SCIP_STAGE_PRESOLVING
7013  * - \ref SCIP_STAGE_PRESOLVED
7014  * - \ref SCIP_STAGE_SOLVING
7015  * - \ref SCIP_STAGE_SOLVED
7016  *
7017  * @post If this method is called in \SCIP stage \ref SCIP_STAGE_INIT or \ref SCIP_STAGE_PROBLEM, the stage of
7018  * \SCIP is not changed; otherwise, the \SCIP stage is changed to \ref SCIP_STAGE_TRANSFORMED
7019  *
7020  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
7021  */
7022 extern
7024  SCIP* scip, /**< SCIP data structure */
7025  SCIP_Bool restart /**< should certain data be preserved for improved restarting? */
7026  );
7027 
7028 /** frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is
7029  * preserved
7030  *
7031  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7032  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7033  *
7034  * @pre This method can be called if @p scip is in one of the following stages:
7035  * - \ref SCIP_STAGE_INIT
7036  * - \ref SCIP_STAGE_PROBLEM
7037  * - \ref SCIP_STAGE_TRANSFORMED
7038  * - \ref SCIP_STAGE_PRESOLVING
7039  * - \ref SCIP_STAGE_PRESOLVED
7040  * - \ref SCIP_STAGE_SOLVING
7041  * - \ref SCIP_STAGE_SOLVED
7042  *
7043  * @post If this method is called in \SCIP stage \ref SCIP_STAGE_INIT or \ref SCIP_STAGE_PROBLEM, the stage of
7044  * \SCIP is not changed; otherwise, the \SCIP stage is changed to \ref SCIP_STAGE_PRESOLVED.
7045  *
7046  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
7047  */
7048 extern
7050  SCIP* scip /**< SCIP data structure */
7051  );
7052 
7053 /** frees all solution process data including presolving and transformed problem, only original problem is kept
7054  *
7055  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7056  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7057  *
7058  * @pre This method can be called if @p scip is in one of the following stages:
7059  * - \ref SCIP_STAGE_INIT
7060  * - \ref SCIP_STAGE_PROBLEM
7061  * - \ref SCIP_STAGE_TRANSFORMED
7062  * - \ref SCIP_STAGE_PRESOLVING
7063  * - \ref SCIP_STAGE_PRESOLVED
7064  * - \ref SCIP_STAGE_SOLVING
7065  * - \ref SCIP_STAGE_SOLVED
7066  *
7067  * @post After calling this method \SCIP reaches one of the following stages:
7068  * - \ref SCIP_STAGE_INIT if the method was called from \SCIP stage \ref SCIP_STAGE_INIT
7069  * - \ref SCIP_STAGE_PROBLEM if the method was called from any other of the allowed stages
7070  *
7071  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
7072  */
7073 extern
7075  SCIP* scip /**< SCIP data structure */
7076  );
7077 
7078 /** informs \SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has
7079  * been solved)
7080  *
7081  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7082  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7083  *
7084  * @pre This method can be called if @p scip is in one of the following stages:
7085  * - \ref SCIP_STAGE_PROBLEM
7086  * - \ref SCIP_STAGE_TRANSFORMING
7087  * - \ref SCIP_STAGE_TRANSFORMED
7088  * - \ref SCIP_STAGE_INITPRESOLVE
7089  * - \ref SCIP_STAGE_PRESOLVING
7090  * - \ref SCIP_STAGE_EXITPRESOLVE
7091  * - \ref SCIP_STAGE_PRESOLVED
7092  * - \ref SCIP_STAGE_SOLVING
7093  * - \ref SCIP_STAGE_SOLVED
7094  * - \ref SCIP_STAGE_EXITSOLVE
7095  * - \ref SCIP_STAGE_FREETRANS
7096  *
7097  * @note the \SCIP stage does not get changed
7098  */
7099 extern
7101  SCIP* scip /**< SCIP data structure */
7102  );
7103 
7104 /** informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has
7105  * been solved)
7106  *
7107  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7108  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7109  *
7110  * @pre This method can be called if @p scip is in one of the following stages:
7111  * - \ref SCIP_STAGE_INITPRESOLVE
7112  * - \ref SCIP_STAGE_PRESOLVING
7113  * - \ref SCIP_STAGE_EXITPRESOLVE
7114  * - \ref SCIP_STAGE_SOLVING
7115  *
7116  * @note the \SCIP stage does not get changed
7117  */
7118 extern
7120  SCIP* scip /**< SCIP data structure */
7121  );
7122 
7123 /** include specific heuristics and branching rules for reoptimization
7124  *
7125  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7126  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7127  *
7128  * @pre This method can be called if @p scip is in one of the following stages:
7129  * - \ref SCIP_STAGE_PROBLEM
7130  */
7131 extern
7133  SCIP* scip, /**< SCIP data structure */
7134  SCIP_Bool enable /**< enable reoptimization (TRUE) or disable it (FALSE) */
7135  );
7136 
7137 /** returns whether reoptimization is enabled or not */
7138 extern
7140  SCIP* scip /**< SCIP data structure */
7141  );
7142 
7143 /** returns the stored solutions corresponding to a given run */
7144 extern
7146  SCIP* scip, /**< SCIP data structue */
7147  int run, /**< number of the run */
7148  SCIP_SOL** sols, /**< array to store solutions */
7149  int allocmem, /**< allocated size of the array */
7150  int* nsols /**< number of solutions */
7151  );
7152 
7153 /** mark all stored solutions as not updated */
7154 extern
7156  SCIP* scip /**< SCIP data structure */
7157  );
7158 
7159 /** check if the reoptimization process should be restarted
7160  *
7161  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7162  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7163  *
7164  * @pre This method can be called if @p scip is in one of the following stages:
7165  * - \ref SCIP_STAGE_TRANSFORMED
7166  * - \ref SCIP_STAGE_SOLVING
7167  */
7168 extern
7170  SCIP* scip, /**< SCIP data structure */
7171  SCIP_NODE* node, /**< current node of the branch and bound tree (or NULL) */
7172  SCIP_Bool* restart /**< pointer to store of the reoptimitation process should be restarted */
7173  );
7174 
7175 /** save bound change based on dual information in the reoptimization tree
7176  *
7177  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7178  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7179  *
7180  * @pre This method can be called if @p scip is in one of the following stages:
7181  * - \ref SCIP_STAGE_SOLVING
7182  * - \ref SCIP_STAGE_SOLVED
7183  */
7184 extern
7186  SCIP* scip, /**< SCIP data structure */
7187  SCIP_NODE* node, /**< node of the search tree */
7188  SCIP_VAR* var, /**< variable whose bound changed */
7189  SCIP_Real newbound, /**< new bound of the variable */
7190  SCIP_Real oldbound /**< old bound of the variable */
7191  );
7192 
7193 /** returns the optimal solution of the last iteration or NULL of none exists */
7194 extern
7196  SCIP* scip /**< SCIP data structure */
7197  );
7198 
7199 /** returns the objective coefficent of a given variable in a previous iteration
7200  *
7201  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7202  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7203  *
7204  * @pre This method can be called if @p scip is in one of the following stages:
7205  * - \ref SCIP_STAGE_PRESOLVING
7206  * - \ref SCIP_STAGE_SOLVING
7207  */
7208 extern
7210  SCIP* scip, /**< SCIP data structure */
7211  SCIP_VAR* var, /**< variable */
7212  int run, /**< number of the run */
7213  SCIP_Real* objcoef /**< pointer to store the objective coefficient */
7214  );
7215 
7216 /** returns whether we are in the restarting phase
7217  *
7218  * @return TRUE, if we are in the restarting phase; FALSE, otherwise
7219  *
7220  * @pre This method can be called if @p scip is in one of the following stages:
7221  * - \ref SCIP_STAGE_INITPRESOLVE
7222  * - \ref SCIP_STAGE_PRESOLVING
7223  * - \ref SCIP_STAGE_EXITPRESOLVE
7224  * - \ref SCIP_STAGE_PRESOLVED
7225  * - \ref SCIP_STAGE_INITSOLVE
7226  * - \ref SCIP_STAGE_SOLVING
7227  * - \ref SCIP_STAGE_SOLVED
7228  * - \ref SCIP_STAGE_EXITSOLVE
7229  * - \ref SCIP_STAGE_FREETRANS
7230  */
7231 extern
7233  SCIP* scip /**< SCIP data structure */
7234  );
7235 
7236 /**@} */
7237 
7238 
7239 
7240 
7241 /*
7242  * variable methods
7243  */
7244 
7245 /**@addtogroup PublicVariableMethods
7246  *
7247  *@{
7248  */
7249 
7250 /** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded;
7251  * an integer variable with bounds zero and one is automatically converted into a binary variable;
7252  *
7253  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
7254  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
7255  * original objective function value of variables created during the solving process has to be multiplied by
7256  * -1, too.
7257  *
7258  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7259  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7260  *
7261  * @pre This method can be called if @p scip is in one of the following stages:
7262  * - \ref SCIP_STAGE_PROBLEM
7263  * - \ref SCIP_STAGE_TRANSFORMING
7264  * - \ref SCIP_STAGE_INITPRESOLVE
7265  * - \ref SCIP_STAGE_PRESOLVING
7266  * - \ref SCIP_STAGE_EXITPRESOLVE
7267  * - \ref SCIP_STAGE_PRESOLVED
7268  * - \ref SCIP_STAGE_SOLVING
7269  *
7270  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
7271  */
7272 extern
7274  SCIP* scip, /**< SCIP data structure */
7275  SCIP_VAR** var, /**< pointer to variable object */
7276  const char* name, /**< name of variable, or NULL for automatic name creation */
7277  SCIP_Real lb, /**< lower bound of variable */
7278  SCIP_Real ub, /**< upper bound of variable */
7279  SCIP_Real obj, /**< objective function value */
7280  SCIP_VARTYPE vartype, /**< type of variable */
7281  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
7282  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
7283  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
7284  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
7285  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
7286  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
7287  SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */
7288  );
7289 
7290 /** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set
7291  * afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(),
7292  * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE
7293  * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.;
7294  * if variable is of integral type, fractional bounds are automatically rounded;
7295  * an integer variable with bounds zero and one is automatically converted into a binary variable;
7296  *
7297  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
7298  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
7299  * original objective function value of variables created during the solving process has to be multiplied by
7300  * -1, too.
7301  *
7302  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7303  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7304  *
7305  * @pre This method can be called if @p scip is in one of the following stages:
7306  * - \ref SCIP_STAGE_PROBLEM
7307  * - \ref SCIP_STAGE_TRANSFORMING
7308  * - \ref SCIP_STAGE_INITPRESOLVE
7309  * - \ref SCIP_STAGE_PRESOLVING
7310  * - \ref SCIP_STAGE_EXITPRESOLVE
7311  * - \ref SCIP_STAGE_PRESOLVED
7312  * - \ref SCIP_STAGE_SOLVING
7313  *
7314  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
7315  */
7316 extern
7318  SCIP* scip, /**< SCIP data structure */
7319  SCIP_VAR** var, /**< pointer to variable object */
7320  const char* name, /**< name of variable, or NULL for automatic name creation */
7321  SCIP_Real lb, /**< lower bound of variable */
7322  SCIP_Real ub, /**< upper bound of variable */
7323  SCIP_Real obj, /**< objective function value */
7324  SCIP_VARTYPE vartype /**< type of variable */
7325  );
7326 
7327 /** outputs the variable name to the file stream
7328  *
7329  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7330  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7331  *
7332  * @pre This method can be called if @p scip is in one of the following stages:
7333  * - \ref SCIP_STAGE_PROBLEM
7334  * - \ref SCIP_STAGE_TRANSFORMING
7335  * - \ref SCIP_STAGE_TRANSFORMED
7336  * - \ref SCIP_STAGE_INITPRESOLVE
7337  * - \ref SCIP_STAGE_PRESOLVING
7338  * - \ref SCIP_STAGE_EXITPRESOLVE
7339  * - \ref SCIP_STAGE_PRESOLVED
7340  * - \ref SCIP_STAGE_INITSOLVE
7341  * - \ref SCIP_STAGE_SOLVING
7342  * - \ref SCIP_STAGE_SOLVED
7343  * - \ref SCIP_STAGE_EXITSOLVE
7344  * - \ref SCIP_STAGE_FREETRANS
7345  */
7346 extern
7348  SCIP* scip, /**< SCIP data structure */
7349  FILE* file, /**< output file, or NULL for stdout */
7350  SCIP_VAR* var, /**< variable to output */
7351  SCIP_Bool type /**< should the variable type be also posted */
7352  );
7353 
7354 /** print the given list of variables to output stream separated by the given delimiter character;
7355  *
7356  * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
7357  *
7358  * the method SCIPparseVarsList() can parse such a string
7359  *
7360  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7361  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7362  *
7363  * @pre This method can be called if @p scip is in one of the following stages:
7364  * - \ref SCIP_STAGE_PROBLEM
7365  * - \ref SCIP_STAGE_TRANSFORMING
7366  * - \ref SCIP_STAGE_TRANSFORMED
7367  * - \ref SCIP_STAGE_INITPRESOLVE
7368  * - \ref SCIP_STAGE_PRESOLVING
7369  * - \ref SCIP_STAGE_EXITPRESOLVE
7370  * - \ref SCIP_STAGE_PRESOLVED
7371  * - \ref SCIP_STAGE_INITSOLVE
7372  * - \ref SCIP_STAGE_SOLVING
7373  * - \ref SCIP_STAGE_SOLVED
7374  * - \ref SCIP_STAGE_EXITSOLVE
7375  * - \ref SCIP_STAGE_FREETRANS
7376  *
7377  * @note The printing process is done via the message handler system.
7378  */
7379 extern
7381  SCIP* scip, /**< SCIP data structure */
7382  FILE* file, /**< output file, or NULL for stdout */
7383  SCIP_VAR** vars, /**< variable array to output */
7384  int nvars, /**< number of variables */
7385  SCIP_Bool type, /**< should the variable type be also posted */
7386  char delimiter /**< character which is used for delimitation */
7387  );
7388 
7389 /** print the given variables and coefficients as linear sum in the following form
7390  * c1 <x1> + c2 <x2> ... + cn <xn>
7391  *
7392  * This string can be parsed by the method SCIPparseVarsLinearsum().
7393  *
7394  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7395  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7396  *
7397  * @pre This method can be called if @p scip is in one of the following stages:
7398  * - \ref SCIP_STAGE_PROBLEM
7399  * - \ref SCIP_STAGE_TRANSFORMING
7400  * - \ref SCIP_STAGE_TRANSFORMED
7401  * - \ref SCIP_STAGE_INITPRESOLVE
7402  * - \ref SCIP_STAGE_PRESOLVING
7403  * - \ref SCIP_STAGE_EXITPRESOLVE
7404  * - \ref SCIP_STAGE_PRESOLVED
7405  * - \ref SCIP_STAGE_INITSOLVE
7406  * - \ref SCIP_STAGE_SOLVING
7407  * - \ref SCIP_STAGE_SOLVED
7408  * - \ref SCIP_STAGE_EXITSOLVE
7409  * - \ref SCIP_STAGE_FREETRANS
7410  *
7411  * @note The printing process is done via the message handler system.
7412  */
7413 extern
7415  SCIP* scip, /**< SCIP data structure */
7416  FILE* file, /**< output file, or NULL for stdout */
7417  SCIP_VAR** vars, /**< variable array to output */
7418  SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
7419  int nvars, /**< number of variables */
7420  SCIP_Bool type /**< should the variable type be also posted */
7421  );
7422 
7423 /** print the given monomials as polynomial in the following form
7424  * c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...
7425  *
7426  * This string can be parsed by the method SCIPparseVarsPolynomial().
7427  *
7428  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7429  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7430  *
7431  * @pre This method can be called if @p scip is in one of the following stages:
7432  * - \ref SCIP_STAGE_PROBLEM
7433  * - \ref SCIP_STAGE_TRANSFORMING
7434  * - \ref SCIP_STAGE_TRANSFORMED
7435  * - \ref SCIP_STAGE_INITPRESOLVE
7436  * - \ref SCIP_STAGE_PRESOLVING
7437  * - \ref SCIP_STAGE_EXITPRESOLVE
7438  * - \ref SCIP_STAGE_PRESOLVED
7439  * - \ref SCIP_STAGE_INITSOLVE
7440  * - \ref SCIP_STAGE_SOLVING
7441  * - \ref SCIP_STAGE_SOLVED
7442  * - \ref SCIP_STAGE_EXITSOLVE
7443  * - \ref SCIP_STAGE_FREETRANS
7444  *
7445  * @note The printing process is done via the message handler system.
7446  */
7447 extern
7449  SCIP* scip, /**< SCIP data structure */
7450  FILE* file, /**< output file, or NULL for stdout */
7451  SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */
7452  SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */
7453  SCIP_Real* monomialcoefs, /**< array with monomial coefficients */
7454  int* monomialnvars, /**< array with number of variables for each monomial */
7455  int nmonomials, /**< number of monomials */
7456  SCIP_Bool type /**< should the variable type be also posted */
7457  );
7458 
7459 /** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
7460  * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
7461  * variable with bounds zero and one is automatically converted into a binary variable
7462  *
7463  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7464  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7465  *
7466  * @pre This method can be called if @p scip is in one of the following stages:
7467  * - \ref SCIP_STAGE_PROBLEM
7468  * - \ref SCIP_STAGE_TRANSFORMING
7469  * - \ref SCIP_STAGE_INITPRESOLVE
7470  * - \ref SCIP_STAGE_PRESOLVING
7471  * - \ref SCIP_STAGE_EXITPRESOLVE
7472  * - \ref SCIP_STAGE_PRESOLVED
7473  * - \ref SCIP_STAGE_SOLVING
7474  */
7475 extern
7477  SCIP* scip, /**< SCIP data structure */
7478  SCIP_VAR** var, /**< pointer to store the problem variable */
7479  const char* str, /**< string to parse */
7480  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
7481  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
7482  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
7483  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
7484  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
7485  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
7486  SCIP_VARDATA* vardata, /**< user data for this specific variable */
7487  char** endptr, /**< pointer to store the final string position if successful */
7488  SCIP_Bool* success /**< pointer store if the paring process was successful */
7489  );
7490 
7491 /** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
7492  * exits and returns the position where the parsing stopped
7493  *
7494  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7495  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7496  *
7497  * @pre This method can be called if @p scip is in one of the following stages:
7498  * - \ref SCIP_STAGE_PROBLEM
7499  * - \ref SCIP_STAGE_TRANSFORMING
7500  * - \ref SCIP_STAGE_INITPRESOLVE
7501  * - \ref SCIP_STAGE_PRESOLVING
7502  * - \ref SCIP_STAGE_EXITPRESOLVE
7503  * - \ref SCIP_STAGE_PRESOLVED
7504  * - \ref SCIP_STAGE_SOLVING
7505  */
7506 extern
7508  SCIP* scip, /**< SCIP data structure */
7509  const char* str, /**< string to parse */
7510  SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */
7511  char** endptr /**< pointer to store the final string position if successful */
7512  );
7513 
7514 /** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
7515  * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
7516  *
7517  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7518  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7519  *
7520  * @pre This method can be called if @p scip is in one of the following stages:
7521  * - \ref SCIP_STAGE_PROBLEM
7522  * - \ref SCIP_STAGE_TRANSFORMING
7523  * - \ref SCIP_STAGE_INITPRESOLVE
7524  * - \ref SCIP_STAGE_PRESOLVING
7525  * - \ref SCIP_STAGE_EXITPRESOLVE
7526  * - \ref SCIP_STAGE_PRESOLVED
7527  * - \ref SCIP_STAGE_SOLVING
7528  *
7529  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
7530  *
7531  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
7532  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
7533  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
7534  * memory functions).
7535  */
7536 extern
7538  SCIP* scip, /**< SCIP data structure */
7539  const char* str, /**< string to parse */
7540  SCIP_VAR** vars, /**< array to store the parsed variable */
7541  int* nvars, /**< pointer to store number of parsed variables */
7542  int varssize, /**< size of the variable array */
7543  int* requiredsize, /**< pointer to store the required array size for the active variables */
7544  char** endptr, /**< pointer to store the final string position if successful */
7545  char delimiter, /**< character which is used for delimitation */
7546  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7547  );
7548 
7549 /** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
7550  * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
7551  *
7552  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7553  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7554  *
7555  * @pre This method can be called if @p scip is in one of the following stages:
7556  * - \ref SCIP_STAGE_PROBLEM
7557  * - \ref SCIP_STAGE_TRANSFORMING
7558  * - \ref SCIP_STAGE_INITPRESOLVE
7559  * - \ref SCIP_STAGE_PRESOLVING
7560  * - \ref SCIP_STAGE_EXITPRESOLVE
7561  * - \ref SCIP_STAGE_PRESOLVED
7562  * - \ref SCIP_STAGE_SOLVING
7563  *
7564  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
7565  *
7566  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
7567  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
7568  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
7569  * memory functions).
7570  */
7571 extern
7573  SCIP* scip, /**< SCIP data structure */
7574  const char* str, /**< string to parse */
7575  SCIP_VAR** vars, /**< array to store the parsed variables */
7576  SCIP_Real* vals, /**< array to store the parsed coefficients */
7577  int* nvars, /**< pointer to store number of parsed variables */
7578  int varssize, /**< size of the variable array */
7579  int* requiredsize, /**< pointer to store the required array size for the active variables */
7580  char** endptr, /**< pointer to store the final string position if successful */
7581  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7582  );
7583 
7584 /** parse the given string as polynomial of variables and coefficients
7585  * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
7586  * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
7587  *
7588  * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
7589  * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
7590  * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
7591  * they use buffer memory that is intended for short term use only.
7592  *
7593  * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
7594  * are recognized.
7595  *
7596  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7597  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7598  *
7599  * @pre This method can be called if @p scip is in one of the following stages:
7600  * - \ref SCIP_STAGE_PROBLEM
7601  * - \ref SCIP_STAGE_TRANSFORMING
7602  * - \ref SCIP_STAGE_INITPRESOLVE
7603  * - \ref SCIP_STAGE_PRESOLVING
7604  * - \ref SCIP_STAGE_EXITPRESOLVE
7605  * - \ref SCIP_STAGE_PRESOLVED
7606  * - \ref SCIP_STAGE_SOLVING
7607  */
7608 extern
7610  SCIP* scip, /**< SCIP data structure */
7611  const char* str, /**< string to parse */
7612  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
7613  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
7614  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
7615  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
7616  int* nmonomials, /**< pointer to store number of parsed monomials */
7617  char** endptr, /**< pointer to store the final string position if successful */
7618  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7619  );
7620 
7621 /** frees memory allocated when parsing a polynomial from a string
7622  *
7623  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7624  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7625  *
7626  * @pre This method can be called if @p scip is in one of the following stages:
7627  * - \ref SCIP_STAGE_PROBLEM
7628  * - \ref SCIP_STAGE_TRANSFORMING
7629  * - \ref SCIP_STAGE_INITPRESOLVE
7630  * - \ref SCIP_STAGE_PRESOLVING
7631  * - \ref SCIP_STAGE_EXITPRESOLVE
7632  * - \ref SCIP_STAGE_PRESOLVED
7633  * - \ref SCIP_STAGE_SOLVING
7634  */
7635 extern
7637  SCIP* scip, /**< SCIP data structure */
7638  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
7639  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
7640  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
7641  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
7642  int nmonomials /**< pointer to store number of parsed monomials */
7643  );
7644 
7645 /** increases usage counter of variable
7646  *
7647  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7648  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7649  *
7650  * @pre This method can be called if @p scip is in one of the following stages:
7651  * - \ref SCIP_STAGE_PROBLEM
7652  * - \ref SCIP_STAGE_TRANSFORMING
7653  * - \ref SCIP_STAGE_TRANSFORMED
7654  * - \ref SCIP_STAGE_INITPRESOLVE
7655  * - \ref SCIP_STAGE_PRESOLVING
7656  * - \ref SCIP_STAGE_EXITPRESOLVE
7657  * - \ref SCIP_STAGE_PRESOLVED
7658  * - \ref SCIP_STAGE_INITSOLVE
7659  * - \ref SCIP_STAGE_SOLVING
7660  * - \ref SCIP_STAGE_SOLVED
7661  * - \ref SCIP_STAGE_EXITSOLVE
7662  */
7663 extern
7665  SCIP* scip, /**< SCIP data structure */
7666  SCIP_VAR* var /**< variable to capture */
7667  );
7668 
7669 /** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
7670  *
7671  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7672  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7673  *
7674  * @pre This method can be called if @p scip is in one of the following stages:
7675  * - \ref SCIP_STAGE_PROBLEM
7676  * - \ref SCIP_STAGE_TRANSFORMING
7677  * - \ref SCIP_STAGE_TRANSFORMED
7678  * - \ref SCIP_STAGE_INITPRESOLVE
7679  * - \ref SCIP_STAGE_PRESOLVING
7680  * - \ref SCIP_STAGE_EXITPRESOLVE
7681  * - \ref SCIP_STAGE_PRESOLVED
7682  * - \ref SCIP_STAGE_INITSOLVE
7683  * - \ref SCIP_STAGE_SOLVING
7684  * - \ref SCIP_STAGE_SOLVED
7685  * - \ref SCIP_STAGE_EXITSOLVE
7686  * - \ref SCIP_STAGE_FREETRANS
7687  *
7688  * @note the pointer of the variable will be NULLed
7689  */
7690 extern
7692  SCIP* scip, /**< SCIP data structure */
7693  SCIP_VAR** var /**< pointer to variable */
7694  );
7695 
7696 /** changes the name of a variable
7697  *
7698  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7699  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7700  *
7701  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM
7702  *
7703  * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h
7704  */
7705 extern
7707  SCIP* scip, /**< SCIP data structure */
7708  SCIP_VAR* var, /**< variable */
7709  const char* name /**< new name of constraint */
7710  );
7711 
7712 /** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
7713  * a new transformed variable for this variable is created
7714  *
7715  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7716  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7717  *
7718  * @pre This method can be called if @p scip is in one of the following stages:
7719  * - \ref SCIP_STAGE_TRANSFORMING
7720  * - \ref SCIP_STAGE_TRANSFORMED
7721  * - \ref SCIP_STAGE_INITPRESOLVE
7722  * - \ref SCIP_STAGE_PRESOLVING
7723  * - \ref SCIP_STAGE_EXITPRESOLVE
7724  * - \ref SCIP_STAGE_PRESOLVED
7725  * - \ref SCIP_STAGE_INITSOLVE
7726  * - \ref SCIP_STAGE_SOLVING
7727  */
7728 extern
7730  SCIP* scip, /**< SCIP data structure */
7731  SCIP_VAR* var, /**< variable to get/create transformed variable for */
7732  SCIP_VAR** transvar /**< pointer to store the transformed variable */
7733  );
7734 
7735 /** gets and captures transformed variables for an array of variables;
7736  * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
7737  * it is possible to call this method with vars == transvars
7738  *
7739  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7740  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7741  *
7742  * @pre This method can be called if @p scip is in one of the following stages:
7743  * - \ref SCIP_STAGE_TRANSFORMING
7744  * - \ref SCIP_STAGE_TRANSFORMED
7745  * - \ref SCIP_STAGE_INITPRESOLVE
7746  * - \ref SCIP_STAGE_PRESOLVING
7747  * - \ref SCIP_STAGE_EXITPRESOLVE
7748  * - \ref SCIP_STAGE_PRESOLVED
7749  * - \ref SCIP_STAGE_INITSOLVE
7750  * - \ref SCIP_STAGE_SOLVING
7751  */
7752 extern
7754  SCIP* scip, /**< SCIP data structure */
7755  int nvars, /**< number of variables to get/create transformed variables for */
7756  SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */
7757  SCIP_VAR** transvars /**< array to store the transformed variables */
7758  );
7759 
7760 /** gets corresponding transformed variable of a given variable;
7761  * returns NULL as transvar, if transformed variable is not yet existing
7762  *
7763  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7764  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7765  *
7766  * @pre This method can be called if @p scip is in one of the following stages:
7767  * - \ref SCIP_STAGE_TRANSFORMING
7768  * - \ref SCIP_STAGE_TRANSFORMED
7769  * - \ref SCIP_STAGE_INITPRESOLVE
7770  * - \ref SCIP_STAGE_PRESOLVING
7771  * - \ref SCIP_STAGE_EXITPRESOLVE
7772  * - \ref SCIP_STAGE_PRESOLVED
7773  * - \ref SCIP_STAGE_INITSOLVE
7774  * - \ref SCIP_STAGE_SOLVING
7775  * - \ref SCIP_STAGE_SOLVED
7776  * - \ref SCIP_STAGE_EXITSOLVE
7777  * - \ref SCIP_STAGE_FREETRANS
7778  */
7779 extern
7781  SCIP* scip, /**< SCIP data structure */
7782  SCIP_VAR* var, /**< variable to get transformed variable for */
7783  SCIP_VAR** transvar /**< pointer to store the transformed variable */
7784  );
7785 
7786 /** gets corresponding transformed variables for an array of variables;
7787  * stores NULL in a transvars slot, if the transformed variable is not yet existing;
7788  * it is possible to call this method with vars == transvars, but remember that variables that are not
7789  * yet transformed will be replaced with NULL
7790  *
7791  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7792  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7793  *
7794  * @pre This method can be called if @p scip is in one of the following stages:
7795  * - \ref SCIP_STAGE_TRANSFORMING
7796  * - \ref SCIP_STAGE_TRANSFORMED
7797  * - \ref SCIP_STAGE_INITPRESOLVE
7798  * - \ref SCIP_STAGE_PRESOLVING
7799  * - \ref SCIP_STAGE_EXITPRESOLVE
7800  * - \ref SCIP_STAGE_PRESOLVED
7801  * - \ref SCIP_STAGE_INITSOLVE
7802  * - \ref SCIP_STAGE_SOLVING
7803  * - \ref SCIP_STAGE_SOLVED
7804  * - \ref SCIP_STAGE_EXITSOLVE
7805  * - \ref SCIP_STAGE_FREETRANS
7806  */
7807 extern
7809  SCIP* scip, /**< SCIP data structure */
7810  int nvars, /**< number of variables to get transformed variables for */
7811  SCIP_VAR** vars, /**< array with variables to get transformed variables for */
7812  SCIP_VAR** transvars /**< array to store the transformed variables */
7813  );
7814 
7815 /** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing
7816  *
7817  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7818  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7819  *
7820  * @pre This method can be called if @p scip is in one of the following stages:
7821  * - \ref SCIP_STAGE_PROBLEM
7822  * - \ref SCIP_STAGE_TRANSFORMING
7823  * - \ref SCIP_STAGE_TRANSFORMED
7824  * - \ref SCIP_STAGE_INITPRESOLVE
7825  * - \ref SCIP_STAGE_PRESOLVING
7826  * - \ref SCIP_STAGE_EXITPRESOLVE
7827  * - \ref SCIP_STAGE_PRESOLVED
7828  * - \ref SCIP_STAGE_INITSOLVE
7829  * - \ref SCIP_STAGE_SOLVING
7830  * - \ref SCIP_STAGE_SOLVED
7831  * - \ref SCIP_STAGE_EXITSOLVE
7832  * - \ref SCIP_STAGE_FREETRANS
7833  */
7834 extern
7836  SCIP* scip, /**< SCIP data structure */
7837  SCIP_VAR* var, /**< variable to get negated variable for */
7838  SCIP_VAR** negvar /**< pointer to store the negated variable */
7839  );
7840 
7841 /** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing;
7842  * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
7843  *
7844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7846  *
7847  * @pre This method can be called if @p scip is in one of the following stages:
7848  * - \ref SCIP_STAGE_PROBLEM
7849  * - \ref SCIP_STAGE_TRANSFORMING
7850  * - \ref SCIP_STAGE_TRANSFORMED
7851  * - \ref SCIP_STAGE_INITPRESOLVE
7852  * - \ref SCIP_STAGE_PRESOLVING
7853  * - \ref SCIP_STAGE_EXITPRESOLVE
7854  * - \ref SCIP_STAGE_PRESOLVED
7855  * - \ref SCIP_STAGE_INITSOLVE
7856  * - \ref SCIP_STAGE_SOLVING
7857  * - \ref SCIP_STAGE_SOLVED
7858  * - \ref SCIP_STAGE_EXITSOLVE
7859  * - \ref SCIP_STAGE_FREETRANS
7860  */
7861 extern
7863  SCIP* scip, /**< SCIP data structure */
7864  int nvars, /**< number of variables to get negated variables for */
7865  SCIP_VAR** vars, /**< array of variables to get negated variables for */
7866  SCIP_VAR** negvars /**< array to store the negated variables */
7867  );
7868 
7869 /** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
7870  * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
7871  *
7872  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7873  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7874  *
7875  * @pre This method can be called if @p scip is in one of the following stages:
7876  * - \ref SCIP_STAGE_PROBLEM
7877  * - \ref SCIP_STAGE_TRANSFORMED
7878  * - \ref SCIP_STAGE_INITPRESOLVE
7879  * - \ref SCIP_STAGE_PRESOLVING
7880  * - \ref SCIP_STAGE_EXITPRESOLVE
7881  * - \ref SCIP_STAGE_PRESOLVED
7882  * - \ref SCIP_STAGE_INITSOLVE
7883  * - \ref SCIP_STAGE_SOLVING
7884  * - \ref SCIP_STAGE_SOLVED
7885  * - \ref SCIP_STAGE_EXITSOLVE
7886  */
7887 extern
7889  SCIP* scip, /**< SCIP data structure */
7890  SCIP_VAR* var, /**< binary variable to get binary representative for */
7891  SCIP_VAR** repvar, /**< pointer to store the binary representative */
7892  SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
7893  );
7894 
7895 /** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
7896  * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
7897  *
7898  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7899  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7900  *
7901  * @pre This method can be called if @p scip is in one of the following stages:
7902  * - \ref SCIP_STAGE_PROBLEM
7903  * - \ref SCIP_STAGE_TRANSFORMED
7904  * - \ref SCIP_STAGE_INITPRESOLVE
7905  * - \ref SCIP_STAGE_PRESOLVING
7906  * - \ref SCIP_STAGE_EXITPRESOLVE
7907  * - \ref SCIP_STAGE_PRESOLVED
7908  * - \ref SCIP_STAGE_INITSOLVE
7909  * - \ref SCIP_STAGE_SOLVING
7910  * - \ref SCIP_STAGE_SOLVED
7911  * - \ref SCIP_STAGE_EXITSOLVE
7912  */
7913 extern
7915  SCIP* scip, /**< SCIP data structure */
7916  int nvars, /**< number of binary variables to get representatives for */
7917  SCIP_VAR** vars, /**< binary variables to get binary representatives for */
7918  SCIP_VAR** repvars, /**< array to store the binary representatives */
7919  SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
7920  );
7921 
7922 /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
7923  *
7924  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7925  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7926  *
7927  * @pre This method can be called if @p scip is in one of the following stages:
7928  * - \ref SCIP_STAGE_INITPRESOLVE
7929  * - \ref SCIP_STAGE_PRESOLVING
7930  * - \ref SCIP_STAGE_EXITPRESOLVE
7931  * - \ref SCIP_STAGE_PRESOLVED
7932  * - \ref SCIP_STAGE_INITSOLVE
7933  * - \ref SCIP_STAGE_SOLVING
7934  * - \ref SCIP_STAGE_SOLVED
7935  */
7936 extern
7938  SCIP* scip, /**< SCIP data structure */
7939  SCIP_VAR* var /**< problem variable */
7940  );
7941 
7942 /** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
7943  * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
7944  *
7945  * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
7946  * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
7947  * representation is stored in the variable array, scalar array and constant.
7948  *
7949  * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
7950  * allocated (e.g., by a C++ 'new' or SCIP functions).
7951  *
7952  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7953  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7954  *
7955  * @pre This method can be called if @p scip is in one of the following stages:
7956  * - \ref SCIP_STAGE_TRANSFORMED
7957  * - \ref SCIP_STAGE_INITPRESOLVE
7958  * - \ref SCIP_STAGE_PRESOLVING
7959  * - \ref SCIP_STAGE_EXITPRESOLVE
7960  * - \ref SCIP_STAGE_PRESOLVED
7961  * - \ref SCIP_STAGE_INITSOLVE
7962  * - \ref SCIP_STAGE_SOLVING
7963  * - \ref SCIP_STAGE_SOLVED
7964  * - \ref SCIP_STAGE_EXITSOLVE
7965  * - \ref SCIP_STAGE_FREETRANS
7966  *
7967  * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
7968  * given entries are overwritten.
7969  *
7970  * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
7971  * the method with the linear sum 1.0*x + 0.0.
7972  */
7973 extern
7975  SCIP* scip, /**< SCIP data structure */
7976  SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
7977  * overwritten by the variable array y_1, ..., y_m in the linear sum
7978  * w.r.t. active variables */
7979  SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
7980  * scalars b_1, ..., b_m in the linear sum of the active variables */
7981  int* nvars, /**< pointer to number of variables in the linear sum which will be
7982  * overwritten by the number of variables in the linear sum corresponding
7983  * to the active variables */
7984  int varssize, /**< available slots in vars and scalars array which is needed to check if
7985  * the array are large enough for the linear sum w.r.t. active
7986  * variables */
7987  SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
7988  * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
7989  * d w.r.t. the active variables */
7990  int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
7991  * active variables */
7992  SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
7993  );
7994 
7995 /** transforms given variable, scalar and constant to the corresponding active, fixed, or
7996  * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
7997  * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
7998  * with only one active variable (this can happen due to fixings after the multi-aggregation),
7999  * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
8000  *
8001  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8002  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8003  *
8004  * @pre This method can be called if @p scip is in one of the following stages:
8005  * - \ref SCIP_STAGE_TRANSFORMED
8006  * - \ref SCIP_STAGE_INITPRESOLVE
8007  * - \ref SCIP_STAGE_PRESOLVING
8008  * - \ref SCIP_STAGE_EXITPRESOLVE
8009  * - \ref SCIP_STAGE_PRESOLVED
8010  * - \ref SCIP_STAGE_INITSOLVE
8011  * - \ref SCIP_STAGE_SOLVING
8012  * - \ref SCIP_STAGE_SOLVED
8013  * - \ref SCIP_STAGE_EXITSOLVE
8014  * - \ref SCIP_STAGE_FREETRANS
8015  */
8016 extern
8018  SCIP* scip, /**< SCIP data structure */
8019  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
8020  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
8021  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
8022  );
8023 
8024 /** return for given variables all their active counterparts; all active variables will be pairwise different
8025  * @note It does not hold that the first output variable is the active variable for the first input variable.
8026  *
8027  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8028  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8029  *
8030  * @pre This method can be called if @p scip is in one of the following stages:
8031  * - \ref SCIP_STAGE_TRANSFORMED
8032  * - \ref SCIP_STAGE_INITPRESOLVE
8033  * - \ref SCIP_STAGE_PRESOLVING
8034  * - \ref SCIP_STAGE_EXITPRESOLVE
8035  * - \ref SCIP_STAGE_PRESOLVED
8036  * - \ref SCIP_STAGE_INITSOLVE
8037  * - \ref SCIP_STAGE_SOLVING
8038  * - \ref SCIP_STAGE_SOLVED
8039  * - \ref SCIP_STAGE_EXITSOLVE
8040  * - \ref SCIP_STAGE_FREETRANS
8041  */
8042 extern
8044  SCIP* scip, /**< SCIP data structure */
8045  SCIP_VAR** vars, /**< variable array with given variables and as output all active
8046  * variables, if enough slots exist */
8047  int* nvars, /**< number of given variables, and as output number of active variables,
8048  * if enough slots exist */
8049  int varssize, /**< available slots in vars array */
8050  int* requiredsize /**< pointer to store the required array size for the active variables */
8051  );
8052 
8053 /** returns the reduced costs of the variable in the current node's LP relaxation;
8054  * the current node has to have a feasible LP.
8055  *
8056  * returns SCIP_INVALID if the variable is active but not in the current LP;
8057  * returns 0 if the variable has been aggregated out or fixed in presolving.
8058  *
8059  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8060  *
8061  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
8062  */
8063 extern
8065  SCIP* scip, /**< SCIP data structure */
8066  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
8067  );
8068 
8069 /** returns the implied reduced costs of the variable in the current node's LP relaxation;
8070  * the current node has to have a feasible LP.
8071  *
8072  * returns SCIP_INVALID if the variable is active but not in the current LP;
8073  * returns 0 if the variable has been aggregated out or fixed in presolving.
8074  *
8075  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8076  *
8077  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
8078  */
8079 extern
8081  SCIP* scip, /**< SCIP data structure */
8082  SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */
8083  SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */
8084  );
8085 
8086 /** returns the Farkas coefficient of the variable in the current node's LP relaxation;
8087  * the current node has to have an infeasible LP.
8088  *
8089  * returns SCIP_INVALID if the variable is active but not in the current LP;
8090  * returns 0 if the variable has been aggregated out or fixed in presolving.
8091  *
8092  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8093  */
8094 extern
8096  SCIP* scip, /**< SCIP data structure */
8097  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
8098  );
8099 
8100 /** returns lower bound of variable directly before or after the bound change given by the bound change index
8101  * was applied
8102  */
8103 extern
8105  SCIP* scip, /**< SCIP data structure */
8106  SCIP_VAR* var, /**< problem variable */
8107  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
8108  SCIP_Bool after /**< should the bound change with given index be included? */
8109  );
8110 
8111 /** returns upper bound of variable directly before or after the bound change given by the bound change index
8112  * was applied
8113  */
8114 extern
8116  SCIP* scip, /**< SCIP data structure */
8117  SCIP_VAR* var, /**< problem variable */
8118  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
8119  SCIP_Bool after /**< should the bound change with given index be included? */
8120  );
8121 
8122 /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
8123  * was applied
8124  */
8125 extern
8127  SCIP* scip, /**< SCIP data structure */
8128  SCIP_VAR* var, /**< problem variable */
8129  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
8130  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
8131  SCIP_Bool after /**< should the bound change with given index be included? */
8132  );
8133 
8134 /** returns whether the binary variable was fixed at the time given by the bound change index */
8135 extern
8137  SCIP* scip, /**< SCIP data structure */
8138  SCIP_VAR* var, /**< problem variable */
8139  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
8140  SCIP_Bool after /**< should the bound change with given index be included? */
8141  );
8142 
8143 /** gets solution value for variable in current node
8144  *
8145  * @return solution value for variable in current node
8146  *
8147  * @pre This method can be called if @p scip is in one of the following stages:
8148  * - \ref SCIP_STAGE_PRESOLVED
8149  * - \ref SCIP_STAGE_SOLVING
8150  */
8151 extern
8153  SCIP* scip, /**< SCIP data structure */
8154  SCIP_VAR* var /**< variable to get solution value for */
8155  );
8156 
8157 /** gets solution values of multiple variables in current node
8158  *
8159  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8160  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8161  *
8162  * @pre This method can be called if @p scip is in one of the following stages:
8163  * - \ref SCIP_STAGE_PRESOLVED
8164  * - \ref SCIP_STAGE_SOLVING
8165  */
8166 extern
8168  SCIP* scip, /**< SCIP data structure */
8169  int nvars, /**< number of variables to get solution value for */
8170  SCIP_VAR** vars, /**< array with variables to get value for */
8171  SCIP_Real* vals /**< array to store solution values of variables */
8172  );
8173 
8174 /** sets the solution value of all variables in the global relaxation solution to zero
8175  *
8176  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8177  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8178  *
8179  * @pre This method can be called if @p scip is in one of the following stages:
8180  * - \ref SCIP_STAGE_PRESOLVED
8181  * - \ref SCIP_STAGE_SOLVING
8182  */
8183 extern
8185  SCIP* scip /**< SCIP data structure */
8186  );
8187 
8188 /** sets the value of the given variable in the global relaxation solution;
8189  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
8190  * You can use SCIPclearRelaxSolVals() to set all values to zero, initially;
8191  * after setting all solution values, you have to call SCIPmarkRelaxSolValid()
8192  * to inform SCIP that the stored solution is valid
8193  *
8194  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8195  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8196  *
8197  * @pre This method can be called if @p scip is in one of the following stages:
8198  * - \ref SCIP_STAGE_PRESOLVED
8199  * - \ref SCIP_STAGE_SOLVING
8200  *
8201  * @note This method incrementally updates the objective value of the relaxation solution. If the whole solution
8202  * should be updated, using SCIPsetRelaxSolVals() instead or calling SCIPclearRelaxSolVals() before setting
8203  * the first value to reset the solution and the objective value to 0 may help the numerics.
8204  */
8205 extern
8207  SCIP* scip, /**< SCIP data structure */
8208  SCIP_VAR* var, /**< variable to set value for */
8209  SCIP_Real val /**< solution value of variable */
8210  );
8211 
8212 /** sets the values of the given variables in the global relaxation solution and informs SCIP about the validity
8213  * and whether the solution can be enforced via linear cuts;
8214  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
8215  * the solution is automatically cleared, s.t. all other variables get value 0.0
8216  *
8217  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8218  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8219  *
8220  * @pre This method can be called if @p scip is in one of the following stages:
8221  * - \ref SCIP_STAGE_PRESOLVED
8222  * - \ref SCIP_STAGE_SOLVING
8223  */
8224 extern
8226  SCIP* scip, /**< SCIP data structure */
8227  int nvars, /**< number of variables to set relaxation solution value for */
8228  SCIP_VAR** vars, /**< array with variables to set value for */
8229  SCIP_Real* vals, /**< array with solution values of variables */
8230  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
8231  );
8232 
8233 /** sets the values of the variables in the global relaxation solution to the values in the given primal solution
8234  * and informs SCIP about the validity and whether the solution can be enforced via linear cuts;
8235  * the relaxation solution can be filled by the relaxation handlers and might be used by heuristics and for separation
8236  *
8237  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8238  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8239  *
8240  * @pre This method can be called if @p scip is in one of the following stages:
8241  * - \ref SCIP_STAGE_PRESOLVED
8242  * - \ref SCIP_STAGE_SOLVING
8243  */
8244 extern
8246  SCIP* scip, /**< SCIP data structure */
8247  SCIP_SOL* sol, /**< primal relaxation solution */
8248  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
8249  );
8250 
8251 /** returns whether the relaxation solution is valid
8252  *
8253  * @return TRUE, if the relaxation solution is valid; FALSE, otherwise
8254  *
8255  * @pre This method can be called if @p scip is in one of the following stages:
8256  * - \ref SCIP_STAGE_PRESOLVED
8257  * - \ref SCIP_STAGE_SOLVING
8258  */
8259 extern
8261  SCIP* scip /**< SCIP data structure */
8262  );
8263 
8264 /** informs SCIP that the relaxation solution is valid and whether the relaxation can be enforced through linear cuts
8265  *
8266  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8267  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8268  *
8269  * @pre This method can be called if @p scip is in one of the following stages:
8270  * - \ref SCIP_STAGE_PRESOLVED
8271  * - \ref SCIP_STAGE_SOLVING
8272  */
8273 extern
8275  SCIP* scip, /**< SCIP data structure */
8276  SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
8277  );
8278 
8279 /** informs SCIP, that the relaxation solution is invalid
8280  *
8281  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8282  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8283  *
8284  * @pre This method can be called if @p scip is in one of the following stages:
8285  * - \ref SCIP_STAGE_PRESOLVED
8286  * - \ref SCIP_STAGE_SOLVING
8287  */
8288 extern
8290  SCIP* scip /**< SCIP data structure */
8291  );
8292 
8293 /** gets the relaxation solution value of the given variable
8294  *
8295  * @return the relaxation solution value of the given variable
8296  *
8297  * @pre This method can be called if @p scip is in one of the following stages:
8298  * - \ref SCIP_STAGE_PRESOLVED
8299  * - \ref SCIP_STAGE_SOLVING
8300  */
8301 extern
8303  SCIP* scip, /**< SCIP data structure */
8304  SCIP_VAR* var /**< variable to get value for */
8305  );
8306 
8307 /** gets the relaxation solution objective value
8308  *
8309  * @return the objective value of the relaxation solution
8310  *
8311  * @pre This method can be called if @p scip is in one of the following stages:
8312  * - \ref SCIP_STAGE_PRESOLVED
8313  * - \ref SCIP_STAGE_SOLVING
8314  */
8315 extern
8317  SCIP* scip /**< SCIP data structure */
8318  );
8319 
8320 /** start strong branching - call before any strong branching
8321  *
8322  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8323  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8324  *
8325  * @pre This method can be called if @p scip is in one of the following stages:
8326  * - \ref SCIP_STAGE_PRESOLVED
8327  * - \ref SCIP_STAGE_SOLVING
8328  *
8329  * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
8330  * which allow to perform propagation but also creates some overhead
8331  */
8332 extern
8334  SCIP* scip, /**< SCIP data structure */
8335  SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
8336  );
8337 
8338 /** end strong branching - call after any strong branching
8339  *
8340  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8341  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8342  *
8343  * @pre This method can be called if @p scip is in one of the following stages:
8344  * - \ref SCIP_STAGE_PRESOLVED
8345  * - \ref SCIP_STAGE_SOLVING
8346  */
8347 extern
8349  SCIP* scip /**< SCIP data structure */
8350  );
8351 
8352 /** gets strong branching information on column variable with fractional value
8353  *
8354  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8355  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8356  *
8357  * @pre This method can be called if @p scip is in one of the following stages:
8358  * - \ref SCIP_STAGE_PRESOLVED
8359  * - \ref SCIP_STAGE_SOLVING
8360  */
8361 extern
8363  SCIP* scip, /**< SCIP data structure */
8364  SCIP_VAR* var, /**< variable to get strong branching values for */
8365  int itlim, /**< iteration limit for strong branchings */
8366  SCIP_Real* down, /**< stores dual bound after branching column down */
8367  SCIP_Real* up, /**< stores dual bound after branching column up */
8368  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8369  * otherwise, it can only be used as an estimate value */
8370  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8371  * otherwise, it can only be used as an estimate value */
8372  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8373  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8374  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8375  * infeasible downwards branch, or NULL */
8376  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8377  * infeasible upwards branch, or NULL */
8378  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8379  * solving process should be stopped (e.g., due to a time limit) */
8380  );
8381 
8382 /** gets strong branching information with previous domain propagation on column variable
8383  *
8384  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
8385  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
8386  * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
8387  * enabled in the SCIPstartStrongbranch() call.
8388  *
8389  * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
8390  * can be specified by the parameter @p maxproprounds.
8391  *
8392  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8393  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8394  *
8395  * @pre This method can be called if @p scip is in one of the following stages:
8396  * - \ref SCIP_STAGE_PRESOLVED
8397  * - \ref SCIP_STAGE_SOLVING
8398  *
8399  * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
8400  * they are updated w.r.t. the strong branching LP solution.
8401  */
8402 extern
8404  SCIP* scip, /**< SCIP data structure */
8405  SCIP_VAR* var, /**< variable to get strong branching values for */
8406  SCIP_Real solval, /**< value of the variable in the current LP solution */
8407  SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
8408  int itlim, /**< iteration limit for strong branchings */
8409  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
8410  * settings) */
8411  SCIP_Real* down, /**< stores dual bound after branching column down */
8412  SCIP_Real* up, /**< stores dual bound after branching column up */
8413  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8414  * otherwise, it can only be used as an estimate value */
8415  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8416  * otherwise, it can only be used as an estimate value */
8417  SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
8418  SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */
8419  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8420  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8421  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8422  * infeasible downwards branch, or NULL */
8423  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8424  * infeasible upwards branch, or NULL */
8425  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
8426  * solving process should be stopped (e.g., due to a time limit) */
8427  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
8428  SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
8429  );
8430 
8431 /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
8432  * is (val -1.0) and the up brach ins (val +1.0)
8433  *
8434  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8435  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8436  *
8437  * @pre This method can be called if @p scip is in one of the following stages:
8438  * - \ref SCIP_STAGE_PRESOLVED
8439  * - \ref SCIP_STAGE_SOLVING
8440  *
8441  * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
8442  * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
8443  */
8444 extern
8446  SCIP* scip, /**< SCIP data structure */
8447  SCIP_VAR* var, /**< variable to get strong branching values for */
8448  int itlim, /**< iteration limit for strong branchings */
8449  SCIP_Real* down, /**< stores dual bound after branching column down */
8450  SCIP_Real* up, /**< stores dual bound after branching column up */
8451  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8452  * otherwise, it can only be used as an estimate value */
8453  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8454  * otherwise, it can only be used as an estimate value */
8455  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8456  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8457  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8458  * infeasible downwards branch, or NULL */
8459  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8460  * infeasible upwards branch, or NULL */
8461  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8462  * solving process should be stopped (e.g., due to a time limit) */
8463  );
8464 
8465 /** gets strong branching information on column variables with fractional values
8466  *
8467  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8468  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8469  *
8470  * @pre This method can be called if @p scip is in one of the following stages:
8471  * - \ref SCIP_STAGE_PRESOLVED
8472  * - \ref SCIP_STAGE_SOLVING
8473  */
8474 extern
8476  SCIP* scip, /**< SCIP data structure */
8477  SCIP_VAR** vars, /**< variables to get strong branching values for */
8478  int nvars, /**< number of variables */
8479  int itlim, /**< iteration limit for strong branchings */
8480  SCIP_Real* down, /**< stores dual bounds after branching variables down */
8481  SCIP_Real* up, /**< stores dual bounds after branching variables up */
8482  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
8483  * otherwise, they can only be used as an estimate value */
8484  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
8485  * otherwise, they can only be used as an estimate value */
8486  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
8487  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
8488  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
8489  * infeasible downward branches, or NULL */
8490  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
8491  * infeasible upward branches, or NULL */
8492  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8493  * solving process should be stopped (e.g., due to a time limit) */
8494  );
8495 
8496 /** gets strong branching information on column variables with integral values
8497  *
8498  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8499  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8500  *
8501  * @pre This method can be called if @p scip is in one of the following stages:
8502  * - \ref SCIP_STAGE_PRESOLVED
8503  * - \ref SCIP_STAGE_SOLVING
8504  */
8505 extern
8507  SCIP* scip, /**< SCIP data structure */
8508  SCIP_VAR** vars, /**< variables to get strong branching values for */
8509  int nvars, /**< number of variables */
8510  int itlim, /**< iteration limit for strong branchings */
8511  SCIP_Real* down, /**< stores dual bounds after branching variables down */
8512  SCIP_Real* up, /**< stores dual bounds after branching variables up */
8513  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
8514  * otherwise, they can only be used as an estimate value */
8515  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
8516  * otherwise, they can only be used as an estimate value */
8517  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
8518  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
8519  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
8520  * infeasible downward branches, or NULL */
8521  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
8522  * infeasible upward branches, or NULL */
8523  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8524  * solving process should be stopped (e.g., due to a time limit) */
8525  );
8526 
8527 /** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */
8528 extern
8530  SCIP* scip, /**< SCIP data structure */
8531  SCIP_BRANCHDIR branchdir /**< branching direction for which LP solution status is requested */
8532  );
8533 
8534 /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
8535  * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
8536  * keep in mind, that the returned old values may have nothing to do with the current LP solution
8537  *
8538  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8539  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8540  *
8541  * @pre This method can be called if @p scip is in one of the following stages:
8542  * - \ref SCIP_STAGE_SOLVING
8543  * - \ref SCIP_STAGE_SOLVED
8544  */
8545 extern
8547  SCIP* scip, /**< SCIP data structure */
8548  SCIP_VAR* var, /**< variable to get last strong branching values for */
8549  SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
8550  SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
8551  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8552  * otherwise, it can only be used as an estimate value */
8553  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8554  * otherwise, it can only be used as an estimate value */
8555  SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */
8556  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
8557  );
8558 
8559 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
8560  * given variable, or -1 if strong branching was never applied to the variable in current run
8561  *
8562  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8563  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8564  *
8565  * @pre This method can be called if @p scip is in one of the following stages:
8566  * - \ref SCIP_STAGE_TRANSFORMING
8567  * - \ref SCIP_STAGE_TRANSFORMED
8568  * - \ref SCIP_STAGE_INITPRESOLVE
8569  * - \ref SCIP_STAGE_PRESOLVING
8570  * - \ref SCIP_STAGE_EXITPRESOLVE
8571  * - \ref SCIP_STAGE_PRESOLVED
8572  * - \ref SCIP_STAGE_INITSOLVE
8573  * - \ref SCIP_STAGE_SOLVING
8574  * - \ref SCIP_STAGE_SOLVED
8575  * - \ref SCIP_STAGE_EXITSOLVE
8576  */
8577 extern
8579  SCIP* scip, /**< SCIP data structure */
8580  SCIP_VAR* var /**< variable to get last strong branching node for */
8581  );
8582 
8583 /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
8584  * the LP where the strong branching on this variable was applied;
8585  * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
8586  *
8587  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8588  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8589  *
8590  * @pre This method can be called if @p scip is in one of the following stages:
8591  * - \ref SCIP_STAGE_TRANSFORMING
8592  * - \ref SCIP_STAGE_TRANSFORMED
8593  * - \ref SCIP_STAGE_INITPRESOLVE
8594  * - \ref SCIP_STAGE_PRESOLVING
8595  * - \ref SCIP_STAGE_EXITPRESOLVE
8596  * - \ref SCIP_STAGE_PRESOLVED
8597  * - \ref SCIP_STAGE_INITSOLVE
8598  * - \ref SCIP_STAGE_SOLVING
8599  * - \ref SCIP_STAGE_SOLVED
8600  * - \ref SCIP_STAGE_EXITSOLVE
8601  */
8602 extern
8604  SCIP* scip, /**< SCIP data structure */
8605  SCIP_VAR* var /**< variable to get strong branching LP age for */
8606  );
8607 
8608 /** gets number of times, strong branching was applied in current run on the given variable
8609  *
8610  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8611  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8612  *
8613  * @pre This method can be called if @p scip is in one of the following stages:
8614  * - \ref SCIP_STAGE_TRANSFORMING
8615  * - \ref SCIP_STAGE_TRANSFORMED
8616  * - \ref SCIP_STAGE_INITPRESOLVE
8617  * - \ref SCIP_STAGE_PRESOLVING
8618  * - \ref SCIP_STAGE_EXITPRESOLVE
8619  * - \ref SCIP_STAGE_PRESOLVED
8620  * - \ref SCIP_STAGE_INITSOLVE
8621  * - \ref SCIP_STAGE_SOLVING
8622  * - \ref SCIP_STAGE_SOLVED
8623  * - \ref SCIP_STAGE_EXITSOLVE
8624  */
8625 extern
8627  SCIP* scip, /**< SCIP data structure */
8628  SCIP_VAR* var /**< variable to get last strong branching node for */
8629  );
8630 
8631 /** adds given values to lock numbers of variable for rounding
8632  *
8633  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8634  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8635  *
8636  * @pre This method can be called if @p scip is in one of the following stages:
8637  * - \ref SCIP_STAGE_PROBLEM
8638  * - \ref SCIP_STAGE_TRANSFORMING
8639  * - \ref SCIP_STAGE_TRANSFORMED
8640  * - \ref SCIP_STAGE_INITPRESOLVE
8641  * - \ref SCIP_STAGE_PRESOLVING
8642  * - \ref SCIP_STAGE_EXITPRESOLVE
8643  * - \ref SCIP_STAGE_PRESOLVED
8644  * - \ref SCIP_STAGE_INITSOLVE
8645  * - \ref SCIP_STAGE_SOLVING
8646  * - \ref SCIP_STAGE_EXITSOLVE
8647  * - \ref SCIP_STAGE_FREETRANS
8648  */
8649 extern
8651  SCIP* scip, /**< SCIP data structure */
8652  SCIP_VAR* var, /**< problem variable */
8653  int nlocksdown, /**< modification in number of rounding down locks */
8654  int nlocksup /**< modification in number of rounding up locks */
8655  );
8656 
8657 /** locks rounding of variable with respect to the lock status of the constraint and its negation;
8658  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
8659  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
8660  * added or removed
8661  *
8662  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8663  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8664  *
8665  * @pre This method can be called if @p scip is in one of the following stages:
8666  * - \ref SCIP_STAGE_PROBLEM
8667  * - \ref SCIP_STAGE_TRANSFORMING
8668  * - \ref SCIP_STAGE_INITPRESOLVE
8669  * - \ref SCIP_STAGE_PRESOLVING
8670  * - \ref SCIP_STAGE_EXITPRESOLVE
8671  * - \ref SCIP_STAGE_INITSOLVE
8672  * - \ref SCIP_STAGE_SOLVING
8673  * - \ref SCIP_STAGE_EXITSOLVE
8674  * - \ref SCIP_STAGE_FREETRANS
8675  */
8676 extern
8678  SCIP* scip, /**< SCIP data structure */
8679  SCIP_VAR* var, /**< problem variable */
8680  SCIP_CONS* cons, /**< constraint */
8681  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
8682  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
8683  );
8684 
8685 /** unlocks rounding of variable with respect to the lock status of the constraint and its negation;
8686  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
8687  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
8688  * added or removed
8689  *
8690  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8691  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8692  *
8693  * @pre This method can be called if @p scip is in one of the following stages:
8694  * - \ref SCIP_STAGE_PROBLEM
8695  * - \ref SCIP_STAGE_TRANSFORMING
8696  * - \ref SCIP_STAGE_INITPRESOLVE
8697  * - \ref SCIP_STAGE_PRESOLVING
8698  * - \ref SCIP_STAGE_EXITPRESOLVE
8699  * - \ref SCIP_STAGE_INITSOLVE
8700  * - \ref SCIP_STAGE_SOLVING
8701  * - \ref SCIP_STAGE_EXITSOLVE
8702  * - \ref SCIP_STAGE_FREETRANS
8703  */
8704 extern
8706  SCIP* scip, /**< SCIP data structure */
8707  SCIP_VAR* var, /**< problem variable */
8708  SCIP_CONS* cons, /**< constraint */
8709  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
8710  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
8711  );
8712 
8713 /** changes variable's objective value
8714  *
8715  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8716  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8717  *
8718  * @pre This method can be called if @p scip is in one of the following stages:
8719  * - \ref SCIP_STAGE_PROBLEM
8720  * - \ref SCIP_STAGE_TRANSFORMING
8721  * - \ref SCIP_STAGE_PRESOLVING
8722  */
8723 extern
8725  SCIP* scip, /**< SCIP data structure */
8726  SCIP_VAR* var, /**< variable to change the objective value for */
8727  SCIP_Real newobj /**< new objective value */
8728  );
8729 
8730 /** adds value to variable's objective value
8731  *
8732  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8733  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8734  *
8735  * @pre This method can be called if @p scip is in one of the following stages:
8736  * - \ref SCIP_STAGE_PROBLEM
8737  * - \ref SCIP_STAGE_TRANSFORMING
8738  * - \ref SCIP_STAGE_PRESOLVING
8739  * - \ref SCIP_STAGE_EXITPRESOLVE
8740  * - \ref SCIP_STAGE_PRESOLVED
8741  */
8742 extern
8744  SCIP* scip, /**< SCIP data structure */
8745  SCIP_VAR* var, /**< variable to change the objective value for */
8746  SCIP_Real addobj /**< additional objective value */
8747  );
8748 
8749 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
8750  * does not change the bounds of the variable
8751  *
8752  * @return adjusted lower bound for the given variable; the bound of the variable is not changed
8753  *
8754  * @pre This method can be called if @p scip is in one of the following stages:
8755  * - \ref SCIP_STAGE_PROBLEM
8756  * - \ref SCIP_STAGE_TRANSFORMING
8757  * - \ref SCIP_STAGE_TRANSFORMED
8758  * - \ref SCIP_STAGE_INITPRESOLVE
8759  * - \ref SCIP_STAGE_PRESOLVING
8760  * - \ref SCIP_STAGE_EXITPRESOLVE
8761  * - \ref SCIP_STAGE_PRESOLVED
8762  * - \ref SCIP_STAGE_INITSOLVE
8763  * - \ref SCIP_STAGE_SOLVING
8764  * - \ref SCIP_STAGE_SOLVED
8765  * - \ref SCIP_STAGE_EXITSOLVE
8766  * - \ref SCIP_STAGE_FREETRANS
8767  */
8768 extern
8770  SCIP* scip, /**< SCIP data structure */
8771  SCIP_VAR* var, /**< variable to adjust the bound for */
8772  SCIP_Real lb /**< lower bound value to adjust */
8773  );
8774 
8775 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
8776  * does not change the bounds of the variable
8777  *
8778  * @return adjusted upper bound for the given variable; the bound of the variable is not changed
8779  *
8780  * @pre This method can be called if @p scip is in one of the following stages:
8781  * - \ref SCIP_STAGE_PROBLEM
8782  * - \ref SCIP_STAGE_TRANSFORMING
8783  * - \ref SCIP_STAGE_TRANSFORMED
8784  * - \ref SCIP_STAGE_INITPRESOLVE
8785  * - \ref SCIP_STAGE_PRESOLVING
8786  * - \ref SCIP_STAGE_EXITPRESOLVE
8787  * - \ref SCIP_STAGE_PRESOLVED
8788  * - \ref SCIP_STAGE_INITSOLVE
8789  * - \ref SCIP_STAGE_SOLVING
8790  * - \ref SCIP_STAGE_SOLVED
8791  * - \ref SCIP_STAGE_EXITSOLVE
8792  * - \ref SCIP_STAGE_FREETRANS
8793  */
8794 extern
8796  SCIP* scip, /**< SCIP data structure */
8797  SCIP_VAR* var, /**< variable to adjust the bound for */
8798  SCIP_Real ub /**< upper bound value to adjust */
8799  );
8800 
8801 /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
8802  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
8803  * that in conflict analysis, this change is treated like a branching decision
8804  *
8805  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8806  * SCIPgetVars()) gets resorted.
8807  *
8808  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8809  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8810  *
8811  * @pre This method can be called if @p scip is in one of the following stages:
8812  * - \ref SCIP_STAGE_PROBLEM
8813  * - \ref SCIP_STAGE_TRANSFORMING
8814  * - \ref SCIP_STAGE_PRESOLVING
8815  * - \ref SCIP_STAGE_SOLVING
8816  *
8817  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8818  */
8819 extern
8821  SCIP* scip, /**< SCIP data structure */
8822  SCIP_VAR* var, /**< variable to change the bound for */
8823  SCIP_Real newbound /**< new value for bound */
8824  );
8825 
8826 /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
8827  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
8828  * that in conflict analysis, this change is treated like a branching decision
8829  *
8830  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8831  * SCIPgetVars()) gets resorted.
8832  *
8833  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8834  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8835  *
8836  * @pre This method can be called if @p scip is in one of the following stages:
8837  * - \ref SCIP_STAGE_PROBLEM
8838  * - \ref SCIP_STAGE_TRANSFORMING
8839  * - \ref SCIP_STAGE_PRESOLVING
8840  * - \ref SCIP_STAGE_SOLVING
8841  *
8842  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8843  */
8844 extern
8846  SCIP* scip, /**< SCIP data structure */
8847  SCIP_VAR* var, /**< variable to change the bound for */
8848  SCIP_Real newbound /**< new value for bound */
8849  );
8850 
8851 /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
8852  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
8853  * decision
8854  *
8855  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8856  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8857  *
8858  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8859  */
8860 extern
8862  SCIP* scip, /**< SCIP data structure */
8863  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
8864  SCIP_VAR* var, /**< variable to change the bound for */
8865  SCIP_Real newbound /**< new value for bound */
8866  );
8867 
8868 /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
8869  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
8870  * decision
8871  *
8872  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8873  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8874  *
8875  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8876  */
8877 extern
8879  SCIP* scip, /**< SCIP data structure */
8880  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
8881  SCIP_VAR* var, /**< variable to change the bound for */
8882  SCIP_Real newbound /**< new value for bound */
8883  );
8884 
8885 /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
8886  * if the global bound is better than the local bound
8887  *
8888  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8889  * SCIPgetVars()) gets resorted.
8890  *
8891  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8892  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8893  *
8894  * @pre This method can be called if @p scip is in one of the following stages:
8895  * - \ref SCIP_STAGE_PROBLEM
8896  * - \ref SCIP_STAGE_TRANSFORMING
8897  * - \ref SCIP_STAGE_PRESOLVING
8898  * - \ref SCIP_STAGE_SOLVING
8899  *
8900  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8901  */
8902 extern
8904  SCIP* scip, /**< SCIP data structure */
8905  SCIP_VAR* var, /**< variable to change the bound for */
8906  SCIP_Real newbound /**< new value for bound */
8907  );
8908 
8909 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
8910  * if the global bound is better than the local bound
8911  *
8912  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8913  * SCIPgetVars()) gets resorted.
8914  *
8915  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8916  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8917  *
8918  * @pre This method can be called if @p scip is in one of the following stages:
8919  * - \ref SCIP_STAGE_PROBLEM
8920  * - \ref SCIP_STAGE_TRANSFORMING
8921  * - \ref SCIP_STAGE_PRESOLVING
8922  * - \ref SCIP_STAGE_SOLVING
8923  *
8924  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8925  */
8926 extern
8928  SCIP* scip, /**< SCIP data structure */
8929  SCIP_VAR* var, /**< variable to change the bound for */
8930  SCIP_Real newbound /**< new value for bound */
8931  );
8932 
8933 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
8934  *
8935  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
8936  * to be put into the LP explicitly.
8937  *
8938  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8939  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8940  *
8941  * @pre This method can be called if @p scip is in one of the following stages:
8942  * - \ref SCIP_STAGE_PROBLEM
8943  * - \ref SCIP_STAGE_TRANSFORMING
8944  * - \ref SCIP_STAGE_TRANSFORMED
8945  * - \ref SCIP_STAGE_PRESOLVING
8946  * - \ref SCIP_STAGE_SOLVING
8947  *
8948  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
8949  */
8950 extern
8952  SCIP* scip, /**< SCIP data structure */
8953  SCIP_VAR* var, /**< problem variable */
8954  SCIP_Real lazylb /**< the lazy lower bound to be set */
8955  );
8956 
8957 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
8958  *
8959  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
8960  * to be put into the LP explicitly.
8961  *
8962  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8963  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8964  *
8965  * @pre This method can be called if @p scip is in one of the following stages:
8966  * - \ref SCIP_STAGE_PROBLEM
8967  * - \ref SCIP_STAGE_TRANSFORMING
8968  * - \ref SCIP_STAGE_TRANSFORMED
8969  * - \ref SCIP_STAGE_PRESOLVING
8970  * - \ref SCIP_STAGE_SOLVING
8971  *
8972  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
8973  */
8974 extern
8976  SCIP* scip, /**< SCIP data structure */
8977  SCIP_VAR* var, /**< problem variable */
8978  SCIP_Real lazyub /**< the lazy lower bound to be set */
8979  );
8980 
8981 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8982  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8983  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
8984  * is treated like a branching decision
8985  *
8986  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8987  * SCIPgetVars()) gets resorted.
8988  *
8989  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8990  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8991  *
8992  * @pre This method can be called if @p scip is in one of the following stages:
8993  * - \ref SCIP_STAGE_PROBLEM
8994  * - \ref SCIP_STAGE_PRESOLVING
8995  * - \ref SCIP_STAGE_SOLVING
8996  *
8997  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8998  */
8999 extern
9001  SCIP* scip, /**< SCIP data structure */
9002  SCIP_VAR* var, /**< variable to change the bound for */
9003  SCIP_Real newbound, /**< new value for bound */
9004  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9005  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
9006  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9007  );
9008 
9009 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
9010  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9011  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
9012  * is treated like a branching decision
9013  *
9014  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9015  * SCIPgetVars()) gets resorted.
9016  *
9017  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9018  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9019  *
9020  * @pre This method can be called if @p scip is in one of the following stages:
9021  * - \ref SCIP_STAGE_PROBLEM
9022  * - \ref SCIP_STAGE_PRESOLVING
9023  * - \ref SCIP_STAGE_SOLVING
9024  *
9025  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9026  */
9027 extern
9029  SCIP* scip, /**< SCIP data structure */
9030  SCIP_VAR* var, /**< variable to change the bound for */
9031  SCIP_Real newbound, /**< new value for bound */
9032  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9033  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
9034  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9035  );
9036 
9037 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
9038  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
9039  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
9040  *
9041  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
9042  * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
9043  * SCIPinferVarUbCons
9044  *
9045  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
9046  * SCIPgetVars()) gets resorted.
9047  *
9048  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
9049  */
9050 extern
9052  SCIP* scip, /**< SCIP data structure */
9053  SCIP_VAR* var, /**< variable to change the bound for */
9054  SCIP_Real fixedval, /**< new value for fixation */
9055  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
9056  int inferinfo, /**< user information for inference to help resolving the conflict */
9057  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9058  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9059  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9060  );
9061 
9062 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
9063  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9064  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
9065  * for the deduction of the bound change
9066  *
9067  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9068  * SCIPgetVars()) gets resorted.
9069  *
9070  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9071  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9072  *
9073  * @pre This method can be called if @p scip is in one of the following stages:
9074  * - \ref SCIP_STAGE_PROBLEM
9075  * - \ref SCIP_STAGE_PRESOLVING
9076  * - \ref SCIP_STAGE_SOLVING
9077  *
9078  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9079  */
9080 extern
9082  SCIP* scip, /**< SCIP data structure */
9083  SCIP_VAR* var, /**< variable to change the bound for */
9084  SCIP_Real newbound, /**< new value for bound */
9085  SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
9086  int inferinfo, /**< user information for inference to help resolving the conflict */
9087  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9088  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9089  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9090  );
9091 
9092 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
9093  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9094  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
9095  * for the deduction of the bound change
9096  *
9097  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9098  * SCIPgetVars()) gets resorted.
9099  *
9100  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9101  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9102  *
9103  * @pre This method can be called if @p scip is in one of the following stages:
9104  * - \ref SCIP_STAGE_PROBLEM
9105  * - \ref SCIP_STAGE_PRESOLVING
9106  * - \ref SCIP_STAGE_SOLVING
9107  *
9108  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9109  */
9110 extern
9112  SCIP* scip, /**< SCIP data structure */
9113  SCIP_VAR* var, /**< variable to change the bound for */
9114  SCIP_Real newbound, /**< new value for bound */
9115  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
9116  int inferinfo, /**< user information for inference to help resolving the conflict */
9117  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9118  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9119  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9120  );
9121 
9122 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
9123  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
9124  * deduction of the fixing
9125  *
9126  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9127  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9128  *
9129  * @pre This method can be called if @p scip is in one of the following stages:
9130  * - \ref SCIP_STAGE_PROBLEM
9131  * - \ref SCIP_STAGE_PRESOLVING
9132  * - \ref SCIP_STAGE_SOLVING
9133  */
9134 extern
9136  SCIP* scip, /**< SCIP data structure */
9137  SCIP_VAR* var, /**< binary variable to fix */
9138  SCIP_Bool fixedval, /**< value to fix binary variable to */
9139  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
9140  int inferinfo, /**< user information for inference to help resolving the conflict */
9141  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
9142  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
9143  );
9144 
9145 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
9146  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
9147  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
9148  *
9149  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
9150  * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
9151  * SCIPinferVarUbProp
9152  *
9153  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
9154  * SCIPgetVars()) gets resorted.
9155  *
9156  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
9157  */
9158 extern
9160  SCIP* scip, /**< SCIP data structure */
9161  SCIP_VAR* var, /**< variable to change the bound for */
9162  SCIP_Real fixedval, /**< new value for fixation */
9163  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
9164  int inferinfo, /**< user information for inference to help resolving the conflict */
9165  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9166  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9167  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9168  );
9169 
9170 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
9171  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9172  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
9173  * for the deduction of the bound change
9174  *
9175  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9176  * SCIPgetVars()) gets resorted.
9177  *
9178  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9179  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9180  *
9181  * @pre This method can be called if @p scip is in one of the following stages:
9182  * - \ref SCIP_STAGE_PROBLEM
9183  * - \ref SCIP_STAGE_PRESOLVING
9184  * - \ref SCIP_STAGE_SOLVING
9185  *
9186  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9187  */
9188 extern
9190  SCIP* scip, /**< SCIP data structure */
9191  SCIP_VAR* var, /**< variable to change the bound for */
9192  SCIP_Real newbound, /**< new value for bound */
9193  SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
9194  int inferinfo, /**< user information for inference to help resolving the conflict */
9195  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9196  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9197  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9198  );
9199 
9200 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
9201  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9202  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
9203  * for the deduction of the bound change
9204  *
9205  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9206  * SCIPgetVars()) gets resorted.
9207  *
9208  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9209  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9210  *
9211  * @pre This method can be called if @p scip is in one of the following stages:
9212  * - \ref SCIP_STAGE_PROBLEM
9213  * - \ref SCIP_STAGE_PRESOLVING
9214  * - \ref SCIP_STAGE_SOLVING
9215  *
9216  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9217  */
9218 extern
9220  SCIP* scip, /**< SCIP data structure */
9221  SCIP_VAR* var, /**< variable to change the bound for */
9222  SCIP_Real newbound, /**< new value for bound */
9223  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
9224  int inferinfo, /**< user information for inference to help resolving the conflict */
9225  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9226  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9227  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9228  );
9229 
9230 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
9231  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
9232  * deduction of the fixing
9233  *
9234  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9235  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9236  *
9237  * @pre This method can be called if @p scip is in one of the following stages:
9238  * - \ref SCIP_STAGE_PROBLEM
9239  * - \ref SCIP_STAGE_PRESOLVING
9240  * - \ref SCIP_STAGE_PRESOLVED
9241  * - \ref SCIP_STAGE_SOLVING
9242  */
9243 extern
9245  SCIP* scip, /**< SCIP data structure */
9246  SCIP_VAR* var, /**< binary variable to fix */
9247  SCIP_Bool fixedval, /**< value to fix binary variable to */
9248  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
9249  int inferinfo, /**< user information for inference to help resolving the conflict */
9250  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
9251  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
9252  );
9253 
9254 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
9255  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
9256  * also tightens the local bound, if the global bound is better than the local bound
9257  *
9258  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9259  * SCIPgetVars()) gets resorted.
9260  *
9261  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9262  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9263  *
9264  * @pre This method can be called if @p scip is in one of the following stages:
9265  * - \ref SCIP_STAGE_PROBLEM
9266  * - \ref SCIP_STAGE_TRANSFORMING
9267  * - \ref SCIP_STAGE_PRESOLVING
9268  * - \ref SCIP_STAGE_SOLVING
9269  *
9270  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9271  */
9272 extern
9274  SCIP* scip, /**< SCIP data structure */
9275  SCIP_VAR* var, /**< variable to change the bound for */
9276  SCIP_Real newbound, /**< new value for bound */
9277  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9278  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
9279  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9280  );
9281 
9282 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
9283  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
9284  * also tightens the local bound, if the global bound is better than the local bound
9285  *
9286  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9287  * SCIPgetVars()) gets resorted.
9288  *
9289  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9290  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9291  *
9292  * @pre This method can be called if @p scip is in one of the following stages:
9293  * - \ref SCIP_STAGE_PROBLEM
9294  * - \ref SCIP_STAGE_TRANSFORMING
9295  * - \ref SCIP_STAGE_PRESOLVING
9296  * - \ref SCIP_STAGE_SOLVING
9297  *
9298  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9299  */
9300 extern
9302  SCIP* scip, /**< SCIP data structure */
9303  SCIP_VAR* var, /**< variable to change the bound for */
9304  SCIP_Real newbound, /**< new value for bound */
9305  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9306  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
9307  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9308  );
9309 
9310 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
9311  *
9312  * This global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is not updated if bounds of aggregation variables are changing
9313  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
9314  *
9315  * @return the global lower bound computed by adding the global bounds from all aggregation variables
9316  */
9317 extern
9319  SCIP* scip, /**< SCIP data structure */
9320  SCIP_VAR* var /**< variable to compute the bound for */
9321  );
9322 
9323 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
9324  *
9325  * This global bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing
9326  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
9327  *
9328  * @return the global upper bound computed by adding the global bounds from all aggregation variables
9329  */
9330 extern
9332  SCIP* scip, /**< SCIP data structure */
9333  SCIP_VAR* var /**< variable to compute the bound for */
9334  );
9335 
9336 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
9337  *
9338  * This local bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing
9339  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
9340  *
9341  * @return the local lower bound computed by adding the global bounds from all aggregation variables
9342  */
9343 extern
9345  SCIP* scip, /**< SCIP data structure */
9346  SCIP_VAR* var /**< variable to compute the bound for */
9347  );
9348 
9349 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
9350  *
9351  * This local bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing
9352  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
9353  *
9354  * @return the local upper bound computed by adding the global bounds from all aggregation variables
9355  */
9356 extern
9358  SCIP* scip, /**< SCIP data structure */
9359  SCIP_VAR* var /**< variable to compute the bound for */
9360  );
9361 
9362 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
9363  * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
9364  * not updated if bounds of aggregation variables are changing
9365  *
9366  * calling this function for a non-multi-aggregated variable is not allowed
9367  */
9368 extern
9370  SCIP* scip, /**< SCIP data structure */
9371  SCIP_VAR* var /**< variable to compute the bound for */
9372  );
9373 
9374 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
9375  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
9376  * not updated if bounds of aggregation variables are changing
9377  *
9378  * calling this function for a non-multi-aggregated variable is not allowed
9379  */
9380 extern
9382  SCIP* scip, /**< SCIP data structure */
9383  SCIP_VAR* var /**< variable to compute the bound for */
9384  );
9385 
9386 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
9387  * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
9388  * not updated if bounds of aggregation variables are changing
9389  *
9390  * calling this function for a non-multi-aggregated variable is not allowed
9391  */
9392 extern
9394  SCIP* scip, /**< SCIP data structure */
9395  SCIP_VAR* var /**< variable to compute the bound for */
9396  );
9397 
9398 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
9399  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
9400  * not updated if bounds of aggregation variables are changing
9401  *
9402  * calling this function for a non-multi-aggregated variable is not allowed
9403  */
9404 extern
9406  SCIP* scip, /**< SCIP data structure */
9407  SCIP_VAR* var /**< variable to compute the bound for */
9408  );
9409 
9410 #ifdef NDEBUG
9411 
9412 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
9413  * speed up the algorithms.
9414  */
9415 
9416 #define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
9417 #define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
9418 #define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
9419 #define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
9420 
9421 #endif
9422 
9423 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
9424  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
9425  * available
9426  *
9427  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9428  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9429  *
9430  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
9431  */
9432 extern
9434  SCIP* scip, /**< SCIP data structure */
9435  SCIP_VAR* var, /**< active problem variable */
9436  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
9437  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
9438  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
9439  );
9440 
9441 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
9442  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
9443  *
9444  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9445  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9446  *
9447  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
9448  */
9449 extern
9451  SCIP* scip, /**< SCIP data structure */
9452  SCIP_VAR* var, /**< active problem variable */
9453  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
9454  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
9455  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
9456  );
9457 
9458 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
9459  * if z is binary, the corresponding valid implication for z is also added;
9460  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
9461  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
9462  * improves the global bounds of the variable and the vlb variable if possible
9463  *
9464  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9465  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9466  *
9467  * @pre This method can be called if @p scip is in one of the following stages:
9468  * - \ref SCIP_STAGE_PRESOLVING
9469  * - \ref SCIP_STAGE_PRESOLVED
9470  * - \ref SCIP_STAGE_SOLVING
9471  */
9472 extern
9474  SCIP* scip, /**< SCIP data structure */
9475  SCIP_VAR* var, /**< problem variable */
9476  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
9477  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
9478  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
9479  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9480  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9481  );
9482 
9483 
9484 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
9485  * if z is binary, the corresponding valid implication for z is also added;
9486  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
9487  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
9488  * improves the global bounds of the variable and the vlb variable if possible
9489  *
9490  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9491  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9492  *
9493  * @pre This method can be called if @p scip is in one of the following stages:
9494  * - \ref SCIP_STAGE_PRESOLVING
9495  * - \ref SCIP_STAGE_PRESOLVED
9496  * - \ref SCIP_STAGE_SOLVING
9497  */
9498 extern
9500  SCIP* scip, /**< SCIP data structure */
9501  SCIP_VAR* var, /**< problem variable */
9502  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
9503  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
9504  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
9505  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9506  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9507  );
9508 
9509 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
9510  * also adds the corresponding implication or variable bound to the implied variable;
9511  * if the implication is conflicting, the variable is fixed to the opposite value;
9512  * if the variable is already fixed to the given value, the implication is performed immediately;
9513  * if the implication is redundant with respect to the variables' global bounds, it is ignored
9514  *
9515  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9516  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9517  *
9518  * @pre This method can be called if @p scip is in one of the following stages:
9519  * - \ref SCIP_STAGE_TRANSFORMED
9520  * - \ref SCIP_STAGE_PRESOLVING
9521  * - \ref SCIP_STAGE_PRESOLVED
9522  * - \ref SCIP_STAGE_SOLVING
9523  */
9524 extern
9526  SCIP* scip, /**< SCIP data structure */
9527  SCIP_VAR* var, /**< problem variable */
9528  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
9529  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
9530  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
9531  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
9532  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
9533  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9534  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9535  );
9536 
9537 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
9538  * if a variable appears twice in the same clique, the corresponding implications are performed
9539  *
9540  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9541  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9542  *
9543  * @pre This method can be called if @p scip is in one of the following stages:
9544  * - \ref SCIP_STAGE_TRANSFORMED
9545  * - \ref SCIP_STAGE_PRESOLVING
9546  * - \ref SCIP_STAGE_PRESOLVED
9547  * - \ref SCIP_STAGE_SOLVING
9548  */
9549 extern
9551  SCIP* scip, /**< SCIP data structure */
9552  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
9553  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
9554  int nvars, /**< number of variables in the clique */
9555  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
9556  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9557  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9558  );
9559 
9560 /** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
9561  *
9562  * The algorithm performs the following steps:
9563  * - recomputes connected components of the clique table, if necessary
9564  * - computes a clique partition for every connected component greedily.
9565  * - relabels the resulting clique partition such that it satisfies the description below
9566  *
9567  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
9568  * were assigned to the same clique;
9569  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
9570  * the preceding variables was assigned to clique i-1;
9571  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
9572  *
9573  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9574  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9575  *
9576  * @pre This method can be called if @p scip is in one of the following stages:
9577  * - \ref SCIP_STAGE_INITPRESOLVE
9578  * - \ref SCIP_STAGE_PRESOLVING
9579  * - \ref SCIP_STAGE_EXITPRESOLVE
9580  * - \ref SCIP_STAGE_PRESOLVED
9581  * - \ref SCIP_STAGE_SOLVING
9582  */
9583 extern
9585  SCIP*const scip, /**< SCIP data structure */
9586  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
9587  int const nvars, /**< number of variables in the clique */
9588  int*const cliquepartition, /**< array of length nvars to store the clique partition */
9589  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
9590  );
9591 
9592 /** calculates a partition of the given set of binary variables into negated cliques;
9593  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
9594  * were assigned to the same negated clique;
9595  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
9596  * the preceding variables was assigned to clique i-1;
9597  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
9598  *
9599  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9600  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9601  *
9602  * @pre This method can be called if @p scip is in one of the following stages:
9603  * - \ref SCIP_STAGE_INITPRESOLVE
9604  * - \ref SCIP_STAGE_PRESOLVING
9605  * - \ref SCIP_STAGE_EXITPRESOLVE
9606  * - \ref SCIP_STAGE_PRESOLVED
9607  * - \ref SCIP_STAGE_SOLVING
9608  */
9609 extern
9611  SCIP*const scip, /**< SCIP data structure */
9612  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
9613  int const nvars, /**< number of variables in the clique */
9614  int*const cliquepartition, /**< array of length nvars to store the clique partition */
9615  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
9616  );
9617 
9618 /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
9619  * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
9620  *
9621  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
9622  *
9623  * @pre This method can be called if @p scip is in one of the following stages:
9624  * - \ref SCIP_STAGE_TRANSFORMED
9625  * - \ref SCIP_STAGE_INITPRESOLVE
9626  * - \ref SCIP_STAGE_PRESOLVING
9627  * - \ref SCIP_STAGE_EXITPRESOLVE
9628  * - \ref SCIP_STAGE_PRESOLVED
9629  * - \ref SCIP_STAGE_INITSOLVE
9630  * - \ref SCIP_STAGE_SOLVING
9631  * - \ref SCIP_STAGE_SOLVED
9632  * - \ref SCIP_STAGE_EXITSOLVE
9633  */
9634 extern
9636  SCIP* scip, /**< SCIP data structure */
9637  SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
9638  );
9639 
9640 /** gets the number of cliques in the clique table
9641  *
9642  * @return number of cliques in the clique table
9643  *
9644  * @pre This method can be called if @p scip is in one of the following stages:
9645  * - \ref SCIP_STAGE_TRANSFORMED
9646  * - \ref SCIP_STAGE_INITPRESOLVE
9647  * - \ref SCIP_STAGE_PRESOLVING
9648  * - \ref SCIP_STAGE_EXITPRESOLVE
9649  * - \ref SCIP_STAGE_PRESOLVED
9650  * - \ref SCIP_STAGE_INITSOLVE
9651  * - \ref SCIP_STAGE_SOLVING
9652  * - \ref SCIP_STAGE_SOLVED
9653  * - \ref SCIP_STAGE_EXITSOLVE
9654  */
9655 extern
9656 int SCIPgetNCliques(
9657  SCIP* scip /**< SCIP data structure */
9658  );
9659 
9660 /** gets the number of cliques created so far by the cliquetable
9661  *
9662  * @return number of cliques created so far by the cliquetable
9663  *
9664  * @pre This method can be called if @p scip is in one of the following stages:
9665  * - \ref SCIP_STAGE_TRANSFORMED
9666  * - \ref SCIP_STAGE_INITPRESOLVE
9667  * - \ref SCIP_STAGE_PRESOLVING
9668  * - \ref SCIP_STAGE_EXITPRESOLVE
9669  * - \ref SCIP_STAGE_PRESOLVED
9670  * - \ref SCIP_STAGE_INITSOLVE
9671  * - \ref SCIP_STAGE_SOLVING
9672  * - \ref SCIP_STAGE_SOLVED
9673  * - \ref SCIP_STAGE_EXITSOLVE
9674  */
9675 extern
9677  SCIP* scip /**< SCIP data structure */
9678  );
9679 
9680 /** gets the array of cliques in the clique table
9681  *
9682  * @return array of cliques in the clique table
9683  *
9684  * @pre This method can be called if @p scip is in one of the following stages:
9685  * - \ref SCIP_STAGE_TRANSFORMED
9686  * - \ref SCIP_STAGE_INITPRESOLVE
9687  * - \ref SCIP_STAGE_PRESOLVING
9688  * - \ref SCIP_STAGE_EXITPRESOLVE
9689  * - \ref SCIP_STAGE_PRESOLVED
9690  * - \ref SCIP_STAGE_INITSOLVE
9691  * - \ref SCIP_STAGE_SOLVING
9692  * - \ref SCIP_STAGE_SOLVED
9693  * - \ref SCIP_STAGE_EXITSOLVE
9694  */
9695 extern
9697  SCIP* scip /**< SCIP data structure */
9698  );
9699 
9700 /** returns whether there is a clique that contains both given variable/value pairs;
9701  * the variables must be active binary variables;
9702  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
9703  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
9704  *
9705  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
9706  *
9707  * @pre This method can be called if @p scip is in one of the following stages:
9708  * - \ref SCIP_STAGE_TRANSFORMED
9709  * - \ref SCIP_STAGE_INITPRESOLVE
9710  * - \ref SCIP_STAGE_PRESOLVING
9711  * - \ref SCIP_STAGE_EXITPRESOLVE
9712  * - \ref SCIP_STAGE_PRESOLVED
9713  * - \ref SCIP_STAGE_INITSOLVE
9714  * - \ref SCIP_STAGE_SOLVING
9715  * - \ref SCIP_STAGE_SOLVED
9716  * - \ref SCIP_STAGE_EXITSOLVE
9717  *
9718  * @note a variable with it's negated variable are NOT! in a clique
9719  * @note a variable with itself are in a clique
9720  */
9721 extern
9723  SCIP* scip, /**< SCIP data structure */
9724  SCIP_VAR* var1, /**< first variable */
9725  SCIP_Bool value1, /**< value of first variable */
9726  SCIP_VAR* var2, /**< second variable */
9727  SCIP_Bool value2, /**< value of second variable */
9728  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
9729  );
9730 
9731 /** writes the clique graph to a gml file
9732  *
9733  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9734  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9735  *
9736  * @pre This method can be called if @p scip is in one of the following stages:
9737  * - \ref SCIP_STAGE_TRANSFORMED
9738  * - \ref SCIP_STAGE_INITPRESOLVE
9739  * - \ref SCIP_STAGE_PRESOLVING
9740  * - \ref SCIP_STAGE_EXITPRESOLVE
9741  * - \ref SCIP_STAGE_PRESOLVED
9742  * - \ref SCIP_STAGE_INITSOLVE
9743  * - \ref SCIP_STAGE_SOLVING
9744  * - \ref SCIP_STAGE_SOLVED
9745  * - \ref SCIP_STAGE_EXITSOLVE
9746  *
9747  * @note there can be duplicated arcs in the output file
9748  *
9749  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
9750  * between such nodes are written.
9751  */
9752 extern
9754  SCIP* scip, /**< SCIP data structure */
9755  const char* fname, /**< name of file */
9756  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
9757  );
9758 
9759 /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
9760  * This is an advanced method which should be used with care.
9761  *
9762  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
9763  *
9764  * @pre This method can be called if @p scip is in one of the following stages:
9765  * - \ref SCIP_STAGE_TRANSFORMED
9766  * - \ref SCIP_STAGE_INITPRESOLVE
9767  * - \ref SCIP_STAGE_PRESOLVING
9768  * - \ref SCIP_STAGE_EXITPRESOLVE
9769  * - \ref SCIP_STAGE_PRESOLVED
9770  * - \ref SCIP_STAGE_INITSOLVE
9771  * - \ref SCIP_STAGE_SOLVING
9772  * - \ref SCIP_STAGE_SOLVED
9773  * - \ref SCIP_STAGE_EXITSOLVE
9774  */
9775 extern
9777  SCIP* scip, /**< SCIP data structure */
9778  SCIP_VAR* var /**< variable to remove from global structures */
9779  );
9780 
9781 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
9782  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
9783  *
9784  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9785  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9786  *
9787  * @pre This method can be called if @p scip is in one of the following stages:
9788  * - \ref SCIP_STAGE_PROBLEM
9789  * - \ref SCIP_STAGE_TRANSFORMING
9790  * - \ref SCIP_STAGE_TRANSFORMED
9791  * - \ref SCIP_STAGE_INITPRESOLVE
9792  * - \ref SCIP_STAGE_PRESOLVING
9793  * - \ref SCIP_STAGE_EXITPRESOLVE
9794  * - \ref SCIP_STAGE_PRESOLVED
9795  * - \ref SCIP_STAGE_SOLVING
9796  */
9797 extern
9799  SCIP* scip, /**< SCIP data structure */
9800  SCIP_VAR* var, /**< problem variable */
9801  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
9802  );
9803 
9804 /** scales the branch factor of the variable with the given value
9805  *
9806  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9807  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9808  *
9809  * @pre This method can be called if @p scip is in one of the following stages:
9810  * - \ref SCIP_STAGE_PROBLEM
9811  * - \ref SCIP_STAGE_TRANSFORMING
9812  * - \ref SCIP_STAGE_TRANSFORMED
9813  * - \ref SCIP_STAGE_INITPRESOLVE
9814  * - \ref SCIP_STAGE_PRESOLVING
9815  * - \ref SCIP_STAGE_EXITPRESOLVE
9816  * - \ref SCIP_STAGE_PRESOLVED
9817  * - \ref SCIP_STAGE_SOLVING
9818  */
9819 extern
9821  SCIP* scip, /**< SCIP data structure */
9822  SCIP_VAR* var, /**< problem variable */
9823  SCIP_Real scale /**< factor to scale variable's branching factor with */
9824  );
9825 
9826 /** adds the given value to the branch factor of the variable
9827  *
9828  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9829  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9830  *
9831  * @pre This method can be called if @p scip is in one of the following stages:
9832  * - \ref SCIP_STAGE_PROBLEM
9833  * - \ref SCIP_STAGE_TRANSFORMING
9834  * - \ref SCIP_STAGE_TRANSFORMED
9835  * - \ref SCIP_STAGE_INITPRESOLVE
9836  * - \ref SCIP_STAGE_PRESOLVING
9837  * - \ref SCIP_STAGE_EXITPRESOLVE
9838  * - \ref SCIP_STAGE_PRESOLVED
9839  * - \ref SCIP_STAGE_SOLVING
9840  */
9841 extern
9843  SCIP* scip, /**< SCIP data structure */
9844  SCIP_VAR* var, /**< problem variable */
9845  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
9846  );
9847 
9848 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
9849  * with lower priority in selection of branching variable
9850  *
9851  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9852  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9853  *
9854  * @pre This method can be called if @p scip is in one of the following stages:
9855  * - \ref SCIP_STAGE_PROBLEM
9856  * - \ref SCIP_STAGE_TRANSFORMING
9857  * - \ref SCIP_STAGE_TRANSFORMED
9858  * - \ref SCIP_STAGE_INITPRESOLVE
9859  * - \ref SCIP_STAGE_PRESOLVING
9860  * - \ref SCIP_STAGE_EXITPRESOLVE
9861  * - \ref SCIP_STAGE_PRESOLVED
9862  * - \ref SCIP_STAGE_SOLVING
9863  *
9864  * @note the default branching priority is 0
9865  */
9866 extern
9868  SCIP* scip, /**< SCIP data structure */
9869  SCIP_VAR* var, /**< problem variable */
9870  int branchpriority /**< branch priority of the variable */
9871  );
9872 
9873 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
9874  *
9875  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9876  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9877  *
9878  * @pre This method can be called if @p scip is in one of the following stages:
9879  * - \ref SCIP_STAGE_PROBLEM
9880  * - \ref SCIP_STAGE_TRANSFORMING
9881  * - \ref SCIP_STAGE_TRANSFORMED
9882  * - \ref SCIP_STAGE_INITPRESOLVE
9883  * - \ref SCIP_STAGE_PRESOLVING
9884  * - \ref SCIP_STAGE_EXITPRESOLVE
9885  * - \ref SCIP_STAGE_PRESOLVED
9886  * - \ref SCIP_STAGE_SOLVING
9887  */
9888 extern
9890  SCIP* scip, /**< SCIP data structure */
9891  SCIP_VAR* var, /**< problem variable */
9892  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
9893  );
9894 
9895 /** adds the given value to the branch priority of the variable
9896  *
9897  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9898  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9899  *
9900  * @pre This method can be called if @p scip is in one of the following stages:
9901  * - \ref SCIP_STAGE_PROBLEM
9902  * - \ref SCIP_STAGE_TRANSFORMING
9903  * - \ref SCIP_STAGE_TRANSFORMED
9904  * - \ref SCIP_STAGE_INITPRESOLVE
9905  * - \ref SCIP_STAGE_PRESOLVING
9906  * - \ref SCIP_STAGE_EXITPRESOLVE
9907  * - \ref SCIP_STAGE_PRESOLVED
9908  * - \ref SCIP_STAGE_SOLVING
9909  */
9910 extern
9912  SCIP* scip, /**< SCIP data structure */
9913  SCIP_VAR* var, /**< problem variable */
9914  int addpriority /**< value to add to the branch priority of the variable */
9915  );
9916 
9917 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
9918  * branch)
9919  *
9920  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9921  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9922  *
9923  * @pre This method can be called if @p scip is in one of the following stages:
9924  * - \ref SCIP_STAGE_PROBLEM
9925  * - \ref SCIP_STAGE_TRANSFORMING
9926  * - \ref SCIP_STAGE_TRANSFORMED
9927  * - \ref SCIP_STAGE_INITPRESOLVE
9928  * - \ref SCIP_STAGE_PRESOLVING
9929  * - \ref SCIP_STAGE_EXITPRESOLVE
9930  * - \ref SCIP_STAGE_PRESOLVED
9931  * - \ref SCIP_STAGE_SOLVING
9932  */
9933 extern
9935  SCIP* scip, /**< SCIP data structure */
9936  SCIP_VAR* var, /**< problem variable */
9937  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
9938  );
9939 
9940 /** changes type of variable in the problem;
9941  *
9942  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
9943  *
9944  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9945  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9946  *
9947  * @pre This method can be called if @p scip is in one of the following stages:
9948  * - \ref SCIP_STAGE_PROBLEM
9949  * - \ref SCIP_STAGE_TRANSFORMING
9950  * - \ref SCIP_STAGE_PRESOLVING
9951  *
9952  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
9953  * corresponding transformed variable is changed; the type of the original variable does not change
9954  *
9955  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
9956  * adjusted w.r.t. to integrality information
9957  */
9958 extern
9960  SCIP* scip, /**< SCIP data structure */
9961  SCIP_VAR* var, /**< variable to change the bound for */
9962  SCIP_VARTYPE vartype, /**< new type of variable */
9963  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
9964  * integrality condition of the new variable type) */
9965  );
9966 
9967 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
9968  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
9969  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
9970  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
9971  *
9972  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9973  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9974  *
9975  * @pre This method can be called if @p scip is in one of the following stages:
9976  * - \ref SCIP_STAGE_PROBLEM
9977  * - \ref SCIP_STAGE_PRESOLVING
9978  * - \ref SCIP_STAGE_SOLVING
9979  */
9980 extern
9982  SCIP* scip, /**< SCIP data structure */
9983  SCIP_VAR* var, /**< variable to fix */
9984  SCIP_Real fixedval, /**< value to fix variable to */
9985  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
9986  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
9987  );
9988 
9989 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
9990  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
9991  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
9992  * In the first step, the equality is transformed into an equality with active problem variables
9993  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
9994  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
9995  * infeasibility) otherwise.
9996  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
9997  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
9998  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
9999  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
10000  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
10001  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
10002  *
10003  * The output flags have the following meaning:
10004  * - infeasible: the problem is infeasible
10005  * - redundant: the equality can be deleted from the constraint set
10006  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
10007  *
10008  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10009  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10010  *
10011  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
10012  */
10013 extern
10015  SCIP* scip, /**< SCIP data structure */
10016  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
10017  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
10018  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
10019  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
10020  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
10021  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
10022  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
10023  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
10024  );
10025 
10026 /** converts variable into multi-aggregated variable; this changes the variable array returned from
10027  * SCIPgetVars() and SCIPgetVarsData();
10028  *
10029  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
10030  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
10031  * implies integrality on the aggregated variable.
10032  *
10033  * The output flags have the following meaning:
10034  * - infeasible: the problem is infeasible
10035  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
10036  *
10037  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10038  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10039  *
10040  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
10041  */
10042 extern
10044  SCIP* scip, /**< SCIP data structure */
10045  SCIP_VAR* var, /**< variable x to aggregate */
10046  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
10047  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
10048  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
10049  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
10050  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
10051  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
10052  );
10053 
10054 /** returns whether aggregation of variables is not allowed */
10055 extern
10057  SCIP* scip /**< SCIP data structure */
10058  );
10059 
10060 /** returns whether multi-aggregation is disabled */
10061 extern
10063  SCIP* scip /**< SCIP data structure */
10064  );
10065 
10066 /** returns whether variable is not allowed to be multi-aggregated */
10067 extern
10069  SCIP* scip, /**< SCIP data structure */
10070  SCIP_VAR* var /**< variable x to aggregate */
10071  );
10072 
10073 /** returns whether dual reduction are allowed during propagation and presolving
10074  *
10075  * @note A reduction is called dual, if it may discard feasible solutions, but leaves at least one optimal solution
10076  * intact. Often such reductions are based on analyzing the objective function, reduced costs and/or dual LPs.
10077  */
10078 extern
10080  SCIP* scip /**< SCIP data structure */
10081  );
10082 
10083 /** returns whether propagation w.r.t. current objective is allowed */
10084 extern
10086  SCIP* scip /**< SCIP data structure */
10087  );
10088 
10089 /** modifies an initial seed value with the global shift of random seeds */
10090 extern
10091 unsigned int SCIPinitializeRandomSeed(
10092  SCIP* scip, /**< SCIP data structure */
10093  int initialseedvalue /**< initial seed value to be modified */
10094  );
10095 
10096 /** marks the variable that it must not be multi-aggregated
10097  *
10098  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10099  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10100  *
10101  * @pre This method can be called if @p scip is in one of the following stages:
10102  * - \ref SCIP_STAGE_INIT
10103  * - \ref SCIP_STAGE_PROBLEM
10104  * - \ref SCIP_STAGE_TRANSFORMING
10105  * - \ref SCIP_STAGE_TRANSFORMED
10106  * - \ref SCIP_STAGE_INITPRESOLVE
10107  * - \ref SCIP_STAGE_PRESOLVING
10108  * - \ref SCIP_STAGE_EXITPRESOLVE
10109  *
10110  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
10111  * multi-aggregated that this is will be the case.
10112  */
10113 extern
10115  SCIP* scip, /**< SCIP data structure */
10116  SCIP_VAR* var /**< variable to delete */
10117  );
10118 
10119 /** enables the collection of statistics for a variable
10120  *
10121  * @pre This method can be called if @p scip is in one of the following stages:
10122  * - \ref SCIP_STAGE_PROBLEM
10123  * - \ref SCIP_STAGE_INITPRESOLVE
10124  * - \ref SCIP_STAGE_PRESOLVING
10125  * - \ref SCIP_STAGE_EXITPRESOLVE
10126  * - \ref SCIP_STAGE_SOLVING
10127  * - \ref SCIP_STAGE_SOLVED
10128  */
10129 extern
10131  SCIP* scip /**< SCIP data structure */
10132  );
10133 
10134 /** disables the collection of any statistic for a variable
10135  *
10136  * @pre This method can be called if @p scip is in one of the following stages:
10137  * - \ref SCIP_STAGE_PROBLEM
10138  * - \ref SCIP_STAGE_INITPRESOLVE
10139  * - \ref SCIP_STAGE_PRESOLVING
10140  * - \ref SCIP_STAGE_EXITPRESOLVE
10141  * - \ref SCIP_STAGE_SOLVING
10142  * - \ref SCIP_STAGE_SOLVED
10143  */
10144 extern
10146  SCIP* scip /**< SCIP data structure */
10147  );
10148 
10149 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
10150  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
10151  * the update is ignored, if the objective value difference is infinite
10152  *
10153  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10154  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10155  *
10156  * @pre This method can be called if @p scip is in one of the following stages:
10157  * - \ref SCIP_STAGE_SOLVING
10158  * - \ref SCIP_STAGE_SOLVED
10159  */
10160 extern
10162  SCIP* scip, /**< SCIP data structure */
10163  SCIP_VAR* var, /**< problem variable */
10164  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
10165  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
10166  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
10167  );
10168 
10169 /** gets the variable's pseudo cost value for the given change of the variable's LP value
10170  *
10171  * @return the variable's pseudo cost value for the given change of the variable's LP value
10172  *
10173  * @pre This method can be called if @p scip is in one of the following stages:
10174  * - \ref SCIP_STAGE_INITPRESOLVE
10175  * - \ref SCIP_STAGE_PRESOLVING
10176  * - \ref SCIP_STAGE_EXITPRESOLVE
10177  * - \ref SCIP_STAGE_PRESOLVED
10178  * - \ref SCIP_STAGE_INITSOLVE
10179  * - \ref SCIP_STAGE_SOLVING
10180  * - \ref SCIP_STAGE_SOLVED
10181  */
10182 extern
10184  SCIP* scip, /**< SCIP data structure */
10185  SCIP_VAR* var, /**< problem variable */
10186  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
10187  );
10188 
10189 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
10190  * only using the pseudo cost information of the current run
10191  *
10192  * @return the variable's pseudo cost value for the given change of the variable's LP value,
10193  * only using the pseudo cost information of the current run
10194  *
10195  * @pre This method can be called if @p scip is in one of the following stages:
10196  * - \ref SCIP_STAGE_INITPRESOLVE
10197  * - \ref SCIP_STAGE_PRESOLVING
10198  * - \ref SCIP_STAGE_EXITPRESOLVE
10199  * - \ref SCIP_STAGE_PRESOLVED
10200  * - \ref SCIP_STAGE_INITSOLVE
10201  * - \ref SCIP_STAGE_SOLVING
10202  * - \ref SCIP_STAGE_SOLVED
10203  */
10204 extern
10206  SCIP* scip, /**< SCIP data structure */
10207  SCIP_VAR* var, /**< problem variable */
10208  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
10209  );
10210 
10211 /** gets the variable's pseudo cost value for the given direction
10212  *
10213  * @return the variable's pseudo cost value for the given direction
10214  *
10215  * @pre This method can be called if @p scip is in one of the following stages:
10216  * - \ref SCIP_STAGE_INITPRESOLVE
10217  * - \ref SCIP_STAGE_PRESOLVING
10218  * - \ref SCIP_STAGE_EXITPRESOLVE
10219  * - \ref SCIP_STAGE_PRESOLVED
10220  * - \ref SCIP_STAGE_INITSOLVE
10221  * - \ref SCIP_STAGE_SOLVING
10222  * - \ref SCIP_STAGE_SOLVED
10223  */
10224 extern
10226  SCIP* scip, /**< SCIP data structure */
10227  SCIP_VAR* var, /**< problem variable */
10228  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10229  );
10230 
10231 /** gets the variable's pseudo cost value for the given direction,
10232  * only using the pseudo cost information of the current run
10233  *
10234  * @return the variable's pseudo cost value for the given direction,
10235  * only using the pseudo cost information of the current run
10236  *
10237  * @pre This method can be called if @p scip is in one of the following stages:
10238  * - \ref SCIP_STAGE_INITPRESOLVE
10239  * - \ref SCIP_STAGE_PRESOLVING
10240  * - \ref SCIP_STAGE_EXITPRESOLVE
10241  * - \ref SCIP_STAGE_PRESOLVED
10242  * - \ref SCIP_STAGE_INITSOLVE
10243  * - \ref SCIP_STAGE_SOLVING
10244  * - \ref SCIP_STAGE_SOLVED
10245  */
10246 extern
10248  SCIP* scip, /**< SCIP data structure */
10249  SCIP_VAR* var, /**< problem variable */
10250  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10251  );
10252 
10253 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
10254  *
10255  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
10256  *
10257  * @pre This method can be called if @p scip is in one of the following stages:
10258  * - \ref SCIP_STAGE_INITPRESOLVE
10259  * - \ref SCIP_STAGE_PRESOLVING
10260  * - \ref SCIP_STAGE_EXITPRESOLVE
10261  * - \ref SCIP_STAGE_PRESOLVED
10262  * - \ref SCIP_STAGE_INITSOLVE
10263  * - \ref SCIP_STAGE_SOLVING
10264  * - \ref SCIP_STAGE_SOLVED
10265  */
10266 extern
10268  SCIP* scip, /**< SCIP data structure */
10269  SCIP_VAR* var, /**< problem variable */
10270  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10271  );
10272 
10273 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
10274  * only using the pseudo cost information of the current run
10275  *
10276  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
10277  * only using the pseudo cost information of the current run
10278  *
10279  * @pre This method can be called if @p scip is in one of the following stages:
10280  * - \ref SCIP_STAGE_INITPRESOLVE
10281  * - \ref SCIP_STAGE_PRESOLVING
10282  * - \ref SCIP_STAGE_EXITPRESOLVE
10283  * - \ref SCIP_STAGE_PRESOLVED
10284  * - \ref SCIP_STAGE_INITSOLVE
10285  * - \ref SCIP_STAGE_SOLVING
10286  * - \ref SCIP_STAGE_SOLVED
10287  */
10288 extern
10290  SCIP* scip, /**< SCIP data structure */
10291  SCIP_VAR* var, /**< problem variable */
10292  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10293  );
10294 
10295 /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
10296  *
10297  * @return returns the (corrected) variance of pseudo code information collected so far.
10298  *
10299  * @pre This method can be called if @p scip is in one of the following stages:
10300  * - \ref SCIP_STAGE_INITPRESOLVE
10301  * - \ref SCIP_STAGE_PRESOLVING
10302  * - \ref SCIP_STAGE_EXITPRESOLVE
10303  * - \ref SCIP_STAGE_PRESOLVED
10304  * - \ref SCIP_STAGE_INITSOLVE
10305  * - \ref SCIP_STAGE_SOLVING
10306  * - \ref SCIP_STAGE_SOLVED
10307  */
10308 extern
10310  SCIP* scip, /**< SCIP data structure */
10311  SCIP_VAR* var, /**< problem variable */
10312  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
10313  SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
10314  );
10315 
10316 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
10317  *
10318  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
10319  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
10320  * of 2 * clevel - 1.
10321  *
10322  * @return value of confidence bound for this variable
10323  */
10324 extern
10326  SCIP* scip, /**< SCIP data structure */
10327  SCIP_VAR* var, /**< variable in question */
10328  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
10329  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
10330  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
10331  );
10332 
10333 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
10334  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
10335  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
10336  * unknown location means of the underlying pseudo-cost distributions of x and y.
10337  *
10338  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
10339  * better than x (despite the current information), meaning that y can be expected to yield branching
10340  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
10341  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
10342  * than y.
10343  *
10344  * @note The order of x and y matters for the one-sided hypothesis
10345  *
10346  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
10347  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
10348  *
10349  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
10350  */
10351 extern
10353  SCIP* scip, /**< SCIP data structure */
10354  SCIP_VAR* varx, /**< variable x */
10355  SCIP_Real fracx, /**< the fractionality of variable x */
10356  SCIP_VAR* vary, /**< variable y */
10357  SCIP_Real fracy, /**< the fractionality of variable y */
10358  SCIP_BRANCHDIR dir, /**< branching direction */
10359  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
10360  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
10361  );
10362 
10363 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
10364  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
10365  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
10366  * of at least \p threshold.
10367  *
10368  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
10369  * the estimated probability to exceed \p threshold is less than 25 %.
10370  *
10371  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
10372  * of confidence.
10373  *
10374  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
10375  * at the given confidence level \p clevel.
10376  */
10377 extern
10379  SCIP* scip, /**< SCIP data structure */
10380  SCIP_VAR* var, /**< variable x */
10381  SCIP_Real frac, /**< the fractionality of variable x */
10382  SCIP_Real threshold, /**< the threshold to test against */
10383  SCIP_BRANCHDIR dir, /**< branching direction */
10384  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
10385  );
10386 
10387 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
10388  * Error is calculated at a specific confidence level
10389  *
10390  * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
10391  */
10392 extern
10394  SCIP* scip, /**< SCIP data structure */
10395  SCIP_VAR* var, /**< variable in question */
10396  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
10397  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
10398  );
10399 
10400 /** gets the variable's pseudo cost score value for the given LP solution value
10401  *
10402  * @return the variable's pseudo cost score value for the given LP solution value
10403  *
10404  * @pre This method can be called if @p scip is in one of the following stages:
10405  * - \ref SCIP_STAGE_INITPRESOLVE
10406  * - \ref SCIP_STAGE_PRESOLVING
10407  * - \ref SCIP_STAGE_EXITPRESOLVE
10408  * - \ref SCIP_STAGE_PRESOLVED
10409  * - \ref SCIP_STAGE_INITSOLVE
10410  * - \ref SCIP_STAGE_SOLVING
10411  * - \ref SCIP_STAGE_SOLVED
10412  */
10413 extern
10415  SCIP* scip, /**< SCIP data structure */
10416  SCIP_VAR* var, /**< problem variable */
10417  SCIP_Real solval /**< variable's LP solution value */
10418  );
10419 
10420 /** gets the variable's pseudo cost score value for the given LP solution value,
10421  * only using the pseudo cost information of the current run
10422  *
10423  * @return the variable's pseudo cost score value for the given LP solution value,
10424  * only using the pseudo cost information of the current run
10425  *
10426  * @pre This method can be called if @p scip is in one of the following stages:
10427  * - \ref SCIP_STAGE_INITPRESOLVE
10428  * - \ref SCIP_STAGE_PRESOLVING
10429  * - \ref SCIP_STAGE_EXITPRESOLVE
10430  * - \ref SCIP_STAGE_PRESOLVED
10431  * - \ref SCIP_STAGE_INITSOLVE
10432  * - \ref SCIP_STAGE_SOLVING
10433  * - \ref SCIP_STAGE_SOLVED
10434  */
10435 extern
10437  SCIP* scip, /**< SCIP data structure */
10438  SCIP_VAR* var, /**< problem variable */
10439  SCIP_Real solval /**< variable's LP solution value */
10440  );
10441 
10442 /** returns the variable's VSIDS value
10443  *
10444  * @return the variable's VSIDS value
10445  *
10446  * @pre This method can be called if @p scip is in one of the following stages:
10447  * - \ref SCIP_STAGE_INITPRESOLVE
10448  * - \ref SCIP_STAGE_PRESOLVING
10449  * - \ref SCIP_STAGE_EXITPRESOLVE
10450  * - \ref SCIP_STAGE_PRESOLVED
10451  * - \ref SCIP_STAGE_INITSOLVE
10452  * - \ref SCIP_STAGE_SOLVING
10453  * - \ref SCIP_STAGE_SOLVED
10454  */
10455 extern
10457  SCIP* scip, /**< SCIP data structure */
10458  SCIP_VAR* var, /**< problem variable */
10459  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10460  );
10461 
10462 /** returns the variable's VSIDS value only using conflicts of the current run
10463  *
10464  * @return the variable's VSIDS value only using conflicts of the current run
10465  *
10466  * @pre This method can be called if @p scip is in one of the following stages:
10467  * - \ref SCIP_STAGE_INITPRESOLVE
10468  * - \ref SCIP_STAGE_PRESOLVING
10469  * - \ref SCIP_STAGE_EXITPRESOLVE
10470  * - \ref SCIP_STAGE_PRESOLVED
10471  * - \ref SCIP_STAGE_INITSOLVE
10472  * - \ref SCIP_STAGE_SOLVING
10473  * - \ref SCIP_STAGE_SOLVED
10474  */
10475 extern
10477  SCIP* scip, /**< SCIP data structure */
10478  SCIP_VAR* var, /**< problem variable */
10479  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10480  );
10481 
10482 /** returns the variable's conflict score value
10483  *
10484  * @return the variable's conflict score value
10485  *
10486  * @pre This method can be called if @p scip is in one of the following stages:
10487  * - \ref SCIP_STAGE_INITPRESOLVE
10488  * - \ref SCIP_STAGE_PRESOLVING
10489  * - \ref SCIP_STAGE_EXITPRESOLVE
10490  * - \ref SCIP_STAGE_PRESOLVED
10491  * - \ref SCIP_STAGE_INITSOLVE
10492  * - \ref SCIP_STAGE_SOLVING
10493  * - \ref SCIP_STAGE_SOLVED
10494  */
10495 extern
10497  SCIP* scip, /**< SCIP data structure */
10498  SCIP_VAR* var /**< problem variable */
10499  );
10500 
10501 /** returns the variable's conflict score value only using conflicts of the current run
10502  *
10503  * @return the variable's conflict score value only using conflicts of the current run
10504  *
10505  * @pre This method can be called if @p scip is in one of the following stages:
10506  * - \ref SCIP_STAGE_INITPRESOLVE
10507  * - \ref SCIP_STAGE_PRESOLVING
10508  * - \ref SCIP_STAGE_EXITPRESOLVE
10509  * - \ref SCIP_STAGE_PRESOLVED
10510  * - \ref SCIP_STAGE_INITSOLVE
10511  * - \ref SCIP_STAGE_SOLVING
10512  * - \ref SCIP_STAGE_SOLVED
10513  */
10514 extern
10516  SCIP* scip, /**< SCIP data structure */
10517  SCIP_VAR* var /**< problem variable */
10518  );
10519 
10520 /** returns the variable's conflict length score
10521  *
10522  * @return the variable's conflict length score
10523  *
10524  * @pre This method can be called if @p scip is in one of the following stages:
10525  * - \ref SCIP_STAGE_INITPRESOLVE
10526  * - \ref SCIP_STAGE_PRESOLVING
10527  * - \ref SCIP_STAGE_EXITPRESOLVE
10528  * - \ref SCIP_STAGE_PRESOLVED
10529  * - \ref SCIP_STAGE_INITSOLVE
10530  * - \ref SCIP_STAGE_SOLVING
10531  * - \ref SCIP_STAGE_SOLVED
10532  */
10533 extern
10535  SCIP* scip, /**< SCIP data structure */
10536  SCIP_VAR* var /**< problem variable */
10537  );
10538 
10539 /** returns the variable's conflict length score only using conflicts of the current run
10540  *
10541  * @return the variable's conflict length score only using conflicts of the current run
10542  *
10543  * @pre This method can be called if @p scip is in one of the following stages:
10544  * - \ref SCIP_STAGE_INITPRESOLVE
10545  * - \ref SCIP_STAGE_PRESOLVING
10546  * - \ref SCIP_STAGE_EXITPRESOLVE
10547  * - \ref SCIP_STAGE_PRESOLVED
10548  * - \ref SCIP_STAGE_INITSOLVE
10549  * - \ref SCIP_STAGE_SOLVING
10550  * - \ref SCIP_STAGE_SOLVED
10551  */
10552 extern
10554  SCIP* scip, /**< SCIP data structure */
10555  SCIP_VAR* var /**< problem variable */
10556  );
10557 
10558 /** returns the variable's average conflict length
10559  *
10560  * @return the variable's average conflict length
10561  *
10562  * @pre This method can be called if @p scip is in one of the following stages:
10563  * - \ref SCIP_STAGE_INITPRESOLVE
10564  * - \ref SCIP_STAGE_PRESOLVING
10565  * - \ref SCIP_STAGE_EXITPRESOLVE
10566  * - \ref SCIP_STAGE_PRESOLVED
10567  * - \ref SCIP_STAGE_INITSOLVE
10568  * - \ref SCIP_STAGE_SOLVING
10569  * - \ref SCIP_STAGE_SOLVED
10570  */
10571 extern
10573  SCIP* scip, /**< SCIP data structure */
10574  SCIP_VAR* var, /**< problem variable */
10575  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10576  );
10577 
10578 /** returns the variable's average conflict length only using conflicts of the current run
10579  *
10580  * @return the variable's average conflict length only using conflicts of the current run
10581  *
10582  * @pre This method can be called if @p scip is in one of the following stages:
10583  * - \ref SCIP_STAGE_INITPRESOLVE
10584  * - \ref SCIP_STAGE_PRESOLVING
10585  * - \ref SCIP_STAGE_EXITPRESOLVE
10586  * - \ref SCIP_STAGE_PRESOLVED
10587  * - \ref SCIP_STAGE_INITSOLVE
10588  * - \ref SCIP_STAGE_SOLVING
10589  * - \ref SCIP_STAGE_SOLVED
10590  */
10591 extern
10593  SCIP* scip, /**< SCIP data structure */
10594  SCIP_VAR* var, /**< problem variable */
10595  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10596  );
10597 
10598 /** returns the average number of inferences found after branching on the variable in given direction;
10599  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
10600  * over all variables for branching in the given direction is returned
10601  *
10602  * @return the average number of inferences found after branching on the variable in given direction
10603  *
10604  * @pre This method can be called if @p scip is in one of the following stages:
10605  * - \ref SCIP_STAGE_INITPRESOLVE
10606  * - \ref SCIP_STAGE_PRESOLVING
10607  * - \ref SCIP_STAGE_EXITPRESOLVE
10608  * - \ref SCIP_STAGE_PRESOLVED
10609  * - \ref SCIP_STAGE_INITSOLVE
10610  * - \ref SCIP_STAGE_SOLVING
10611  * - \ref SCIP_STAGE_SOLVED
10612  */
10613 extern
10615  SCIP* scip, /**< SCIP data structure */
10616  SCIP_VAR* var, /**< problem variable */
10617  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10618  );
10619 
10620 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
10621  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
10622  * over all variables for branching in the given direction is returned
10623  *
10624  * @return the average number of inferences found after branching on the variable in given direction in the current run
10625  *
10626  * @pre This method can be called if @p scip is in one of the following stages:
10627  * - \ref SCIP_STAGE_INITPRESOLVE
10628  * - \ref SCIP_STAGE_PRESOLVING
10629  * - \ref SCIP_STAGE_EXITPRESOLVE
10630  * - \ref SCIP_STAGE_PRESOLVED
10631  * - \ref SCIP_STAGE_INITSOLVE
10632  * - \ref SCIP_STAGE_SOLVING
10633  * - \ref SCIP_STAGE_SOLVED
10634  */
10635 extern
10637  SCIP* scip, /**< SCIP data structure */
10638  SCIP_VAR* var, /**< problem variable */
10639  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10640  );
10641 
10642 /** returns the variable's average inference score value
10643  *
10644  * @return the variable's average inference score value
10645  *
10646  * @pre This method can be called if @p scip is in one of the following stages:
10647  * - \ref SCIP_STAGE_INITPRESOLVE
10648  * - \ref SCIP_STAGE_PRESOLVING
10649  * - \ref SCIP_STAGE_EXITPRESOLVE
10650  * - \ref SCIP_STAGE_PRESOLVED
10651  * - \ref SCIP_STAGE_INITSOLVE
10652  * - \ref SCIP_STAGE_SOLVING
10653  * - \ref SCIP_STAGE_SOLVED
10654  */
10655 extern
10657  SCIP* scip, /**< SCIP data structure */
10658  SCIP_VAR* var /**< problem variable */
10659  );
10660 
10661 /** returns the variable's average inference score value only using inferences of the current run
10662  *
10663  * @return the variable's average inference score value only using inferences of the current run
10664  *
10665  * @pre This method can be called if @p scip is in one of the following stages:
10666  * - \ref SCIP_STAGE_INITPRESOLVE
10667  * - \ref SCIP_STAGE_PRESOLVING
10668  * - \ref SCIP_STAGE_EXITPRESOLVE
10669  * - \ref SCIP_STAGE_PRESOLVED
10670  * - \ref SCIP_STAGE_INITSOLVE
10671  * - \ref SCIP_STAGE_SOLVING
10672  * - \ref SCIP_STAGE_SOLVED
10673  */
10674 extern
10676  SCIP* scip, /**< SCIP data structure */
10677  SCIP_VAR* var /**< problem variable */
10678  );
10679 
10680 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
10681  * of a variable to the given values
10682  *
10683  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10684  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10685  *
10686  * @pre This method can be called if @p scip is in one of the following stages:
10687  * - \ref SCIP_STAGE_TRANSFORMED
10688  * - \ref SCIP_STAGE_INITPRESOLVE
10689  * - \ref SCIP_STAGE_PRESOLVING
10690  * - \ref SCIP_STAGE_EXITPRESOLVE
10691  * - \ref SCIP_STAGE_PRESOLVED
10692  * - \ref SCIP_STAGE_INITSOLVE
10693  * - \ref SCIP_STAGE_SOLVING
10694  */
10695 extern
10697  SCIP* scip, /**< SCIP data structure */
10698  SCIP_VAR* var, /**< variable which should be initialized */
10699  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
10700  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
10701  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
10702  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
10703  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
10704  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
10705  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
10706  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
10707  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
10708  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
10709  );
10710 
10711 /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
10712  * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
10713  *
10714  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10715  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10716  *
10717  * @pre This method can be called if @p scip is in one of the following stages:
10718  * - \ref SCIP_STAGE_TRANSFORMED
10719  * - \ref SCIP_STAGE_INITPRESOLVE
10720  * - \ref SCIP_STAGE_PRESOLVING
10721  * - \ref SCIP_STAGE_EXITPRESOLVE
10722  * - \ref SCIP_STAGE_PRESOLVED
10723  * - \ref SCIP_STAGE_INITSOLVE
10724  * - \ref SCIP_STAGE_SOLVING
10725  */
10726 extern
10728  SCIP* scip, /**< SCIP data structure */
10729  SCIP_VAR* var, /**< variable which should be initialized */
10730  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
10731  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
10732  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
10733  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
10734  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
10735  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
10736  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
10737  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
10738  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
10739  );
10740 
10741 /** returns the average number of cutoffs found after branching on the variable in given direction;
10742  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
10743  * over all variables for branching in the given direction is returned
10744  *
10745  * @return the average number of cutoffs found after branching on the variable in given direction
10746  *
10747  * @pre This method can be called if @p scip is in one of the following stages:
10748  * - \ref SCIP_STAGE_INITPRESOLVE
10749  * - \ref SCIP_STAGE_PRESOLVING
10750  * - \ref SCIP_STAGE_EXITPRESOLVE
10751  * - \ref SCIP_STAGE_PRESOLVED
10752  * - \ref SCIP_STAGE_INITSOLVE
10753  * - \ref SCIP_STAGE_SOLVING
10754  * - \ref SCIP_STAGE_SOLVED
10755  */
10756 extern
10758  SCIP* scip, /**< SCIP data structure */
10759  SCIP_VAR* var, /**< problem variable */
10760  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10761  );
10762 
10763 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
10764  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
10765  * over all variables for branching in the given direction is returned
10766  *
10767  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
10768  *
10769  * @pre This method can be called if @p scip is in one of the following stages:
10770  * - \ref SCIP_STAGE_INITPRESOLVE
10771  * - \ref SCIP_STAGE_PRESOLVING
10772  * - \ref SCIP_STAGE_EXITPRESOLVE
10773  * - \ref SCIP_STAGE_PRESOLVED
10774  * - \ref SCIP_STAGE_INITSOLVE
10775  * - \ref SCIP_STAGE_SOLVING
10776  * - \ref SCIP_STAGE_SOLVED
10777  */
10778 extern
10780  SCIP* scip, /**< SCIP data structure */
10781  SCIP_VAR* var, /**< problem variable */
10782  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10783  );
10784 
10785 /** returns the variable's average cutoff score value
10786  *
10787  * @return the variable's average cutoff score value
10788  *
10789  * @pre This method can be called if @p scip is in one of the following stages:
10790  * - \ref SCIP_STAGE_INITPRESOLVE
10791  * - \ref SCIP_STAGE_PRESOLVING
10792  * - \ref SCIP_STAGE_EXITPRESOLVE
10793  * - \ref SCIP_STAGE_PRESOLVED
10794  * - \ref SCIP_STAGE_INITSOLVE
10795  * - \ref SCIP_STAGE_SOLVING
10796  * - \ref SCIP_STAGE_SOLVED
10797  */
10798 extern
10800  SCIP* scip, /**< SCIP data structure */
10801  SCIP_VAR* var /**< problem variable */
10802  );
10803 
10804 /** returns the variable's average cutoff score value, only using cutoffs of the current run
10805  *
10806  * @return the variable's average cutoff score value, only using cutoffs of the current run
10807  *
10808  * @pre This method can be called if @p scip is in one of the following stages:
10809  * - \ref SCIP_STAGE_INITPRESOLVE
10810  * - \ref SCIP_STAGE_PRESOLVING
10811  * - \ref SCIP_STAGE_EXITPRESOLVE
10812  * - \ref SCIP_STAGE_PRESOLVED
10813  * - \ref SCIP_STAGE_INITSOLVE
10814  * - \ref SCIP_STAGE_SOLVING
10815  * - \ref SCIP_STAGE_SOLVED
10816  */
10817 extern
10819  SCIP* scip, /**< SCIP data structure */
10820  SCIP_VAR* var /**< problem variable */
10821  );
10822 
10823 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
10824  * factor
10825  *
10826  * @return the variable's average inference/cutoff score value
10827  *
10828  * @pre This method can be called if @p scip is in one of the following stages:
10829  * - \ref SCIP_STAGE_INITPRESOLVE
10830  * - \ref SCIP_STAGE_PRESOLVING
10831  * - \ref SCIP_STAGE_EXITPRESOLVE
10832  * - \ref SCIP_STAGE_PRESOLVED
10833  * - \ref SCIP_STAGE_INITSOLVE
10834  * - \ref SCIP_STAGE_SOLVING
10835  * - \ref SCIP_STAGE_SOLVED
10836  */
10837 extern
10839  SCIP* scip, /**< SCIP data structure */
10840  SCIP_VAR* var, /**< problem variable */
10841  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
10842  );
10843 
10844 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
10845  * factor, only using inferences and cutoffs of the current run
10846  *
10847  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
10848  *
10849  * @pre This method can be called if @p scip is in one of the following stages:
10850  * - \ref SCIP_STAGE_INITPRESOLVE
10851  * - \ref SCIP_STAGE_PRESOLVING
10852  * - \ref SCIP_STAGE_EXITPRESOLVE
10853  * - \ref SCIP_STAGE_PRESOLVED
10854  * - \ref SCIP_STAGE_INITSOLVE
10855  * - \ref SCIP_STAGE_SOLVING
10856  * - \ref SCIP_STAGE_SOLVED
10857  */
10858 extern
10860  SCIP* scip, /**< SCIP data structure */
10861  SCIP_VAR* var, /**< problem variable */
10862  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
10863  );
10864 
10865 /** outputs variable information to file stream via the message system
10866  *
10867  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10868  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10869  *
10870  * @pre This method can be called if @p scip is in one of the following stages:
10871  * - \ref SCIP_STAGE_PROBLEM
10872  * - \ref SCIP_STAGE_TRANSFORMING
10873  * - \ref SCIP_STAGE_TRANSFORMED
10874  * - \ref SCIP_STAGE_INITPRESOLVE
10875  * - \ref SCIP_STAGE_PRESOLVING
10876  * - \ref SCIP_STAGE_EXITPRESOLVE
10877  * - \ref SCIP_STAGE_PRESOLVED
10878  * - \ref SCIP_STAGE_INITSOLVE
10879  * - \ref SCIP_STAGE_SOLVING
10880  * - \ref SCIP_STAGE_SOLVED
10881  * - \ref SCIP_STAGE_EXITSOLVE
10882  * - \ref SCIP_STAGE_FREETRANS
10883  *
10884  * @note If the message handler is set to a NULL pointer nothing will be printed
10885  */
10886 extern
10888  SCIP* scip, /**< SCIP data structure */
10889  SCIP_VAR* var, /**< problem variable */
10890  FILE* file /**< output file (or NULL for standard output) */
10891  );
10892 
10893 /**@} */
10894 
10895 
10896 
10897 
10898 /*
10899  * conflict analysis methods
10900  */
10901 
10902 /**@addtogroup PublicConflictMethods
10903  *
10904  * @{
10905  */
10906 
10907 /** return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
10908  * conflict analysis since it will not be applied
10909  *
10910  * @return return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
10911  * conflict analysis since it will not be applied
10912  *
10913  * @pre This method can be called if SCIP is in one of the following stages:
10914  * - \ref SCIP_STAGE_INITPRESOLVE
10915  * - \ref SCIP_STAGE_PRESOLVING
10916  * - \ref SCIP_STAGE_EXITPRESOLVE
10917  * - \ref SCIP_STAGE_SOLVING
10918  *
10919  * @note SCIP stage does not get changed
10920  */
10921 extern
10923  SCIP* scip /**< SCIP data structure */
10924  );
10925 
10926 /** initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you
10927  * enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
10928  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
10929  *
10930  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10931  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10932  *
10933  * @pre This method can be called if SCIP is in one of the following stages:
10934  * - \ref SCIP_STAGE_PRESOLVING
10935  * - \ref SCIP_STAGE_SOLVING
10936  *
10937  * @note SCIP stage does not get changed
10938  */
10939 extern
10941  SCIP* scip, /**< SCIP data structure */
10942  SCIP_CONFTYPE conftype, /**< type of conflict */
10943  SCIP_Bool iscutoffinvolved /**< is the current cutoff bound involved? */
10944  );
10945 
10946 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
10947  * this method should be called in one of the following two cases:
10948  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound
10949  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10950  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called
10951  * for each lower bound, whose current assignment led to the deduction of the given conflict bound.
10952  *
10953  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10954  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10955  *
10956  * @pre This method can be called if SCIP is in one of the following stages:
10957  * - \ref SCIP_STAGE_PRESOLVING
10958  * - \ref SCIP_STAGE_SOLVING
10959  *
10960  * @note SCIP stage does not get changed
10961  */
10962 extern
10964  SCIP* scip, /**< SCIP data structure */
10965  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
10966  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10967  * conflicting bound was valid, NULL for current local bound */
10968  );
10969 
10970 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
10971  * with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough
10972  * to explain a certain bound change;
10973  * this method should be called in one of the following two cases:
10974  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound
10975  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10976  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called
10977  * for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.
10978  *
10979  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10980  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10981  *
10982  * @pre This method can be called if SCIP is in one of the following stages:
10983  * - \ref SCIP_STAGE_PRESOLVING
10984  * - \ref SCIP_STAGE_SOLVING
10985  *
10986  * @note SCIP stage does not get changed
10987  */
10988 extern
10990  SCIP* scip, /**< SCIP data structure */
10991  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
10992  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10993  * conflicting bound was valid, NULL for current local bound */
10994  SCIP_Real relaxedlb /**< the relaxed lower bound */
10995  );
10996 
10997 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
10998  * this method should be called in one of the following two cases:
10999  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that
11000  * led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
11001  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for
11002  * each upper bound, whose current assignment led to the deduction of the given conflict bound.
11003  *
11004  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11005  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11006  *
11007  * @pre This method can be called if SCIP is in one of the following stages:
11008  * - \ref SCIP_STAGE_PRESOLVING
11009  * - \ref SCIP_STAGE_SOLVING
11010  *
11011  * @note SCIP stage does not get changed
11012  */
11013 extern
11015  SCIP* scip, /**< SCIP data structure */
11016  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
11017  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
11018  * conflicting bound was valid, NULL for current local bound */
11019  );
11020 
11021 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
11022  * with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough
11023  * to explain a certain bound change;
11024  * this method should be called in one of the following two cases:
11025  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper
11026  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
11027  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be
11028  * called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict
11029  * bound.
11030  *
11031  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11032  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11033  *
11034  * @pre This method can be called if SCIP is in one of the following stages:
11035  * - \ref SCIP_STAGE_PRESOLVING
11036  * - \ref SCIP_STAGE_SOLVING
11037  *
11038  * @note SCIP stage does not get changed
11039  */
11040 extern
11042  SCIP* scip, /**< SCIP data structure */
11043  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
11044  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
11045  * conflicting bound was valid, NULL for current local bound */
11046  SCIP_Real relaxedub /**< the relaxed upper bound */
11047  );
11048 
11049 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate
11050  * storage; this method should be called in one of the following two cases:
11051  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound
11052  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
11053  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called
11054  * for each bound, whose current assignment led to the deduction of the given conflict bound.
11055  *
11056  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11057  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11058  *
11059  * @pre This method can be called if SCIP is in one of the following stages:
11060  * - \ref SCIP_STAGE_PRESOLVING
11061  * - \ref SCIP_STAGE_SOLVING
11062  *
11063  * @note SCIP stage does not get changed
11064  */
11065 extern
11067  SCIP* scip, /**< SCIP data structure */
11068  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
11069  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
11070  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
11071  * conflicting bound was valid, NULL for current local bound */
11072  );
11073 
11074 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis'
11075  * candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one
11076  * which would be enough to explain a certain bound change;
11077  * this method should be called in one of the following two cases:
11078  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed)
11079  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
11080  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be
11081  * called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.
11082  *
11083  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11084  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11085  *
11086  * @pre This method can be called if SCIP is in one of the following stages:
11087  * - \ref SCIP_STAGE_PRESOLVING
11088  * - \ref SCIP_STAGE_SOLVING
11089  *
11090  * @note SCIP stage does not get changed
11091  */
11092 extern
11094  SCIP* scip, /**< SCIP data structure */
11095  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
11096  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
11097  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
11098  * conflicting bound was valid, NULL for current local bound */
11099  SCIP_Real relaxedbd /**< the relaxed bound */
11100  );
11101 
11102 /** adds changed bound of fixed binary variable to the conflict analysis' candidate storage;
11103  * this method should be called in one of the following two cases:
11104  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary
11105  * variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
11106  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called
11107  * for each binary variable, whose current fixing led to the deduction of the given conflict bound.
11108  *
11109  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11110  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11111  *
11112  * @pre This method can be called if SCIP is in one of the following stages:
11113  * - \ref SCIP_STAGE_PRESOLVING
11114  * - \ref SCIP_STAGE_SOLVING
11115  *
11116  * @note SCIP stage does not get changed
11117  */
11118 extern
11120  SCIP* scip, /**< SCIP data structure */
11121  SCIP_VAR* var /**< binary variable whose changed bound should be added to conflict queue */
11122  );
11123 
11124 /** checks if the given variable is already part of the current conflict set or queued for resolving with the same or
11125  * even stronger bound
11126  *
11127  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11128  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11129  *
11130  * @pre This method can be called if SCIP is in one of the following stages:
11131  * - \ref SCIP_STAGE_PRESOLVING
11132  * - \ref SCIP_STAGE_SOLVING
11133  *
11134  * @note SCIP stage does not get changed
11135  */
11136 extern
11138  SCIP* scip, /**< SCIP data structure */
11139  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
11140  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
11141  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
11142  * conflicting bound was valid, NULL for current local bound */
11143  SCIP_Bool* used /**< pointer to store if the variable is already used */
11144  );
11145 
11146 /** returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
11147  * bound
11148  *
11149  * @return returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
11150  * bound
11151  *
11152  * @pre This method can be called if SCIP is in one of the following stages:
11153  * - \ref SCIP_STAGE_PRESOLVING
11154  * - \ref SCIP_STAGE_SOLVING
11155  *
11156  * @note SCIP stage does not get changed
11157  */
11158 extern
11160  SCIP* scip, /**< SCIP data structure */
11161  SCIP_VAR* var /**< problem variable */
11162  );
11163 
11164 /** returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
11165  * upper bound
11166  *
11167  * @return returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
11168  * upper bound
11169  *
11170  * @pre This method can be called if SCIP is in one of the following stages:
11171  * - \ref SCIP_STAGE_PRESOLVING
11172  * - \ref SCIP_STAGE_SOLVING
11173  *
11174  * @note SCIP stage does not get changed
11175  */
11176 extern
11178  SCIP* scip, /**< SCIP data structure */
11179  SCIP_VAR* var /**< problem variable */
11180  );
11181 
11182 /** analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to
11183  * SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
11184  * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict
11185  * handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth
11186  * level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
11187  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is
11188  * valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons()
11189  * instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used
11190  *
11191  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11192  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11193  *
11194  * @pre This method can be called if SCIP is in one of the following stages:
11195  * - \ref SCIP_STAGE_PRESOLVING
11196  * - \ref SCIP_STAGE_SOLVING
11197  *
11198  * @note SCIP stage does not get changed
11199  */
11200 extern
11202  SCIP* scip, /**< SCIP data structure */
11203  int validdepth, /**< minimal depth level at which the initial conflict set is valid */
11204  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
11205  );
11206 
11207 /** analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(),
11208  * SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or
11209  * SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the
11210  * resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint
11211  * that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(),
11212  * SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(),
11213  * SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())
11214  *
11215  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11216  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11217  *
11218  * @pre This method can be called if SCIP is in one of the following stages:
11219  * - \ref SCIP_STAGE_PRESOLVING
11220  * - \ref SCIP_STAGE_SOLVING
11221  *
11222  * @note SCIP stage does not get changed
11223  */
11224 extern
11226  SCIP* scip, /**< SCIP data structure */
11227  SCIP_CONS* cons, /**< constraint that detected the conflict */
11228  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
11229  );
11230 
11231 /**@} */
11232 
11233 
11234 
11235 
11236 /*
11237  * constraint methods
11238  */
11239 
11240 /**@addtogroup PublicConstraintMethods
11241  *
11242  * @{
11243  */
11244 
11245 /** creates and captures a constraint of the given constraint handler
11246  *
11247  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
11248  * be declared feasible even if it violates this particular constraint. This constellation should only be
11249  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
11250  * to the variable's local bounds.
11251  *
11252  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11253  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11254  *
11255  * @pre This method can be called if @p scip is in one of the following stages:
11256  * - \ref SCIP_STAGE_PROBLEM
11257  * - \ref SCIP_STAGE_TRANSFORMING
11258  * - \ref SCIP_STAGE_INITPRESOLVE
11259  * - \ref SCIP_STAGE_PRESOLVING
11260  * - \ref SCIP_STAGE_EXITPRESOLVE
11261  * - \ref SCIP_STAGE_PRESOLVED
11262  * - \ref SCIP_STAGE_INITSOLVE
11263  * - \ref SCIP_STAGE_SOLVING
11264  * - \ref SCIP_STAGE_EXITSOLVE
11265  *
11266  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
11267  */
11268 extern
11270  SCIP* scip, /**< SCIP data structure */
11271  SCIP_CONS** cons, /**< pointer to constraint */
11272  const char* name, /**< name of constraint */
11273  SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
11274  SCIP_CONSDATA* consdata, /**< data for this specific constraint */
11275  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
11276  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
11277  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
11278  * Usually set to TRUE. */
11279  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
11280  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11281  SCIP_Bool check, /**< should the constraint be checked for feasibility?
11282  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11283  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
11284  * Usually set to TRUE. */
11285  SCIP_Bool local, /**< is constraint only valid locally?
11286  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
11287  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
11288  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
11289  * adds coefficients to this constraint. */
11290  SCIP_Bool dynamic, /**< is constraint subject to aging?
11291  * Usually set to FALSE. Set to TRUE for own cuts which
11292  * are separated as constraints. */
11293  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
11294  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
11295  SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
11296  * if it may be moved to a more global node?
11297  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
11298  );
11299 
11300 /** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
11301  * creates and captures;
11302  *
11303  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11304  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11305  *
11306  * @pre This method can be called if @p scip is in one of the following stages:
11307  * - \ref SCIP_STAGE_PROBLEM
11308  * - \ref SCIP_STAGE_TRANSFORMING
11309  * - \ref SCIP_STAGE_INITPRESOLVE
11310  * - \ref SCIP_STAGE_PRESOLVING
11311  * - \ref SCIP_STAGE_EXITPRESOLVE
11312  * - \ref SCIP_STAGE_PRESOLVED
11313  * - \ref SCIP_STAGE_SOLVING
11314  * - \ref SCIP_STAGE_EXITSOLVE
11315  *
11316  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
11317  * be declared feasible even if it violates this particular constraint. This constellation should only be
11318  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
11319  * to the variable's local bounds.
11320  */
11321 extern
11323  SCIP* scip, /**< SCIP data structure */
11324  SCIP_CONS** cons, /**< pointer to store constraint */
11325  const char* str, /**< string to parse for constraint */
11326  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
11327  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
11328  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
11329  * Usually set to TRUE. */
11330  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
11331  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11332  SCIP_Bool check, /**< should the constraint be checked for feasibility?
11333  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11334  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
11335  * Usually set to TRUE. */
11336  SCIP_Bool local, /**< is constraint only valid locally?
11337  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
11338  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
11339  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
11340  * adds coefficients to this constraint. */
11341  SCIP_Bool dynamic, /**< is constraint subject to aging?
11342  * Usually set to FALSE. Set to TRUE for own cuts which
11343  * are separated as constraints. */
11344  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
11345  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
11346  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
11347  * if it may be moved to a more global node?
11348  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
11349  SCIP_Bool* success /**< pointer to store if the paring process was successful */
11350  );
11351 
11352 /** increases usage counter of constraint
11353  *
11354  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11355  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11356  *
11357  * @pre This method can be called if @p scip is in one of the following stages:
11358  * - \ref SCIP_STAGE_PROBLEM
11359  * - \ref SCIP_STAGE_TRANSFORMING
11360  * - \ref SCIP_STAGE_TRANSFORMED
11361  * - \ref SCIP_STAGE_INITPRESOLVE
11362  * - \ref SCIP_STAGE_PRESOLVING
11363  * - \ref SCIP_STAGE_EXITPRESOLVE
11364  * - \ref SCIP_STAGE_PRESOLVED
11365  * - \ref SCIP_STAGE_INITSOLVE
11366  * - \ref SCIP_STAGE_SOLVING
11367  * - \ref SCIP_STAGE_SOLVED
11368  */
11369 extern
11371  SCIP* scip, /**< SCIP data structure */
11372  SCIP_CONS* cons /**< constraint to capture */
11373  );
11374 
11375 /** decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
11376  *
11377  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11378  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11379  *
11380  * @pre This method can be called if @p scip is in one of the following stages:
11381  * - \ref SCIP_STAGE_PROBLEM
11382  * - \ref SCIP_STAGE_TRANSFORMING
11383  * - \ref SCIP_STAGE_TRANSFORMED
11384  * - \ref SCIP_STAGE_INITPRESOLVE
11385  * - \ref SCIP_STAGE_PRESOLVING
11386  * - \ref SCIP_STAGE_EXITPRESOLVE
11387  * - \ref SCIP_STAGE_PRESOLVED
11388  * - \ref SCIP_STAGE_INITSOLVE
11389  * - \ref SCIP_STAGE_SOLVING
11390  * - \ref SCIP_STAGE_SOLVED
11391  * - \ref SCIP_STAGE_EXITSOLVE
11392  * - \ref SCIP_STAGE_FREETRANS
11393  *
11394  * @note the pointer of the constraint will be NULLed
11395  */
11396 extern
11398  SCIP* scip, /**< SCIP data structure */
11399  SCIP_CONS** cons /**< pointer to constraint */
11400  );
11401 
11402 /** change constraint name
11403  *
11404  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11405  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11406  *
11407  * @pre This method can be called if @p scip is in one of the following stages:
11408  * - \ref SCIP_STAGE_PROBLEM
11409  *
11410  * @note to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h
11411  */
11412 extern
11414  SCIP* scip, /**< SCIP data structure */
11415  SCIP_CONS* cons, /**< constraint */
11416  const char* name /**< new name of constraint */
11417  );
11418 
11419 /** sets the initial flag of the given constraint
11420  *
11421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11423  *
11424  * @pre This method can be called if @p scip is in one of the following stages:
11425  * - \ref SCIP_STAGE_PROBLEM
11426  * - \ref SCIP_STAGE_TRANSFORMING
11427  * - \ref SCIP_STAGE_PRESOLVING
11428  * - \ref SCIP_STAGE_PRESOLVED
11429  * - \ref SCIP_STAGE_SOLVING
11430  */
11431 extern
11433  SCIP* scip, /**< SCIP data structure */
11434  SCIP_CONS* cons, /**< constraint */
11435  SCIP_Bool initial /**< new value */
11436  );
11437 
11438 /** sets the separate flag of the given constraint
11439  *
11440  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11441  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11442  *
11443  * @pre This method can be called if @p scip is in one of the following stages:
11444  * - \ref SCIP_STAGE_PROBLEM
11445  * - \ref SCIP_STAGE_TRANSFORMING
11446  * - \ref SCIP_STAGE_PRESOLVING
11447  * - \ref SCIP_STAGE_PRESOLVED
11448  * - \ref SCIP_STAGE_SOLVING
11449  */
11450 extern
11452  SCIP* scip, /**< SCIP data structure */
11453  SCIP_CONS* cons, /**< constraint */
11454  SCIP_Bool separate /**< new value */
11455  );
11456 
11457 /** sets the enforce flag of the given constraint
11458  *
11459  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11460  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11461  *
11462  * @pre This method can be called if @p scip is in one of the following stages:
11463  * - \ref SCIP_STAGE_PROBLEM
11464  * - \ref SCIP_STAGE_TRANSFORMING
11465  * - \ref SCIP_STAGE_PRESOLVING
11466  * - \ref SCIP_STAGE_PRESOLVED
11467  * - \ref SCIP_STAGE_SOLVING
11468  */
11469 extern
11471  SCIP* scip, /**< SCIP data structure */
11472  SCIP_CONS* cons, /**< constraint */
11473  SCIP_Bool enforce /**< new value */
11474  );
11475 
11476 /** sets the check flag of the given constraint
11477  *
11478  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11479  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11480  *
11481  * @pre This method can be called if @p scip is in one of the following stages:
11482  * - \ref SCIP_STAGE_PROBLEM
11483  * - \ref SCIP_STAGE_TRANSFORMING
11484  * - \ref SCIP_STAGE_PRESOLVING
11485  * - \ref SCIP_STAGE_PRESOLVED
11486  * - \ref SCIP_STAGE_SOLVING
11487  */
11488 extern
11490  SCIP* scip, /**< SCIP data structure */
11491  SCIP_CONS* cons, /**< constraint */
11492  SCIP_Bool check /**< new value */
11493  );
11494 
11495 /** sets the propagate flag of the given constraint
11496  *
11497  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11498  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11499  *
11500  * @pre This method can be called if @p scip is in one of the following stages:
11501  * - \ref SCIP_STAGE_PROBLEM
11502  * - \ref SCIP_STAGE_TRANSFORMING
11503  * - \ref SCIP_STAGE_PRESOLVING
11504  * - \ref SCIP_STAGE_PRESOLVED
11505  * - \ref SCIP_STAGE_SOLVING
11506  */
11507 extern
11509  SCIP* scip, /**< SCIP data structure */
11510  SCIP_CONS* cons, /**< constraint */
11511  SCIP_Bool propagate /**< new value */
11512  );
11513 
11514 /** sets the local flag of the given constraint
11515  *
11516  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11517  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11518  *
11519  * @pre This method can be called if @p scip is in one of the following stages:
11520  * - \ref SCIP_STAGE_PROBLEM
11521  * - \ref SCIP_STAGE_TRANSFORMING
11522  * - \ref SCIP_STAGE_INITPRESOLVE
11523  * - \ref SCIP_STAGE_PRESOLVING
11524  * - \ref SCIP_STAGE_PRESOLVED
11525  * - \ref SCIP_STAGE_INITSOLVE
11526  * - \ref SCIP_STAGE_SOLVING
11527  */
11528 extern
11530  SCIP* scip, /**< SCIP data structure */
11531  SCIP_CONS* cons, /**< constraint */
11532  SCIP_Bool local /**< new value */
11533  );
11534 
11535 /** sets the modifiable flag of the given constraint
11536  *
11537  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11538  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11539  *
11540  * @pre This method can be called if @p scip is in one of the following stages:
11541  * - \ref SCIP_STAGE_PROBLEM
11542  * - \ref SCIP_STAGE_TRANSFORMING
11543  * - \ref SCIP_STAGE_PRESOLVING
11544  * - \ref SCIP_STAGE_PRESOLVED
11545  * - \ref SCIP_STAGE_SOLVING
11546  * - \ref SCIP_STAGE_EXITSOLVE
11547  */
11548 extern
11550  SCIP* scip, /**< SCIP data structure */
11551  SCIP_CONS* cons, /**< constraint */
11552  SCIP_Bool modifiable /**< new value */
11553  );
11554 
11555 /** sets the dynamic flag of the given constraint
11556  *
11557  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11558  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11559  *
11560  * @pre This method can be called if @p scip is in one of the following stages:
11561  * - \ref SCIP_STAGE_PROBLEM
11562  * - \ref SCIP_STAGE_TRANSFORMING
11563  * - \ref SCIP_STAGE_PRESOLVING
11564  * - \ref SCIP_STAGE_PRESOLVED
11565  * - \ref SCIP_STAGE_SOLVING
11566  */
11567 extern
11569  SCIP* scip, /**< SCIP data structure */
11570  SCIP_CONS* cons, /**< constraint */
11571  SCIP_Bool dynamic /**< new value */
11572  );
11573 
11574 /** sets the removable flag of the given constraint
11575  *
11576  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11577  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11578  *
11579  * @pre This method can be called if @p scip is in one of the following stages:
11580  * - \ref SCIP_STAGE_PROBLEM
11581  * - \ref SCIP_STAGE_TRANSFORMING
11582  * - \ref SCIP_STAGE_PRESOLVING
11583  * - \ref SCIP_STAGE_PRESOLVED
11584  * - \ref SCIP_STAGE_SOLVING
11585  */
11586 extern
11588  SCIP* scip, /**< SCIP data structure */
11589  SCIP_CONS* cons, /**< constraint */
11590  SCIP_Bool removable /**< new value */
11591  );
11592 
11593 /** sets the stickingatnode flag of the given constraint
11594  *
11595  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11596  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11597  *
11598  * @pre This method can be called if @p scip is in one of the following stages:
11599  * - \ref SCIP_STAGE_PROBLEM
11600  * - \ref SCIP_STAGE_TRANSFORMING
11601  * - \ref SCIP_STAGE_PRESOLVING
11602  * - \ref SCIP_STAGE_PRESOLVED
11603  * - \ref SCIP_STAGE_SOLVING
11604  */
11605 extern
11607  SCIP* scip, /**< SCIP data structure */
11608  SCIP_CONS* cons, /**< constraint */
11609  SCIP_Bool stickingatnode /**< new value */
11610  );
11611 
11612 /** updates the flags of the first constraint according to the ones of the second constraint
11613  *
11614  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11615  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11616  *
11617  * @pre This method can be called if @p scip is in one of the following stages:
11618  * - \ref SCIP_STAGE_PROBLEM
11619  * - \ref SCIP_STAGE_TRANSFORMING
11620  * - \ref SCIP_STAGE_PRESOLVING
11621  * - \ref SCIP_STAGE_PRESOLVED
11622  * - \ref SCIP_STAGE_SOLVING
11623  */
11624 extern
11626  SCIP* scip, /**< SCIP data structure */
11627  SCIP_CONS* cons0, /**< constraint that should stay */
11628  SCIP_CONS* cons1 /**< constraint that should be deleted */
11629  );
11630 
11631 /** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
11632  * a new transformed constraint for this constraint is created
11633  *
11634  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11635  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11636  *
11637  * @pre This method can be called if @p scip is in one of the following stages:
11638  * - \ref SCIP_STAGE_TRANSFORMING
11639  * - \ref SCIP_STAGE_TRANSFORMED
11640  * - \ref SCIP_STAGE_INITPRESOLVE
11641  * - \ref SCIP_STAGE_PRESOLVING
11642  * - \ref SCIP_STAGE_EXITPRESOLVE
11643  * - \ref SCIP_STAGE_PRESOLVED
11644  * - \ref SCIP_STAGE_INITSOLVE
11645  * - \ref SCIP_STAGE_SOLVING
11646  */
11647 extern
11649  SCIP* scip, /**< SCIP data structure */
11650  SCIP_CONS* cons, /**< constraint to get/create transformed constraint for */
11651  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
11652  );
11653 
11654 /** gets and captures transformed constraints for an array of constraints;
11655  * if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created;
11656  * it is possible to call this method with conss == transconss
11657  *
11658  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11659  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11660  *
11661  * @pre This method can be called if @p scip is in one of the following stages:
11662  * - \ref SCIP_STAGE_TRANSFORMING
11663  * - \ref SCIP_STAGE_TRANSFORMED
11664  * - \ref SCIP_STAGE_INITPRESOLVE
11665  * - \ref SCIP_STAGE_PRESOLVING
11666  * - \ref SCIP_STAGE_EXITPRESOLVE
11667  * - \ref SCIP_STAGE_PRESOLVED
11668  * - \ref SCIP_STAGE_INITSOLVE
11669  * - \ref SCIP_STAGE_SOLVING
11670  */
11671 extern
11673  SCIP* scip, /**< SCIP data structure */
11674  int nconss, /**< number of constraints to get/create transformed constraints for */
11675  SCIP_CONS** conss, /**< array with constraints to get/create transformed constraints for */
11676  SCIP_CONS** transconss /**< array to store the transformed constraints */
11677  );
11678 
11679 /** gets corresponding transformed constraint of a given constraint;
11680  * returns NULL as transcons, if transformed constraint is not yet existing
11681  *
11682  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11683  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11684  *
11685  * @pre This method can be called if @p scip is in one of the following stages:
11686  * - \ref SCIP_STAGE_TRANSFORMING
11687  * - \ref SCIP_STAGE_TRANSFORMED
11688  * - \ref SCIP_STAGE_INITPRESOLVE
11689  * - \ref SCIP_STAGE_PRESOLVING
11690  * - \ref SCIP_STAGE_EXITPRESOLVE
11691  * - \ref SCIP_STAGE_PRESOLVED
11692  * - \ref SCIP_STAGE_INITSOLVE
11693  * - \ref SCIP_STAGE_SOLVING
11694  * - \ref SCIP_STAGE_SOLVED
11695  * - \ref SCIP_STAGE_EXITSOLVE
11696  * - \ref SCIP_STAGE_FREETRANS
11697  */
11698 extern
11700  SCIP* scip, /**< SCIP data structure */
11701  SCIP_CONS* cons, /**< constraint to get the transformed constraint for */
11702  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
11703  );
11704 
11705 /** gets corresponding transformed constraints for an array of constraints;
11706  * stores NULL in a transconss slot, if the transformed constraint is not yet existing;
11707  * it is possible to call this method with conss == transconss, but remember that constraints that are not
11708  * yet transformed will be replaced with NULL
11709  *
11710  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11711  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11712  *
11713  * @pre This method can be called if @p scip is in one of the following stages:
11714  * - \ref SCIP_STAGE_TRANSFORMING
11715  * - \ref SCIP_STAGE_TRANSFORMED
11716  * - \ref SCIP_STAGE_INITPRESOLVE
11717  * - \ref SCIP_STAGE_PRESOLVING
11718  * - \ref SCIP_STAGE_EXITPRESOLVE
11719  * - \ref SCIP_STAGE_PRESOLVED
11720  * - \ref SCIP_STAGE_INITSOLVE
11721  * - \ref SCIP_STAGE_SOLVING
11722  * - \ref SCIP_STAGE_SOLVED
11723  * - \ref SCIP_STAGE_EXITSOLVE
11724  * - \ref SCIP_STAGE_FREETRANS
11725  */
11726 extern
11728  SCIP* scip, /**< SCIP data structure */
11729  int nconss, /**< number of constraints to get the transformed constraints for */
11730  SCIP_CONS** conss, /**< constraints to get the transformed constraints for */
11731  SCIP_CONS** transconss /**< array to store the transformed constraints */
11732  );
11733 
11734 /** adds given value to age of constraint, but age can never become negative;
11735  * should be called
11736  * - in constraint separation, if no cut was found for this constraint,
11737  * - in constraint enforcing, if constraint was feasible, and
11738  * - in constraint propagation, if no domain reduction was deduced;
11739  *
11740  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11741  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11742  *
11743  * @pre This method can be called if @p scip is in one of the following stages:
11744  * - \ref SCIP_STAGE_TRANSFORMED
11745  * - \ref SCIP_STAGE_PRESOLVING
11746  * - \ref SCIP_STAGE_PRESOLVED
11747  * - \ref SCIP_STAGE_SOLVING
11748  * - \ref SCIP_STAGE_SOLVED
11749  */
11750 extern
11752  SCIP* scip, /**< SCIP data structure */
11753  SCIP_CONS* cons, /**< constraint */
11754  SCIP_Real deltaage /**< value to add to the constraint's age */
11755  );
11756 
11757 /** increases age of constraint by 1.0;
11758  * should be called
11759  * - in constraint separation, if no cut was found for this constraint,
11760  * - in constraint enforcing, if constraint was feasible, and
11761  * - in constraint propagation, if no domain reduction was deduced;
11762  *
11763  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11764  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11765  *
11766  * @pre This method can be called if @p scip is in one of the following stages:
11767  * - \ref SCIP_STAGE_TRANSFORMED
11768  * - \ref SCIP_STAGE_PRESOLVING
11769  * - \ref SCIP_STAGE_PRESOLVED
11770  * - \ref SCIP_STAGE_SOLVING
11771  * - \ref SCIP_STAGE_SOLVED
11772  */
11773 extern
11775  SCIP* scip, /**< SCIP data structure */
11776  SCIP_CONS* cons /**< constraint */
11777  );
11778 
11779 /** resets age of constraint to zero;
11780  * should be called
11781  * - in constraint separation, if a cut was found for this constraint,
11782  * - in constraint enforcing, if the constraint was violated, and
11783  * - in constraint propagation, if a domain reduction was deduced;
11784  *
11785  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11786  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11787  *
11788  * @pre This method can be called if @p scip is in one of the following stages:
11789  * - \ref SCIP_STAGE_TRANSFORMED
11790  * - \ref SCIP_STAGE_PRESOLVING
11791  * - \ref SCIP_STAGE_PRESOLVED
11792  * - \ref SCIP_STAGE_SOLVING
11793  * - \ref SCIP_STAGE_SOLVED
11794  */
11795 extern
11797  SCIP* scip, /**< SCIP data structure */
11798  SCIP_CONS* cons /**< constraint */
11799  );
11800 
11801 /** enables constraint's separation, propagation, and enforcing capabilities
11802  *
11803  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11804  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11805  *
11806  * @pre This method can be called if @p scip is in one of the following stages:
11807  * - \ref SCIP_STAGE_TRANSFORMED
11808  * - \ref SCIP_STAGE_PRESOLVING
11809  * - \ref SCIP_STAGE_PRESOLVED
11810  * - \ref SCIP_STAGE_INITSOLVE
11811  * - \ref SCIP_STAGE_SOLVING
11812  * - \ref SCIP_STAGE_SOLVED
11813  */
11814 extern
11816  SCIP* scip, /**< SCIP data structure */
11817  SCIP_CONS* cons /**< constraint */
11818  );
11819 
11820 /** disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated,
11821  * separated, and enforced anymore until it is enabled again with a call to SCIPenableCons();
11822  * in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and
11823  * does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor
11824  * automatically disabled again on entering the node again;
11825  * note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint
11826  * is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree,
11827  * and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using
11828  * an appropriate event handler that watches the corresponding variables' domain changes)
11829  *
11830  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11831  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11832  *
11833  * @pre This method can be called if @p scip is in one of the following stages:
11834  * - \ref SCIP_STAGE_TRANSFORMED
11835  * - \ref SCIP_STAGE_INITPRESOLVE
11836  * - \ref SCIP_STAGE_PRESOLVING
11837  * - \ref SCIP_STAGE_PRESOLVED
11838  * - \ref SCIP_STAGE_INITSOLVE
11839  * - \ref SCIP_STAGE_SOLVING
11840  * - \ref SCIP_STAGE_SOLVED
11841  */
11842 extern
11844  SCIP* scip, /**< SCIP data structure */
11845  SCIP_CONS* cons /**< constraint */
11846  );
11847 
11848 /** enables constraint's separation capabilities
11849  *
11850  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11851  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11852  *
11853  * @pre This method can be called if @p scip is in one of the following stages:
11854  * - \ref SCIP_STAGE_TRANSFORMED
11855  * - \ref SCIP_STAGE_PRESOLVING
11856  * - \ref SCIP_STAGE_PRESOLVED
11857  * - \ref SCIP_STAGE_INITSOLVE
11858  * - \ref SCIP_STAGE_SOLVING
11859  * - \ref SCIP_STAGE_SOLVED
11860  */
11861 extern
11863  SCIP* scip, /**< SCIP data structure */
11864  SCIP_CONS* cons /**< constraint */
11865  );
11866 
11867 /** disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation
11868  * is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
11869  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
11870  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
11871  *
11872  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11873  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11874  *
11875  * @pre This method can be called if @p scip is in one of the following stages:
11876  * - \ref SCIP_STAGE_TRANSFORMED
11877  * - \ref SCIP_STAGE_PRESOLVING
11878  * - \ref SCIP_STAGE_PRESOLVED
11879  * - \ref SCIP_STAGE_INITSOLVE
11880  * - \ref SCIP_STAGE_SOLVING
11881  * - \ref SCIP_STAGE_SOLVED
11882  */
11883 extern
11885  SCIP* scip, /**< SCIP data structure */
11886  SCIP_CONS* cons /**< constraint */
11887  );
11888 
11889 /** enables constraint's propagation capabilities
11890  *
11891  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11892  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11893  *
11894  * @pre This method can be called if @p scip is in one of the following stages:
11895  * - \ref SCIP_STAGE_TRANSFORMED
11896  * - \ref SCIP_STAGE_INITPRESOLVE
11897  * - \ref SCIP_STAGE_PRESOLVING
11898  * - \ref SCIP_STAGE_EXITPRESOLVE
11899  * - \ref SCIP_STAGE_PRESOLVED
11900  * - \ref SCIP_STAGE_INITSOLVE
11901  * - \ref SCIP_STAGE_SOLVING
11902  * - \ref SCIP_STAGE_SOLVED
11903  */
11904 extern
11906  SCIP* scip, /**< SCIP data structure */
11907  SCIP_CONS* cons /**< constraint */
11908  );
11909 
11910 /** disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation
11911  * is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
11912  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
11913  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
11914  *
11915  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11916  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11917  *
11918  * @pre This method can be called if @p scip is in one of the following stages:
11919  * - \ref SCIP_STAGE_TRANSFORMED
11920  * - \ref SCIP_STAGE_INITPRESOLVE
11921  * - \ref SCIP_STAGE_PRESOLVING
11922  * - \ref SCIP_STAGE_EXITPRESOLVE
11923  * - \ref SCIP_STAGE_PRESOLVED
11924  * - \ref SCIP_STAGE_INITSOLVE
11925  * - \ref SCIP_STAGE_SOLVING
11926  * - \ref SCIP_STAGE_SOLVED
11927  */
11928 extern
11930  SCIP* scip, /**< SCIP data structure */
11931  SCIP_CONS* cons /**< constraint */
11932  );
11933 
11934 
11935 /** marks constraint to be propagated
11936  *
11937  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11938  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11939  *
11940  * @pre This method can be called if @p scip is in one of the following stages:
11941  * - \ref SCIP_STAGE_TRANSFORMING
11942  * - \ref SCIP_STAGE_TRANSFORMED
11943  * - \ref SCIP_STAGE_PRESOLVING
11944  * - \ref SCIP_STAGE_EXITPRESOLVE
11945  * - \ref SCIP_STAGE_PRESOLVED
11946  * - \ref SCIP_STAGE_INITSOLVE
11947  * - \ref SCIP_STAGE_SOLVING
11948  * - \ref SCIP_STAGE_SOLVED
11949  *
11950  * @note if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation
11951  */
11952 extern
11954  SCIP* scip, /**< SCIP data structure */
11955  SCIP_CONS* cons /**< constraint */
11956  );
11957 
11958 /** unmarks the constraint to be propagated
11959  *
11960  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11961  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11962  *
11963  * @pre This method can be called if @p scip is in one of the following stages:
11964  * - \ref SCIP_STAGE_TRANSFORMED
11965  * - \ref SCIP_STAGE_PRESOLVING
11966  * - \ref SCIP_STAGE_EXITPRESOLVE
11967  * - \ref SCIP_STAGE_PRESOLVED
11968  * - \ref SCIP_STAGE_INITSOLVE
11969  * - \ref SCIP_STAGE_SOLVING
11970  * - \ref SCIP_STAGE_SOLVED
11971  */
11972 extern
11974  SCIP* scip, /**< SCIP data structure */
11975  SCIP_CONS* cons /**< constraint */
11976  );
11977 
11978 /** adds given values to lock status of the constraint and updates the rounding locks of the involved variables
11979  *
11980  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11981  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11982  *
11983  * @pre This method can be called if @p scip is in one of the following stages:
11984  * - \ref SCIP_STAGE_PROBLEM
11985  * - \ref SCIP_STAGE_TRANSFORMING
11986  * - \ref SCIP_STAGE_INITPRESOLVE
11987  * - \ref SCIP_STAGE_PRESOLVING
11988  * - \ref SCIP_STAGE_EXITPRESOLVE
11989  * - \ref SCIP_STAGE_INITSOLVE
11990  * - \ref SCIP_STAGE_SOLVING
11991  * - \ref SCIP_STAGE_EXITSOLVE
11992  * - \ref SCIP_STAGE_FREETRANS
11993  */
11994 extern
11996  SCIP* scip, /**< SCIP data structure */
11997  SCIP_CONS* cons, /**< constraint */
11998  int nlockspos, /**< increase in number of rounding locks for constraint */
11999  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
12000  );
12001 
12002 /** checks single constraint for feasibility of the given solution
12003  *
12004  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12005  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12006  *
12007  * @pre This method can be called if @p scip is in one of the following stages:
12008  * - \ref SCIP_STAGE_TRANSFORMED
12009  * - \ref SCIP_STAGE_INITPRESOLVE
12010  * - \ref SCIP_STAGE_PRESOLVING
12011  * - \ref SCIP_STAGE_EXITPRESOLVE
12012  * - \ref SCIP_STAGE_PRESOLVED
12013  * - \ref SCIP_STAGE_INITSOLVE
12014  * - \ref SCIP_STAGE_SOLVING
12015  * - \ref SCIP_STAGE_SOLVED
12016  */
12017 extern
12019  SCIP* scip, /**< SCIP data structure */
12020  SCIP_CONS* cons, /**< constraint to check */
12021  SCIP_SOL* sol, /**< primal CIP solution */
12022  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
12023  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
12024  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
12025  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12026  );
12027 
12028 /** enforces single constraint for a given pseudo solution
12029  *
12030  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12031  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12032  *
12033  * @pre This method can be called if @p scip is in one of the following stages:
12034  * - \ref SCIP_STAGE_SOLVING
12035  *
12036  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12037  * added to SCIP beforehand.
12038  */
12039 extern
12041  SCIP* scip, /**< SCIP data structure */
12042  SCIP_CONS* cons, /**< constraint to enforce */
12043  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
12044  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
12045  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12046  );
12047 
12048 /** enforces single constraint for a given LP solution
12049  *
12050  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12051  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12052  *
12053  * @pre This method can be called if @p scip is in one of the following stages:
12054  * - \ref SCIP_STAGE_SOLVING
12055  *
12056  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12057  * added to SCIP beforehand.
12058  */
12059 extern
12061  SCIP* scip, /**< SCIP data structure */
12062  SCIP_CONS* cons, /**< constraint to enforce */
12063  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
12064  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12065  );
12066 
12067 /** enforces single constraint for a given relaxation solution
12068  *
12069  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12070  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12071  *
12072  * @pre This method can be called if @p scip is in one of the following stages:
12073  * - \ref SCIP_STAGE_SOLVING
12074  *
12075  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12076  * added to SCIP beforehand.
12077  */
12079  SCIP* scip, /**< SCIP data structure */
12080  SCIP_CONS* cons, /**< constraint to enforce */
12081  SCIP_SOL* sol, /**< solution to enforce */
12082  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
12083  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12084  );
12085 
12086 /** calls LP initialization method for single constraint
12087  *
12088  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12089  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12090  *
12091  * @pre This method can be called if @p scip is in one of the following stages:
12092  * - \ref SCIP_STAGE_SOLVING
12093  *
12094  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12095  * added to SCIP beforehand.
12096  */
12097 extern
12099  SCIP* scip, /**< SCIP data structure */
12100  SCIP_CONS* cons, /**< constraint to initialize */
12101  SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
12102 
12103  );
12104 
12105 /** calls separation method of single constraint for LP solution
12106  *
12107  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12108  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12109  *
12110  * @pre This method can be called if @p scip is in one of the following stages:
12111  * - \ref SCIP_STAGE_SOLVING
12112  *
12113  * @note This is an advanced method and should be used with caution.
12114  */
12115 extern
12117  SCIP* scip, /**< SCIP data structure */
12118  SCIP_CONS* cons, /**< constraint to separate */
12119  SCIP_RESULT* result /**< pointer to store the result of the separation call */
12120  );
12121 
12122 /** calls separation method of single constraint for given primal solution
12123  *
12124  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12125  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12126  *
12127  * @pre This method can be called if @p scip is in one of the following stages:
12128  * - \ref SCIP_STAGE_SOLVING
12129  *
12130  * @note This is an advanced method and should be used with caution.
12131  */
12132 extern
12134  SCIP* scip, /**< SCIP data structure */
12135  SCIP_CONS* cons, /**< constraint to separate */
12136  SCIP_SOL* sol, /**< primal solution that should be separated*/
12137  SCIP_RESULT* result /**< pointer to store the result of the separation call */
12138  );
12139 
12140 /** calls domain propagation method of single constraint
12141  *
12142  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12143  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12144  *
12145  * @pre This method can be called if @p scip is in one of the following stages:
12146  * - \ref SCIP_STAGE_PRESOLVING
12147  * - \ref SCIP_STAGE_SOLVING
12148  *
12149  * @note This is an advanced method and should be used with caution.
12150  */
12151 extern
12153  SCIP* scip, /**< SCIP data structure */
12154  SCIP_CONS* cons, /**< constraint to propagate */
12155  SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
12156  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12157  );
12158 
12159 /** resolves propagation conflict of single constraint
12160  *
12161  *
12162  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12163  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12164  *
12165  * @pre This method can be called if @p scip is in one of the following stages:
12166  * - \ref SCIP_STAGE_PRESOLVING
12167  * - \ref SCIP_STAGE_SOLVING
12168  *
12169  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12170  * added to SCIP beforehand.
12171  */
12172 extern
12174  SCIP* scip, /**< SCIP data structure */
12175  SCIP_CONS* cons, /**< constraint to resolve conflict for */
12176  SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
12177  int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
12178  SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
12179  SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
12180  SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
12181  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12182  );
12183 
12184 /** presolves of single constraint
12185  *
12186  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12187  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12188  *
12189  * @pre This method can be called if @p scip is in one of the following stages:
12190  * - \ref SCIP_STAGE_PRESOLVING
12191  *
12192  * @note This is an advanced method and should be used with caution.
12193  */
12194 extern
12196  SCIP* scip, /**< SCIP data structure */
12197  SCIP_CONS* cons, /**< constraint to presolve */
12198  int nrounds, /**< number of presolving rounds already done */
12199  SCIP_PRESOLTIMING presoltiming, /**< presolving timing(s) to be performed */
12200  int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
12201  int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
12202  int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
12203  int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
12204  int nnewholes, /**< number of domain holes added since the last call to the presolving method */
12205  int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
12206  int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
12207  int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
12208  int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
12209  int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
12210  int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
12211  int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
12212  int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
12213  int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
12214  int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
12215  int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
12216  int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
12217  int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
12218  int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
12219  int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
12220  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12221  );
12222 
12223 /** calls constraint activation notification method of single constraint
12224  *
12225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12227  *
12228  * @pre This method can be called if @p scip is in one of the following stages:
12229  * - \ref SCIP_STAGE_TRANSFORMING
12230  *
12231  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12232  * added to SCIP beforehand.
12233  */
12234 extern
12236  SCIP* scip, /**< SCIP data structure */
12237  SCIP_CONS* cons /**< constraint to notify */
12238  );
12239 
12240 /** calls constraint deactivation notification method of single constraint
12241  *
12242  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12243  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12244  *
12245  * @pre This method can be called if @p scip is in one of the following stages:
12246  * - \ref SCIP_STAGE_PRESOLVING
12247  * - \ref SCIP_STAGE_SOLVING
12248  *
12249  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12250  * added to SCIP beforehand.
12251  */
12252 extern
12254  SCIP* scip, /**< SCIP data structure */
12255  SCIP_CONS* cons /**< constraint to notify */
12256  );
12257 
12258 /** outputs constraint information to file stream via the message handler system
12259  *
12260  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12261  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12262  *
12263  * @pre This method can be called if @p scip is in one of the following stages:
12264  * - \ref SCIP_STAGE_PROBLEM
12265  * - \ref SCIP_STAGE_TRANSFORMING
12266  * - \ref SCIP_STAGE_TRANSFORMED
12267  * - \ref SCIP_STAGE_INITPRESOLVE
12268  * - \ref SCIP_STAGE_PRESOLVING
12269  * - \ref SCIP_STAGE_EXITPRESOLVE
12270  * - \ref SCIP_STAGE_PRESOLVED
12271  * - \ref SCIP_STAGE_INITSOLVE
12272  * - \ref SCIP_STAGE_SOLVING
12273  * - \ref SCIP_STAGE_SOLVED
12274  * - \ref SCIP_STAGE_EXITSOLVE
12275  * - \ref SCIP_STAGE_FREETRANS
12276  *
12277  * @note If the message handler is set to a NULL pointer nothing will be printed.
12278  * @note The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a
12279  * newline character.
12280  */
12281 extern
12283  SCIP* scip, /**< SCIP data structure */
12284  SCIP_CONS* cons, /**< constraint */
12285  FILE* file /**< output file (or NULL for standard output) */
12286  );
12287 
12288 /** method to collect the variables of a constraint
12289  *
12290  * If the number of variables is greater than the available slots in the variable array, nothing happens except that
12291  * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
12292  * a constraint has in its scope.
12293  *
12294  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12295  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12296  *
12297  * @pre This method can be called if @p scip is in one of the following stages:
12298  * - \ref SCIP_STAGE_PROBLEM
12299  * - \ref SCIP_STAGE_TRANSFORMING
12300  * - \ref SCIP_STAGE_TRANSFORMED
12301  * - \ref SCIP_STAGE_INITPRESOLVE
12302  * - \ref SCIP_STAGE_PRESOLVING
12303  * - \ref SCIP_STAGE_EXITPRESOLVE
12304  * - \ref SCIP_STAGE_PRESOLVED
12305  * - \ref SCIP_STAGE_INITSOLVE
12306  * - \ref SCIP_STAGE_SOLVING
12307  * - \ref SCIP_STAGE_SOLVED
12308  * - \ref SCIP_STAGE_EXITSOLVE
12309  * - \ref SCIP_STAGE_FREETRANS
12310  *
12311  * @note The success pointer indicates if all variables were copied into the vars arrray.
12312  *
12313  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
12314  * set to FALSE.
12315  */
12316 extern
12318  SCIP* scip, /**< SCIP data structure */
12319  SCIP_CONS* cons, /**< constraint for which the variables are wanted */
12320  SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
12321  int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
12322  SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
12323  );
12324 
12325 /** method to collect the number of variables of a constraint
12326  *
12327  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12328  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12329  *
12330  * @pre This method can be called if @p scip is in one of the following stages:
12331  * - \ref SCIP_STAGE_PROBLEM
12332  * - \ref SCIP_STAGE_TRANSFORMING
12333  * - \ref SCIP_STAGE_TRANSFORMED
12334  * - \ref SCIP_STAGE_INITPRESOLVE
12335  * - \ref SCIP_STAGE_PRESOLVING
12336  * - \ref SCIP_STAGE_EXITPRESOLVE
12337  * - \ref SCIP_STAGE_PRESOLVED
12338  * - \ref SCIP_STAGE_INITSOLVE
12339  * - \ref SCIP_STAGE_SOLVING
12340  * - \ref SCIP_STAGE_SOLVED
12341  * - \ref SCIP_STAGE_EXITSOLVE
12342  * - \ref SCIP_STAGE_FREETRANS
12343  *
12344  * @note The success pointer indicates if the contraint handler was able to return the number of variables
12345  *
12346  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
12347  * set to FALSE
12348  */
12349 extern
12351  SCIP* scip, /**< SCIP data structure */
12352  SCIP_CONS* cons, /**< constraint for which the number of variables is wanted */
12353  int* nvars, /**< pointer to store the number of variables */
12354  SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
12355  );
12356 
12357 /**@} */
12358 
12359 
12360 
12361 
12362 /*
12363  * LP methods
12364  */
12365 
12366 /**@addtogroup PublicLPMethods
12367  *
12368  * @{
12369  */
12370 
12371 /** returns, whether the LP was or is to be solved in the current node
12372  *
12373  * @return whether the LP was or is to be solved in the current node.
12374  *
12375  * @pre This method can be called if @p scip is in one of the following stages:
12376  * - \ref SCIP_STAGE_SOLVING
12377  *
12378  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12379  */
12380 extern
12382  SCIP* scip /**< SCIP data structure */
12383  );
12384 
12385 /** returns, whether the LP of the current node is already constructed
12386  *
12387  * @return whether the LP of the current node is already constructed.
12388  *
12389  * @pre This method can be called if @p scip is in one of the following stages:
12390  * - \ref SCIP_STAGE_SOLVING
12391  *
12392  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12393  */
12394 extern
12396  SCIP* scip /**< SCIP data structure */
12397  );
12398 
12399 /** makes sure that the LP of the current node is loaded and may be accessed through the LP information methods
12400  *
12401  * @warning Contructing the LP might change the amount of variables known in the transformed problem and therefore also
12402  * the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to
12403  * call one of the later method after this one
12404  *
12405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12407  *
12408  * @pre This method can be called if @p scip is in one of the following stages:
12409  * - \ref SCIP_STAGE_SOLVING
12410  *
12411  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12412  */
12413 extern
12415  SCIP* scip, /**< SCIP data structure */
12416  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
12417  );
12418 
12419 /** makes sure that the LP of the current node is flushed
12420  *
12421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12423  *
12424  * @pre This method can be called if @p scip is in one of the following stages:
12425  * - \ref SCIP_STAGE_SOLVING
12426  *
12427  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12428  */
12429 extern
12431  SCIP* scip /**< SCIP data structure */
12432  );
12433 
12434 /** gets solution status of current LP
12435  *
12436  * @return the solution status of current LP.
12437  *
12438  * @pre This method can be called if @p scip is in one of the following stages:
12439  * - \ref SCIP_STAGE_SOLVING
12440  *
12441  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12442  */
12443 extern
12445  SCIP* scip /**< SCIP data structure */
12446  );
12447 
12448 /** returns whether the current LP solution passed the primal feasibility check
12449  *
12450  * @returns whether the current LP solution passed the primal feasibility check.
12451  *
12452  * @pre This method can be called if @p scip is in one of the following stages:
12453  * - \ref SCIP_STAGE_SOLVING
12454  *
12455  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12456  */
12457 extern
12459  SCIP* scip /**< SCIP data structure */
12460  );
12461 
12462 /** returns whether the current LP solution passed the dual feasibility check
12463  *
12464  * @returns whether the current LP solution passed the dual feasibility check.
12465  *
12466  * @pre This method can be called if @p scip is in one of the following stages:
12467  * - \ref SCIP_STAGE_SOLVING
12468  *
12469  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12470  */
12471 extern
12473  SCIP* scip /**< SCIP data structure */
12474  );
12475 
12476 /** returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
12477  *
12478  * @return whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.
12479  *
12480  * @pre This method can be called if @p scip is in one of the following stages:
12481  * - \ref SCIP_STAGE_SOLVING
12482  *
12483  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12484  */
12485 extern
12487  SCIP* scip /**< SCIP data structure */
12488  );
12489 
12490 /** gets objective value of current LP (which is the sum of column and loose objective value)
12491  *
12492  * @return the objective value of current LP (which is the sum of column and loose objective value).
12493  *
12494  * @pre This method can be called if @p scip is in one of the following stages:
12495  * - \ref SCIP_STAGE_SOLVING
12496  *
12497  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
12498  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by
12499  * SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
12500  *
12501  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12502  */
12503 extern
12505  SCIP* scip /**< SCIP data structure */
12506  );
12507 
12508 /** gets part of objective value of current LP that results from COLUMN variables only
12509  *
12510  * @return the part of objective value of current LP that results from COLUMN variables only.
12511  *
12512  * @pre This method can be called if @p scip is in one of the following stages:
12513  * - \ref SCIP_STAGE_SOLVING
12514  *
12515  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12516  */
12517 extern
12519  SCIP* scip /**< SCIP data structure */
12520  );
12521 
12522 /** gets part of objective value of current LP that results from LOOSE variables only
12523  *
12524  * @return part of objective value of current LP that results from LOOSE variables only.
12525  *
12526  * @pre This method can be called if @p scip is in one of the following stages:
12527  * - \ref SCIP_STAGE_SOLVING
12528  *
12529  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12530  */
12531 extern
12533  SCIP* scip /**< SCIP data structure */
12534  );
12535 
12536 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
12537  * function) global bound
12538  *
12539  * @return the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
12540  * function) global bound.
12541  *
12542  * @pre This method can be called if @p scip is in one of the following stages:
12543  * - \ref SCIP_STAGE_INITPRESOLVE
12544  * - \ref SCIP_STAGE_PRESOLVING
12545  * - \ref SCIP_STAGE_EXITPRESOLVE
12546  * - \ref SCIP_STAGE_PRESOLVED
12547  * - \ref SCIP_STAGE_INITSOLVE
12548  * - \ref SCIP_STAGE_SOLVING
12549  *
12550  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12551  */
12552 extern
12554  SCIP* scip /**< SCIP data structure */
12555  );
12556 
12557 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
12558  * objective function) local bound
12559  *
12560  * @return the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
12561  * objective function) local bound.
12562  *
12563  * @pre This method can be called if @p scip is in one of the following stages:
12564  * - \ref SCIP_STAGE_INITPRESOLVE
12565  * - \ref SCIP_STAGE_PRESOLVING
12566  * - \ref SCIP_STAGE_EXITPRESOLVE
12567  * - \ref SCIP_STAGE_PRESOLVED
12568  * - \ref SCIP_STAGE_INITSOLVE
12569  * - \ref SCIP_STAGE_SOLVING
12570  *
12571  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12572  */
12573 extern
12575  SCIP* scip /**< SCIP data structure */
12576  );
12577 
12578 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
12579  *
12580  * @return whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.
12581  *
12582  * @pre This method can be called if @p scip is in one of the following stages:
12583  * - \ref SCIP_STAGE_SOLVING
12584  *
12585  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12586  */
12587 extern
12589  SCIP* scip /**< SCIP data structure */
12590  );
12591 
12592 /** gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved
12593  *
12594  * @return the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved.
12595  *
12596  * @pre This method can be called if @p scip is in one of the following stages:
12597  * - \ref SCIP_STAGE_INITPRESOLVE
12598  * - \ref SCIP_STAGE_PRESOLVING
12599  * - \ref SCIP_STAGE_EXITPRESOLVE
12600  * - \ref SCIP_STAGE_SOLVING
12601  *
12602  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12603  */
12604 extern
12606  SCIP* scip /**< SCIP data structure */
12607  );
12608 
12609 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
12610  * returns SCIP_INVALID if the root node LP was not (yet) solved
12611  *
12612  * @return the part of the objective value of the root node LP that results from COLUMN variables only;
12613  * or SCIP_INVALID if the root node LP was not (yet) solved.
12614  *
12615  * @pre This method can be called if @p scip is in one of the following stages:
12616  * - \ref SCIP_STAGE_INITPRESOLVE
12617  * - \ref SCIP_STAGE_PRESOLVING
12618  * - \ref SCIP_STAGE_EXITPRESOLVE
12619  * - \ref SCIP_STAGE_SOLVING
12620  *
12621  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12622  */
12623 extern
12625  SCIP* scip /**< SCIP data structure */
12626  );
12627 
12628 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
12629  * returns SCIP_INVALID if the root node LP was not (yet) solved
12630  *
12631  * @return the part of the objective value of the root node LP that results from LOOSE variables only;
12632  * or SCIP_INVALID if the root node LP was not (yet) solved.
12633  *
12634  * @pre This method can be called if @p scip is in one of the following stages:
12635  * - \ref SCIP_STAGE_INITPRESOLVE
12636  * - \ref SCIP_STAGE_PRESOLVING
12637  * - \ref SCIP_STAGE_EXITPRESOLVE
12638  * - \ref SCIP_STAGE_SOLVING
12639  *
12640  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12641  */
12642 extern
12644  SCIP* scip /**< SCIP data structure */
12645  );
12646 
12647 /** gets current LP columns along with the current number of LP columns
12648  *
12649  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12650  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12651  *
12652  * @pre This method can be called if @p scip is in one of the following stages:
12653  * - \ref SCIP_STAGE_SOLVING
12654  *
12655  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12656  */
12657 extern
12659  SCIP* scip, /**< SCIP data structure */
12660  SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */
12661  int* ncols /**< pointer to store the number of LP columns, or NULL */
12662  );
12663 
12664 /** gets current LP columns
12665  *
12666  * @return the current LP columns.
12667  *
12668  * @pre This method can be called if @p scip is in one of the following stages:
12669  * - \ref SCIP_STAGE_SOLVING
12670  *
12671  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12672  */
12673 extern
12675  SCIP* scip /**< SCIP data structure */
12676  );
12677 
12678 /** gets current number of LP columns
12679  *
12680  * @return the current number of LP columns.
12681  *
12682  * @pre This method can be called if @p scip is in one of the following stages:
12683  * - \ref SCIP_STAGE_SOLVING
12684  *
12685  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12686  */
12687 extern
12688 int SCIPgetNLPCols(
12689  SCIP* scip /**< SCIP data structure */
12690  );
12691 
12692 /** gets current LP rows along with the current number of LP rows
12693  *
12694  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12695  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12696  *
12697  * @pre This method can be called if @p scip is in one of the following stages:
12698  * - \ref SCIP_STAGE_SOLVING
12699  *
12700  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12701  */
12702 extern
12704  SCIP* scip, /**< SCIP data structure */
12705  SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */
12706  int* nrows /**< pointer to store the number of LP rows, or NULL */
12707  );
12708 
12709 /** gets current LP rows
12710  *
12711  * @return the current LP rows.
12712  *
12713  * @pre This method can be called if @p scip is in one of the following stages:
12714  * - \ref SCIP_STAGE_SOLVING
12715  *
12716  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12717  */
12718 extern
12720  SCIP* scip /**< SCIP data structure */
12721  );
12722 
12723 /** gets current number of LP rows
12724  *
12725  * @return the current number of LP rows.
12726  *
12727  * @pre This method can be called if @p scip is in one of the following stages:
12728  * - \ref SCIP_STAGE_SOLVING
12729  *
12730  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12731  */
12732 extern
12733 int SCIPgetNLPRows(
12734  SCIP* scip /**< SCIP data structure */
12735  );
12736 
12737 /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
12738  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
12739  *
12740  * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
12741  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.
12742  *
12743  * @pre This method can be called if @p scip is in one of the following stages:
12744  * - \ref SCIP_STAGE_SOLVING
12745  *
12746  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12747  */
12748 extern
12750  SCIP* scip /**< SCIP data structure */
12751  );
12752 
12753 /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
12754  *
12755  * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis.
12756  *
12757  * @pre This method can be called if @p scip is in one of the following stages:
12758  * - \ref SCIP_STAGE_SOLVING
12759  *
12760  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12761  */
12762 extern
12764  SCIP* scip /**< SCIP data structure */
12765  );
12766 
12767 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
12768  *
12769  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12770  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12771  *
12772  * @pre This method can be called if @p scip is in one of the following stages:
12773  * - \ref SCIP_STAGE_SOLVING
12774  *
12775  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12776  */
12777 extern
12779  SCIP* scip, /**< SCIP data structure */
12780  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
12781  );
12782 
12783 /** gets a row from the inverse basis matrix B^-1
12784  *
12785  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12786  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12787  *
12788  * @pre This method can be called if @p scip is in one of the following stages:
12789  * - \ref SCIP_STAGE_SOLVING
12790  *
12791  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12792  */
12793 extern
12795  SCIP* scip, /**< SCIP data structure */
12796  int r, /**< row number */
12797  SCIP_Real* coefs, /**< array to store the coefficients of the row */
12798  int* inds, /**< array to store the non-zero indices, or NULL */
12799  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12800  * (-1: if we do not store sparsity informations) */
12801  );
12802 
12803 /** gets a column from the inverse basis matrix B^-1
12804  *
12805  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12806  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12807  *
12808  * @pre This method can be called if @p scip is in one of the following stages:
12809  * - \ref SCIP_STAGE_SOLVING
12810  *
12811  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12812  */
12813 extern
12815  SCIP* scip, /**< SCIP data structure */
12816  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
12817  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
12818  * to get the array which links the B^-1 column numbers to the row and
12819  * column numbers of the LP! c must be between 0 and nrows-1, since the
12820  * basis has the size nrows * nrows */
12821  SCIP_Real* coefs, /**< array to store the coefficients of the column */
12822  int* inds, /**< array to store the non-zero indices, or NULL */
12823  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12824  * (-1: if we do not store sparsity informations) */
12825  );
12826 
12827 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
12828  *
12829  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12830  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12831  *
12832  * @pre This method can be called if @p scip is in one of the following stages:
12833  * - \ref SCIP_STAGE_SOLVING
12834  *
12835  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12836  */
12837 extern
12839  SCIP* scip, /**< SCIP data structure */
12840  int r, /**< row number */
12841  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */
12842  SCIP_Real* coefs, /**< array to store the coefficients of the row */
12843  int* inds, /**< array to store the non-zero indices, or NULL */
12844  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12845  * (-1: if we do not store sparsity informations) */
12846  );
12847 
12848 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
12849  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
12850  *
12851  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12852  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12853  *
12854  * @pre This method can be called if @p scip is in one of the following stages:
12855  * - \ref SCIP_STAGE_SOLVING
12856  *
12857  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12858  */
12859 extern
12861  SCIP* scip, /**< SCIP data structure */
12862  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
12863  SCIP_Real* coefs, /**< array to store the coefficients of the column */
12864  int* inds, /**< array to store the non-zero indices, or NULL */
12865  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12866  * (-1: if we do not store sparsity informations) */
12867  );
12868 
12869 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
12870  * LP row are swapped in the summation
12871  *
12872  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12873  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12874  *
12875  * @pre This method can be called if @p scip is in one of the following stages:
12876  * - \ref SCIP_STAGE_SOLVING
12877  *
12878  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12879  */
12880 extern
12882  SCIP* scip, /**< SCIP data structure */
12883  SCIP_Real* weights, /**< row weights in row summation */
12884  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
12885  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
12886  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
12887  );
12888 
12889 /** writes current LP to a file
12890  *
12891  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12892  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12893  *
12894  * @pre This method can be called if @p scip is in one of the following stages:
12895  * - \ref SCIP_STAGE_SOLVING
12896  *
12897  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12898  */
12899 extern
12901  SCIP* scip, /**< SCIP data structure */
12902  const char* filename /**< file name */
12903  );
12904 
12905 /** writes MIP relaxation of the current branch-and-bound node to a file
12906  *
12907  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12908  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12909  *
12910  * @pre This method can be called if @p scip is in one of the following stages:
12911  * - \ref SCIP_STAGE_SOLVING
12912  *
12913  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12914  */
12915 extern
12917  SCIP* scip, /**< SCIP data structure */
12918  const char* filename, /**< file name */
12919  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
12920  * troubles with reserved symbols? */
12921  SCIP_Bool origobj, /**< should the original objective function be used? */
12922  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
12923  );
12924 
12925 /** gets the LP interface of SCIP;
12926  * with the LPI you can use all of the methods defined in lpi/lpi.h;
12927  *
12928  * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely
12929  * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution
12930  * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in
12931  * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make
12932  * sure, the internal solution status is recovered completely at the end of your method. This can be achieved
12933  * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it
12934  * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the
12935  * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.
12936  *
12937  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
12938  *
12939  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12940  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12941  *
12942  * @pre This method can be called if @p scip is in one of the following stages:
12943  * - \ref SCIP_STAGE_TRANSFORMED
12944  * - \ref SCIP_STAGE_INITPRESOLVE
12945  * - \ref SCIP_STAGE_PRESOLVING
12946  * - \ref SCIP_STAGE_EXITPRESOLVE
12947  * - \ref SCIP_STAGE_PRESOLVED
12948  * - \ref SCIP_STAGE_INITSOLVE
12949  * - \ref SCIP_STAGE_SOLVING
12950  * - \ref SCIP_STAGE_SOLVED
12951  * - \ref SCIP_STAGE_EXITSOLVE
12952  *
12953  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12954  */
12955 extern
12957  SCIP* scip, /**< SCIP data structure */
12958  SCIP_LPI** lpi /**< pointer to store the LP interface */
12959  );
12960 
12961 /** Displays quality information about the current LP solution. An LP solution need to be available. Information printed
12962  * is subject to what the LP solver supports
12963  *
12964  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12965  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12966  *
12967  * @pre This method can be called if @p scip is in one of the following stages:
12968  * - \ref SCIP_STAGE_INIT
12969  * - \ref SCIP_STAGE_PROBLEM
12970  * - \ref SCIP_STAGE_TRANSFORMED
12971  * - \ref SCIP_STAGE_INITPRESOLVE
12972  * - \ref SCIP_STAGE_PRESOLVING
12973  * - \ref SCIP_STAGE_EXITPRESOLVE
12974  * - \ref SCIP_STAGE_PRESOLVED
12975  * - \ref SCIP_STAGE_SOLVING
12976  * - \ref SCIP_STAGE_SOLVED
12977  * - \ref SCIP_STAGE_FREE
12978  *
12979  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12980  *
12981  * @note The printing process is done via the message handler system.
12982  */
12983 extern
12985  SCIP* scip, /**< SCIP data structure */
12986  FILE* file /**< output file (or NULL for standard output) */
12987  );
12988 
12989 /** compute relative interior point to current LP
12990  * @see SCIPlpComputeRelIntPoint
12991  *
12992  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12993  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12994  *
12995  * @pre This method can be called if @p scip is in one of the following stages:
12996  * - \ref SCIP_STAGE_TRANSFORMED
12997  * - \ref SCIP_STAGE_INITPRESOLVE
12998  * - \ref SCIP_STAGE_PRESOLVING
12999  * - \ref SCIP_STAGE_EXITPRESOLVE
13000  * - \ref SCIP_STAGE_PRESOLVED
13001  * - \ref SCIP_STAGE_SOLVING
13002  * - \ref SCIP_STAGE_SOLVED
13003  *
13004  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13005  */
13006 extern
13008  SCIP* scip, /**< SCIP data structure */
13009  SCIP_Bool relaxrows, /**< should the rows be relaxed */
13010  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
13011  SCIP_Real timelimit, /**< time limit for LP solver */
13012  int iterlimit, /**< iteration limit for LP solver */
13013  SCIP_SOL** point /**< relative interior point on exit */
13014  );
13015 
13016 /**@} */
13017 
13018 
13019 
13020 /*
13021  * LP column methods
13022  */
13023 
13024 /**@addtogroup PublicColumnMethods
13025  *
13026  * @{
13027  */
13028 
13029 /** returns the reduced costs of a column in the last (feasible) LP
13030  *
13031  * @return the reduced costs of a column in the last (feasible) LP
13032  *
13033  * @pre this method can be called in one of the following stages of the SCIP solving process:
13034  * - \ref SCIP_STAGE_SOLVING
13035  * - \ref SCIP_STAGE_SOLVED
13036  *
13037  * @note calling this method in SCIP_STAGE_SOLVED is only recommended to experienced users and should only be called
13038  * for pure LP instances (without presolving)
13039  *
13040  * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
13041  */
13042 extern
13044  SCIP* scip, /**< SCIP data structure */
13045  SCIP_COL* col /**< LP column */
13046  );
13047 
13048 /** returns the Farkas coefficient of a column in the last (infeasible) LP
13049  *
13050  * @return the Farkas coefficient of a column in the last (infeasible) LP
13051  *
13052  * @pre this method can be called in one of the following stages of the SCIP solving process:
13053  * - \ref SCIP_STAGE_SOLVING
13054  */
13055 extern
13057  SCIP* scip, /**< SCIP data structure */
13058  SCIP_COL* col /**< LP column */
13059  );
13060 
13061 /** marks a column to be not removable from the LP in the current node
13062  *
13063  * @pre this method can be called in the following stage of the SCIP solving process:
13064  * - \ref SCIP_STAGE_SOLVING
13065  */
13066 extern
13068  SCIP* scip, /**< SCIP data structure */
13069  SCIP_COL* col /**< LP column */
13070  );
13071 
13072 /**@} */
13073 
13074 
13075 
13076 
13077 /*
13078  * LP row methods
13079  */
13080 
13081 /**@addtogroup PublicRowMethods
13082  *
13083  * @{
13084  */
13085 
13086 /** creates and captures an LP row from a constraint handler
13087  *
13088  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13089  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13090  *
13091  * @pre this method can be called in one of the following stages of the SCIP solving process:
13092  * - \ref SCIP_STAGE_INITSOLVE
13093  * - \ref SCIP_STAGE_SOLVING
13094  */
13095 extern
13097  SCIP* scip, /**< SCIP data structure */
13098  SCIP_ROW** row, /**< pointer to row */
13099  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
13100  const char* name, /**< name of row */
13101  int len, /**< number of nonzeros in the row */
13102  SCIP_COL** cols, /**< array with columns of row entries */
13103  SCIP_Real* vals, /**< array with coefficients of row entries */
13104  SCIP_Real lhs, /**< left hand side of row */
13105  SCIP_Real rhs, /**< right hand side of row */
13106  SCIP_Bool local, /**< is row only valid locally? */
13107  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13108  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13109  );
13110 
13111 /** creates and captures an LP row from a separator
13112  *
13113  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13114  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13115  *
13116  * @pre this method can be called in one of the following stages of the SCIP solving process:
13117  * - \ref SCIP_STAGE_INITSOLVE
13118  * - \ref SCIP_STAGE_SOLVING
13119  */
13120 extern
13122  SCIP* scip, /**< SCIP data structure */
13123  SCIP_ROW** row, /**< pointer to row */
13124  SCIP_SEPA* sepa, /**< separator that creates the row */
13125  const char* name, /**< name of row */
13126  int len, /**< number of nonzeros in the row */
13127  SCIP_COL** cols, /**< array with columns of row entries */
13128  SCIP_Real* vals, /**< array with coefficients of row entries */
13129  SCIP_Real lhs, /**< left hand side of row */
13130  SCIP_Real rhs, /**< right hand side of row */
13131  SCIP_Bool local, /**< is row only valid locally? */
13132  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13133  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13134  );
13135 
13136 /** creates and captures an LP row from an unspecified source
13137  *
13138  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13139  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13140  *
13141  * @pre this method can be called in one of the following stages of the SCIP solving process:
13142  * - \ref SCIP_STAGE_INITSOLVE
13143  * - \ref SCIP_STAGE_SOLVING
13144  */
13145 extern
13147  SCIP* scip, /**< SCIP data structure */
13148  SCIP_ROW** row, /**< pointer to row */
13149  const char* name, /**< name of row */
13150  int len, /**< number of nonzeros in the row */
13151  SCIP_COL** cols, /**< array with columns of row entries */
13152  SCIP_Real* vals, /**< array with coefficients of row entries */
13153  SCIP_Real lhs, /**< left hand side of row */
13154  SCIP_Real rhs, /**< right hand side of row */
13155  SCIP_Bool local, /**< is row only valid locally? */
13156  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13157  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13158  );
13159 
13160 /** creates and captures an LP row
13161  *
13162  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13163  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13164  *
13165  * @pre this method can be called in one of the following stages of the SCIP solving process:
13166  * - \ref SCIP_STAGE_INITSOLVE
13167  * - \ref SCIP_STAGE_SOLVING
13168  *
13169  * @deprecated Please use SCIPcreateRowCons() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order
13170  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().
13171  */
13172 extern
13174  SCIP* scip, /**< SCIP data structure */
13175  SCIP_ROW** row, /**< pointer to row */
13176  const char* name, /**< name of row */
13177  int len, /**< number of nonzeros in the row */
13178  SCIP_COL** cols, /**< array with columns of row entries */
13179  SCIP_Real* vals, /**< array with coefficients of row entries */
13180  SCIP_Real lhs, /**< left hand side of row */
13181  SCIP_Real rhs, /**< right hand side of row */
13182  SCIP_Bool local, /**< is row only valid locally? */
13183  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13184  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13185  );
13186 
13187 /** creates and captures an LP row without any coefficients from a constraint handler
13188  *
13189  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13190  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13191  *
13192  * @pre this method can be called in one of the following stages of the SCIP solving process:
13193  * - \ref SCIP_STAGE_INITSOLVE
13194  * - \ref SCIP_STAGE_SOLVING
13195  */
13196 extern
13198  SCIP* scip, /**< SCIP data structure */
13199  SCIP_ROW** row, /**< pointer to row */
13200  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
13201  const char* name, /**< name of row */
13202  SCIP_Real lhs, /**< left hand side of row */
13203  SCIP_Real rhs, /**< right hand side of row */
13204  SCIP_Bool local, /**< is row only valid locally? */
13205  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13206  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13207  );
13208 
13209 /** creates and captures an LP row without any coefficients from a separator
13210  *
13211  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13212  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13213  *
13214  * @pre this method can be called in one of the following stages of the SCIP solving process:
13215  * - \ref SCIP_STAGE_INITSOLVE
13216  * - \ref SCIP_STAGE_SOLVING
13217  */
13218 extern
13220  SCIP* scip, /**< SCIP data structure */
13221  SCIP_ROW** row, /**< pointer to row */
13222  SCIP_SEPA* sepa, /**< separator that creates the row */
13223  const char* name, /**< name of row */
13224  SCIP_Real lhs, /**< left hand side of row */
13225  SCIP_Real rhs, /**< right hand side of row */
13226  SCIP_Bool local, /**< is row only valid locally? */
13227  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13228  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13229  );
13230 
13231 /** creates and captures an LP row without any coefficients from an unspecified source
13232  *
13233  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13234  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13235  *
13236  * @pre this method can be called in one of the following stages of the SCIP solving process:
13237  * - \ref SCIP_STAGE_INITSOLVE
13238  * - \ref SCIP_STAGE_SOLVING
13239  */
13240 extern
13242  SCIP* scip, /**< SCIP data structure */
13243  SCIP_ROW** row, /**< pointer to row */
13244  const char* name, /**< name of row */
13245  SCIP_Real lhs, /**< left hand side of row */
13246  SCIP_Real rhs, /**< right hand side of row */
13247  SCIP_Bool local, /**< is row only valid locally? */
13248  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13249  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13250  );
13251 
13252 /** creates and captures an LP row without any coefficients
13253  *
13254  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13255  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13256  *
13257  * @pre this method can be called in one of the following stages of the SCIP solving process:
13258  * - \ref SCIP_STAGE_INITSOLVE
13259  * - \ref SCIP_STAGE_SOLVING
13260  *
13261  * @deprecated Please use SCIPcreateEmptyRowCons() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order
13262  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().
13263  */
13264 extern
13266  SCIP* scip, /**< SCIP data structure */
13267  SCIP_ROW** row, /**< pointer to row */
13268  const char* name, /**< name of row */
13269  SCIP_Real lhs, /**< left hand side of row */
13270  SCIP_Real rhs, /**< right hand side of row */
13271  SCIP_Bool local, /**< is row only valid locally? */
13272  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13273  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13274  );
13275 
13276 /** increases usage counter of LP row
13277  *
13278  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13279  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13280  *
13281  * @pre this method can be called in one of the following stages of the SCIP solving process:
13282  * - \ref SCIP_STAGE_INITSOLVE
13283  * - \ref SCIP_STAGE_SOLVING
13284  */
13285 extern
13287  SCIP* scip, /**< SCIP data structure */
13288  SCIP_ROW* row /**< row to capture */
13289  );
13290 
13291 /** decreases usage counter of LP row, and frees memory if necessary
13292  *
13293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13295  *
13296  * @pre this method can be called in one of the following stages of the SCIP solving process:
13297  * - \ref SCIP_STAGE_INITSOLVE
13298  * - \ref SCIP_STAGE_SOLVING
13299  * - \ref SCIP_STAGE_EXITSOLVE
13300  */
13301 extern
13303  SCIP* scip, /**< SCIP data structure */
13304  SCIP_ROW** row /**< pointer to LP row */
13305  );
13306 
13307 /** changes left hand side of LP row
13308  *
13309  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13310  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13311  *
13312  * @pre this method can be called in one of the following stages of the SCIP solving process:
13313  * - \ref SCIP_STAGE_INITSOLVE
13314  * - \ref SCIP_STAGE_SOLVING
13315  */
13316 extern
13318  SCIP* scip, /**< SCIP data structure */
13319  SCIP_ROW* row, /**< LP row */
13320  SCIP_Real lhs /**< new left hand side */
13321  );
13322 
13323 /** changes right hand side of LP row
13324  *
13325  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13326  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13327  *
13328  * @pre this method can be called in one of the following stages of the SCIP solving process:
13329  * - \ref SCIP_STAGE_INITSOLVE
13330  * - \ref SCIP_STAGE_SOLVING
13331  */
13332 extern
13334  SCIP* scip, /**< SCIP data structure */
13335  SCIP_ROW* row, /**< LP row */
13336  SCIP_Real rhs /**< new right hand side */
13337  );
13338 
13339 /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
13340  * after all additions were applied, SCIPflushRowExtensions() must be called;
13341  * while the caching of row extensions is activated, information methods of the row give invalid results;
13342  * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase
13343  * the performance
13344  *
13345  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13346  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13347  *
13348  * @pre this method can be called in one of the following stages of the SCIP solving process:
13349  * - \ref SCIP_STAGE_INITSOLVE
13350  * - \ref SCIP_STAGE_SOLVING
13351  */
13352 extern
13354  SCIP* scip, /**< SCIP data structure */
13355  SCIP_ROW* row /**< LP row */
13356  );
13357 
13358 /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with
13359  * equal columns into a single coefficient
13360  *
13361  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13362  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13363  *
13364  * @pre this method can be called in one of the following stages of the SCIP solving process:
13365  * - \ref SCIP_STAGE_INITSOLVE
13366  * - \ref SCIP_STAGE_SOLVING
13367  */
13368 extern
13370  SCIP* scip, /**< SCIP data structure */
13371  SCIP_ROW* row /**< LP row */
13372  );
13373 
13374 /** resolves variable to columns and adds them with the coefficient to the row
13375  *
13376  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13377  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13378  *
13379  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variable will not added.
13380  *
13381  * @pre this method can be called in one of the following stages of the SCIP solving process:
13382  * - \ref SCIP_STAGE_INITSOLVE
13383  * - \ref SCIP_STAGE_SOLVING
13384  *
13385  * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables,
13386  * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP.
13387  * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution
13388  * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but
13389  * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the
13390  * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was
13391  * violated, the linear relaxation might not be violated anymore.)
13392  */
13393 extern
13395  SCIP* scip, /**< SCIP data structure */
13396  SCIP_ROW* row, /**< LP row */
13397  SCIP_VAR* var, /**< problem variable */
13398  SCIP_Real val /**< value of coefficient */
13399  );
13400 
13401 /** resolves variables to columns and adds them with the coefficients to the row;
13402  * this method caches the row extensions and flushes them afterwards to gain better performance
13403  *
13404  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13405  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13406  *
13407  * @attention If a coefficients absolute value is below the SCIP epsilon tolerance, the variable with its value is not added.
13408  *
13409  * @pre this method can be called in one of the following stages of the SCIP solving process:
13410  * - \ref SCIP_STAGE_INITSOLVE
13411  * - \ref SCIP_STAGE_SOLVING
13412  */
13413 extern
13415  SCIP* scip, /**< SCIP data structure */
13416  SCIP_ROW* row, /**< LP row */
13417  int nvars, /**< number of variables to add to the row */
13418  SCIP_VAR** vars, /**< problem variables to add */
13419  SCIP_Real* vals /**< values of coefficients */
13420  );
13421 
13422 /** resolves variables to columns and adds them with the same single coefficient to the row;
13423  * this method caches the row extensions and flushes them afterwards to gain better performance
13424  *
13425  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13426  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13427  *
13428  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variables will not added.
13429  *
13430  * @pre this method can be called in one of the following stages of the SCIP solving process:
13431  * - \ref SCIP_STAGE_INITSOLVE
13432  * - \ref SCIP_STAGE_SOLVING
13433  */
13434 extern
13436  SCIP* scip, /**< SCIP data structure */
13437  SCIP_ROW* row, /**< LP row */
13438  int nvars, /**< number of variables to add to the row */
13439  SCIP_VAR** vars, /**< problem variables to add */
13440  SCIP_Real val /**< unique value of all coefficients */
13441  );
13442 
13443 /** tries to find a value, such that all row coefficients, if scaled with this value become integral
13444  *
13445  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13446  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13447  *
13448  * @pre this method can be called in one of the following stages of the SCIP solving process:
13449  * - \ref SCIP_STAGE_INITSOLVE
13450  * - \ref SCIP_STAGE_SOLVING
13451  */
13452 extern
13454  SCIP* scip, /**< SCIP data structure */
13455  SCIP_ROW* row, /**< LP row */
13456  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
13457  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
13458  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
13459  SCIP_Real maxscale, /**< maximal allowed scalar */
13460  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
13461  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
13462  SCIP_Bool* success /**< stores whether returned value is valid */
13463  );
13464 
13465 /** tries to scale row, s.t. all coefficients (of integer variables) become integral
13466  *
13467  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13468  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13469  *
13470  * @pre this method can be called in one of the following stages of the SCIP solving process:
13471  * - \ref SCIP_STAGE_INITSOLVE
13472  * - \ref SCIP_STAGE_SOLVING
13473  */
13474 extern
13476  SCIP* scip, /**< SCIP data structure */
13477  SCIP_ROW* row, /**< LP row */
13478  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
13479  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
13480  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
13481  SCIP_Real maxscale, /**< maximal value to scale row with */
13482  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
13483  SCIP_Bool* success /**< stores whether row could be made rational */
13484  );
13485 
13486 /** marks a row to be not removable from the LP in the current node
13487  *
13488  * @pre this method can be called in the following stage of the SCIP solving process:
13489  * - \ref SCIP_STAGE_SOLVING
13490  */
13491 extern
13493  SCIP* scip, /**< SCIP data structure */
13494  SCIP_ROW* row /**< LP row */
13495  );
13496 
13497 /** returns number of integral columns in the row
13498  *
13499  * @return number of integral columns in the row
13500  *
13501  * @pre this method can be called in one of the following stages of the SCIP solving process:
13502  * - \ref SCIP_STAGE_INITSOLVE
13503  * - \ref SCIP_STAGE_SOLVING
13504  */
13505 extern
13507  SCIP* scip, /**< SCIP data structure */
13508  SCIP_ROW* row /**< LP row */
13509  );
13510 
13511 /** returns minimal absolute value of row vector's non-zero coefficients
13512  *
13513  * @return minimal absolute value of row vector's non-zero coefficients
13514  *
13515  * @pre this method can be called in one of the following stages of the SCIP solving process:
13516  * - \ref SCIP_STAGE_INITSOLVE
13517  * - \ref SCIP_STAGE_SOLVING
13518  */
13519 extern
13521  SCIP* scip, /**< SCIP data structure */
13522  SCIP_ROW* row /**< LP row */
13523  );
13524 
13525 /** returns maximal absolute value of row vector's non-zero coefficients
13526  *
13527  * @return maximal absolute value of row vector's non-zero coefficients
13528  *
13529  * @pre this method can be called in one of the following stages of the SCIP solving process:
13530  * - \ref SCIP_STAGE_INITSOLVE
13531  * - \ref SCIP_STAGE_SOLVING
13532  */
13533 extern
13535  SCIP* scip, /**< SCIP data structure */
13536  SCIP_ROW* row /**< LP row */
13537  );
13538 
13539 /** returns the minimal activity of a row w.r.t. the column's bounds
13540  *
13541  * @return the minimal activity of a row w.r.t. the column's bounds
13542  *
13543  * @pre this method can be called in one of the following stages of the SCIP solving process:
13544  * - \ref SCIP_STAGE_SOLVING
13545  */
13546 extern
13548  SCIP* scip, /**< SCIP data structure */
13549  SCIP_ROW* row /**< LP row */
13550  );
13551 
13552 /** returns the maximal activity of a row w.r.t. the column's bounds
13553  *
13554  * @return the maximal activity of a row w.r.t. the column's bounds
13555  *
13556  * @pre this method can be called in one of the following stages of the SCIP solving process:
13557  * - \ref SCIP_STAGE_SOLVING
13558  */
13559 extern
13561  SCIP* scip, /**< SCIP data structure */
13562  SCIP_ROW* row /**< LP row */
13563  );
13564 
13565 /** recalculates the activity of a row in the last LP solution
13566  *
13567  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13568  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13569  *
13570  * @pre this method can be called in one of the following stages of the SCIP solving process:
13571  * - \ref SCIP_STAGE_SOLVING
13572  */
13573 extern
13575  SCIP* scip, /**< SCIP data structure */
13576  SCIP_ROW* row /**< LP row */
13577  );
13578 
13579 /** returns the activity of a row in the last LP solution
13580  *
13581  * @return activity of a row in the last LP solution
13582  *
13583  * @pre this method can be called in one of the following stages of the SCIP solving process:
13584  * - \ref SCIP_STAGE_SOLVING
13585  */
13586 extern
13588  SCIP* scip, /**< SCIP data structure */
13589  SCIP_ROW* row /**< LP row */
13590  );
13591 
13592 /** returns the feasibility of a row in the last LP solution
13593  *
13594  * @return the feasibility of a row in the last LP solution: negative value means infeasibility
13595  *
13596  * @pre this method can be called in one of the following stages of the SCIP solving process:
13597  * - \ref SCIP_STAGE_SOLVING
13598  */
13599 extern
13601  SCIP* scip, /**< SCIP data structure */
13602  SCIP_ROW* row /**< LP row */
13603  );
13604 
13605 /** recalculates the activity of a row for the current pseudo solution
13606  *
13607  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13608  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13609  *
13610  * @pre this method can be called in one of the following stages of the SCIP solving process:
13611  * - \ref SCIP_STAGE_SOLVING
13612  */
13613 extern
13615  SCIP* scip, /**< SCIP data structure */
13616  SCIP_ROW* row /**< LP row */
13617  );
13618 
13619 /** returns the activity of a row for the current pseudo solution
13620  *
13621  * @return the activity of a row for the current pseudo solution
13622  *
13623  * @pre this method can be called in one of the following stages of the SCIP solving process:
13624  * - \ref SCIP_STAGE_SOLVING
13625  */
13626 extern
13628  SCIP* scip, /**< SCIP data structure */
13629  SCIP_ROW* row /**< LP row */
13630  );
13631 
13632 /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
13633  *
13634  * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility
13635  *
13636  * @pre this method can be called in one of the following stages of the SCIP solving process:
13637  * - \ref SCIP_STAGE_SOLVING
13638  */
13639 extern
13641  SCIP* scip, /**< SCIP data structure */
13642  SCIP_ROW* row /**< LP row */
13643  );
13644 
13645 /** recalculates the activity of a row in the last LP or pseudo solution
13646  *
13647  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13648  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13649  *
13650  * @pre this method can be called in one of the following stages of the SCIP solving process:
13651  * - \ref SCIP_STAGE_SOLVING
13652  */
13653 extern
13655  SCIP* scip, /**< SCIP data structure */
13656  SCIP_ROW* row /**< LP row */
13657  );
13658 
13659 /** returns the activity of a row in the last LP or pseudo solution
13660  *
13661  * @return the activity of a row in the last LP or pseudo solution
13662  *
13663  * @pre this method can be called in one of the following stages of the SCIP solving process:
13664  * - \ref SCIP_STAGE_SOLVING
13665  */
13666 extern
13668  SCIP* scip, /**< SCIP data structure */
13669  SCIP_ROW* row /**< LP row */
13670  );
13671 
13672 /** returns the feasibility of a row in the last LP or pseudo solution
13673  *
13674  * @return the feasibility of a row in the last LP or pseudo solution
13675  *
13676  * @pre this method can be called in one of the following stages of the SCIP solving process:
13677  * - \ref SCIP_STAGE_SOLVING
13678  */
13679 extern
13681  SCIP* scip, /**< SCIP data structure */
13682  SCIP_ROW* row /**< LP row */
13683  );
13684 
13685 /** returns the activity of a row for the given primal solution
13686  *
13687  * @return the activitiy of a row for the given primal solution
13688  *
13689  * @pre this method can be called in one of the following stages of the SCIP solving process:
13690  * - \ref SCIP_STAGE_SOLVING
13691  */
13692 extern
13694  SCIP* scip, /**< SCIP data structure */
13695  SCIP_ROW* row, /**< LP row */
13696  SCIP_SOL* sol /**< primal CIP solution */
13697  );
13698 
13699 /** returns the feasibility of a row for the given primal solution
13700  *
13701  * @return the feasibility of a row for the given primal solution
13702  *
13703  * @pre this method can be called in one of the following stages of the SCIP solving process:
13704  * - \ref SCIP_STAGE_SOLVING
13705  */
13706 extern
13708  SCIP* scip, /**< SCIP data structure */
13709  SCIP_ROW* row, /**< LP row */
13710  SCIP_SOL* sol /**< primal CIP solution */
13711  );
13712 
13713 /** output row to file stream via the message handler system
13714  *
13715  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13716  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13717  *
13718  * @pre this method can be called in one of the following stages of the SCIP solving process:
13719  * - \ref SCIP_STAGE_INITSOLVE
13720  * - \ref SCIP_STAGE_SOLVING
13721  * - \ref SCIP_STAGE_SOLVED
13722  * - \ref SCIP_STAGE_EXITSOLVE
13723  */
13724 extern
13726  SCIP* scip, /**< SCIP data structure */
13727  SCIP_ROW* row, /**< LP row */
13728  FILE* file /**< output file (or NULL for standard output) */
13729  );
13730 
13731 /**@} */
13732 
13733 
13734 /*
13735  * NLP methods
13736  */
13737 
13738 /**@addtogroup PublicNLPMethods
13739  *
13740  * @{
13741  */
13742 
13743 /** returns whether the NLP relaxation has been enabled
13744  *
13745  * If the NLP relaxation is enabled, then SCIP will construct the NLP relaxation when the solving process is about to begin.
13746  * To check whether an NLP is existing, use SCIPisNLPConstructed().
13747  *
13748  * @pre This method can be called if SCIP is in one of the following stages:
13749  * - \ref SCIP_STAGE_INITPRESOLVE
13750  * - \ref SCIP_STAGE_PRESOLVING
13751  * - \ref SCIP_STAGE_EXITPRESOLVE
13752  * - \ref SCIP_STAGE_PRESOLVED
13753  * - \ref SCIP_STAGE_INITSOLVE
13754  * - \ref SCIP_STAGE_SOLVING
13755  *
13756  * @see SCIPenableNLP
13757  */
13758 extern
13760  SCIP* scip /**< SCIP data structure */
13761  );
13762 
13763 /** marks that there are constraints that are representable by nonlinear rows
13764  *
13765  * This method should be called by a constraint handler if it has constraints that have a representation as nonlinear rows.
13766  *
13767  * The function should be called before the branch-and-bound process is initialized, e.g., when presolve is exiting.
13768  *
13769  * @pre This method can be called if SCIP is in one of the following stages:
13770  * - \ref SCIP_STAGE_INITPRESOLVE
13771  * - \ref SCIP_STAGE_PRESOLVING
13772  * - \ref SCIP_STAGE_EXITPRESOLVE
13773  * - \ref SCIP_STAGE_PRESOLVED
13774  * - \ref SCIP_STAGE_INITSOLVE
13775  * - \ref SCIP_STAGE_SOLVING
13776  */
13777 extern
13778 void SCIPenableNLP(
13779  SCIP* scip /**< SCIP data structure */
13780  );
13781 
13782 /** returns, whether an NLP has been constructed
13783  *
13784  * @pre This method can be called if SCIP is in one of the following stages:
13785  * - \ref SCIP_STAGE_INITSOLVE
13786  * - \ref SCIP_STAGE_SOLVING
13787  */
13788 extern
13790  SCIP* scip /**< SCIP data structure */
13791  );
13792 
13793 /** returns whether the NLP has a continuous variable in a nonlinear term
13794  *
13795  * @pre This method can be called if SCIP is in one of the following stages:
13796  * - \ref SCIP_STAGE_INITSOLVE
13797  * - \ref SCIP_STAGE_SOLVING
13798  */
13799 extern
13801  SCIP* scip /**< SCIP data structure */
13802  );
13803 
13804 /** gets current NLP variables along with the current number of NLP variables
13805  *
13806  * @pre This method can be called if SCIP is in one of the following stages:
13807  * - \ref SCIP_STAGE_INITSOLVE
13808  * - \ref SCIP_STAGE_SOLVING
13809  */
13810 extern
13812  SCIP* scip, /**< SCIP data structure */
13813  SCIP_VAR*** vars, /**< pointer to store the array of NLP variables, or NULL */
13814  int* nvars /**< pointer to store the number of NLP variables, or NULL */
13815  );
13816 
13817 /** gets array with variables of the NLP
13818  *
13819  * @pre This method can be called if SCIP is in one of the following stages:
13820  * - \ref SCIP_STAGE_INITSOLVE
13821  * - \ref SCIP_STAGE_SOLVING
13822  */
13823 extern
13825  SCIP* scip /**< SCIP data structure */
13826  );
13827 
13828 /** gets current number of variables in NLP
13829  *
13830  * @pre This method can be called if SCIP is in one of the following stages:
13831  * - \ref SCIP_STAGE_INITSOLVE
13832  * - \ref SCIP_STAGE_SOLVING
13833  */
13834 extern
13835 int SCIPgetNNLPVars(
13836  SCIP* scip /**< SCIP data structure */
13837  );
13838 
13839 /** computes for each variables the number of NLP rows in which the variable appears in a nonlinear var
13840  *
13841  * @pre This method can be called if SCIP is in one of the following stages:
13842  * - \ref SCIP_STAGE_INITSOLVE
13843  * - \ref SCIP_STAGE_SOLVING
13844  */
13845 extern
13847  SCIP* scip, /**< SCIP data structure */
13848  int* nlcount /**< an array of length at least SCIPnlpGetNVars() to store nonlinearity counts of variables */
13849  );
13850 
13851 /** returns dual solution values associated with lower bounds of NLP variables
13852  *
13853  * @pre This method can be called if SCIP is in one of the following stages:
13854  * - \ref SCIP_STAGE_INITSOLVE
13855  * - \ref SCIP_STAGE_SOLVING
13856  */
13857 extern
13859  SCIP* scip /**< SCIP data structure */
13860  );
13861 
13862 /** returns dual solution values associated with upper bounds of NLP variables
13863  *
13864  * @pre This method can be called if SCIP is in one of the following stages:
13865  * - \ref SCIP_STAGE_INITSOLVE
13866  * - \ref SCIP_STAGE_SOLVING
13867  */
13868 extern
13870  SCIP* scip /**< SCIP data structure */
13871  );
13872 
13873 /** gets current NLP nonlinear rows along with the current number of NLP nonlinear rows
13874  *
13875  * @pre This method can be called if SCIP is in one of the following stages:
13876  * - \ref SCIP_STAGE_INITSOLVE
13877  * - \ref SCIP_STAGE_SOLVING
13878  */
13879 extern
13881  SCIP* scip, /**< SCIP data structure */
13882  SCIP_NLROW*** nlrows, /**< pointer to store the array of NLP nonlinear rows, or NULL */
13883  int* nnlrows /**< pointer to store the number of NLP nonlinear rows, or NULL */
13884  );
13885 
13886 /** gets array with nonlinear rows of the NLP
13887  *
13888  * @pre This method can be called if SCIP is in one of the following stages:
13889  * - \ref SCIP_STAGE_INITSOLVE
13890  * - \ref SCIP_STAGE_SOLVING
13891  */
13892 extern
13894  SCIP* scip /**< SCIP data structure */
13895  );
13896 
13897 /** gets current number of nonlinear rows in NLP
13898  *
13899  * @pre This method can be called if SCIP is in one of the following stages:
13900  * - \ref SCIP_STAGE_INITSOLVE
13901  * - \ref SCIP_STAGE_SOLVING
13902  */
13903 extern
13904 int SCIPgetNNLPNlRows(
13905  SCIP* scip /**< SCIP data structure */
13906  );
13907 
13908 /** adds a nonlinear row to the NLP. This row is captured by the NLP.
13909  *
13910  * @pre This method can be called if SCIP is in one of the following stages:
13911  * - \ref SCIP_STAGE_INITSOLVE
13912  * - \ref SCIP_STAGE_SOLVING
13913  */
13914 extern
13916  SCIP* scip, /**< SCIP data structure */
13917  SCIP_NLROW* nlrow /**< nonlinear row to add to NLP */
13918  );
13919 
13920 /** makes sure that the NLP of the current node is flushed
13921  *
13922  * @pre This method can be called if SCIP is in one of the following stages:
13923  * - \ref SCIP_STAGE_INITSOLVE
13924  * - \ref SCIP_STAGE_SOLVING
13925  */
13926 extern
13928  SCIP* scip /**< SCIP data structure */
13929  );
13930 
13931 /** sets or clears initial primal guess for NLP solution (start point for NLP solver)
13932  *
13933  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13934  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13935  *
13936  * @pre This method can be called if SCIP is in one of the following stages:
13937  * - \ref SCIP_STAGE_INITSOLVE
13938  * - \ref SCIP_STAGE_SOLVING
13939  */
13940 extern
13942  SCIP* scip, /**< SCIP data structure */
13943  SCIP_Real* initialguess /**< values of initial guess (corresponding to variables from SCIPgetNLPVarsData), or NULL to use no start point */
13944  );
13945 
13946 /** sets initial primal guess for NLP solution (start point for NLP solver)
13947  *
13948  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13949  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13950  *
13951  * @pre This method can be called if SCIP is in one of the following stages:
13952  * - \ref SCIP_STAGE_INITSOLVE
13953  * - \ref SCIP_STAGE_SOLVING
13954  */
13955 extern
13957  SCIP* scip, /**< SCIP data structure */
13958  SCIP_SOL* sol /**< solution which values should be taken as initial guess, or NULL for LP solution */
13959  );
13960 
13961 /** solves the current NLP
13962  *
13963  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13964  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13965  *
13966  * @pre This method can be called if SCIP is in one of the following stages:
13967  * - \ref SCIP_STAGE_INITSOLVE
13968  * - \ref SCIP_STAGE_SOLVING
13969  */
13970 extern
13972  SCIP* scip /**< SCIP data structure */
13973  );
13974 
13975 /** gets solution status of current NLP
13976  *
13977  * @pre This method can be called if SCIP is in one of the following stages:
13978  * - \ref SCIP_STAGE_INITSOLVE
13979  * - \ref SCIP_STAGE_SOLVING
13980  */
13981 extern
13983  SCIP* scip /**< SCIP data structure */
13984  );
13985 
13986 /** gets termination status of last NLP solve
13987  *
13988  * @pre This method can be called if SCIP is in one of the following stages:
13989  * - \ref SCIP_STAGE_INITSOLVE
13990  * - \ref SCIP_STAGE_SOLVING
13991  */
13992 extern
13994  SCIP* scip /**< SCIP data structure */
13995  );
13996 
13997 /** gives statistics (number of iterations, solving time, ...) of last NLP solve
13998  *
13999  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14000  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14001  *
14002  * @pre This method can be called if SCIP is in one of the following stages:
14003  * - \ref SCIP_STAGE_INITSOLVE
14004  * - \ref SCIP_STAGE_SOLVING
14005  */
14006 extern
14008  SCIP* scip, /**< SCIP data structure */
14009  SCIP_NLPSTATISTICS* statistics /**< pointer to store statistics */
14010  );
14011 
14012 /** gets objective value of current NLP
14013  *
14014  * @pre This method can be called if SCIP is in one of the following stages:
14015  * - \ref SCIP_STAGE_INITSOLVE
14016  * - \ref SCIP_STAGE_SOLVING
14017  */
14018 extern
14020  SCIP* scip /**< SCIP data structure */
14021  );
14022 
14023 /** indicates whether a feasible solution for the current NLP is available
14024  * thus, returns whether the solution status <= feasible
14025  *
14026  * @pre This method can be called if SCIP is in one of the following stages:
14027  * - \ref SCIP_STAGE_INITSOLVE
14028  * - \ref SCIP_STAGE_SOLVING
14029  */
14030 extern
14032  SCIP* scip /**< SCIP data structure */
14033  );
14034 
14035 /** gets fractional variables of last NLP solution along with solution values and fractionalities
14036  *
14037  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14038  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14039  *
14040  * @pre This method can be called if SCIP is in one of the following stages:
14041  * - \ref SCIP_STAGE_INITSOLVE
14042  * - \ref SCIP_STAGE_SOLVING
14043  */
14044 extern
14046  SCIP* scip, /**< SCIP data structure */
14047  SCIP_VAR*** fracvars, /**< pointer to store the array of NLP fractional variables, or NULL */
14048  SCIP_Real** fracvarssol, /**< pointer to store the array of NLP fractional variables solution values, or NULL */
14049  SCIP_Real** fracvarsfrac, /**< pointer to store the array of NLP fractional variables fractionalities, or NULL */
14050  int* nfracvars, /**< pointer to store the number of NLP fractional variables , or NULL */
14051  int* npriofracvars /**< pointer to store the number of NLP fractional variables with maximal branching priority, or NULL */
14052  );
14053 
14054 /** gets integer parameter of NLP
14055  *
14056  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14057  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14058  *
14059  * @pre This method can be called if SCIP is in one of the following stages:
14060  * - \ref SCIP_STAGE_INITSOLVE
14061  * - \ref SCIP_STAGE_SOLVING
14062  */
14063 extern
14065  SCIP* scip, /**< SCIP data structure */
14066  SCIP_NLPPARAM type, /**< parameter number */
14067  int* ival /**< pointer to store the parameter value */
14068  );
14069 
14070 /** sets integer parameter of NLP
14071  *
14072  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14073  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14074  *
14075  * @pre This method can be called if SCIP is in one of the following stages:
14076  * - \ref SCIP_STAGE_INITSOLVE
14077  * - \ref SCIP_STAGE_SOLVING
14078  */
14079 extern
14081  SCIP* scip, /**< SCIP data structure */
14082  SCIP_NLPPARAM type, /**< parameter number */
14083  int ival /**< parameter value */
14084  );
14085 
14086 /** gets floating point parameter of NLP
14087  *
14088  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14089  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14090  *
14091  * @pre This method can be called if SCIP is in one of the following stages:
14092  * - \ref SCIP_STAGE_INITSOLVE
14093  * - \ref SCIP_STAGE_SOLVING
14094  */
14095 extern
14097  SCIP* scip, /**< SCIP data structure */
14098  SCIP_NLPPARAM type, /**< parameter number */
14099  SCIP_Real* dval /**< pointer to store the parameter value */
14100  );
14101 
14102 /** sets floating point parameter of NLP
14103  *
14104  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14105  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14106  *
14107  * @pre This method can be called if SCIP is in one of the following stages:
14108  * - \ref SCIP_STAGE_INITSOLVE
14109  * - \ref SCIP_STAGE_SOLVING
14110  */
14111 extern
14113  SCIP* scip, /**< SCIP data structure */
14114  SCIP_NLPPARAM type, /**< parameter number */
14115  SCIP_Real dval /**< parameter value */
14116  );
14117 
14118 /** gets string parameter of NLP
14119  *
14120  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14121  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14122  *
14123  * @pre This method can be called if SCIP is in one of the following stages:
14124  * - \ref SCIP_STAGE_INITSOLVE
14125  * - \ref SCIP_STAGE_SOLVING
14126  */
14127 extern
14129  SCIP* scip, /**< SCIP data structure */
14130  SCIP_NLPPARAM type, /**< parameter number */
14131  const char** sval /**< pointer to store the parameter value */
14132  );
14133 
14134 /** sets string parameter of NLP
14135  *
14136  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14137  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14138  *
14139  * @pre This method can be called if SCIP is in one of the following stages:
14140  * - \ref SCIP_STAGE_INITSOLVE
14141  * - \ref SCIP_STAGE_SOLVING
14142  */
14143 extern
14145  SCIP* scip, /**< SCIP data structure */
14146  SCIP_NLPPARAM type, /**< parameter number */
14147  const char* sval /**< parameter value */
14148  );
14149 
14150 /** writes current NLP to a file
14151  *
14152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14154  *
14155  * @pre This method can be called if SCIP is in one of the following stages:
14156  * - \ref SCIP_STAGE_INITSOLVE
14157  * - \ref SCIP_STAGE_SOLVING
14158  */
14159 extern
14161  SCIP* scip, /**< SCIP data structure */
14162  const char* filename /**< file name */
14163  );
14164 
14165 /** gets the NLP interface and problem used by the SCIP NLP;
14166  * with the NLPI and its problem you can use all of the methods defined in nlpi/nlpi.h;
14167  *
14168  * @warning You have to make sure, that the full internal state of the NLPI does not change or is recovered completely
14169  * after the end of the method that uses the NLPI. In particular, if you manipulate the NLP or its solution
14170  * (e.g. by calling one of the SCIPnlpiAdd...() or the SCIPnlpiSolve() method), you have to check in advance
14171  * whether the NLP is currently solved. If this is the case, you have to make sure, the internal solution
14172  * status is recovered completely at the end of your method. Additionally you have to resolve the NLP with
14173  * SCIPnlpiSolve() in order to reinstall the internal solution status.
14174  *
14175  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
14176  *
14177  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14178  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14179  *
14180  * @pre This method can be called if SCIP is in one of the following stages:
14181  * - \ref SCIP_STAGE_INITSOLVE
14182  * - \ref SCIP_STAGE_SOLVING
14183  */
14184 extern
14186  SCIP* scip, /**< SCIP data structure */
14187  SCIP_NLPI** nlpi, /**< pointer to store the NLP solver interface */
14188  SCIP_NLPIPROBLEM** nlpiproblem /**< pointer to store the NLP solver interface problem */
14189  );
14190 
14191 /**@} */
14192 
14193 
14194 /*
14195  * NLP diving methods
14196  */
14197 
14198 /**@addtogroup PublicNLPDiveMethods
14199  *
14200  * @{ */
14201 
14202 /** initiates NLP diving making methods SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), SCIPchgVarsBoundsDiveNLP(), and SCIPsolveDiveNLP() available
14203  *
14204  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14205  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14206  *
14207  * @pre This method can be called if SCIP is in one of the following stages:
14208  * - \ref SCIP_STAGE_INITSOLVE
14209  * - \ref SCIP_STAGE_SOLVING
14210  */
14211 extern
14213  SCIP* scip /**< SCIP data structure */
14214  );
14215 
14216 /** ends NLP diving
14217  *
14218  * Resets changes made by SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), and SCIPchgVarsBoundsDiveNLP().
14219  *
14220  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14221  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14222  *
14223  * @pre This method can be called if SCIP is in one of the following stages:
14224  * - \ref SCIP_STAGE_INITSOLVE
14225  * - \ref SCIP_STAGE_SOLVING
14226  */
14227 extern
14229  SCIP* scip /**< SCIP data structure */
14230  );
14231 
14232 /** changes linear objective coefficient of a variable in diving NLP
14233  *
14234  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14235  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14236  *
14237  * @pre This method can be called if SCIP is in one of the following stages:
14238  * - \ref SCIP_STAGE_INITSOLVE
14239  * - \ref SCIP_STAGE_SOLVING
14240  */
14241 extern
14243  SCIP* scip, /**< SCIP data structure */
14244  SCIP_VAR* var, /**< variable which coefficient to change */
14245  SCIP_Real coef /**< new value for coefficient */
14246  );
14247 
14248 /** changes bounds of a variable in diving NLP
14249  *
14250  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14251  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14252  *
14253  * @pre This method can be called if SCIP is in one of the following stages:
14254  * - \ref SCIP_STAGE_INITSOLVE
14255  * - \ref SCIP_STAGE_SOLVING
14256  */
14257 extern
14259  SCIP* scip, /**< SCIP data structure */
14260  SCIP_VAR* var, /**< variable which bounds to change */
14261  SCIP_Real lb, /**< new lower bound */
14262  SCIP_Real ub /**< new upper bound */
14263  );
14264 
14265 /** changes bounds of a set of variables in diving NLP
14266  *
14267  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14268  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14269  *
14270  * @pre This method can be called if SCIP is in one of the following stages:
14271  * - \ref SCIP_STAGE_INITSOLVE
14272  * - \ref SCIP_STAGE_SOLVING
14273  */
14274 extern
14276  SCIP* scip, /**< SCIP data structure */
14277  int nvars, /**< number of variables which bounds to changes */
14278  SCIP_VAR** vars, /**< variables which bounds to change */
14279  SCIP_Real* lbs, /**< new lower bounds */
14280  SCIP_Real* ubs /**< new upper bounds */
14281  );
14282 
14283 /** solves diving NLP
14284  *
14285  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14286  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14287  *
14288  * @pre This method can be called if SCIP is in one of the following stages:
14289  * - \ref SCIP_STAGE_INITSOLVE
14290  * - \ref SCIP_STAGE_SOLVING
14291  */
14292 extern
14294  SCIP* scip /**< SCIP data structure */
14295  );
14296 
14297 /**@} */
14298 
14299 
14300 /*
14301  * NLP nonlinear row methods
14302  */
14303 
14304 /**@addtogroup PublicNLRowMethods
14305  *
14306  * @{
14307  */
14308 
14309 /** creates and captures an NLP row
14310  *
14311  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14312  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14313  *
14314  * @pre This method can be called if SCIP is in one of the following stages:
14315  * - \ref SCIP_STAGE_PRESOLVED
14316  * - \ref SCIP_STAGE_INITSOLVE
14317  * - \ref SCIP_STAGE_SOLVING
14318  */
14319 extern
14321  SCIP* scip, /**< SCIP data structure */
14322  SCIP_NLROW** nlrow, /**< buffer to store pointer to nonlinear row */
14323  const char* name, /**< name of nonlinear row */
14324  SCIP_Real constant, /**< constant */
14325  int nlinvars, /**< number of linear variables */
14326  SCIP_VAR** linvars, /**< linear variables, or NULL if nlinvars == 0 */
14327  SCIP_Real* lincoefs, /**< linear coefficients, or NULL if nlinvars == 0 */
14328  int nquadvars, /**< number of variables in quadratic term */
14329  SCIP_VAR** quadvars, /**< variables in quadratic terms, or NULL if nquadvars == 0 */
14330  int nquadelems, /**< number of elements in quadratic term */
14331  SCIP_QUADELEM* quadelems, /**< elements (i.e., monomials) in quadratic term, or NULL if nquadelems == 0 */
14332  SCIP_EXPRTREE* expression, /**< nonlinear expression, or NULL */
14333  SCIP_Real lhs, /**< left hand side */
14334  SCIP_Real rhs, /**< right hand side */
14335  SCIP_EXPRCURV curvature /**< curvature of the nonlinear row */
14336  );
14337 
14338 /** creates and captures an NLP nonlinear row without any coefficients
14339  *
14340  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14341  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14342  *
14343  * @pre This method can be called if SCIP is in one of the following stages:
14344  * - \ref SCIP_STAGE_PRESOLVED
14345  * - \ref SCIP_STAGE_INITSOLVE
14346  * - \ref SCIP_STAGE_SOLVING
14347  */
14348 extern
14350  SCIP* scip, /**< SCIP data structure */
14351  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
14352  const char* name, /**< name of nonlinear row */
14353  SCIP_Real lhs, /**< left hand side */
14354  SCIP_Real rhs /**< right hand side */
14355  );
14356 
14357 /** creates and captures an NLP row from a linear row
14358  *
14359  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14360  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14361  *
14362  * @pre This method can be called if SCIP is in one of the following stages:
14363  * - \ref SCIP_STAGE_PRESOLVED
14364  * - \ref SCIP_STAGE_INITSOLVE
14365  * - \ref SCIP_STAGE_SOLVING
14366  */
14367 extern
14369  SCIP* scip, /**< SCIP data structure */
14370  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
14371  SCIP_ROW* row /**< the linear row to copy */
14372  );
14373 
14374 /** increases usage counter of NLP nonlinear row
14375  *
14376  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14377  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14378  *
14379  * @pre This method can be called if SCIP is in one of the following stages:
14380  * - \ref SCIP_STAGE_PRESOLVED
14381  * - \ref SCIP_STAGE_INITSOLVE
14382  * - \ref SCIP_STAGE_SOLVING
14383  */
14384 extern
14386  SCIP* scip, /**< SCIP data structure */
14387  SCIP_NLROW* nlrow /**< nonlinear row to capture */
14388  );
14389 
14390 /** decreases usage counter of NLP nonlinear row, and frees memory if necessary
14391  *
14392  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14393  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14394  *
14395  * @pre This method can be called if SCIP is in one of the following stages:
14396  * - \ref SCIP_STAGE_PRESOLVED
14397  * - \ref SCIP_STAGE_INITSOLVE
14398  * - \ref SCIP_STAGE_SOLVING
14399  * - \ref SCIP_STAGE_EXITSOLVE
14400  */
14401 extern
14403  SCIP* scip, /**< SCIP data structure */
14404  SCIP_NLROW** nlrow /**< pointer to nonlinear row */
14405  );
14406 
14407 /** changes left hand side of NLP nonlinear row
14408  *
14409  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14410  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14411  *
14412  * @pre This method can be called if SCIP is in one of the following stages:
14413  * - \ref SCIP_STAGE_PRESOLVED
14414  * - \ref SCIP_STAGE_INITSOLVE
14415  * - \ref SCIP_STAGE_SOLVING
14416  */
14417 extern
14419  SCIP* scip, /**< SCIP data structure */
14420  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14421  SCIP_Real lhs /**< new left hand side */
14422  );
14423 
14424 /** changes right hand side of NLP nonlinear row
14425  *
14426  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14427  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14428  *
14429  * @pre This method can be called if SCIP is in one of the following stages:
14430  * - \ref SCIP_STAGE_PRESOLVED
14431  * - \ref SCIP_STAGE_INITSOLVE
14432  * - \ref SCIP_STAGE_SOLVING
14433  */
14434 extern
14436  SCIP* scip, /**< SCIP data structure */
14437  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14438  SCIP_Real rhs /**< new right hand side */
14439  );
14440 
14441 /** changes constant of NLP nonlinear row
14442  *
14443  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14444  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14445  *
14446  * @pre This method can be called if SCIP is in one of the following stages:
14447  * - \ref SCIP_STAGE_PRESOLVED
14448  * - \ref SCIP_STAGE_INITSOLVE
14449  * - \ref SCIP_STAGE_SOLVING
14450  */
14451 extern
14453  SCIP* scip, /**< SCIP data structure */
14454  SCIP_NLROW* nlrow, /**< NLP row */
14455  SCIP_Real constant /**< new value for constant */
14456  );
14457 
14458 /** adds variable with a linear coefficient to the nonlinear row
14459  *
14460  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14461  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14462  *
14463  * @pre This method can be called if SCIP is in one of the following stages:
14464  * - \ref SCIP_STAGE_PRESOLVED
14465  * - \ref SCIP_STAGE_INITSOLVE
14466  * - \ref SCIP_STAGE_SOLVING
14467  */
14468 extern
14470  SCIP* scip, /**< SCIP data structure */
14471  SCIP_NLROW* nlrow, /**< NLP row */
14472  SCIP_VAR* var, /**< problem variable */
14473  SCIP_Real val /**< value of coefficient in linear part of row */
14474  );
14475 
14476 /** adds variables with linear coefficients to the row
14477  *
14478  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14479  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14480  *
14481  * @pre This method can be called if SCIP is in one of the following stages:
14482  * - \ref SCIP_STAGE_PRESOLVED
14483  * - \ref SCIP_STAGE_INITSOLVE
14484  * - \ref SCIP_STAGE_SOLVING
14485  */
14486 extern
14488  SCIP* scip, /**< SCIP data structure */
14489  SCIP_NLROW* nlrow, /**< NLP row */
14490  int nvars, /**< number of variables to add to the row */
14491  SCIP_VAR** vars, /**< problem variables to add */
14492  SCIP_Real* vals /**< values of coefficients in linear part of row */
14493  );
14494 
14495 /** changes linear coefficient of a variables in a row
14496  *
14497  * Setting the coefficient to 0.0 means that it is removed from the row
14498  * the variable does not need to exists before.
14499  *
14500  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14501  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14502  *
14503  * @pre This method can be called if SCIP is in one of the following stages:
14504  * - \ref SCIP_STAGE_PRESOLVED
14505  * - \ref SCIP_STAGE_INITSOLVE
14506  * - \ref SCIP_STAGE_SOLVING
14507  */
14508 extern
14510  SCIP* scip, /**< SCIP data structure */
14511  SCIP_NLROW* nlrow, /**< NLP row */
14512  SCIP_VAR* var, /**< variable */
14513  SCIP_Real coef /**< new value of coefficient */
14514  );
14515 
14516 /** adds quadratic variable to the nonlinear row
14517  *
14518  * After adding a quadratic variable, it can be used to add quadratic elements.
14519  *
14520  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14521  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14522  *
14523  * @pre This method can be called if SCIP is in one of the following stages:
14524  * - \ref SCIP_STAGE_PRESOLVED
14525  * - \ref SCIP_STAGE_INITSOLVE
14526  * - \ref SCIP_STAGE_SOLVING
14527  */
14528 extern
14530  SCIP* scip, /**< SCIP data structure */
14531  SCIP_NLROW* nlrow, /**< NLP row */
14532  SCIP_VAR* var /**< problem variable */
14533  );
14534 
14535 /** adds quadratic variables to the nonlinear row
14536  *
14537  * After adding quadratic variables, they can be used to add quadratic elements.
14538  *
14539  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14540  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14541  *
14542  * @pre This method can be called if SCIP is in one of the following stages:
14543  * - \ref SCIP_STAGE_PRESOLVED
14544  * - \ref SCIP_STAGE_INITSOLVE
14545  * - \ref SCIP_STAGE_SOLVING
14546  */
14547 extern
14549  SCIP* scip, /**< SCIP data structure */
14550  SCIP_NLROW* nlrow, /**< NLP row */
14551  int nvars, /**< number of problem variables */
14552  SCIP_VAR** vars /**< problem variables */
14553  );
14554 
14555 /** add a quadratic element to the nonlinear row
14556  *
14557  * Variable indices of the quadratic element need to be relative to quadratic variables array of row.
14558  *
14559  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14560  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14561  *
14562  * @pre This method can be called if SCIP is in one of the following stages:
14563  * - \ref SCIP_STAGE_PRESOLVED
14564  * - \ref SCIP_STAGE_INITSOLVE
14565  * - \ref SCIP_STAGE_SOLVING
14566  */
14567 extern
14569  SCIP* scip, /**< SCIP data structure */
14570  SCIP_NLROW* nlrow, /**< NLP row */
14571  SCIP_QUADELEM quadelem /**< quadratic element */
14572  );
14573 
14574 /** adds quadratic elements to the nonlinear row
14575  *
14576  * Variable indices of the quadratic elements need to be relative to quadratic variables array of row.
14577  *
14578  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14579  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14580  *
14581  * @pre This method can be called if SCIP is in one of the following stages:
14582  * - \ref SCIP_STAGE_PRESOLVED
14583  * - \ref SCIP_STAGE_INITSOLVE
14584  * - \ref SCIP_STAGE_SOLVING
14585  */
14586 extern
14588  SCIP* scip, /**< SCIP data structure */
14589  SCIP_NLROW* nlrow, /**< NLP row */
14590  int nquadelems, /**< number of quadratic elements */
14591  SCIP_QUADELEM* quadelems /**< quadratic elements */
14592  );
14593 
14594 /** changes coefficient in quadratic part of a row
14595  *
14596  * Setting the coefficient in the quadelement to 0.0 means that it is removed from the row
14597  * the element does not need to exists before.
14598  *
14599  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14600  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14601  *
14602  * @pre This method can be called if SCIP is in one of the following stages:
14603  * - \ref SCIP_STAGE_PRESOLVED
14604  * - \ref SCIP_STAGE_INITSOLVE
14605  * - \ref SCIP_STAGE_SOLVING
14606  */
14607 extern
14609  SCIP* scip, /**< SCIP data structure */
14610  SCIP_NLROW* nlrow, /**< NLP row */
14611  SCIP_QUADELEM quadelement /**< new quadratic element, or update for existing one */
14612  );
14613 
14614 /** sets or deletes expression tree in the nonlinear row
14615  *
14616  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14617  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14618  *
14619  * @pre This method can be called if SCIP is in one of the following stages:
14620  * - \ref SCIP_STAGE_PRESOLVED
14621  * - \ref SCIP_STAGE_INITSOLVE
14622  * - \ref SCIP_STAGE_SOLVING
14623  */
14624 extern
14626  SCIP* scip, /**< SCIP data structure */
14627  SCIP_NLROW* nlrow, /**< NLP row */
14628  SCIP_EXPRTREE* exprtree /**< expression tree, or NULL */
14629  );
14630 
14631 /** sets a parameter of expression tree in the nonlinear row
14632  *
14633  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14634  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14635  *
14636  * @pre This method can be called if SCIP is in one of the following stages:
14637  * - \ref SCIP_STAGE_PRESOLVED
14638  * - \ref SCIP_STAGE_INITSOLVE
14639  * - \ref SCIP_STAGE_SOLVING
14640  */
14641 extern
14643  SCIP* scip, /**< SCIP data structure */
14644  SCIP_NLROW* nlrow, /**< NLP row */
14645  int paramidx, /**< index of parameter in expression tree */
14646  SCIP_Real paramval /**< new value of parameter in expression tree */
14647  );
14648 
14649 /** sets parameters of expression tree in the nonlinear row
14650  *
14651  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14652  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14653  *
14654  * @pre This method can be called if SCIP is in one of the following stages:
14655  * - \ref SCIP_STAGE_PRESOLVED
14656  * - \ref SCIP_STAGE_INITSOLVE
14657  * - \ref SCIP_STAGE_SOLVING
14658  */
14659 extern
14661  SCIP* scip, /**< SCIP data structure */
14662  SCIP_NLROW* nlrow, /**< NLP row */
14663  SCIP_Real* paramvals /**< new values of parameter in expression tree */
14664  );
14665 
14666 /** recalculates the activity of a nonlinear row in the last NLP solution
14667  *
14668  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14669  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14670  *
14671  * @pre This method can be called if SCIP is in one of the following stages:
14672  * - \ref SCIP_STAGE_PRESOLVED
14673  * - \ref SCIP_STAGE_INITSOLVE
14674  * - \ref SCIP_STAGE_SOLVING
14675  */
14676 extern
14678  SCIP* scip, /**< SCIP data structure */
14679  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14680  );
14681 
14682 /** returns the activity of a nonlinear row in the last NLP solution
14683  *
14684  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14685  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14686  *
14687  * @pre This method can be called if SCIP is in one of the following stages:
14688  * - \ref SCIP_STAGE_INITSOLVE
14689  * - \ref SCIP_STAGE_SOLVING
14690  */
14691 extern
14693  SCIP* scip, /**< SCIP data structure */
14694  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14695  SCIP_Real* activity /**< pointer to store activity value */
14696  );
14697 
14698 /** gives the feasibility of a nonlinear row in the last NLP solution: negative value means infeasibility
14699  *
14700  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14701  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14702  *
14703  * @pre This method can be called if SCIP is in one of the following stages:
14704  * - \ref SCIP_STAGE_INITSOLVE
14705  * - \ref SCIP_STAGE_SOLVING
14706  */
14707 extern
14709  SCIP* scip, /**< SCIP data structure */
14710  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14711  SCIP_Real* feasibility /**< pointer to store feasibility value */
14712  );
14713 
14714 /** recalculates the activity of a nonlinear row for the current pseudo solution
14715  *
14716  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14717  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14718  *
14719  * @pre This method can be called if SCIP is in one of the following stages:
14720  * - \ref SCIP_STAGE_INITSOLVE
14721  * - \ref SCIP_STAGE_SOLVING
14722  */
14723 extern
14725  SCIP* scip, /**< SCIP data structure */
14726  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14727  );
14728 
14729 /** gives the activity of a nonlinear row for the current pseudo solution
14730  *
14731  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14732  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14733  *
14734  * @pre This method can be called if SCIP is in one of the following stages:
14735  * - \ref SCIP_STAGE_INITSOLVE
14736  * - \ref SCIP_STAGE_SOLVING
14737  */
14738 extern
14740  SCIP* scip, /**< SCIP data structure */
14741  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14742  SCIP_Real* pseudoactivity /**< pointer to store pseudo activity value */
14743  );
14744 
14745 /** gives the feasibility of a nonlinear row for the current pseudo solution: negative value means infeasibility
14746  *
14747  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14748  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14749  *
14750  * @pre This method can be called if SCIP is in one of the following stages:
14751  * - \ref SCIP_STAGE_INITSOLVE
14752  * - \ref SCIP_STAGE_SOLVING
14753  */
14754 extern
14756  SCIP* scip, /**< SCIP data structure */
14757  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14758  SCIP_Real* pseudofeasibility /**< pointer to store pseudo feasibility value */
14759  );
14760 
14761 /** recalculates the activity of a nonlinear row in the last NLP or pseudo solution
14762  *
14763  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14764  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14765  *
14766  * @pre This method can be called if SCIP is in one of the following stages:
14767  * - \ref SCIP_STAGE_INITSOLVE
14768  * - \ref SCIP_STAGE_SOLVING
14769  */
14770 extern
14772  SCIP* scip, /**< SCIP data structure */
14773  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14774  );
14775 
14776 /** gives the activity of a nonlinear row in the last NLP or pseudo solution
14777  *
14778  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14779  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14780  *
14781  * @pre This method can be called if SCIP is in one of the following stages:
14782  * - \ref SCIP_STAGE_INITSOLVE
14783  * - \ref SCIP_STAGE_SOLVING
14784  */
14785 extern
14787  SCIP* scip, /**< SCIP data structure */
14788  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14789  SCIP_Real* activity /**< pointer to store activity value */
14790  );
14791 
14792 /** gives the feasibility of a nonlinear row in the last NLP or pseudo solution
14793  *
14794  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14795  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14796  *
14797  * @pre This method can be called if SCIP is in one of the following stages:
14798  * - \ref SCIP_STAGE_INITSOLVE
14799  * - \ref SCIP_STAGE_SOLVING
14800  */
14801 extern
14803  SCIP* scip, /**< SCIP data structure */
14804  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14805  SCIP_Real* feasibility /**< pointer to store feasibility value */
14806  );
14807 
14808 /** gives the activity of a nonlinear row for the given primal solution or NLP solution or pseudo solution
14809  *
14810  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14811  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14812  *
14813  * @pre This method can be called if SCIP is in one of the following stages:
14814  * - \ref SCIP_STAGE_INITSOLVE
14815  * - \ref SCIP_STAGE_SOLVING
14816  */
14817 extern
14819  SCIP* scip, /**< SCIP data structure */
14820  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14821  SCIP_SOL* sol, /**< primal CIP solution, or NULL for NLP solution of pseudo solution */
14822  SCIP_Real* activity /**< pointer to store activity value */
14823  );
14824 
14825 /** gives the feasibility of a nonlinear row for the given primal solution
14826  *
14827  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14828  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14829  *
14830  * @pre This method can be called if SCIP is in one of the following stages:
14831  * - \ref SCIP_STAGE_INITSOLVE
14832  * - \ref SCIP_STAGE_SOLVING
14833  */
14834 extern
14836  SCIP* scip, /**< SCIP data structure */
14837  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14838  SCIP_SOL* sol, /**< primal CIP solution */
14839  SCIP_Real* feasibility /**< pointer to store feasibility value */
14840  );
14841 
14842 /** gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds
14843  *
14844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14846  *
14847  * @pre This method can be called if SCIP is in one of the following stages:
14848  * - \ref SCIP_STAGE_PRESOLVED
14849  * - \ref SCIP_STAGE_INITSOLVE
14850  * - \ref SCIP_STAGE_SOLVING
14851  */
14852 extern
14854  SCIP* scip, /**< SCIP data structure */
14855  SCIP_NLROW* nlrow, /**< NLP row */
14856  SCIP_Real* minactivity, /**< buffer to store minimal activity, or NULL */
14857  SCIP_Real* maxactivity /**< buffer to store maximal activity, or NULL */
14858  );
14859 
14860 /** output nonlinear row to file stream
14861  *
14862  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14863  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14864  *
14865  * @pre This method can be called if SCIP is in one of the following stages:
14866  * - \ref SCIP_STAGE_PRESOLVED
14867  * - \ref SCIP_STAGE_INITSOLVE
14868  * - \ref SCIP_STAGE_SOLVING
14869  */
14870 extern
14872  SCIP* scip, /**< SCIP data structure */
14873  SCIP_NLROW* nlrow, /**< NLP row */
14874  FILE* file /**< output file (or NULL for standard output) */
14875  );
14876 
14877 /**@} */
14878 
14879 /**@addtogroup PublicExpressionTreeMethods
14880  *
14881  * @{
14882  */
14883 
14884 /** replaces array of variables in expression tree by corresponding transformed variables
14885  *
14886  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14887  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14888  *
14889  * @pre This method can be called if @p scip is in one of the following stages:
14890  * - \ref SCIP_STAGE_TRANSFORMING
14891  * - \ref SCIP_STAGE_TRANSFORMED
14892  * - \ref SCIP_STAGE_INITPRESOLVE
14893  * - \ref SCIP_STAGE_PRESOLVING
14894  * - \ref SCIP_STAGE_EXITPRESOLVE
14895  * - \ref SCIP_STAGE_PRESOLVED
14896  * - \ref SCIP_STAGE_INITSOLVE
14897  * - \ref SCIP_STAGE_SOLVING
14898  * - \ref SCIP_STAGE_SOLVED
14899  * - \ref SCIP_STAGE_EXITSOLVE
14900  * - \ref SCIP_STAGE_FREETRANS
14901  *
14902  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14903  */
14904 extern
14906  SCIP* scip, /**< SCIP data structure */
14907  SCIP_EXPRTREE* tree /**< expression tree */
14908  );
14909 
14910 /** evaluates an expression tree for a primal solution or LP solution
14911  *
14912  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14913  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14914  *
14915  * @pre This method can be called if @p scip is in one of the following stages:
14916  * - \ref SCIP_STAGE_PROBLEM
14917  * - \ref SCIP_STAGE_TRANSFORMING
14918  * - \ref SCIP_STAGE_TRANSFORMED
14919  * - \ref SCIP_STAGE_INITPRESOLVE
14920  * - \ref SCIP_STAGE_PRESOLVING
14921  * - \ref SCIP_STAGE_EXITPRESOLVE
14922  * - \ref SCIP_STAGE_PRESOLVED
14923  * - \ref SCIP_STAGE_INITSOLVE
14924  * - \ref SCIP_STAGE_SOLVING
14925  * - \ref SCIP_STAGE_SOLVED
14926  * - \ref SCIP_STAGE_EXITSOLVE
14927  * - \ref SCIP_STAGE_FREETRANS
14928  *
14929  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14930  */
14931 extern
14933  SCIP* scip, /**< SCIP data structure */
14934  SCIP_EXPRTREE* tree, /**< expression tree */
14935  SCIP_SOL* sol, /**< a solution, or NULL for current LP solution */
14936  SCIP_Real* val /**< buffer to store value */
14937  );
14938 
14939 /** evaluates an expression tree w.r.t. current global bounds
14940  *
14941  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14942  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14943  *
14944  * @pre This method can be called if @p scip is in one of the following stages:
14945  * - \ref SCIP_STAGE_PROBLEM
14946  * - \ref SCIP_STAGE_TRANSFORMING
14947  * - \ref SCIP_STAGE_TRANSFORMED
14948  * - \ref SCIP_STAGE_INITPRESOLVE
14949  * - \ref SCIP_STAGE_PRESOLVING
14950  * - \ref SCIP_STAGE_EXITPRESOLVE
14951  * - \ref SCIP_STAGE_PRESOLVED
14952  * - \ref SCIP_STAGE_INITSOLVE
14953  * - \ref SCIP_STAGE_SOLVING
14954  * - \ref SCIP_STAGE_SOLVED
14955  * - \ref SCIP_STAGE_EXITSOLVE
14956  * - \ref SCIP_STAGE_FREETRANS
14957  *
14958  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14959  */
14960 extern
14962  SCIP* scip, /**< SCIP data structure */
14963  SCIP_EXPRTREE* tree, /**< expression tree */
14964  SCIP_Real infinity, /**< value to use for infinity */
14965  SCIP_INTERVAL* val /**< buffer to store result */
14966  );
14967 
14968 /** evaluates an expression tree w.r.t. current local bounds
14969  *
14970  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14971  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14972  *
14973  * @pre This method can be called if @p scip is in one of the following stages:
14974  * - \ref SCIP_STAGE_PROBLEM
14975  * - \ref SCIP_STAGE_TRANSFORMING
14976  * - \ref SCIP_STAGE_TRANSFORMED
14977  * - \ref SCIP_STAGE_INITPRESOLVE
14978  * - \ref SCIP_STAGE_PRESOLVING
14979  * - \ref SCIP_STAGE_EXITPRESOLVE
14980  * - \ref SCIP_STAGE_PRESOLVED
14981  * - \ref SCIP_STAGE_INITSOLVE
14982  * - \ref SCIP_STAGE_SOLVING
14983  * - \ref SCIP_STAGE_SOLVED
14984  * - \ref SCIP_STAGE_EXITSOLVE
14985  * - \ref SCIP_STAGE_FREETRANS
14986  *
14987  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14988  */
14989 extern
14991  SCIP* scip, /**< SCIP data structure */
14992  SCIP_EXPRTREE* tree, /**< expression tree */
14993  SCIP_Real infinity, /**< value to use for infinity */
14994  SCIP_INTERVAL* val /**< buffer to store result */
14995  );
14996 
14997 /**@} */
14998 
14999 
15000 
15001 
15002 /*
15003  * nonlinear methods
15004  */
15005 
15006 /**@addtogroup PublicNonlinearMethods
15007  *
15008  * @{
15009  */
15010 
15011 /** computes coefficients of linearization of a square term in a reference point */
15012 extern
15014  SCIP* scip, /**< SCIP data structure */
15015  SCIP_Real sqrcoef, /**< coefficient of square term */
15016  SCIP_Real refpoint, /**< point where to linearize */
15017  SCIP_Bool isint, /**< whether corresponding variable is a discrete variable, and thus linearization could be moved */
15018  SCIP_Real* lincoef, /**< buffer to add coefficient of linearization */
15019  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
15020  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
15021  );
15022 
15023 /** computes coefficients of secant of a square term */
15024 extern
15025 void SCIPaddSquareSecant(
15026  SCIP* scip, /**< SCIP data structure */
15027  SCIP_Real sqrcoef, /**< coefficient of square term */
15028  SCIP_Real lb, /**< lower bound on variable */
15029  SCIP_Real ub, /**< upper bound on variable */
15030  SCIP_Real refpoint, /**< point for which to compute value of linearization */
15031  SCIP_Real* lincoef, /**< buffer to add coefficient of secant */
15032  SCIP_Real* linconstant, /**< buffer to add constant of secant */
15033  SCIP_Bool* success /**< buffer to set to FALSE if secant has failed due to large numbers or unboundedness */
15034  );
15035 
15036 /** computes coefficients of linearization of a bilinear term in a reference point */
15037 extern
15039  SCIP* scip, /**< SCIP data structure */
15040  SCIP_Real bilincoef, /**< coefficient of bilinear term */
15041  SCIP_Real refpointx, /**< point where to linearize first variable */
15042  SCIP_Real refpointy, /**< point where to linearize second variable */
15043  SCIP_Real* lincoefx, /**< buffer to add coefficient of first variable in linearization */
15044  SCIP_Real* lincoefy, /**< buffer to add coefficient of second variable in linearization */
15045  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
15046  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
15047  );
15048 
15049 /** computes coefficients of McCormick under- or overestimation of a bilinear term */
15050 extern
15052  SCIP* scip, /**< SCIP data structure */
15053  SCIP_Real bilincoef, /**< coefficient of bilinear term */
15054  SCIP_Real lbx, /**< lower bound on first variable */
15055  SCIP_Real ubx, /**< upper bound on first variable */
15056  SCIP_Real refpointx, /**< reference point for first variable */
15057  SCIP_Real lby, /**< lower bound on second variable */
15058  SCIP_Real uby, /**< upper bound on second variable */
15059  SCIP_Real refpointy, /**< reference point for second variable */
15060  SCIP_Bool overestimate, /**< whether to compute an overestimator instead of an underestimator */
15061  SCIP_Real* lincoefx, /**< buffer to add coefficient of first variable in linearization */
15062  SCIP_Real* lincoefy, /**< buffer to add coefficient of second variable in linearization */
15063  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
15064  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
15065  );
15066 
15067 /** computes coefficients of linearization of a bilinear term in a reference point when given a linear inequality
15068  * involving only the variables of the bilinear term
15069  *
15070  * @note the formulas are extracted from "Convex envelopes of bivariate functions through the solution of KKT systems"
15071  * by Marco Locatelli
15072  */
15073 extern
15075  SCIP* scip, /**< SCIP data structure */
15076  SCIP_Real bilincoef, /**< coefficient of bilinear term */
15077  SCIP_Real lbx, /**< lower bound on first variable */
15078  SCIP_Real ubx, /**< upper bound on first variable */
15079  SCIP_Real refpointx, /**< reference point for first variable */
15080  SCIP_Real lby, /**< lower bound on second variable */
15081  SCIP_Real uby, /**< upper bound on second variable */
15082  SCIP_Real refpointy, /**< reference point for second variable */
15083  SCIP_Bool overestimate, /**< whether to compute an overestimator instead of an underestimator */
15084  SCIP_Real xcoef, /**< x coefficient of linear inequality; must be in {-1,0,1} */
15085  SCIP_Real ycoef, /**< y coefficient of linear inequality */
15086  SCIP_Real constant, /**< constant of linear inequality */
15087  SCIP_Real* RESTRICT lincoefx, /**< buffer to store coefficient of first variable in linearization */
15088  SCIP_Real* RESTRICT lincoefy, /**< buffer to store coefficient of second variable in linearization */
15089  SCIP_Real* RESTRICT linconstant, /**< buffer to store constant of linearization */
15090  SCIP_Bool* RESTRICT success /**< buffer to store whether linearization was successful */
15091  );
15092 
15093 /** computes coefficients of linearization of a bilinear term in a reference point when given two linear inequality
15094  * involving only the variables of the bilinear term
15095  *
15096  * @note the formulas are extracted from "Convex envelopes of bivariate functions through the solution of KKT systems"
15097  * by Marco Locatelli
15098  *
15099  */
15100 extern
15102  SCIP* scip, /**< SCIP data structure */
15103  SCIP_Real bilincoef, /**< coefficient of bilinear term */
15104  SCIP_Real lbx, /**< lower bound on first variable */
15105  SCIP_Real ubx, /**< upper bound on first variable */
15106  SCIP_Real refpointx, /**< reference point for first variable */
15107  SCIP_Real lby, /**< lower bound on second variable */
15108  SCIP_Real uby, /**< upper bound on second variable */
15109  SCIP_Real refpointy, /**< reference point for second variable */
15110  SCIP_Bool overestimate, /**< whether to compute an overestimator instead of an underestimator */
15111  SCIP_Real alpha1, /**< x coefficient of linear inequality; must be in {-1,0,1} */
15112  SCIP_Real beta1, /**< y coefficient of linear inequality */
15113  SCIP_Real gamma1, /**< constant of linear inequality */
15114  SCIP_Real alpha2, /**< x coefficient of linear inequality; must be in {-1,0,1} */
15115  SCIP_Real beta2, /**< y coefficient of linear inequality */
15116  SCIP_Real gamma2, /**< constant of linear inequality */
15117  SCIP_Real* RESTRICT lincoefx, /**< buffer to store coefficient of first variable in linearization */
15118  SCIP_Real* RESTRICT lincoefy, /**< buffer to store coefficient of second variable in linearization */
15119  SCIP_Real* RESTRICT linconstant, /**< buffer to store constant of linearization */
15120  SCIP_Bool* RESTRICT success /**< buffer to store whether linearization was successful */
15121  );
15122 
15123 /** creates an NLP relaxation and stores it in a given NLPI problem; the function computes for each variable which the
15124  * number of non-linearly occurrences and stores it in the nlscore array
15125  *
15126  * @note the first row corresponds always to the cutoff row (even if cutoffbound is SCIPinfinity(scip))
15127  **/
15128 extern
15130  SCIP* scip, /**< SCIP data structure */
15131  SCIP_NLPI* nlpi, /**< interface to NLP solver */
15132  SCIP_NLROW** nlrows, /**< nonlinear rows */
15133  int nnlrows, /**< total number of nonlinear rows */
15134  SCIP_NLPIPROBLEM* nlpiprob, /**< empty nlpi problem */
15135  SCIP_HASHMAP* var2idx, /**< empty hash map to store mapping between variables and indices in nlpi
15136  * problem */
15137  SCIP_Real* nlscore, /**< array to store the score of each nonlinear variable (NULL if not
15138  * needed) */
15139  SCIP_Real cutoffbound, /**< cutoff bound */
15140  SCIP_Bool setobj, /**< should the objective function be set? */
15141  SCIP_Bool onlyconvex /**< filter only for convex constraints */
15142  );
15143 
15144 /** updates bounds of each variable and the cutoff row in the nlpiproblem */
15145 extern
15147  SCIP* scip, /**< SCIP data structure */
15148  SCIP_NLPI* nlpi, /**< interface to NLP solver */
15149  SCIP_NLPIPROBLEM* nlpiprob, /**< nlpi problem representing the convex NLP relaxation */
15150  SCIP_HASHMAP* var2nlpiidx, /**< mapping between variables and nlpi indices */
15151  SCIP_VAR** nlpivars, /**< array containing all variables of the nlpi */
15152  int nlpinvars, /**< total number of nlpi variables */
15153  SCIP_Real cutoffbound /**< new cutoff bound */
15154  );
15155 
15156 /** adds linear rows to the NLP relaxation */
15157 extern
15159  SCIP* scip, /**< SCIP data structure */
15160  SCIP_NLPI* nlpi, /**< interface to NLP solver */
15161  SCIP_NLPIPROBLEM* nlpiprob, /**< nlpi problem */
15162  SCIP_HASHMAP* var2idx, /**< empty hash map to store mapping between variables and indices in nlpi
15163  * problem */
15164  SCIP_ROW** rows, /**< rows to add */
15165  int nrows /**< total number of rows to add */
15166  );
15167 
15168 /**@} */
15169 
15170 
15171 
15172 
15173 /*
15174  * cutting plane methods
15175  */
15176 
15177 /**@addtogroup PublicCutMethods
15178  *
15179  * @{
15180  */
15181 
15182 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
15183  * e = -feasibility/norm
15184  *
15185  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
15186  * e = -feasibility/norm
15187  *
15188  * @pre This method can be called if @p scip is in one of the following stages:
15189  * - \ref SCIP_STAGE_SOLVING
15190  */
15191 extern
15193  SCIP* scip, /**< SCIP data structure */
15194  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
15195  SCIP_ROW* cut /**< separated cut */
15196  );
15197 
15198 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
15199  * than the minimal cut efficacy
15200  *
15201  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
15202  * than the minimal cut efficacy, otherwise FALSE
15203  *
15204  * @pre This method can be called if @p scip is in one of the following stages:
15205  * - \ref SCIP_STAGE_SOLVING
15206  */
15207 extern
15209  SCIP* scip, /**< SCIP data structure */
15210  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
15211  SCIP_ROW* cut /**< separated cut */
15212  );
15213 
15214 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
15215  *
15216  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
15217  */
15218 extern
15220  SCIP* scip, /**< SCIP data structure */
15221  SCIP_Real efficacy /**< efficacy of the cut */
15222  );
15223 
15224 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
15225  *
15226  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
15227  */
15228 extern
15230  SCIP* scip, /**< SCIP data structure */
15231  SCIP_Real* vals, /**< array of values */
15232  int nvals /**< number of values */
15233  );
15234 
15235 /** indicates whether a cut is applicable
15236  *
15237  * If the cut has only one variable and this method returns FALSE, it may
15238  * still be possible that the cut can be added to the LP (as a row instead
15239  * of a boundchange), but it will be a very weak cut. The user is asked
15240  * to avoid such cuts.
15241  *
15242  * @pre This method can be called if @p scip is in one of the following stages:
15243  * - \ref SCIP_STAGE_SOLVING
15244  *
15245  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
15246  */
15247 extern
15249  SCIP* scip, /**< SCIP data structure */
15250  SCIP_ROW* cut /**< separated cut */
15251  );
15252 
15253 /** adds cut to separation storage
15254  *
15255  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15256  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15257  *
15258  * @pre This method can be called if @p scip is in one of the following stages:
15259  * - \ref SCIP_STAGE_SOLVING
15260  *
15261  * @deprecated Please use SCIPaddRow() instead, or, if the row is a global cut and it might be useful to keep it for future use,
15262  * consider adding it to the global cutpool with SCIPaddPoolCut().
15263  */
15264 extern
15266  SCIP* scip, /**< SCIP data structure */
15267  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
15268  SCIP_ROW* cut, /**< separated cut */
15269  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
15270  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
15271  );
15272 
15273 /** adds row to separation storage
15274  *
15275  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15276  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15277  *
15278  * @pre This method can be called if @p scip is in one of the following stages:
15279  * - \ref SCIP_STAGE_SOLVING
15280  */
15281 extern
15283  SCIP* scip, /**< SCIP data structure */
15284  SCIP_ROW* row, /**< row */
15285  SCIP_Bool forcecut, /**< should the row be forced to enter the LP? */
15286  SCIP_Bool* infeasible /**< pointer to store whether row has been detected to be infeasible for local bounds */
15287  );
15288 
15289 /** checks if cut is already existing in global cutpool
15290  *
15291  * @return TRUE is returned if the cut is not already existing in the global cutpool, FALSE otherwise
15292  *
15293  * @pre This method can be called if @p scip is in one of the following stages:
15294  * - \ref SCIP_STAGE_SOLVING
15295  */
15296 extern
15298  SCIP* scip, /**< SCIP data structure */
15299  SCIP_ROW* row /**< cutting plane to add */
15300  );
15301 
15302 /** if not already existing, adds row to global cut pool
15303  *
15304  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15305  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15306  *
15307  * @pre This method can be called if @p scip is in one of the following stages:
15308  * - \ref SCIP_STAGE_SOLVING
15309  */
15310 extern
15312  SCIP* scip, /**< SCIP data structure */
15313  SCIP_ROW* row /**< cutting plane to add */
15314  );
15315 
15316 /** removes the row from the global cut pool
15317  *
15318  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15319  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15320  *
15321  * @pre This method can be called if @p scip is in one of the following stages:
15322  * - \ref SCIP_STAGE_SOLVING
15323  */
15324 extern
15326  SCIP* scip, /**< SCIP data structure */
15327  SCIP_ROW* row /**< row to remove */
15328  );
15329 
15330 /** gets current cuts in the global cut pool
15331  *
15332  * @return the current cuts in the global cut pool
15333  *
15334  * @pre This method can be called if @p scip is in one of the following stages:
15335  * - \ref SCIP_STAGE_SOLVING
15336  * - \ref SCIP_STAGE_SOLVED
15337  * - \ref SCIP_STAGE_EXITSOLVE
15338  */
15339 extern
15341  SCIP* scip /**< SCIP data structure */
15342  );
15343 
15344 /** gets current number of rows in the global cut pool
15345  *
15346  * @return the current number of rows in the global cut pool
15347  *
15348  * @pre This method can be called if @p scip is in one of the following stages:
15349  * - \ref SCIP_STAGE_SOLVING
15350  * - \ref SCIP_STAGE_SOLVED
15351  * - \ref SCIP_STAGE_EXITSOLVE
15352  */
15353 extern
15354 int SCIPgetNPoolCuts(
15355  SCIP* scip /**< SCIP data structure */
15356  );
15357 
15358 /** gets the global cut pool used by SCIP
15359  *
15360  * @return the global cut pool used by SCIP
15361  *
15362  * @pre This method can be called if @p scip is in one of the following stages:
15363  * - \ref SCIP_STAGE_SOLVING
15364  * - \ref SCIP_STAGE_SOLVED
15365  * - \ref SCIP_STAGE_EXITSOLVE
15366  */
15367 extern
15369  SCIP* scip /**< SCIP data structure */
15370  );
15371 
15372 /** creates a cut pool
15373  *
15374  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15375  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15376  *
15377  * @pre This method can be called if @p scip is in one of the following stages:
15378  * - \ref SCIP_STAGE_TRANSFORMING
15379  * - \ref SCIP_STAGE_TRANSFORMED
15380  * - \ref SCIP_STAGE_INITPRESOLVE
15381  * - \ref SCIP_STAGE_PRESOLVING
15382  * - \ref SCIP_STAGE_EXITPRESOLVE
15383  * - \ref SCIP_STAGE_PRESOLVED
15384  * - \ref SCIP_STAGE_INITSOLVE
15385  * - \ref SCIP_STAGE_SOLVING
15386  */
15387 extern
15389  SCIP* scip, /**< SCIP data structure */
15390  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
15391  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
15392  );
15393 
15394 /** frees a cut pool
15395  *
15396  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15397  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15398  *
15399  * @pre This method can be called if @p scip is in one of the following stages:
15400  * - \ref SCIP_STAGE_TRANSFORMING
15401  * - \ref SCIP_STAGE_TRANSFORMED
15402  * - \ref SCIP_STAGE_INITPRESOLVE
15403  * - \ref SCIP_STAGE_PRESOLVING
15404  * - \ref SCIP_STAGE_EXITPRESOLVE
15405  * - \ref SCIP_STAGE_PRESOLVED
15406  * - \ref SCIP_STAGE_INITSOLVE
15407  * - \ref SCIP_STAGE_SOLVING
15408  * - \ref SCIP_STAGE_SOLVED
15409  * - \ref SCIP_STAGE_EXITSOLVE
15410  * - \ref SCIP_STAGE_FREETRANS
15411  */
15412 extern
15414  SCIP* scip, /**< SCIP data structure */
15415  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
15416  );
15417 
15418 /** if not already existing, adds row to a cut pool and captures it
15419  *
15420  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15421  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15422  *
15423  * @pre This method can be called if @p scip is in one of the following stages:
15424  * - \ref SCIP_STAGE_INITSOLVE
15425  * - \ref SCIP_STAGE_SOLVING
15426  */
15427 extern
15429  SCIP* scip, /**< SCIP data structure */
15430  SCIP_CUTPOOL* cutpool, /**< cut pool */
15431  SCIP_ROW* row /**< cutting plane to add */
15432  );
15433 
15434 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
15435  *
15436  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15437  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15438  *
15439  * @pre This method can be called if @p scip is in one of the following stages:
15440  * - \ref SCIP_STAGE_INITSOLVE
15441  * - \ref SCIP_STAGE_SOLVING
15442  */
15443 extern
15445  SCIP* scip, /**< SCIP data structure */
15446  SCIP_CUTPOOL* cutpool, /**< cut pool */
15447  SCIP_ROW* row /**< cutting plane to add */
15448  );
15449 
15450 /** removes the LP row from a cut pool
15451  *
15452  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15453  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15454  *
15455  * @pre This method can be called if @p scip is in one of the following stages:
15456  * - \ref SCIP_STAGE_INITSOLVE
15457  * - \ref SCIP_STAGE_SOLVING
15458  * - \ref SCIP_STAGE_SOLVED
15459  */
15460 extern
15462  SCIP* scip, /**< SCIP data structure */
15463  SCIP_CUTPOOL* cutpool, /**< cut pool */
15464  SCIP_ROW* row /**< row to remove */
15465  );
15466 
15467 /** separates cuts from a cut pool
15468  *
15469  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15470  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15471  *
15472  * @pre This method can be called if @p scip is in one of the following stages:
15473  * - \ref SCIP_STAGE_SOLVING
15474  */
15475 extern
15477  SCIP* scip, /**< SCIP data structure */
15478  SCIP_CUTPOOL* cutpool, /**< cut pool */
15479  SCIP_RESULT* result /**< pointer to store the result of the separation call */
15480  );
15481 
15482 /** separates cuts w.r.t. given solution from a cut pool
15483  *
15484  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15485  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15486  *
15487  * @pre This method can be called if @p scip is in one of the following stages:
15488  * - \ref SCIP_STAGE_SOLVING
15489  */
15490 extern
15492  SCIP* scip, /**< SCIP data structure */
15493  SCIP_CUTPOOL* cutpool, /**< cut pool */
15494  SCIP_SOL* sol, /**< solution to be separated */
15495  SCIP_RESULT* result /**< pointer to store the result of the separation call */
15496  );
15497 
15498 /** if not already existing, adds row to the delayed global cut pool
15499  *
15500  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15501  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15502  *
15503  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15504  */
15505 extern
15507  SCIP* scip, /**< SCIP data structure */
15508  SCIP_ROW* row /**< cutting plane to add */
15509  );
15510 
15511 /** removes the row from the delayed global cut pool
15512  *
15513  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15514  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15515  *
15516  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15517  */
15518 extern
15520  SCIP* scip, /**< SCIP data structure */
15521  SCIP_ROW* row /**< cutting plane to add */
15522  );
15523 
15524 /** gets current cuts in the delayed global cut pool
15525  *
15526  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15527  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15528  *
15529  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15530  */
15531 extern
15533  SCIP* scip /**< SCIP data structure */
15534  );
15535 
15536 /** gets current number of rows in the delayed global cut pool
15537  *
15538  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15539  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15540  *
15541  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15542  */
15543 extern
15545  SCIP* scip /**< SCIP data structure */
15546  );
15547 
15548 /** gets the delayed global cut pool used by SCIP
15549  *
15550  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15551  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15552  *
15553  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15554  */
15555 extern
15557  SCIP* scip /**< SCIP data structure */
15558  );
15559 
15560 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
15561  * separation methods;
15562  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
15563  * SCIPgetNCuts();
15564  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
15565  * separation storage;
15566  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
15567  * afterwards
15568  *
15569  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15570  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15571  *
15572  * @pre This method can be called if @p scip is in one of the following stages:
15573  * - \ref SCIP_STAGE_SOLVING
15574  */
15575 extern
15577  SCIP* scip, /**< SCIP data structure */
15578  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
15579  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
15580  SCIP_Bool allowlocal, /**< should the separator be asked to separate local cuts */
15581  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
15582  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
15583  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
15584  );
15585 
15586 /** gets the array of cuts currently stored in the separation storage
15587  *
15588  * @return the array of cuts currently stored in the separation storage
15589  *
15590  * @pre This method can be called if @p scip is in one of the following stages:
15591  * - \ref SCIP_STAGE_PRESOLVED
15592  * - \ref SCIP_STAGE_SOLVING
15593  * - \ref SCIP_STAGE_SOLVED
15594  */
15595 extern
15597  SCIP* scip /**< SCIP data structure */
15598  );
15599 
15600 /** get current number of cuts in the separation storage
15601  *
15602  * @return the current number of cuts in the separation storage
15603  *
15604  * @pre This method can be called if @p scip is in one of the following stages:
15605  * - \ref SCIP_STAGE_PRESOLVED
15606  * - \ref SCIP_STAGE_SOLVING
15607  * - \ref SCIP_STAGE_SOLVED
15608  */
15609 extern
15610 int SCIPgetNCuts(
15611  SCIP* scip /**< SCIP data structure */
15612  );
15613 
15614 /** clears the separation storage
15615  *
15616  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15617  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15618  *
15619  * @pre This method can be called if @p scip is in one of the following stages:
15620  * - \ref SCIP_STAGE_SOLVING
15621  */
15622 extern
15624  SCIP* scip /**< SCIP data structure */
15625  );
15626 
15627 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
15628  *
15629  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15630  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15631  *
15632  * @pre This method can be called if @p scip is in one of the following stages:
15633  * - \ref SCIP_STAGE_SOLVING
15634  */
15635 extern
15637  SCIP* scip /**< SCIP data structure */
15638  );
15639 
15640 /**@} */
15641 
15642 
15643 
15644 
15645 /*
15646  * LP diving methods
15647  */
15648 
15649 /**@addtogroup PublicLPDivingMethods
15650  *
15651  * @{
15652  */
15653 
15654 /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
15655  *
15656  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15657  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15658  *
15659  * @pre This method can be called if @p scip is in one of the following stages:
15660  * - \ref SCIP_STAGE_SOLVING
15661  *
15662  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15663  *
15664  * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware
15665  * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from
15666  * numerical troubles during the last LP solve; because of this, most users will want to call this method only if
15667  * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL
15668  */
15669 extern
15671  SCIP* scip /**< SCIP data structure */
15672  );
15673 
15674 /** quits LP diving and resets bounds and objective values of columns to the current node's values
15675  *
15676  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15677  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15678  *
15679  * @pre This method can be called if @p scip is in one of the following stages:
15680  * - \ref SCIP_STAGE_SOLVING
15681  *
15682  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15683  */
15684 extern
15686  SCIP* scip /**< SCIP data structure */
15687  );
15688 
15689 /** changes cutoffbound in current dive
15690  *
15691  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15692  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15693  *
15694  * @pre This method can be called if @p scip is in one of the following stages:
15695  * - \ref SCIP_STAGE_SOLVING
15696  *
15697  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15698  */
15699 extern
15701  SCIP* scip, /**< SCIP data structure */
15702  SCIP_Real newcutoffbound /**< new cutoffbound */
15703  );
15704 
15705 /** changes variable's objective value in current dive
15706  *
15707  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15708  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15709  *
15710  * @pre This method can be called if @p scip is in one of the following stages:
15711  * - \ref SCIP_STAGE_SOLVING
15712  *
15713  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15714  */
15715 extern
15717  SCIP* scip, /**< SCIP data structure */
15718  SCIP_VAR* var, /**< variable to change the objective value for */
15719  SCIP_Real newobj /**< new objective value */
15720  );
15721 
15722 /** changes variable's lower bound in current dive
15723  *
15724  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15725  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15726  *
15727  * @pre This method can be called if @p scip is in one of the following stages:
15728  * - \ref SCIP_STAGE_SOLVING
15729  *
15730  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15731  */
15732 extern
15734  SCIP* scip, /**< SCIP data structure */
15735  SCIP_VAR* var, /**< variable to change the bound for */
15736  SCIP_Real newbound /**< new value for bound */
15737  );
15738 
15739 /** changes variable's upper bound in current dive
15740  *
15741  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15742  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15743  *
15744  * @pre This method can be called if @p scip is in one of the following stages:
15745  * - \ref SCIP_STAGE_SOLVING
15746  *
15747  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15748  */
15749 extern
15751  SCIP* scip, /**< SCIP data structure */
15752  SCIP_VAR* var, /**< variable to change the bound for */
15753  SCIP_Real newbound /**< new value for bound */
15754  );
15755 
15756 /** adds a row to the LP in current dive
15757  *
15758  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15759  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15760  *
15761  * @pre This method can be called if @p scip is in one of the following stages:
15762  * - \ref SCIP_STAGE_SOLVING
15763  *
15764  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15765  */
15766 extern
15768  SCIP* scip, /**< SCIP data structure */
15769  SCIP_ROW* row /**< row to be added */
15770  );
15771 
15772 /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
15773  *
15774  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15775  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15776  *
15777  * @pre This method can be called if @p scip is in one of the following stages:
15778  * - \ref SCIP_STAGE_SOLVING
15779  *
15780  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15781  */
15782 extern
15784  SCIP* scip, /**< SCIP data structure */
15785  SCIP_ROW* row, /**< row to change the lhs for */
15786  SCIP_Real newlhs /**< new value for lhs */
15787  );
15788 
15789 /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
15790  *
15791  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15792  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15793  *
15794  * @pre This method can be called if @p scip is in one of the following stages:
15795  * - \ref SCIP_STAGE_SOLVING
15796  *
15797  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15798  */
15799 extern
15801  SCIP* scip, /**< SCIP data structure */
15802  SCIP_ROW* row, /**< row to change the lhs for */
15803  SCIP_Real newrhs /**< new value for rhs */
15804  );
15805 
15806 /** gets variable's objective value in current dive
15807  *
15808  * @return the variable's objective value in current dive.
15809  *
15810  * @pre This method can be called if @p scip is in one of the following stages:
15811  * - \ref SCIP_STAGE_SOLVING
15812  *
15813  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15814  */
15815 extern
15817  SCIP* scip, /**< SCIP data structure */
15818  SCIP_VAR* var /**< variable to get the bound for */
15819  );
15820 
15821 /** gets variable's lower bound in current dive
15822  *
15823  * @return the variable's lower bound in current dive.
15824  *
15825  * @pre This method can be called if @p scip is in one of the following stages:
15826  * - \ref SCIP_STAGE_SOLVING
15827  *
15828  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15829  */
15830 extern
15832  SCIP* scip, /**< SCIP data structure */
15833  SCIP_VAR* var /**< variable to get the bound for */
15834  );
15835 
15836 /** gets variable's upper bound in current dive
15837  *
15838  * @return the variable's upper bound in current dive.
15839  *
15840  * @pre This method can be called if @p scip is in one of the following stages:
15841  * - \ref SCIP_STAGE_SOLVING
15842  *
15843  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15844  */
15845 extern
15847  SCIP* scip, /**< SCIP data structure */
15848  SCIP_VAR* var /**< variable to get the bound for */
15849  );
15850 /** solves the LP of the current dive; no separation or pricing is applied
15851  *
15852  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15853  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15854  *
15855  * @pre This method can be called if @p scip is in one of the following stages:
15856  * - \ref SCIP_STAGE_SOLVING
15857  *
15858  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15859  *
15860  * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL,
15861  * compare the explanation of SCIPstartDive()
15862  */
15863 extern
15865  SCIP* scip, /**< SCIP data structure */
15866  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
15867  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
15868  SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective
15869  * limit was reached (or NULL, if not needed) */
15870  );
15871 
15872 /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving
15873  * or probing mode
15874  *
15875  * @return the number of the node in the current branch and bound run, where the last LP was solved in diving
15876  * or probing mode.
15877  *
15878  * @pre This method can be called if @p scip is in one of the following stages:
15879  * - \ref SCIP_STAGE_TRANSFORMING
15880  * - \ref SCIP_STAGE_TRANSFORMED
15881  * - \ref SCIP_STAGE_INITPRESOLVE
15882  * - \ref SCIP_STAGE_PRESOLVING
15883  * - \ref SCIP_STAGE_EXITPRESOLVE
15884  * - \ref SCIP_STAGE_PRESOLVED
15885  * - \ref SCIP_STAGE_INITSOLVE
15886  * - \ref SCIP_STAGE_SOLVING
15887  * - \ref SCIP_STAGE_SOLVED
15888  * - \ref SCIP_STAGE_EXITSOLVE
15889  * - \ref SCIP_STAGE_FREETRANS
15890  *
15891  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15892  */
15893 extern
15895  SCIP* scip /**< SCIP data structure */
15896  );
15897 
15898 /** returns whether we are in diving mode
15899  *
15900  * @return whether we are in diving mode.
15901  *
15902  * @pre This method can be called if @p scip is in one of the following stages:
15903  * - \ref SCIP_STAGE_TRANSFORMING
15904  * - \ref SCIP_STAGE_TRANSFORMED
15905  * - \ref SCIP_STAGE_INITPRESOLVE
15906  * - \ref SCIP_STAGE_PRESOLVING
15907  * - \ref SCIP_STAGE_EXITPRESOLVE
15908  * - \ref SCIP_STAGE_PRESOLVED
15909  * - \ref SCIP_STAGE_INITSOLVE
15910  * - \ref SCIP_STAGE_SOLVING
15911  * - \ref SCIP_STAGE_SOLVED
15912  * - \ref SCIP_STAGE_EXITSOLVE
15913  * - \ref SCIP_STAGE_FREETRANS
15914  *
15915  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15916  */
15917 extern
15919  SCIP* scip /**< SCIP data structure */
15920  );
15921 
15922 /**@} */
15923 
15924 
15925 
15926 
15927 /*
15928  * probing methods
15929  */
15930 
15931 /**@addtogroup PublicProbingMethods
15932  *
15933  * @{
15934  */
15935 
15936 /** returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped
15937  * via SCIPendProbing()
15938  *
15939  * @return TRUE, if SCIP is currently in probing mode, otherwise FALSE
15940  *
15941  * @pre This method can be called if @p scip is in one of the following stages:
15942  * - \ref SCIP_STAGE_TRANSFORMED
15943  * - \ref SCIP_STAGE_INITPRESOLVE
15944  * - \ref SCIP_STAGE_PRESOLVING
15945  * - \ref SCIP_STAGE_EXITPRESOLVE
15946  * - \ref SCIP_STAGE_PRESOLVED
15947  * - \ref SCIP_STAGE_INITSOLVE
15948  * - \ref SCIP_STAGE_SOLVING
15949  * - \ref SCIP_STAGE_SOLVED
15950  * - \ref SCIP_STAGE_EXITSOLVE
15951  */
15952 extern
15954  SCIP* scip /**< SCIP data structure */
15955  );
15956 
15957 /** initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),
15958  * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available
15959  *
15960  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15961  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15962  *
15963  * @pre This method can be called if @p scip is in one of the following stages:
15964  * - \ref SCIP_STAGE_PRESOLVING
15965  * - \ref SCIP_STAGE_SOLVING
15966  *
15967  * @note The collection of variable statistics is turned off during probing. If these statistics should be collected
15968  * during probing use the method SCIPenableVarHistory() to turn the collection explicitly on.
15969  */
15970 extern
15972  SCIP* scip /**< SCIP data structure */
15973  );
15974 
15975 /** creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path
15976  * with a call to SCIPbacktrackProbing();
15977  * using a sub node for each set of probing bound changes can improve conflict analysis
15978  *
15979  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15980  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15981  *
15982  * @pre This method can be called if @p scip is in one of the following stages:
15983  * - \ref SCIP_STAGE_PRESOLVING
15984  * - \ref SCIP_STAGE_SOLVING
15985  */
15986 extern
15988  SCIP* scip /**< SCIP data structure */
15989  );
15990 
15991 /** returns the current probing depth
15992  *
15993  * @return the probing depth, i.e. the number of probing sub nodes existing in the probing path
15994  *
15995  * @pre This method can be called if @p scip is in one of the following stages:
15996  * - \ref SCIP_STAGE_PRESOLVING
15997  * - \ref SCIP_STAGE_SOLVING
15998  */
15999 extern
16001  SCIP* scip /**< SCIP data structure */
16002  );
16003 
16004 /** undoes all changes to the problem applied in probing up to the given probing depth;
16005  * the changes of the probing node of the given probing depth are the last ones that remain active;
16006  * changes that were applied before calling SCIPnewProbingNode() cannot be undone
16007  *
16008  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16009  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16010  *
16011  * @pre This method can be called if @p scip is in one of the following stages:
16012  * - \ref SCIP_STAGE_PRESOLVING
16013  * - \ref SCIP_STAGE_SOLVING
16014  */
16015 extern
16017  SCIP* scip, /**< SCIP data structure */
16018  int probingdepth /**< probing depth of the node in the probing path that should be reactivated */
16019  );
16020 
16021 /** quits probing and resets bounds and constraints to the focus node's environment
16022  *
16023  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16024  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16025  *
16026  * @pre This method can be called if @p scip is in one of the following stages:
16027  * - \ref SCIP_STAGE_PRESOLVING
16028  * - \ref SCIP_STAGE_SOLVING
16029  */
16030 extern
16032  SCIP* scip /**< SCIP data structure */
16033  );
16034 
16035 /** injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to
16036  * SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
16037  *
16038  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16039  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16040  *
16041  * @pre This method can be called if @p scip is in one of the following stages:
16042  * - \ref SCIP_STAGE_PRESOLVING
16043  * - \ref SCIP_STAGE_SOLVING
16044  */
16045 extern
16047  SCIP* scip, /**< SCIP data structure */
16048  SCIP_VAR* var, /**< variable to change the bound for */
16049  SCIP_Real newbound /**< new value for bound */
16050  );
16051 
16052 /** injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to
16053  * SCIPchgVarUb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
16054  *
16055  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16056  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16057  *
16058  * @pre This method can be called if @p scip is in one of the following stages:
16059  * - \ref SCIP_STAGE_PRESOLVING
16060  * - \ref SCIP_STAGE_SOLVING
16061  */
16062 extern
16064  SCIP* scip, /**< SCIP data structure */
16065  SCIP_VAR* var, /**< variable to change the bound for */
16066  SCIP_Real newbound /**< new value for bound */
16067  );
16068 
16069 /** gets variable's objective value in current probing
16070  *
16071  * @return the variable's objective value in current probing.
16072  *
16073  * @pre This method can be called if @p scip is in one of the following stages:
16074  * - \ref SCIP_STAGE_SOLVING
16075  *
16076  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16077  */
16078 extern
16080  SCIP* scip, /**< SCIP data structure */
16081  SCIP_VAR* var /**< variable to get the bound for */
16082  );
16083 
16084 /** injects a change of variable's bounds into current probing node to fix the variable to the specified value;
16085  * the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated
16086  * like deductions instead of branching decisions
16087  *
16088  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16089  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16090  *
16091  * @pre This method can be called if @p scip is in one of the following stages:
16092  * - \ref SCIP_STAGE_PRESOLVING
16093  * - \ref SCIP_STAGE_SOLVING
16094  */
16095 extern
16097  SCIP* scip, /**< SCIP data structure */
16098  SCIP_VAR* var, /**< variable to change the bound for */
16099  SCIP_Real fixedval /**< value to fix variable to */
16100  );
16101 
16102 /** changes (column) variable's objective value during probing mode
16103  *
16104  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16105  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16106  *
16107  * @pre This method can be called if @p scip is in one of the following stages:
16108  * - \ref SCIP_STAGE_PRESOLVING
16109  * - \ref SCIP_STAGE_SOLVING
16110  *
16111  * @pre The variable needs to be a column variable.
16112  */
16113 extern
16115  SCIP* scip, /**< SCIP data structure */
16116  SCIP_VAR* var, /**< variable to change the objective for */
16117  SCIP_Real newobj /**< new objective function value */
16118  );
16119 
16120 /** returns whether the objective function has changed during probing mode
16121  *
16122  * @return \ref TRUE if objective has changed, \ref FALSE otherwise
16123  *
16124  * @pre This method can be called if @p scip is in one of the following stages:
16125  * - \ref SCIP_STAGE_TRANSFORMED
16126  * - \ref SCIP_STAGE_INITPRESOLVE
16127  * - \ref SCIP_STAGE_PRESOLVING
16128  * - \ref SCIP_STAGE_EXITPRESOLVE
16129  * - \ref SCIP_STAGE_PRESOLVED
16130  * - \ref SCIP_STAGE_INITSOLVE
16131  * - \ref SCIP_STAGE_SOLVING
16132  * - \ref SCIP_STAGE_SOLVED
16133  * - \ref SCIP_STAGE_EXITSOLVE
16134  */
16135 extern
16137  SCIP* scip /**< SCIP data structure */
16138  );
16139 
16140 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
16141  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
16142  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
16143  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
16144  *
16145  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16146  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16147  *
16148  * @pre This method can be called if @p scip is in one of the following stages:
16149  * - \ref SCIP_STAGE_PRESOLVING
16150  * - \ref SCIP_STAGE_SOLVING
16151  */
16152 extern
16154  SCIP* scip, /**< SCIP data structure */
16155  int maxproprounds, /**< maximal number of propagation rounds (-1: no limit, 0: parameter settings) */
16156  SCIP_Bool* cutoff, /**< pointer to store whether the probing node can be cut off */
16157  SCIP_Longint* ndomredsfound /**< pointer to store the number of domain reductions found, or NULL */
16158  );
16159 
16160 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
16161  * only propagations of the binary variables fixed at the current probing node that are triggered by the implication
16162  * graph and the clique table are applied;
16163  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
16164  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
16165  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
16166  *
16167  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16168  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16169  *
16170  * @pre This method can be called if @p scip is in one of the following stages:
16171  * - \ref SCIP_STAGE_PRESOLVING
16172  * - \ref SCIP_STAGE_SOLVING
16173  */
16174 extern
16176  SCIP* scip, /**< SCIP data structure */
16177  SCIP_Bool* cutoff /**< pointer to store whether the probing node can be cut off */
16178  );
16179 
16180 /** solves the LP at the current probing node (cannot be applied at preprocessing stage);
16181  * no separation or pricing is applied
16182  *
16183  * The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()).
16184  *
16185  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16186  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16187  *
16188  * @pre This method can be called if @p scip is in one of the following stages:
16189  * - \ref SCIP_STAGE_SOLVING
16190  */
16191 extern
16193  SCIP* scip, /**< SCIP data structure */
16194  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
16195  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
16196  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
16197  * limit was reached (or NULL, if not needed) */
16198  );
16199 
16200 /** solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing
16201  * until the LP is solved to optimality; no separation is applied
16202  *
16203  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See \ref
16204  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16205  *
16206  * @pre This method can be called if @p scip is in one of the following stages:
16207  * - \ref SCIP_STAGE_SOLVING
16208  */
16209 extern
16211  SCIP* scip, /**< SCIP data structure */
16212  SCIP_Bool pretendroot, /**< should the pricers be called as if we are at the root node? */
16213  SCIP_Bool displayinfo, /**< should info lines be displayed after each pricing round? */
16214  int maxpricerounds, /**< maximal number of pricing rounds (-1: no limit);
16215  * a finite limit means that the LP might not be solved to optimality! */
16216  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
16217  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
16218  * limit was reached (or NULL, if not needed) */
16219  );
16220 
16221 /** sets the LP state for the current probing node
16222  *
16223  * @note state and norms are stored at the node and later released by SCIP; therefore, the pointers are set
16224  * to NULL by the method
16225  *
16226  * @note the pointers to state and norms must not be NULL; however, they may point to a NULL pointer if the
16227  * respective information should not be set
16228  *
16229  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16230  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16231  *
16232  * @pre This method can be called if @p scip is in one of the following stages:
16233  * - \ref SCIP_STAGE_PRESOLVING
16234  * - \ref SCIP_STAGE_SOLVING
16235  */
16236 extern
16238  SCIP* scip, /**< SCIP data structure */
16239  SCIP_LPISTATE** lpistate, /**< pointer to LP state information (like basis information) */
16240  SCIP_LPINORMS** lpinorms, /**< pointer to LP pricing norms information */
16241  SCIP_Bool primalfeas, /**< primal feasibility when LP state information was stored */
16242  SCIP_Bool dualfeas /**< dual feasibility when LP state information was stored */
16243  );
16244 
16245 /** adds a row to the LP in the current probing node
16246  *
16247  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16248  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16249  *
16250  * @pre This method can be called if @p scip is in one of the following stages:
16251  * - \ref SCIP_STAGE_SOLVING
16252  *
16253  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16254  */
16255 extern
16257  SCIP* scip, /**< SCIP data structure */
16258  SCIP_ROW* row /**< row to be added */
16259  );
16260 
16261 /** applies the cuts in the separation storage to the LP and clears the storage afterwards;
16262  * this method can only be applied during probing; the user should resolve the probing LP afterwards
16263  * in order to get a new solution
16264  *
16265  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16266  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16267  *
16268  * @pre This method can be called if @p scip is in one of the following stages:
16269  * - \ref SCIP_STAGE_SOLVING
16270  */
16271 extern
16273  SCIP* scip, /**< SCIP data structure */
16274  SCIP_Bool* cutoff /**< pointer to store whether an empty domain was created */
16275  );
16276 
16277 /** solves relaxation(s) at the current probing node (cannot be applied at preprocessing stage);
16278  * no separation or pricing is applied
16279  *
16280  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16281  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16282  *
16283  * @pre This method can be called if @p scip is in one of the following stages:
16284  * - \ref SCIP_STAGE_SOLVING
16285  */
16286 extern
16288  SCIP* scip, /**< SCIP data structure */
16289  SCIP_Bool* cutoff /**< pointer to store whether a relaxation was infeasible or the objective
16290  * limit was reached (or NULL, if not needed) */
16291  );
16292 
16293 /** stores the candidate score and preferred rounding direction for a candidate variable */
16294 extern
16296  SCIP* scip, /**< SCIP data structure */
16297  SCIP_DIVESET* diveset, /**< general diving settings */
16298  SCIP_DIVETYPE divetype, /**< represents different methods for a dive set to explore the next children */
16299  SCIP_VAR* divecand, /**< the candidate for which the branching direction is requested */
16300  SCIP_Real divecandsol, /**< LP solution value of the candidate */
16301  SCIP_Real divecandfrac, /**< fractionality of the candidate */
16302  SCIP_Real* candscore, /**< pointer to store the candidate score */
16303  SCIP_Bool* roundup /**< pointer to store whether preferred direction for diving is upwards */
16304  );
16305 
16306 /** update diveset LP statistics, should be called after every LP solved by this diving heuristic */
16307 extern
16309  SCIP* scip, /**< SCIP data structure */
16310  SCIP_DIVESET* diveset, /**< diving settings */
16311  SCIP_Longint niterstoadd /**< additional number of LP iterations to be added */
16312  );
16313 
16314 /** update diveset statistics and global diveset statistics */
16315 extern
16317  SCIP* scip, /**< SCIP data structure */
16318  SCIP_DIVESET* diveset, /**< diveset to be reset */
16319  int nprobingnodes, /**< the number of probing nodes explored this time */
16320  int nbacktracks, /**< the number of backtracks during probing this time */
16321  SCIP_Longint nsolsfound, /**< the number of solutions found */
16322  SCIP_Longint nbestsolsfound, /**< the number of best solutions found */
16323  SCIP_Bool leavewassol /**< was a solution found at the leaf? */
16324  );
16325 
16326 /** enforces a probing/diving solution by suggesting bound changes that maximize the score w.r.t. the current diving settings
16327  *
16328  * the process is guided by the enforcement priorities of the constraint handlers and the scoring mechanism provided by
16329  * the dive set.
16330  * Constraint handlers may suggest diving bound changes in decreasing order of their enforcement priority, based on the
16331  * solution values in the solution @p sol and the current local bounds of the variables. A diving bound change
16332  * is a triple (variable,branching direction,value) and is used inside SCIPperformGenericDivingAlgorithm().
16333  *
16334  * After a successful call, SCIP holds two arrays of suggested dive bound changes, one for the preferred child
16335  * and one for the alternative.
16336  *
16337  * @see SCIPgetDiveBoundChangeData() for retrieving the dive bound change suggestions.
16338  *
16339  * The method stops after the first constraint handler was successful
16340  *
16341  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16342  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16343  *
16344  * @pre This method can be called if @p scip is in one of the following stages:
16345  * - \ref SCIP_STAGE_SOLVING
16346  *
16347  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16348  */
16349 extern
16351  SCIP* scip, /**< SCIP data structure */
16352  SCIP_DIVESET* diveset, /**< diving settings to control scoring */
16353  SCIP_SOL* sol, /**< current solution of diving mode */
16354  SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */
16355  SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */
16356  );
16357 
16358 /** adds a diving bound change to the diving bound change storage of SCIP together with the information if this is a
16359  * bound change for the preferred direction or not
16360  *
16361  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16362  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16363  *
16364  * @pre This method can be called if @p scip is in one of the following stages:
16365  * - \ref SCIP_STAGE_SOLVING
16366  *
16367  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16368  */
16369 extern
16371  SCIP* scip, /**< SCIP data structure */
16372  SCIP_VAR* var, /**< variable to apply the bound change to */
16373  SCIP_BRANCHDIR dir, /**< direction of the bound change */
16374  SCIP_Real value, /**< value to adjust this variable bound to */
16375  SCIP_Bool preferred /**< is this a bound change for the preferred child? */
16376  );
16377 
16378 /** get the dive bound change data for the preferred or the alternative direction
16379  *
16380  * @pre This method can be called if @p scip is in one of the following stages:
16381  * - \ref SCIP_STAGE_SOLVING
16382  *
16383  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16384  */
16385 extern
16387  SCIP* scip, /**< SCIP data structure */
16388  SCIP_VAR*** variables, /**< pointer to store variables for the specified direction */
16389  SCIP_BRANCHDIR** directions, /**< pointer to store the branching directions */
16390  SCIP_Real** values, /**< pointer to store bound change values */
16391  int* ndivebdchgs, /**< pointer to store the number of dive bound changes */
16392  SCIP_Bool preferred /**< should the dive bound changes for the preferred child be output? */
16393  );
16394 
16395 /** clear the dive bound change data structures
16396  *
16397  * @pre This method can be called if @p scip is in one of the following stages:
16398  * - \ref SCIP_STAGE_SOLVING
16399  *
16400  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16401  */
16402 extern
16404  SCIP* scip /**< SCIP data structure */
16405  );
16406 
16407 /**@} */
16408 
16409 /*
16410  * branching methods
16411  */
16412 
16413 /**@addtogroup PublicBranchingMethods
16414  *
16415  * @{
16416  */
16417 
16418 /** gets branching candidates for LP solution branching (fractional variables) along with solution values,
16419  * fractionalities, and number of branching candidates; The number of branching candidates does NOT
16420  * account for fractional implicit integer variables which should not be used for branching decisions.
16421  *
16422  * Fractional implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1
16423  *
16424  * branching rules should always select the branching candidate among the first npriolpcands of the candidate
16425  * list
16426  *
16427  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16428  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16429  *
16430  * @pre This method can be called if @p scip is in one of the following stages:
16431  * - \ref SCIP_STAGE_SOLVING
16432  *
16433  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16434  */
16435 extern
16437  SCIP* scip, /**< SCIP data structure */
16438  SCIP_VAR*** lpcands, /**< pointer to store the array of LP branching candidates, or NULL */
16439  SCIP_Real** lpcandssol, /**< pointer to store the array of LP candidate solution values, or NULL */
16440  SCIP_Real** lpcandsfrac, /**< pointer to store the array of LP candidate fractionalities, or NULL */
16441  int* nlpcands, /**< pointer to store the number of LP branching candidates, or NULL */
16442  int* npriolpcands, /**< pointer to store the number of candidates with maximal priority, or NULL */
16443  int* nfracimplvars /**< pointer to store the number of fractional implicit integer variables, or NULL */
16444  );
16445 
16446 /** gets number of branching candidates for LP solution branching (number of fractional variables)
16447  *
16448  * @return the number of branching candidates for LP solution branching (number of fractional variables).
16449  *
16450  * @pre This method can be called if @p scip is in one of the following stages:
16451  * - \ref SCIP_STAGE_SOLVING
16452  *
16453  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16454  */
16455 extern
16457  SCIP* scip /**< SCIP data structure */
16458  );
16459 
16460 /** gets number of branching candidates with maximal priority for LP solution branching
16461  *
16462  * @return the number of branching candidates with maximal priority for LP solution branching.
16463  *
16464  * @pre This method can be called if @p scip is in one of the following stages:
16465  * - \ref SCIP_STAGE_SOLVING
16466  *
16467  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16468  */
16469 extern
16471  SCIP* scip /**< SCIP data structure */
16472  );
16473 
16474 /** gets external branching candidates along with solution values, scores, and number of branching candidates;
16475  * these branching candidates can be used by relaxations or nonlinear constraint handlers;
16476  * branching rules should always select the branching candidate among the first nprioexterncands of the candidate
16477  * list
16478  *
16479  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16480  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16481  *
16482  * @pre This method can be called if @p scip is in one of the following stages:
16483  * - \ref SCIP_STAGE_SOLVING
16484  *
16485  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16486  *
16487  * @note Candidate variables with maximal priority are ordered: binaries first, then integers, implicit integers and
16488  * continuous last.
16489  */
16490 extern
16492  SCIP* scip, /**< SCIP data structure */
16493  SCIP_VAR*** externcands, /**< pointer to store the array of extern branching candidates, or NULL */
16494  SCIP_Real** externcandssol, /**< pointer to store the array of extern candidate solution values, or NULL */
16495  SCIP_Real** externcandsscore, /**< pointer to store the array of extern candidate scores, or NULL */
16496  int* nexterncands, /**< pointer to store the number of extern branching candidates, or NULL */
16497  int* nprioexterncands, /**< pointer to store the number of candidates with maximal priority, or NULL */
16498  int* nprioexternbins, /**< pointer to store the number of binary candidates with maximal priority, or NULL */
16499  int* nprioexternints, /**< pointer to store the number of integer candidates with maximal priority, or NULL */
16500  int* nprioexternimpls /**< pointer to store the number of implicit integer candidates with maximal priority,
16501  * or NULL */
16502  );
16503 
16504 /** gets number of external branching candidates
16505  *
16506  * @return the number of external branching candidates.
16507  *
16508  * @pre This method can be called if @p scip is in one of the following stages:
16509  * - \ref SCIP_STAGE_SOLVING
16510  *
16511  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16512  */
16513 extern
16515  SCIP* scip /**< SCIP data structure */
16516  );
16517 
16518 /** gets number of external branching candidates with maximal branch priority
16519  *
16520  * @return the number of external branching candidates with maximal branch priority.
16521  *
16522  * @pre This method can be called if @p scip is in one of the following stages:
16523  * - \ref SCIP_STAGE_SOLVING
16524  *
16525  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16526  */
16527 extern
16529  SCIP* scip /**< SCIP data structure */
16530  );
16531 
16532 /** gets number of binary external branching candidates with maximal branch priority
16533  *
16534  * @return the number of binary external branching candidates with maximal branch priority.
16535  *
16536  * @pre This method can be called if @p scip is in one of the following stages:
16537  * - \ref SCIP_STAGE_SOLVING
16538  *
16539  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16540  */
16541 extern
16543  SCIP* scip /**< SCIP data structure */
16544  );
16545 
16546 /** gets number of integer external branching candidates with maximal branch priority
16547  *
16548  * @return the number of integer external branching candidates with maximal branch priority.
16549  *
16550  * @pre This method can be called if @p scip is in one of the following stages:
16551  * - \ref SCIP_STAGE_SOLVING
16552  *
16553  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16554  */
16555 extern
16557  SCIP* scip /**< SCIP data structure */
16558  );
16559 
16560 /** gets number of implicit integer external branching candidates with maximal branch priority
16561  *
16562  * @return the number of implicit integer external branching candidates with maximal branch priority.
16563  *
16564  * @pre This method can be called if @p scip is in one of the following stages:
16565  * - \ref SCIP_STAGE_SOLVING
16566  *
16567  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16568  */
16569 extern
16571  SCIP* scip /**< SCIP data structure */
16572  );
16573 
16574 /** gets number of continuous external branching candidates with maximal branch priority
16575  *
16576  * @return the number of continuous external branching candidates with maximal branch priority.
16577  *
16578  * @pre This method can be called if @p scip is in one of the following stages:
16579  * - \ref SCIP_STAGE_SOLVING
16580  *
16581  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16582  */
16583 extern
16585  SCIP* scip /**< SCIP data structure */
16586  );
16587 
16588 /** insert variable, its score and its solution value into the external branching candidate storage
16589  * the relative difference of the current lower and upper bounds of a continuous variable must be at least epsilon
16590  *
16591  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16592  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16593  *
16594  * @pre This method can be called if @p scip is in one of the following stages:
16595  * - \ref SCIP_STAGE_SOLVING
16596  *
16597  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16598  */
16599 extern
16601  SCIP* scip, /**< SCIP data structure */
16602  SCIP_VAR* var, /**< variable to insert */
16603  SCIP_Real score, /**< score of external candidate, e.g. infeasibility */
16604  SCIP_Real solval /**< value of the variable in the current solution */
16605  );
16606 
16607 /** removes all external candidates from the storage for external branching
16608  *
16609  * @pre This method can be called if @p scip is in one of the following stages:
16610  * - \ref SCIP_STAGE_SOLVING
16611  *
16612  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16613  */
16614 extern
16616  SCIP* scip /**< SCIP data structure */
16617  );
16618 
16619 /** checks whether the given variable is contained in the candidate storage for external branching
16620  *
16621  * @return whether the given variable is contained in the candidate storage for external branching.
16622  *
16623  * @pre This method can be called if @p scip is in one of the following stages:
16624  * - \ref SCIP_STAGE_SOLVING
16625  *
16626  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16627  */
16628 extern
16630  SCIP* scip, /**< SCIP data structure */
16631  SCIP_VAR* var /**< variable to look for */
16632  );
16633 
16634 /** gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates
16635  *
16636  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16637  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16638  *
16639  * @pre This method can be called if @p scip is in one of the following stages:
16640  * - \ref SCIP_STAGE_PRESOLVING
16641  * - \ref SCIP_STAGE_SOLVING
16642  *
16643  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16644  */
16645 extern
16647  SCIP* scip, /**< SCIP data structure */
16648  SCIP_VAR*** pseudocands, /**< pointer to store the array of pseudo branching candidates, or NULL */
16649  int* npseudocands, /**< pointer to store the number of pseudo branching candidates, or NULL */
16650  int* npriopseudocands /**< pointer to store the number of candidates with maximal priority, or NULL */
16651  );
16652 
16653 /** gets number of branching candidates for pseudo solution branching (non-fixed variables)
16654  *
16655  * @return the number branching candidates for pseudo solution branching (non-fixed variables).
16656  *
16657  * @pre This method can be called if @p scip is in one of the following stages:
16658  * - \ref SCIP_STAGE_PRESOLVING
16659  * - \ref SCIP_STAGE_SOLVING
16660  *
16661  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16662  */
16663 extern
16665  SCIP* scip /**< SCIP data structure */
16666  );
16667 
16668 /** gets number of branching candidates with maximal branch priority for pseudo solution branching
16669  *
16670  * @return the number of branching candidates with maximal branch priority for pseudo solution branching.
16671  *
16672  * @pre This method can be called if @p scip is in one of the following stages:
16673  * - \ref SCIP_STAGE_PRESOLVING
16674  * - \ref SCIP_STAGE_SOLVING
16675  *
16676  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16677  */
16678 extern
16680  SCIP* scip /**< SCIP data structure */
16681  );
16682 
16683 /** gets number of binary branching candidates with maximal branch priority for pseudo solution branching
16684  *
16685  * @return the number of binary branching candidates with maximal branch priority for pseudo solution branching.
16686  *
16687  * @pre This method can be called if @p scip is in one of the following stages:
16688  * - \ref SCIP_STAGE_SOLVING
16689  *
16690  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16691  */
16692 extern
16694  SCIP* scip /**< SCIP data structure */
16695  );
16696 
16697 /** gets number of integer branching candidates with maximal branch priority for pseudo solution branching
16698  *
16699  * @return the number of integer branching candidates with maximal branch priority for pseudo solution branching.
16700  *
16701  * @pre This method can be called if @p scip is in one of the following stages:
16702  * - \ref SCIP_STAGE_SOLVING
16703  *
16704  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16705  */
16706 extern
16708  SCIP* scip /**< SCIP data structure */
16709  );
16710 
16711 /** gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching
16712  *
16713  * @return the number of implicit integer branching candidates with maximal branch priority for pseudo solution branching.
16714  *
16715  * @pre This method can be called if @p scip is in one of the following stages:
16716  * - \ref SCIP_STAGE_SOLVING
16717  *
16718  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16719  */
16720 extern
16722  SCIP* scip /**< SCIP data structure */
16723  );
16724 
16725 /** calculates the branching score out of the gain predictions for a binary branching
16726  *
16727  * @return the branching score out of the gain predictions for a binary branching.
16728  *
16729  * @pre This method can be called if @p scip is in one of the following stages:
16730  * - \ref SCIP_STAGE_SOLVING
16731  *
16732  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16733  */
16734 extern
16736  SCIP* scip, /**< SCIP data structure */
16737  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
16738  SCIP_Real downgain, /**< prediction of objective gain for rounding downwards */
16739  SCIP_Real upgain /**< prediction of objective gain for rounding upwards */
16740  );
16741 
16742 /** calculates the branching score out of the gain predictions for a branching with arbitrary many children
16743  *
16744  * @return the branching score out of the gain predictions for a branching with arbitrary many children.
16745  *
16746  * @pre This method can be called if @p scip is in one of the following stages:
16747  * - \ref SCIP_STAGE_SOLVING
16748  *
16749  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16750  */
16751 extern
16753  SCIP* scip, /**< SCIP data structure */
16754  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
16755  int nchildren, /**< number of children that the branching will create */
16756  SCIP_Real* gains /**< prediction of objective gain for each child */
16757  );
16758 
16759 /** computes a branching point for a continuous or discrete variable
16760  *
16761  * @see SCIPbranchGetBranchingPoint
16762  *
16763  * @return the branching point for a continuous or discrete variable.
16764  *
16765  * @pre This method can be called if @p scip is in one of the following stages:
16766  * - \ref SCIP_STAGE_SOLVING
16767  *
16768  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16769  */
16770 extern
16772  SCIP* scip, /**< SCIP data structure */
16773  SCIP_VAR* var, /**< variable, of which the branching point should be computed */
16774  SCIP_Real suggestion /**< suggestion for branching point, or SCIP_INVALID if no suggestion */
16775  );
16776 
16777 /** calculates the node selection priority for moving the given variable's LP value to the given target value;
16778  * this node selection priority can be given to the SCIPcreateChild() call
16779  *
16780  * @return the node selection priority for moving the given variable's LP value to the given target value.
16781  *
16782  * @pre This method can be called if @p scip is in one of the following stages:
16783  * - \ref SCIP_STAGE_SOLVING
16784  *
16785  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16786  */
16787 extern
16789  SCIP* scip, /**< SCIP data structure */
16790  SCIP_VAR* var, /**< variable on which the branching is applied */
16791  SCIP_BRANCHDIR branchdir, /**< type of branching that was performed: upwards, downwards, or fixed;
16792  * fixed should only be used, when both bounds changed
16793  */
16794  SCIP_Real targetvalue /**< new value of the variable in the child node */
16795  );
16796 
16797 /** calculates an estimate for the objective of the best feasible solution contained in the subtree after applying the given
16798  * branching; this estimate can be given to the SCIPcreateChild() call
16799  *
16800  * @return the estimate for the objective of the best feasible solution contained in the subtree after applying the given
16801  * branching.
16802  *
16803  * @pre This method can be called if @p scip is in one of the following stages:
16804  * - \ref SCIP_STAGE_SOLVING
16805  *
16806  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16807  */
16808 extern
16810  SCIP* scip, /**< SCIP data structure */
16811  SCIP_VAR* var, /**< variable on which the branching is applied */
16812  SCIP_Real targetvalue /**< new value of the variable in the child node */
16813  );
16814 
16815 /** creates a child node of the focus node
16816  *
16817  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16818  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16819  *
16820  * @pre This method can be called if @p scip is in one of the following stages:
16821  * - \ref SCIP_STAGE_SOLVING
16822  *
16823  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16824  */
16825 extern
16827  SCIP* scip, /**< SCIP data structure */
16828  SCIP_NODE** node, /**< pointer to node data structure */
16829  SCIP_Real nodeselprio, /**< node selection priority of new node */
16830  SCIP_Real estimate /**< estimate for (transformed) objective value of best feasible solution in subtree */
16831  );
16832 
16833 /** branches on a non-continuous variable v using the current LP or pseudo solution;
16834  * if solution value x' is fractional, two child nodes will be created
16835  * (x <= floor(x'), x >= ceil(x')),
16836  * if solution value is integral, the x' is equal to lower or upper bound of the branching
16837  * variable and the bounds of v are finite, then two child nodes will be created
16838  * (x <= x'', x >= x''+1 with x'' = floor((lb + ub)/2)),
16839  * otherwise (up to) three child nodes will be created
16840  * (x <= x'-1, x == x', x >= x'+1)
16841  *
16842  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16843  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16844  *
16845  * @pre This method can be called if @p scip is in one of the following stages:
16846  * - \ref SCIP_STAGE_SOLVING
16847  *
16848  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16849  */
16850 extern
16852  SCIP* scip, /**< SCIP data structure */
16853  SCIP_VAR* var, /**< variable to branch on */
16854  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
16855  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
16856  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
16857  );
16858 
16859 /** branches a variable x using a given domain hole; two child nodes (x <= left, x >= right) are created
16860  *
16861  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16862  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16863  *
16864  * @pre This method can be called if @p scip is in one of the following stages:
16865  * - \ref SCIP_STAGE_SOLVING
16866  *
16867  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16868  */
16869 extern
16871  SCIP* scip, /**< SCIP data structure */
16872  SCIP_VAR* var, /**< variable to branch on */
16873  SCIP_Real left, /**< left side of the domain hole */
16874  SCIP_Real right, /**< right side of the domain hole */
16875  SCIP_NODE** downchild, /**< pointer to return the left child (x <= left), or NULL */
16876  SCIP_NODE** upchild /**< pointer to return the right child (x >= right), or NULL */
16877  );
16878 
16879 /** branches on a variable x using a given value x';
16880  * for continuous variables with relative domain width larger epsilon, x' must not be one of the bounds;
16881  * two child nodes (x <= x', x >= x') are created;
16882  * for integer variables, if solution value x' is fractional, two child nodes are created
16883  * (x <= floor(x'), x >= ceil(x')),
16884  * if x' is integral, three child nodes are created
16885  * (x <= x'-1, x == x', x >= x'+1)
16886  *
16887  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16888  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16889  *
16890  * @pre This method can be called if @p scip is in one of the following stages:
16891  * - \ref SCIP_STAGE_SOLVING
16892  *
16893  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16894  */
16895 extern
16897  SCIP* scip, /**< SCIP data structure */
16898  SCIP_VAR* var, /**< variable to branch on */
16899  SCIP_Real val, /**< value to branch on */
16900  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
16901  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
16902  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
16903  );
16904 
16905 /** n-ary branching on a variable x using a given value
16906  *
16907  * Branches on variable x such that up to n/2 children are created on each side of the usual branching value.
16908  * The branching value is selected as in SCIPbranchVarVal().
16909  * The parameters minwidth and widthfactor determine the domain width of the branching variable in the child nodes.
16910  * If n is odd, one child with domain width 'width' and having the branching value in the middle is created.
16911  * Otherwise, two children with domain width 'width' and being left and right of the branching value are created.
16912  * Next further nodes to the left and right are created, where width is multiplied by widthfactor with increasing distance
16913  * from the first nodes.
16914  * The initial width is calculated such that n/2 nodes are created to the left and to the right of the branching value.
16915  * If this value is below minwidth, the initial width is set to minwidth, which may result in creating less than n nodes.
16916  *
16917  * Giving a large value for widthfactor results in creating children with small domain when close to the branching value
16918  * and large domain when closer to the current variable bounds. That is, setting widthfactor to a very large value and n to 3
16919  * results in a ternary branching where the branching variable is mostly fixed in the middle child.
16920  * Setting widthfactor to 1.0 results in children where the branching variable always has the same domain width
16921  * (except for one child if the branching value is not in the middle).
16922  *
16923  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16924  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16925  *
16926  * @pre This method can be called if @p scip is in one of the following stages:
16927  * - \ref SCIP_STAGE_SOLVING
16928  *
16929  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16930  */
16931 extern
16933  SCIP* scip, /**< SCIP data structure */
16934  SCIP_VAR* var, /**< variable to branch on */
16935  SCIP_Real val, /**< value to branch on */
16936  int n, /**< attempted number of children to be created, must be >= 2 */
16937  SCIP_Real minwidth, /**< minimal domain width in children */
16938  SCIP_Real widthfactor, /**< multiplier for children domain width with increasing distance from val, must be >= 1.0 */
16939  int* nchildren /**< pointer to store number of created children, or NULL */
16940  );
16941 
16942 /** calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN;
16943  * if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional
16944  * variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority
16945  *
16946  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16947  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16948  *
16949  * @pre This method can be called if @p scip is in one of the following stages:
16950  * - \ref SCIP_STAGE_SOLVING
16951  *
16952  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16953  */
16954 extern
16956  SCIP* scip, /**< SCIP data structure */
16957  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16958  );
16959 
16960 /** calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN
16961  *
16962  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16963  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16964  *
16965  * @pre This method can be called if @p scip is in one of the following stages:
16966  * - \ref SCIP_STAGE_SOLVING
16967  *
16968  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16969  */
16970 extern
16972  SCIP* scip, /**< SCIP data structure */
16973  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16974  );
16975 
16976 /** calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN
16977  *
16978  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16979  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16980  *
16981  * @pre This method can be called if @p scip is in one of the following stages:
16982  * - \ref SCIP_STAGE_SOLVING
16983  *
16984  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16985  */
16986 extern
16988  SCIP* scip, /**< SCIP data structure */
16989  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16990  );
16991 
16992 /**@} */
16993 
16994 
16995 
16996 
16997 /*
16998  * primal solutions
16999  */
17000 
17001 /**@addtogroup PublicSolutionMethods
17002  *
17003  * @{
17004  */
17005 
17006 /** creates a primal solution, initialized to zero
17007  *
17008  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17009  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17010  *
17011  * @pre This method can be called if SCIP is in one of the following stages:
17012  * - \ref SCIP_STAGE_PROBLEM
17013  * - \ref SCIP_STAGE_TRANSFORMING
17014  * - \ref SCIP_STAGE_TRANSFORMED
17015  * - \ref SCIP_STAGE_INITPRESOLVE
17016  * - \ref SCIP_STAGE_PRESOLVING
17017  * - \ref SCIP_STAGE_EXITPRESOLVE
17018  * - \ref SCIP_STAGE_PRESOLVED
17019  * - \ref SCIP_STAGE_INITSOLVE
17020  * - \ref SCIP_STAGE_SOLVING
17021  */
17022 extern
17024  SCIP* scip, /**< SCIP data structure */
17025  SCIP_SOL** sol, /**< pointer to store the solution */
17026  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17027  );
17028 
17029 /** creates a primal solution, initialized to the current LP solution
17030  *
17031  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17032  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17033  *
17034  * @pre This method can be called if SCIP is in one of the following stages:
17035  * - \ref SCIP_STAGE_SOLVING
17036  */
17037 extern
17039  SCIP* scip, /**< SCIP data structure */
17040  SCIP_SOL** sol, /**< pointer to store the solution */
17041  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17042  );
17043 
17044 /** creates a primal solution, initialized to the current NLP solution
17045  *
17046  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17047  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17048  *
17049  * @pre This method can be called if SCIP is in one of the following stages:
17050  * - \ref SCIP_STAGE_SOLVING
17051  */
17052 extern
17054  SCIP* scip, /**< SCIP data structure */
17055  SCIP_SOL** sol, /**< pointer to store the solution */
17056  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17057  );
17058 
17059 /** creates a primal solution, initialized to the current relaxation solution
17060  *
17061  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17062  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17063  *
17064  * @pre This method can be called if SCIP is in one of the following stages:
17065  * - \ref SCIP_STAGE_SOLVING
17066  */
17067 extern
17069  SCIP* scip, /**< SCIP data structure */
17070  SCIP_SOL** sol, /**< pointer to store the solution */
17071  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17072  );
17073 
17074 /** creates a primal solution, initialized to the current pseudo solution
17075  *
17076  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17077  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17078  *
17079  * @pre This method can be called if SCIP is in one of the following stages:
17080  * - \ref SCIP_STAGE_SOLVING
17081  */
17082 extern
17084  SCIP* scip, /**< SCIP data structure */
17085  SCIP_SOL** sol, /**< pointer to store the solution */
17086  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17087  );
17088 
17089 /** creates a primal solution, initialized to the current LP or pseudo solution, depending on whether the LP was solved
17090  * at the current node
17091  *
17092  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17093  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17094  *
17095  * @pre This method can be called if SCIP is in one of the following stages:
17096  * - \ref SCIP_STAGE_SOLVING
17097  */
17098 extern
17100  SCIP* scip, /**< SCIP data structure */
17101  SCIP_SOL** sol, /**< pointer to store the solution */
17102  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17103  );
17104 
17105 /** creates a partial primal solution, initialized to unknown values
17106  *
17107  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17108  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17109  *
17110  * @pre This method can be called if SCIP is in one of the following stages:
17111  * - \ref SCIP_STAGE_PROBLEM
17112  */
17113 extern
17115  SCIP* scip, /**< SCIP data structure */
17116  SCIP_SOL** sol, /**< pointer to store the solution */
17117  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17118  );
17119 
17120 /** creates a primal solution, initialized to unknown values
17121  *
17122  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17123  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17124  *
17125  * @pre This method can be called if SCIP is in one of the following stages:
17126  * - \ref SCIP_STAGE_TRANSFORMING
17127  * - \ref SCIP_STAGE_TRANSFORMED
17128  * - \ref SCIP_STAGE_INITPRESOLVE
17129  * - \ref SCIP_STAGE_PRESOLVING
17130  * - \ref SCIP_STAGE_EXITPRESOLVE
17131  * - \ref SCIP_STAGE_PRESOLVED
17132  * - \ref SCIP_STAGE_INITSOLVE
17133  * - \ref SCIP_STAGE_SOLVING
17134  */
17135 extern
17137  SCIP* scip, /**< SCIP data structure */
17138  SCIP_SOL** sol, /**< pointer to store the solution */
17139  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17140  );
17141 
17142 /** creates a primal solution living in the original problem space, initialized to zero;
17143  * a solution in original space allows to set original variables to values that would be invalid in the
17144  * transformed problem due to preprocessing fixings or aggregations
17145  *
17146  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17147  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17148  *
17149  * @pre This method can be called if SCIP is in one of the following stages:
17150  * - \ref SCIP_STAGE_PROBLEM
17151  * - \ref SCIP_STAGE_TRANSFORMING
17152  * - \ref SCIP_STAGE_TRANSFORMED
17153  * - \ref SCIP_STAGE_INITPRESOLVE
17154  * - \ref SCIP_STAGE_PRESOLVING
17155  * - \ref SCIP_STAGE_EXITPRESOLVE
17156  * - \ref SCIP_STAGE_PRESOLVED
17157  * - \ref SCIP_STAGE_INITSOLVE
17158  * - \ref SCIP_STAGE_SOLVING
17159  */
17160 extern
17162  SCIP* scip, /**< SCIP data structure */
17163  SCIP_SOL** sol, /**< pointer to store the solution */
17164  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
17165  );
17166 
17167 /** creates a copy of a primal solution; note that a copy of a linked solution is also linked and needs to be unlinked
17168  * if it should stay unaffected from changes in the LP or pseudo solution
17169  *
17170  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17171  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17172  *
17173  * @pre This method can be called if SCIP is in one of the following stages:
17174  * - \ref SCIP_STAGE_PROBLEM
17175  * - \ref SCIP_STAGE_TRANSFORMING
17176  * - \ref SCIP_STAGE_TRANSFORMED
17177  * - \ref SCIP_STAGE_INITPRESOLVE
17178  * - \ref SCIP_STAGE_PRESOLVING
17179  * - \ref SCIP_STAGE_EXITPRESOLVE
17180  * - \ref SCIP_STAGE_PRESOLVED
17181  * - \ref SCIP_STAGE_INITSOLVE
17182  * - \ref SCIP_STAGE_SOLVING
17183  */
17184 extern
17186  SCIP* scip, /**< SCIP data structure */
17187  SCIP_SOL** sol, /**< pointer to store the solution */
17188  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
17189  );
17190 
17191 /** creates a copy of a solution in the original primal solution space
17192  *
17193  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17194  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17195  *
17196  * @pre This method can be called if SCIP is in one of the following stages:
17197  * - \ref SCIP_STAGE_PROBLEM
17198  * - \ref SCIP_STAGE_TRANSFORMING
17199  * - \ref SCIP_STAGE_TRANSFORMED
17200  * - \ref SCIP_STAGE_INITPRESOLVE
17201  * - \ref SCIP_STAGE_PRESOLVING
17202  * - \ref SCIP_STAGE_EXITPRESOLVE
17203  * - \ref SCIP_STAGE_PRESOLVED
17204  * - \ref SCIP_STAGE_INITSOLVE
17205  * - \ref SCIP_STAGE_SOLVING
17206  * - \ref SCIP_STAGE_SOLVED
17207  * - \ref SCIP_STAGE_EXITSOLVE
17208  * - \ref SCIP_STAGE_FREETRANS
17209  */
17210 extern
17212  SCIP* scip, /**< SCIP data structure */
17213  SCIP_SOL** sol, /**< pointer to store the solution */
17214  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
17215  );
17216 
17217 /** creates a copy of a primal solution, thereby replacing infinite fixings of variables by finite values;
17218  * the copy is always defined in the original variable space;
17219  * success indicates whether the objective value of the solution was changed by removing infinite values
17220  *
17221  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17222  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17223  *
17224  * @pre This method can be called if SCIP is in one of the following stages:
17225  * - \ref SCIP_STAGE_PROBLEM
17226  * - \ref SCIP_STAGE_TRANSFORMING
17227  * - \ref SCIP_STAGE_TRANSFORMED
17228  * - \ref SCIP_STAGE_INITPRESOLVE
17229  * - \ref SCIP_STAGE_PRESOLVING
17230  * - \ref SCIP_STAGE_EXITPRESOLVE
17231  * - \ref SCIP_STAGE_PRESOLVED
17232  * - \ref SCIP_STAGE_INITSOLVE
17233  * - \ref SCIP_STAGE_SOLVING
17234  * - \ref SCIP_STAGE_SOLVED
17235  * - \ref SCIP_STAGE_EXITSOLVE
17236  */
17237 extern
17239  SCIP* scip, /**< SCIP data structure */
17240  SCIP_SOL** sol, /**< pointer to store the solution */
17241  SCIP_SOL* sourcesol, /**< primal CIP solution to copy */
17242  SCIP_Bool* success /**< does the finite solution have the same objective value? */
17243  );
17244 
17245 /** frees primal CIP solution
17246  *
17247  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17248  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17249  *
17250  * @pre This method can be called if SCIP is in one of the following stages:
17251  * - \ref SCIP_STAGE_PROBLEM
17252  * - \ref SCIP_STAGE_TRANSFORMING
17253  * - \ref SCIP_STAGE_TRANSFORMED
17254  * - \ref SCIP_STAGE_INITPRESOLVE
17255  * - \ref SCIP_STAGE_PRESOLVING
17256  * - \ref SCIP_STAGE_EXITPRESOLVE
17257  * - \ref SCIP_STAGE_PRESOLVED
17258  * - \ref SCIP_STAGE_INITSOLVE
17259  * - \ref SCIP_STAGE_SOLVING
17260  * - \ref SCIP_STAGE_SOLVED
17261  * - \ref SCIP_STAGE_EXITSOLVE
17262  * - \ref SCIP_STAGE_FREETRANS
17263  */
17264 extern
17266  SCIP* scip, /**< SCIP data structure */
17267  SCIP_SOL** sol /**< pointer to the solution */
17268  );
17269 
17270 /** links a primal solution to the current LP solution
17271  *
17272  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17273  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17274  *
17275  * @pre This method can be called if SCIP is in one of the following stages:
17276  * - \ref SCIP_STAGE_SOLVING
17277  */
17278 extern
17280  SCIP* scip, /**< SCIP data structure */
17281  SCIP_SOL* sol /**< primal solution */
17282  );
17283 
17284 /** links a primal solution to the current NLP solution
17285  *
17286  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17287  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17288  *
17289  * @pre This method can be called if SCIP is in one of the following stages:
17290  * - \ref SCIP_STAGE_SOLVING
17291  */
17292 extern
17294  SCIP* scip, /**< SCIP data structure */
17295  SCIP_SOL* sol /**< primal solution */
17296  );
17297 
17298 /** links a primal solution to the current relaxation solution
17299  *
17300  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17301  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17302  *
17303  * @pre This method can be called if SCIP is in one of the following stages:
17304  * - \ref SCIP_STAGE_SOLVING
17305  */
17306 extern
17308  SCIP* scip, /**< SCIP data structure */
17309  SCIP_SOL* sol /**< primal solution */
17310  );
17311 
17312 /** links a primal solution to the current pseudo solution
17313  *
17314  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17315  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17316  *
17317  * @pre This method can be called if SCIP is in one of the following stages:
17318  * - \ref SCIP_STAGE_PRESOLVING
17319  * - \ref SCIP_STAGE_SOLVING
17320  */
17321 extern
17323  SCIP* scip, /**< SCIP data structure */
17324  SCIP_SOL* sol /**< primal solution */
17325  );
17326 
17327 /** links a primal solution to the current LP or pseudo solution
17328  *
17329  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17330  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17331  *
17332  * @pre This method can be called if SCIP is in one of the following stages:
17333  * - \ref SCIP_STAGE_SOLVING
17334  */
17335 extern
17337  SCIP* scip, /**< SCIP data structure */
17338  SCIP_SOL* sol /**< primal solution */
17339  );
17340 
17341 /** clears a primal solution
17342  *
17343  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17344  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17345  *
17346  * @pre This method can be called if SCIP is in one of the following stages:
17347  * - \ref SCIP_STAGE_PROBLEM
17348  * - \ref SCIP_STAGE_TRANSFORMING
17349  * - \ref SCIP_STAGE_TRANSFORMED
17350  * - \ref SCIP_STAGE_INITPRESOLVE
17351  * - \ref SCIP_STAGE_PRESOLVING
17352  * - \ref SCIP_STAGE_EXITPRESOLVE
17353  * - \ref SCIP_STAGE_PRESOLVED
17354  * - \ref SCIP_STAGE_INITSOLVE
17355  * - \ref SCIP_STAGE_SOLVING
17356  * - \ref SCIP_STAGE_SOLVED
17357  * - \ref SCIP_STAGE_EXITSOLVE
17358  * - \ref SCIP_STAGE_FREETRANS
17359  */
17360 extern
17362  SCIP* scip, /**< SCIP data structure */
17363  SCIP_SOL* sol /**< primal solution */
17364  );
17365 
17366 /** stores solution values of variables in solution's own array
17367  *
17368  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17369  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17370  *
17371  * @pre This method can be called if SCIP is in one of the following stages:
17372  * - \ref SCIP_STAGE_TRANSFORMING
17373  * - \ref SCIP_STAGE_TRANSFORMED
17374  * - \ref SCIP_STAGE_PRESOLVING
17375  * - \ref SCIP_STAGE_PRESOLVED
17376  * - \ref SCIP_STAGE_INITSOLVE
17377  * - \ref SCIP_STAGE_SOLVING
17378  * - \ref SCIP_STAGE_SOLVED
17379  * - \ref SCIP_STAGE_EXITSOLVE
17380  * - \ref SCIP_STAGE_FREETRANS
17381  */
17382 extern
17384  SCIP* scip, /**< SCIP data structure */
17385  SCIP_SOL* sol /**< primal solution */
17386  );
17387 
17388 /** sets value of variable in primal CIP solution
17389  *
17390  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17391  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17392  *
17393  * @pre This method can be called if SCIP is in one of the following stages:
17394  * - \ref SCIP_STAGE_PROBLEM
17395  * - \ref SCIP_STAGE_TRANSFORMING
17396  * - \ref SCIP_STAGE_TRANSFORMED
17397  * - \ref SCIP_STAGE_INITPRESOLVE
17398  * - \ref SCIP_STAGE_PRESOLVING
17399  * - \ref SCIP_STAGE_EXITPRESOLVE
17400  * - \ref SCIP_STAGE_PRESOLVED
17401  * - \ref SCIP_STAGE_INITSOLVE
17402  * - \ref SCIP_STAGE_SOLVING
17403  * - \ref SCIP_STAGE_SOLVED
17404  * - \ref SCIP_STAGE_EXITSOLVE
17405  * - \ref SCIP_STAGE_FREETRANS
17406  */
17407 extern
17409  SCIP* scip, /**< SCIP data structure */
17410  SCIP_SOL* sol, /**< primal solution */
17411  SCIP_VAR* var, /**< variable to add to solution */
17412  SCIP_Real val /**< solution value of variable */
17413  );
17414 
17415 /** sets values of multiple variables in primal CIP solution
17416  *
17417  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17418  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17419  *
17420  * @pre This method can be called if SCIP is in one of the following stages:
17421  * - \ref SCIP_STAGE_PROBLEM
17422  * - \ref SCIP_STAGE_TRANSFORMING
17423  * - \ref SCIP_STAGE_TRANSFORMED
17424  * - \ref SCIP_STAGE_INITPRESOLVE
17425  * - \ref SCIP_STAGE_PRESOLVING
17426  * - \ref SCIP_STAGE_EXITPRESOLVE
17427  * - \ref SCIP_STAGE_PRESOLVED
17428  * - \ref SCIP_STAGE_INITSOLVE
17429  * - \ref SCIP_STAGE_SOLVING
17430  * - \ref SCIP_STAGE_SOLVED
17431  * - \ref SCIP_STAGE_EXITSOLVE
17432  * - \ref SCIP_STAGE_FREETRANS
17433  */
17434 extern
17436  SCIP* scip, /**< SCIP data structure */
17437  SCIP_SOL* sol, /**< primal solution */
17438  int nvars, /**< number of variables to set solution value for */
17439  SCIP_VAR** vars, /**< array with variables to add to solution */
17440  SCIP_Real* vals /**< array with solution values of variables */
17441  );
17442 
17443 /** increases value of variable in primal CIP solution
17444  *
17445  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17446  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17447  *
17448  * @pre This method can be called if SCIP is in one of the following stages:
17449  * - \ref SCIP_STAGE_PROBLEM
17450  * - \ref SCIP_STAGE_TRANSFORMING
17451  * - \ref SCIP_STAGE_TRANSFORMED
17452  * - \ref SCIP_STAGE_INITPRESOLVE
17453  * - \ref SCIP_STAGE_PRESOLVING
17454  * - \ref SCIP_STAGE_EXITPRESOLVE
17455  * - \ref SCIP_STAGE_PRESOLVED
17456  * - \ref SCIP_STAGE_INITSOLVE
17457  * - \ref SCIP_STAGE_SOLVING
17458  * - \ref SCIP_STAGE_SOLVED
17459  * - \ref SCIP_STAGE_EXITSOLVE
17460  * - \ref SCIP_STAGE_FREETRANS
17461  */
17462 extern
17464  SCIP* scip, /**< SCIP data structure */
17465  SCIP_SOL* sol, /**< primal solution */
17466  SCIP_VAR* var, /**< variable to increase solution value for */
17467  SCIP_Real incval /**< increment for solution value of variable */
17468  );
17469 
17470 /** returns value of variable in primal CIP solution, or in current LP/pseudo solution
17471  *
17472  * @return value of variable in primal CIP solution, or in current LP/pseudo solution
17473  *
17474  * @pre In case the solution pointer @p sol is @b NULL, that means it is asked for the LP or pseudo solution, this method
17475  * can only be called if @p scip is in the solving stage \ref SCIP_STAGE_SOLVING. In any other case, this method
17476  * can be called if @p scip is in one of the following stages:
17477  * - \ref SCIP_STAGE_PROBLEM
17478  * - \ref SCIP_STAGE_TRANSFORMING
17479  * - \ref SCIP_STAGE_TRANSFORMED
17480  * - \ref SCIP_STAGE_INITPRESOLVE
17481  * - \ref SCIP_STAGE_PRESOLVING
17482  * - \ref SCIP_STAGE_EXITPRESOLVE
17483  * - \ref SCIP_STAGE_PRESOLVED
17484  * - \ref SCIP_STAGE_INITSOLVE
17485  * - \ref SCIP_STAGE_SOLVING
17486  * - \ref SCIP_STAGE_SOLVED
17487  * - \ref SCIP_STAGE_EXITSOLVE
17488  * - \ref SCIP_STAGE_FREETRANS
17489  */
17490 extern
17492  SCIP* scip, /**< SCIP data structure */
17493  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17494  SCIP_VAR* var /**< variable to get value for */
17495  );
17496 
17497 /** gets values of multiple variables in primal CIP solution
17498  *
17499  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17500  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17501  *
17502  * @pre This method can be called if SCIP is in one of the following stages:
17503  * - \ref SCIP_STAGE_PROBLEM
17504  * - \ref SCIP_STAGE_TRANSFORMING
17505  * - \ref SCIP_STAGE_TRANSFORMED
17506  * - \ref SCIP_STAGE_INITPRESOLVE
17507  * - \ref SCIP_STAGE_PRESOLVING
17508  * - \ref SCIP_STAGE_EXITPRESOLVE
17509  * - \ref SCIP_STAGE_PRESOLVED
17510  * - \ref SCIP_STAGE_INITSOLVE
17511  * - \ref SCIP_STAGE_SOLVING
17512  * - \ref SCIP_STAGE_SOLVED
17513  * - \ref SCIP_STAGE_EXITSOLVE
17514  * - \ref SCIP_STAGE_FREETRANS
17515  */
17516 extern
17518  SCIP* scip, /**< SCIP data structure */
17519  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17520  int nvars, /**< number of variables to get solution value for */
17521  SCIP_VAR** vars, /**< array with variables to get value for */
17522  SCIP_Real* vals /**< array to store solution values of variables */
17523  );
17524 
17525 /** returns objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
17526  *
17527  * @return objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
17528  *
17529  * @pre This method can be called if SCIP is in one of the following stages:
17530  * - \ref SCIP_STAGE_PROBLEM
17531  * - \ref SCIP_STAGE_TRANSFORMING
17532  * - \ref SCIP_STAGE_TRANSFORMED
17533  * - \ref SCIP_STAGE_INITPRESOLVE
17534  * - \ref SCIP_STAGE_PRESOLVING
17535  * - \ref SCIP_STAGE_EXITPRESOLVE
17536  * - \ref SCIP_STAGE_PRESOLVED
17537  * - \ref SCIP_STAGE_INITSOLVE
17538  * - \ref SCIP_STAGE_SOLVING
17539  * - \ref SCIP_STAGE_SOLVED
17540  * - \ref SCIP_STAGE_EXITSOLVE
17541  * - \ref SCIP_STAGE_FREETRANS
17542  */
17543 extern
17545  SCIP* scip, /**< SCIP data structure */
17546  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
17547  );
17548 
17549 /** returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
17550  *
17551  * @return transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
17552  *
17553  * @pre This method can be called if SCIP is in one of the following stages:
17554  * - \ref SCIP_STAGE_TRANSFORMING
17555  * - \ref SCIP_STAGE_TRANSFORMED
17556  * - \ref SCIP_STAGE_INITPRESOLVE
17557  * - \ref SCIP_STAGE_PRESOLVING
17558  * - \ref SCIP_STAGE_EXITPRESOLVE
17559  * - \ref SCIP_STAGE_PRESOLVED
17560  * - \ref SCIP_STAGE_INITSOLVE
17561  * - \ref SCIP_STAGE_SOLVING
17562  * - \ref SCIP_STAGE_SOLVED
17563  * - \ref SCIP_STAGE_EXITSOLVE
17564  * - \ref SCIP_STAGE_FREETRANS
17565  */
17566 extern
17568  SCIP* scip, /**< SCIP data structure */
17569  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
17570  );
17571 
17572 /** recomputes the objective value of an original solution, e.g., when transferring solutions
17573  * from the solution pool (objective coefficients might have changed in the meantime)
17574  *
17575  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17576  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17577  *
17578  * @pre This method can be called if SCIP is in one of the following stages:
17579  * - \ref SCIP_STAGE_PRESOLVING
17580  * - \ref SCIP_STAGE_SOLVING
17581  *
17582  */
17583 extern
17585  SCIP* scip,
17586  SCIP_SOL* sol
17587  );
17588 
17589 /** maps original space objective value into transformed objective value
17590  *
17591  * @return transformed objective value
17592  *
17593  * @pre This method can be called if SCIP is in one of the following stages:
17594  * - \ref SCIP_STAGE_TRANSFORMING
17595  * - \ref SCIP_STAGE_TRANSFORMED
17596  * - \ref SCIP_STAGE_INITPRESOLVE
17597  * - \ref SCIP_STAGE_PRESOLVING
17598  * - \ref SCIP_STAGE_EXITPRESOLVE
17599  * - \ref SCIP_STAGE_PRESOLVED
17600  * - \ref SCIP_STAGE_INITSOLVE
17601  * - \ref SCIP_STAGE_SOLVING
17602  * - \ref SCIP_STAGE_SOLVED
17603  */
17604 extern
17606  SCIP* scip, /**< SCIP data structure */
17607  SCIP_Real obj /**< original space objective value to transform */
17608  );
17609 
17610 /** maps transformed objective value into original space
17611  *
17612  * @return objective value into original space
17613  *
17614  * @pre This method can be called if SCIP is in one of the following stages:
17615  * - \ref SCIP_STAGE_TRANSFORMING
17616  * - \ref SCIP_STAGE_TRANSFORMED
17617  * - \ref SCIP_STAGE_INITPRESOLVE
17618  * - \ref SCIP_STAGE_PRESOLVING
17619  * - \ref SCIP_STAGE_EXITPRESOLVE
17620  * - \ref SCIP_STAGE_PRESOLVED
17621  * - \ref SCIP_STAGE_INITSOLVE
17622  * - \ref SCIP_STAGE_SOLVING
17623  * - \ref SCIP_STAGE_SOLVED
17624  */
17625 extern
17627  SCIP* scip, /**< SCIP data structure */
17628  SCIP_Real obj /**< transformed objective value to retransform in original space */
17629  );
17630 
17631 /** gets clock time, when this solution was found
17632  *
17633  * @return clock time, when this solution was found
17634  *
17635  * @pre This method can be called if SCIP is in one of the following stages:
17636  * - \ref SCIP_STAGE_TRANSFORMING
17637  * - \ref SCIP_STAGE_TRANSFORMED
17638  * - \ref SCIP_STAGE_INITPRESOLVE
17639  * - \ref SCIP_STAGE_PRESOLVING
17640  * - \ref SCIP_STAGE_EXITPRESOLVE
17641  * - \ref SCIP_STAGE_PRESOLVED
17642  * - \ref SCIP_STAGE_INITSOLVE
17643  * - \ref SCIP_STAGE_SOLVING
17644  * - \ref SCIP_STAGE_SOLVED
17645  * - \ref SCIP_STAGE_EXITSOLVE
17646  * - \ref SCIP_STAGE_FREETRANS
17647  */
17648 extern
17650  SCIP* scip, /**< SCIP data structure */
17651  SCIP_SOL* sol /**< primal solution */
17652  );
17653 
17654 /** gets branch and bound run number, where this solution was found
17655  *
17656  * @return branch and bound run number, where this solution was found
17657  *
17658  * @pre This method can be called if SCIP is in one of the following stages:
17659  * - \ref SCIP_STAGE_TRANSFORMING
17660  * - \ref SCIP_STAGE_TRANSFORMED
17661  * - \ref SCIP_STAGE_INITPRESOLVE
17662  * - \ref SCIP_STAGE_PRESOLVING
17663  * - \ref SCIP_STAGE_EXITPRESOLVE
17664  * - \ref SCIP_STAGE_PRESOLVED
17665  * - \ref SCIP_STAGE_INITSOLVE
17666  * - \ref SCIP_STAGE_SOLVING
17667  * - \ref SCIP_STAGE_SOLVED
17668  * - \ref SCIP_STAGE_EXITSOLVE
17669  * - \ref SCIP_STAGE_FREETRANS
17670  */
17671 extern
17672 int SCIPgetSolRunnum(
17673  SCIP* scip, /**< SCIP data structure */
17674  SCIP_SOL* sol /**< primal solution */
17675  );
17676 
17677 /** gets node number of the specific branch and bound run, where this solution was found
17678  *
17679  * @return node number of the specific branch and bound run, where this solution was found
17680  *
17681  * @pre This method can be called if SCIP is in one of the following stages:
17682  * - \ref SCIP_STAGE_TRANSFORMING
17683  * - \ref SCIP_STAGE_TRANSFORMED
17684  * - \ref SCIP_STAGE_INITPRESOLVE
17685  * - \ref SCIP_STAGE_PRESOLVING
17686  * - \ref SCIP_STAGE_EXITPRESOLVE
17687  * - \ref SCIP_STAGE_PRESOLVED
17688  * - \ref SCIP_STAGE_INITSOLVE
17689  * - \ref SCIP_STAGE_SOLVING
17690  * - \ref SCIP_STAGE_SOLVED
17691  * - \ref SCIP_STAGE_EXITSOLVE
17692  * - \ref SCIP_STAGE_FREETRANS
17693  */
17694 extern
17696  SCIP* scip, /**< SCIP data structure */
17697  SCIP_SOL* sol /**< primal solution */
17698  );
17699 
17700 /** gets heuristic, that found this solution (or NULL if it's from the tree)
17701  *
17702  * @return heuristic, that found this solution (or NULL if it's from the tree)
17703  *
17704  * @pre This method can be called if SCIP is in one of the following stages:
17705  * - \ref SCIP_STAGE_TRANSFORMING
17706  * - \ref SCIP_STAGE_TRANSFORMED
17707  * - \ref SCIP_STAGE_INITPRESOLVE
17708  * - \ref SCIP_STAGE_PRESOLVING
17709  * - \ref SCIP_STAGE_EXITPRESOLVE
17710  * - \ref SCIP_STAGE_PRESOLVED
17711  * - \ref SCIP_STAGE_INITSOLVE
17712  * - \ref SCIP_STAGE_SOLVING
17713  * - \ref SCIP_STAGE_SOLVED
17714  * - \ref SCIP_STAGE_EXITSOLVE
17715  * - \ref SCIP_STAGE_FREETRANS
17716  */
17717 extern
17719  SCIP* scip, /**< SCIP data structure */
17720  SCIP_SOL* sol /**< primal solution */
17721  );
17722 
17723 /** returns whether two given solutions are exactly equal
17724  *
17725  * @return returns whether two given solutions are exactly equal
17726  *
17727  * @pre This method can be called if SCIP is in one of the following stages:
17728  * - \ref SCIP_STAGE_PROBLEM
17729  * - \ref SCIP_STAGE_TRANSFORMING
17730  * - \ref SCIP_STAGE_TRANSFORMED
17731  * - \ref SCIP_STAGE_INITPRESOLVE
17732  * - \ref SCIP_STAGE_PRESOLVING
17733  * - \ref SCIP_STAGE_EXITPRESOLVE
17734  * - \ref SCIP_STAGE_PRESOLVED
17735  * - \ref SCIP_STAGE_INITSOLVE
17736  * - \ref SCIP_STAGE_SOLVING
17737  * - \ref SCIP_STAGE_SOLVED
17738  * - \ref SCIP_STAGE_EXITSOLVE
17739  * - \ref SCIP_STAGE_FREETRANS
17740  */
17741 extern
17743  SCIP* scip, /**< SCIP data structure */
17744  SCIP_SOL* sol1, /**< first primal CIP solution */
17745  SCIP_SOL* sol2 /**< second primal CIP solution */
17746  );
17747 
17748 /** adjusts solution values of implicit integer variables in handed solution. Solution objective value is not
17749  * deteriorated by this method.
17750  *
17751  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17752  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17753  *
17754  * @pre This method can be called if SCIP is in one of the following stages:
17755  * - \ref SCIP_STAGE_SOLVING
17756  */
17757 extern
17759  SCIP* scip, /**< SCIP data structure */
17760  SCIP_SOL* sol, /**< primal CIP solution */
17761  SCIP_Bool uselprows /**< should LP row information be considered for none-objective variables */
17762  );
17763 
17764 /** outputs non-zero variables of solution in original problem space to the given file stream
17765  *
17766  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17767  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17768  *
17769  * @pre In case the solution pointer @p sol is NULL (askinking for the current LP/pseudo solution), this method can be
17770  * called if @p scip is in one of the following stages:
17771  * - \ref SCIP_STAGE_PRESOLVING
17772  * - \ref SCIP_STAGE_EXITPRESOLVE
17773  * - \ref SCIP_STAGE_PRESOLVED
17774  * - \ref SCIP_STAGE_INITSOLVE
17775  * - \ref SCIP_STAGE_SOLVING
17776  * - \ref SCIP_STAGE_SOLVED
17777  * - \ref SCIP_STAGE_EXITSOLVE
17778  *
17779  * @pre In case the solution pointer @p sol is @b not NULL, this method can be called if @p scip is in one of the
17780  * following stages:
17781  * - \ref SCIP_STAGE_PROBLEM
17782  * - \ref SCIP_STAGE_TRANSFORMED
17783  * - \ref SCIP_STAGE_INITPRESOLVE
17784  * - \ref SCIP_STAGE_PRESOLVING
17785  * - \ref SCIP_STAGE_EXITPRESOLVE
17786  * - \ref SCIP_STAGE_PRESOLVED
17787  * - \ref SCIP_STAGE_INITSOLVE
17788  * - \ref SCIP_STAGE_SOLVING
17789  * - \ref SCIP_STAGE_SOLVED
17790  * - \ref SCIP_STAGE_EXITSOLVE
17791  */
17792 extern
17794  SCIP* scip, /**< SCIP data structure */
17795  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17796  FILE* file, /**< output file (or NULL for standard output) */
17797  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17798  );
17799 
17800 /** outputs non-zero variables of solution in transformed problem space to file stream
17801  *
17802  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17803  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17804  *
17805  * @pre This method can be called if SCIP is in one of the following stages:
17806  * - \ref SCIP_STAGE_TRANSFORMED
17807  * - \ref SCIP_STAGE_INITPRESOLVE
17808  * - \ref SCIP_STAGE_PRESOLVING
17809  * - \ref SCIP_STAGE_EXITPRESOLVE
17810  * - \ref SCIP_STAGE_PRESOLVED
17811  * - \ref SCIP_STAGE_INITSOLVE
17812  * - \ref SCIP_STAGE_SOLVING
17813  * - \ref SCIP_STAGE_SOLVED
17814  * - \ref SCIP_STAGE_EXITSOLVE
17815  */
17816 extern
17818  SCIP* scip, /**< SCIP data structure */
17819  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17820  FILE* file, /**< output file (or NULL for standard output) */
17821  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17822  );
17823 
17824 /** outputs discrete variables of solution in original problem space to the given file stream
17825  *
17826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17828  *
17829  * @pre This method can be called if @p scip is in one of the following stages:
17830  * - \ref SCIP_STAGE_PROBLEM
17831  * - \ref SCIP_STAGE_TRANSFORMED
17832  * - \ref SCIP_STAGE_INITPRESOLVE
17833  * - \ref SCIP_STAGE_PRESOLVING
17834  * - \ref SCIP_STAGE_EXITPRESOLVE
17835  * - \ref SCIP_STAGE_PRESOLVED
17836  * - \ref SCIP_STAGE_INITSOLVE
17837  * - \ref SCIP_STAGE_SOLVING
17838  * - \ref SCIP_STAGE_SOLVED
17839  * - \ref SCIP_STAGE_EXITSOLVE
17840  */
17841 extern
17843  SCIP* scip, /**< SCIP data structure */
17844  SCIP_SOL* sol, /**< primal solution */
17845  FILE* file /**< output file (or NULL for standard output) */
17846  );
17847 
17848 /** returns dual solution value of a constraint */
17849 extern
17851  SCIP* scip, /**< SCIP data structure */
17852  SCIP_CONS* cons, /**< constraint for which the dual solution should be returned */
17853  SCIP_Real* dualsolval, /**< pointer to store the dual solution value */
17854  SCIP_Bool* boundconstraint /**< pointer to store whether the constraint is a bound constraint (or NULL) */
17855  );
17856 
17857 /** check whether the dual solution is available
17858  *
17859  * @note This is used when calling \ref SCIPprintDualSol()
17860  *
17861  * @return is dual solution available?
17862  *
17863  * @pre This method can be called if SCIP is in one of the following stages:
17864  * - \ref SCIP_STAGE_SOLVED
17865  */
17866 extern
17868  SCIP* scip, /**< SCIP data structure */
17869  SCIP_Bool printreason /**< print warning message if dualsol is not available? */
17870  );
17871 
17872 /** outputs dual solution from LP solver to file stream
17873  *
17874  * @note This only works if no presolving has been performed, which can be checked by calling method \ref
17875  * SCIPhasPerformedPresolve().
17876  *
17877  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17878  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17879  *
17880  * @pre This method can be called if SCIP is in one of the following stages:
17881  * - \ref SCIP_STAGE_SOLVED
17882  */
17883 extern
17885  SCIP* scip, /**< SCIP data structure */
17886  FILE* file, /**< output file (or NULL for standard output) */
17887  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17888  );
17889 
17890 
17891 /** outputs non-zero variables of solution representing a ray in original problem space to file stream
17892  *
17893  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17894  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17895  *
17896  * @pre This method can be called if SCIP is in one of the following stages:
17897  * - \ref SCIP_STAGE_PROBLEM
17898  * - \ref SCIP_STAGE_TRANSFORMED
17899  * - \ref SCIP_STAGE_INITPRESOLVE
17900  * - \ref SCIP_STAGE_PRESOLVING
17901  * - \ref SCIP_STAGE_EXITPRESOLVE
17902  * - \ref SCIP_STAGE_PRESOLVED
17903  * - \ref SCIP_STAGE_INITSOLVE
17904  * - \ref SCIP_STAGE_SOLVING
17905  * - \ref SCIP_STAGE_SOLVED
17906  * - \ref SCIP_STAGE_EXITSOLVE
17907  */
17908 extern
17910  SCIP* scip, /**< SCIP data structure */
17911  SCIP_SOL* sol, /**< primal solution representing ray */
17912  FILE* file, /**< output file (or NULL for standard output) */
17913  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17914  );
17915 
17916 /** gets number of feasible primal solutions stored in the solution storage in case the problem is transformed;
17917  * in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate
17918  * storage is returned
17919  *
17920  * @return number of feasible primal solutions stored in the solution storage in case the problem is transformed; or
17921  * number of solution in the original solution candidate storage if the problem stage is SCIP_STAGE_PROBLEM
17922  *
17923  * @pre This method can be called if SCIP is in one of the following stages:
17924  * - \ref SCIP_STAGE_PROBLEM
17925  * - \ref SCIP_STAGE_TRANSFORMED
17926  * - \ref SCIP_STAGE_INITPRESOLVE
17927  * - \ref SCIP_STAGE_PRESOLVING
17928  * - \ref SCIP_STAGE_EXITPRESOLVE
17929  * - \ref SCIP_STAGE_PRESOLVED
17930  * - \ref SCIP_STAGE_INITSOLVE
17931  * - \ref SCIP_STAGE_SOLVING
17932  * - \ref SCIP_STAGE_SOLVED
17933  * - \ref SCIP_STAGE_EXITSOLVE
17934  */
17935 extern
17936 int SCIPgetNSols(
17937  SCIP* scip /**< SCIP data structure */
17938  );
17939 
17940 /** gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case
17941  * if the problem stage is in SCIP_STAGE_PROBLEM, it returns the number array of solution candidate stored
17942  *
17943  * @return array of feasible primal solutions
17944  *
17945  * @pre This method can be called if SCIP is in one of the following stages:
17946  * - \ref SCIP_STAGE_PROBLEM
17947  * - \ref SCIP_STAGE_TRANSFORMED
17948  * - \ref SCIP_STAGE_INITPRESOLVE
17949  * - \ref SCIP_STAGE_PRESOLVING
17950  * - \ref SCIP_STAGE_EXITPRESOLVE
17951  * - \ref SCIP_STAGE_PRESOLVED
17952  * - \ref SCIP_STAGE_INITSOLVE
17953  * - \ref SCIP_STAGE_SOLVING
17954  * - \ref SCIP_STAGE_SOLVED
17955  * - \ref SCIP_STAGE_EXITSOLVE
17956  */
17957 extern
17959  SCIP* scip /**< SCIP data structure */
17960  );
17961 
17962 /** gets best feasible primal solution found so far if the problem is transformed; in case the problem is in
17963  * SCIP_STAGE_PROBLEM it returns the best solution candidate, or NULL if no solution has been found or the candidate
17964  * store is empty;
17965  *
17966  * @return best feasible primal solution so far
17967  *
17968  * @pre This method can be called if SCIP is in one of the following stages:
17969  * - \ref SCIP_STAGE_PROBLEM
17970  * - \ref SCIP_STAGE_TRANSFORMED
17971  * - \ref SCIP_STAGE_INITPRESOLVE
17972  * - \ref SCIP_STAGE_PRESOLVING
17973  * - \ref SCIP_STAGE_EXITPRESOLVE
17974  * - \ref SCIP_STAGE_PRESOLVED
17975  * - \ref SCIP_STAGE_INITSOLVE
17976  * - \ref SCIP_STAGE_SOLVING
17977  * - \ref SCIP_STAGE_SOLVED
17978  * - \ref SCIP_STAGE_EXITSOLVE
17979  */
17980 extern
17982  SCIP* scip /**< SCIP data structure */
17983  );
17984 
17985 /** outputs best feasible primal solution found so far to file stream
17986  *
17987  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17988  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17989  *
17990  * @pre This method can be called if SCIP is in one of the following stages:
17991  * - \ref SCIP_STAGE_INIT
17992  * - \ref SCIP_STAGE_PROBLEM
17993  * - \ref SCIP_STAGE_TRANSFORMING
17994  * - \ref SCIP_STAGE_TRANSFORMED
17995  * - \ref SCIP_STAGE_INITPRESOLVE
17996  * - \ref SCIP_STAGE_PRESOLVING
17997  * - \ref SCIP_STAGE_EXITPRESOLVE
17998  * - \ref SCIP_STAGE_PRESOLVED
17999  * - \ref SCIP_STAGE_INITSOLVE
18000  * - \ref SCIP_STAGE_SOLVING
18001  * - \ref SCIP_STAGE_SOLVED
18002  * - \ref SCIP_STAGE_EXITSOLVE
18003  * - \ref SCIP_STAGE_FREE
18004  */
18005 extern
18007  SCIP* scip, /**< SCIP data structure */
18008  FILE* file, /**< output file (or NULL for standard output) */
18009  SCIP_Bool printzeros /**< should variables set to zero be printed? */
18010  );
18011 
18012 /** outputs best feasible primal solution found so far in transformed variables to file stream
18013  *
18014  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18015  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18016  *
18017  * @pre This method can be called if SCIP is in one of the following stages:
18018  * - \ref SCIP_STAGE_INIT
18019  * - \ref SCIP_STAGE_PROBLEM
18020  * - \ref SCIP_STAGE_TRANSFORMING
18021  * - \ref SCIP_STAGE_TRANSFORMED
18022  * - \ref SCIP_STAGE_INITPRESOLVE
18023  * - \ref SCIP_STAGE_PRESOLVING
18024  * - \ref SCIP_STAGE_EXITPRESOLVE
18025  * - \ref SCIP_STAGE_PRESOLVED
18026  * - \ref SCIP_STAGE_INITSOLVE
18027  * - \ref SCIP_STAGE_SOLVING
18028  * - \ref SCIP_STAGE_SOLVED
18029  * - \ref SCIP_STAGE_EXITSOLVE
18030  * - \ref SCIP_STAGE_FREE
18031  */
18032 extern
18034  SCIP* scip, /**< SCIP data structure */
18035  FILE* file, /**< output file (or NULL for standard output) */
18036  SCIP_Bool printzeros /**< should variables set to zero be printed? */
18037  );
18038 
18039 /** try to round given solution
18040  *
18041  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18042  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18043  *
18044  * @pre This method can be called if SCIP is in one of the following stages:
18045  * - \ref SCIP_STAGE_SOLVING
18046  */
18047 extern
18049  SCIP* scip, /**< SCIP data structure */
18050  SCIP_SOL* sol, /**< primal solution */
18051  SCIP_Bool* success /**< pointer to store whether rounding was successful */
18052  );
18053 
18054 /** retransforms solution to original problem space
18055  *
18056  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18057  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18058  *
18059  * @pre This method can be called if SCIP is in one of the following stages:
18060  * - \ref SCIP_STAGE_PROBLEM
18061  * - \ref SCIP_STAGE_TRANSFORMING
18062  * - \ref SCIP_STAGE_TRANSFORMED
18063  * - \ref SCIP_STAGE_INITPRESOLVE
18064  * - \ref SCIP_STAGE_PRESOLVING
18065  * - \ref SCIP_STAGE_EXITPRESOLVE
18066  * - \ref SCIP_STAGE_PRESOLVED
18067  * - \ref SCIP_STAGE_INITSOLVE
18068  * - \ref SCIP_STAGE_SOLVING
18069  * - \ref SCIP_STAGE_SOLVED
18070  * - \ref SCIP_STAGE_EXITSOLVE
18071  * - \ref SCIP_STAGE_FREETRANS
18072  */
18073 extern
18075  SCIP* scip, /**< SCIP data structure */
18076  SCIP_SOL* sol /**< primal CIP solution */
18077  );
18078 
18079 /** reads a given solution file, problem has to be transformed in advance
18080  *
18081  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18082  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18083  *
18084  * @pre This method can be called if SCIP is in one of the following stages:
18085  * - \ref SCIP_STAGE_PROBLEM
18086  * - \ref SCIP_STAGE_TRANSFORMED
18087  * - \ref SCIP_STAGE_INITPRESOLVE
18088  * - \ref SCIP_STAGE_PRESOLVING
18089  * - \ref SCIP_STAGE_EXITPRESOLVE
18090  * - \ref SCIP_STAGE_PRESOLVED
18091  * - \ref SCIP_STAGE_INITSOLVE
18092  * - \ref SCIP_STAGE_SOLVING
18093  */
18094 extern
18096  SCIP* scip, /**< SCIP data structure */
18097  const char* filename /**< name of the input file */
18098  );
18099 
18100 /** reads a given solution file and store the solution values in the given solution pointer
18101  *
18102  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18103  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18104  *
18105  * @pre This method can be called if SCIP is in one of the following stages:
18106  * - \ref SCIP_STAGE_PROBLEM
18107  * - \ref SCIP_STAGE_TRANSFORMED
18108  * - \ref SCIP_STAGE_INITPRESOLVE
18109  * - \ref SCIP_STAGE_PRESOLVING
18110  * - \ref SCIP_STAGE_EXITPRESOLVE
18111  * - \ref SCIP_STAGE_PRESOLVED
18112  * - \ref SCIP_STAGE_INITSOLVE
18113  * - \ref SCIP_STAGE_SOLVING
18114  */
18115 extern
18117  SCIP* scip, /**< SCIP data structure */
18118  const char* filename, /**< name of the input file */
18119  SCIP_SOL* sol, /**< solution pointer */
18120  SCIP_Bool xml, /**< true, iff the given solution in written in XML */
18121  SCIP_Bool* partial, /**< pointer to store if the solution is partial */
18122  SCIP_Bool* error /**< pointer store if an error occured */
18123  );
18124 
18125 /** adds feasible primal solution to solution storage by copying it
18126  *
18127  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18128  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18129  *
18130  * @pre This method can be called if SCIP is in one of the following stages:
18131  * - \ref SCIP_STAGE_PROBLEM
18132  * - \ref SCIP_STAGE_TRANSFORMED
18133  * - \ref SCIP_STAGE_INITPRESOLVE
18134  * - \ref SCIP_STAGE_PRESOLVING
18135  * - \ref SCIP_STAGE_EXITPRESOLVE
18136  * - \ref SCIP_STAGE_PRESOLVED
18137  * - \ref SCIP_STAGE_SOLVING
18138  * - \ref SCIP_STAGE_FREETRANS
18139  *
18140  * @note Do not call during propagation, use heur_trysol instead.
18141  */
18142 extern
18144  SCIP* scip, /**< SCIP data structure */
18145  SCIP_SOL* sol, /**< primal CIP solution */
18146  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
18147  );
18148 
18149 /** adds primal solution to solution storage, frees the solution afterwards
18150  *
18151  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18152  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18153  *
18154  * @pre This method can be called if SCIP is in one of the following stages:
18155  * - \ref SCIP_STAGE_PROBLEM
18156  * - \ref SCIP_STAGE_TRANSFORMED
18157  * - \ref SCIP_STAGE_INITPRESOLVE
18158  * - \ref SCIP_STAGE_PRESOLVING
18159  * - \ref SCIP_STAGE_EXITPRESOLVE
18160  * - \ref SCIP_STAGE_PRESOLVED
18161  * - \ref SCIP_STAGE_SOLVING
18162  * - \ref SCIP_STAGE_FREETRANS
18163  *
18164  * @note Do not call during propagation, use heur_trysol instead.
18165  */
18166 extern
18168  SCIP* scip, /**< SCIP data structure */
18169  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
18170  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
18171  );
18172 
18173 /** adds current LP/pseudo solution to solution storage
18174  *
18175  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18176  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18177  *
18178  * @pre This method can be called if SCIP is in one of the following stages:
18179  * - \ref SCIP_STAGE_PRESOLVED
18180  * - \ref SCIP_STAGE_SOLVING
18181  */
18182 extern
18184  SCIP* scip, /**< SCIP data structure */
18185  SCIP_HEUR* heur, /**< heuristic that found the solution */
18186  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
18187  );
18188 
18189 /** checks solution for feasibility; if possible, adds it to storage by copying
18190  *
18191  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18192  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18193  *
18194  * @pre This method can be called if SCIP is in one of the following stages:
18195  * - \ref SCIP_STAGE_TRANSFORMED
18196  * - \ref SCIP_STAGE_INITPRESOLVE
18197  * - \ref SCIP_STAGE_PRESOLVING
18198  * - \ref SCIP_STAGE_EXITPRESOLVE
18199  * - \ref SCIP_STAGE_PRESOLVED
18200  * - \ref SCIP_STAGE_SOLVING
18201  *
18202  * @note Do not call during propagation, use heur_trysol instead.
18203  */
18204 extern
18206  SCIP* scip, /**< SCIP data structure */
18207  SCIP_SOL* sol, /**< primal CIP solution */
18208  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
18209  SCIP_Bool completely, /**< Should all violations be checked? */
18210  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
18211  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
18212  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
18213  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
18214  );
18215 
18216 /** checks primal solution; if feasible, adds it to storage; solution is freed afterwards
18217  *
18218  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18219  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18220  *
18221  * @pre This method can be called if SCIP is in one of the following stages:
18222  * - \ref SCIP_STAGE_TRANSFORMED
18223  * - \ref SCIP_STAGE_INITPRESOLVE
18224  * - \ref SCIP_STAGE_PRESOLVING
18225  * - \ref SCIP_STAGE_EXITPRESOLVE
18226  * - \ref SCIP_STAGE_PRESOLVED
18227  * - \ref SCIP_STAGE_SOLVING
18228  *
18229  * @note Do not call during propagation, use heur_trysol instead.
18230  */
18231 extern
18233  SCIP* scip, /**< SCIP data structure */
18234  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
18235  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
18236  SCIP_Bool completely, /**< Should all violation be checked? */
18237  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
18238  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
18239  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
18240  SCIP_Bool* stored /**< stores whether solution was feasible and good enough to keep */
18241  );
18242 
18243 /** checks current LP/pseudo solution for feasibility; if possible, adds it to storage
18244  *
18245  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18246  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18247  *
18248  * @pre This method can be called if SCIP is in one of the following stages:
18249  * - \ref SCIP_STAGE_PRESOLVED
18250  * - \ref SCIP_STAGE_SOLVING
18251  */
18252 extern
18254  SCIP* scip, /**< SCIP data structure */
18255  SCIP_HEUR* heur, /**< heuristic that found the solution */
18256  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
18257  SCIP_Bool completely, /**< Should all violation be checked? */
18258  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
18259  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
18260  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
18261  );
18262 
18263 /** returns all partial solutions
18264  *
18265  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18266  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18267  *
18268  * @pre This method can be called if SCIP is in one of the following stages:
18269  * - \ref SCIP_STAGE_PROBLEM
18270  * - \ref SCIP_STAGE_PRESOLVING
18271  * - \ref SCIP_STAGE_SOLVING
18272  * - \ref SCIP_STAGE_SOLVED
18273  */
18274 extern
18276  SCIP* scip /**< SCIP data structure */
18277  );
18278 
18279 /** returns number of partial solutions
18280  *
18281  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18282  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18283  *
18284  * @pre This method can be called if SCIP is in one of the following stages:
18285  * - \ref SCIP_STAGE_PROBLEM
18286  * - \ref SCIP_STAGE_PRESOLVING
18287  * - \ref SCIP_STAGE_SOLVING
18288  * - \ref SCIP_STAGE_SOLVED
18289  */
18291  SCIP* scip /**< SCIP data structure */
18292  );
18293 
18294 /** checks solution for feasibility without adding it to the solution store
18295  *
18296  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18297  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18298  *
18299  * @pre This method can be called if SCIP is in one of the following stages:
18300  * - \ref SCIP_STAGE_PROBLEM
18301  * - \ref SCIP_STAGE_TRANSFORMED
18302  * - \ref SCIP_STAGE_INITPRESOLVE
18303  * - \ref SCIP_STAGE_PRESOLVING
18304  * - \ref SCIP_STAGE_EXITPRESOLVE
18305  * - \ref SCIP_STAGE_PRESOLVED
18306  * - \ref SCIP_STAGE_INITSOLVE
18307  * - \ref SCIP_STAGE_SOLVING
18308  * - \ref SCIP_STAGE_SOLVED
18309  */
18310 extern
18312  SCIP* scip, /**< SCIP data structure */
18313  SCIP_SOL* sol, /**< primal CIP solution */
18314  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
18315  SCIP_Bool completely, /**< Should all violation be checked? */
18316  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
18317  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
18318  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
18319  SCIP_Bool* feasible /**< stores whether given solution is feasible */
18320  );
18321 
18322 /** checks solution for feasibility in original problem without adding it to the solution store;
18323  * this method is used to double check a solution in order to validate the presolving process
18324  *
18325  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18326  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18327  *
18328  * @pre This method can be called if SCIP is in one of the following stages:
18329  * - \ref SCIP_STAGE_PROBLEM
18330  * - \ref SCIP_STAGE_TRANSFORMED
18331  * - \ref SCIP_STAGE_INITPRESOLVE
18332  * - \ref SCIP_STAGE_PRESOLVING
18333  * - \ref SCIP_STAGE_EXITPRESOLVE
18334  * - \ref SCIP_STAGE_PRESOLVED
18335  * - \ref SCIP_STAGE_INITSOLVE
18336  * - \ref SCIP_STAGE_SOLVING
18337  * - \ref SCIP_STAGE_SOLVED
18338  */
18339 extern
18341  SCIP* scip, /**< SCIP data structure */
18342  SCIP_SOL* sol, /**< primal CIP solution */
18343  SCIP_Bool* feasible, /**< stores whether given solution is feasible */
18344  SCIP_Bool printreason, /**< should the reason for the violation be printed? */
18345  SCIP_Bool completely /**< should all violations be checked? */
18346  );
18347 
18348 /** update integrality violation of a solution */
18349 extern
18351  SCIP* scip, /**< SCIP data structure */
18352  SCIP_SOL* sol, /**< primal CIP solution */
18353  SCIP_Real absviol /**< absolute violation */
18354  );
18355 
18356 /** update bound violation of a solution */
18357 extern
18359  SCIP* scip, /**< SCIP data structure */
18360  SCIP_SOL* sol, /**< primal CIP solution */
18361  SCIP_Real absviol, /**< absolute violation */
18362  SCIP_Real relviol /**< relative violation */
18363  );
18364 
18365 /** update LP row violation of a solution */
18366 extern
18368  SCIP* scip, /**< SCIP data structure */
18369  SCIP_SOL* sol, /**< primal CIP solution */
18370  SCIP_Real absviol, /**< absolute violation */
18371  SCIP_Real relviol /**< relative violation */
18372  );
18373 
18374 /** update constraint violation of a solution */
18375 extern
18377  SCIP* scip, /**< SCIP data structure */
18378  SCIP_SOL* sol, /**< primal CIP solution */
18379  SCIP_Real absviol, /**< absolute violation */
18380  SCIP_Real relviol /**< relative violation */
18381  );
18382 
18383 /** update LP row and constraint violations of a solution */
18384 extern
18386  SCIP* scip, /**< SCIP data structure */
18387  SCIP_SOL* sol, /**< primal CIP solution */
18388  SCIP_Real absviol, /**< absolute violation */
18389  SCIP_Real relviol /**< relative violation */
18390  );
18391 
18392 /** allow violation updates */
18393 extern
18395  SCIP* scip /**< SCIP data structure */
18396  );
18397 
18398 /** disallow violation updates */
18399 extern
18401  SCIP* scip /**< SCIP data structure */
18402  );
18403 
18404 /** return whether a primal ray is stored that proves unboundedness of the LP relaxation
18405  *
18406  * @return return whether a primal ray is stored that proves unboundedness of the LP relaxation
18407  *
18408  * @pre This method can be called if SCIP is in one of the following stages:
18409  * - \ref SCIP_STAGE_SOLVING
18410  * - \ref SCIP_STAGE_SOLVED
18411  */
18412 extern
18414  SCIP* scip /**< SCIP data structure */
18415  );
18416 
18417 /** gets value of given variable in primal ray causing unboundedness of the LP relaxation;
18418  * should only be called if such a ray is stored (check with SCIPhasPrimalRay())
18419  *
18420  * @return value of given variable in primal ray causing unboundedness of the LP relaxation
18421  *
18422  * @pre This method can be called if SCIP is in one of the following stages:
18423  * - \ref SCIP_STAGE_SOLVING
18424  * - \ref SCIP_STAGE_SOLVED
18425  */
18426 extern
18428  SCIP* scip, /**< SCIP data structure */
18429  SCIP_VAR* var /**< variable to get value for */
18430  );
18431 
18432 /** updates the primal ray thats proves unboundedness
18433  *
18434  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18435  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18436  *
18437  * @pre This method can be called if @p scip is in one of the following stages:
18438  * - \ref SCIP_STAGE_PRESOLVING
18439  * - \ref SCIP_STAGE_PRESOLVED
18440  * - \ref SCIP_STAGE_SOLVING
18441  * - \ref SCIP_STAGE_SOLVED
18442  *
18443  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18444  */
18445 extern
18447  SCIP* scip, /**< SCIP data structure */
18448  SCIP_SOL* primalray /**< the new primal ray */
18449  );
18450 
18451 /**@} */
18452 
18453 
18454 
18455 
18456 /*
18457  * event methods
18458  */
18459 
18460 /**@addtogroup PublicEventMethods
18461  *
18462  * @{
18463  */
18464 
18465 /** catches a global (not variable or row dependent) event
18466  *
18467  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18468  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18469  *
18470  * @pre This method can be called if @p scip is in one of the following stages:
18471  * - \ref SCIP_STAGE_TRANSFORMING
18472  * - \ref SCIP_STAGE_TRANSFORMED
18473  * - \ref SCIP_STAGE_INITPRESOLVE
18474  * - \ref SCIP_STAGE_PRESOLVING
18475  * - \ref SCIP_STAGE_EXITPRESOLVE
18476  * - \ref SCIP_STAGE_PRESOLVED
18477  * - \ref SCIP_STAGE_INITSOLVE
18478  * - \ref SCIP_STAGE_SOLVING
18479  * - \ref SCIP_STAGE_SOLVED
18480  * - \ref SCIP_STAGE_EXITSOLVE
18481  * - \ref SCIP_STAGE_FREETRANS
18482  */
18483 extern
18485  SCIP* scip, /**< SCIP data structure */
18486  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18487  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18488  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18489  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18490  );
18491 
18492 /** drops a global event (stops to track event)
18493  *
18494  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18495  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18496  *
18497  * @pre This method can be called if @p scip is in one of the following stages:
18498  * - \ref SCIP_STAGE_TRANSFORMING
18499  * - \ref SCIP_STAGE_TRANSFORMED
18500  * - \ref SCIP_STAGE_INITPRESOLVE
18501  * - \ref SCIP_STAGE_PRESOLVING
18502  * - \ref SCIP_STAGE_EXITPRESOLVE
18503  * - \ref SCIP_STAGE_PRESOLVED
18504  * - \ref SCIP_STAGE_INITSOLVE
18505  * - \ref SCIP_STAGE_SOLVING
18506  * - \ref SCIP_STAGE_SOLVED
18507  * - \ref SCIP_STAGE_EXITSOLVE
18508  * - \ref SCIP_STAGE_FREETRANS
18509  */
18510 extern
18512  SCIP* scip, /**< SCIP data structure */
18513  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18514  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18515  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18516  int filterpos /**< position of event filter entry returned by SCIPcatchEvent(), or -1 */
18517  );
18518 
18519 /** catches an objective value or domain change event on the given transformed variable
18520  *
18521  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18522  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18523  *
18524  * @pre This method can be called if @p scip is in one of the following stages:
18525  * - \ref SCIP_STAGE_TRANSFORMING
18526  * - \ref SCIP_STAGE_TRANSFORMED
18527  * - \ref SCIP_STAGE_INITPRESOLVE
18528  * - \ref SCIP_STAGE_PRESOLVING
18529  * - \ref SCIP_STAGE_EXITPRESOLVE
18530  * - \ref SCIP_STAGE_PRESOLVED
18531  * - \ref SCIP_STAGE_INITSOLVE
18532  * - \ref SCIP_STAGE_SOLVING
18533  * - \ref SCIP_STAGE_SOLVED
18534  * - \ref SCIP_STAGE_EXITSOLVE
18535  * - \ref SCIP_STAGE_FREETRANS
18536  */
18537 extern
18539  SCIP* scip, /**< SCIP data structure */
18540  SCIP_VAR* var, /**< transformed variable to catch event for */
18541  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18542  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18543  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18544  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18545  );
18546 
18547 /** drops an objective value or domain change event (stops to track event) on the given transformed variable
18548  *
18549  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18550  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18551  *
18552  * @pre This method can be called if @p scip is in one of the following stages:
18553  * - \ref SCIP_STAGE_TRANSFORMING
18554  * - \ref SCIP_STAGE_TRANSFORMED
18555  * - \ref SCIP_STAGE_INITPRESOLVE
18556  * - \ref SCIP_STAGE_PRESOLVING
18557  * - \ref SCIP_STAGE_EXITPRESOLVE
18558  * - \ref SCIP_STAGE_PRESOLVED
18559  * - \ref SCIP_STAGE_INITSOLVE
18560  * - \ref SCIP_STAGE_SOLVING
18561  * - \ref SCIP_STAGE_SOLVED
18562  * - \ref SCIP_STAGE_EXITSOLVE
18563  * - \ref SCIP_STAGE_FREETRANS
18564  */
18565 extern
18567  SCIP* scip, /**< SCIP data structure */
18568  SCIP_VAR* var, /**< transformed variable to drop event for */
18569  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18570  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18571  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18572  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
18573  );
18574 
18575 /** catches a row coefficient, constant, or side change event on the given row
18576  *
18577  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18578  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18579  *
18580  * @pre This method can be called if @p scip is in one of the following stages:
18581  * - \ref SCIP_STAGE_TRANSFORMING
18582  * - \ref SCIP_STAGE_TRANSFORMED
18583  * - \ref SCIP_STAGE_INITPRESOLVE
18584  * - \ref SCIP_STAGE_PRESOLVING
18585  * - \ref SCIP_STAGE_EXITPRESOLVE
18586  * - \ref SCIP_STAGE_PRESOLVED
18587  * - \ref SCIP_STAGE_INITSOLVE
18588  * - \ref SCIP_STAGE_SOLVING
18589  * - \ref SCIP_STAGE_SOLVED
18590  * - \ref SCIP_STAGE_EXITSOLVE
18591  * - \ref SCIP_STAGE_FREETRANS
18592  */
18593 extern
18595  SCIP* scip, /**< SCIP data structure */
18596  SCIP_ROW* row, /**< linear row to catch event for */
18597  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18598  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18599  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18600  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18601  );
18602 
18603 /** drops a row coefficient, constant, or side change event (stops to track event) on the given row
18604  *
18605  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18606  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18607  *
18608  * @pre This method can be called if @p scip is in one of the following stages:
18609  * - \ref SCIP_STAGE_TRANSFORMING
18610  * - \ref SCIP_STAGE_TRANSFORMED
18611  * - \ref SCIP_STAGE_INITPRESOLVE
18612  * - \ref SCIP_STAGE_PRESOLVING
18613  * - \ref SCIP_STAGE_EXITPRESOLVE
18614  * - \ref SCIP_STAGE_PRESOLVED
18615  * - \ref SCIP_STAGE_INITSOLVE
18616  * - \ref SCIP_STAGE_SOLVING
18617  * - \ref SCIP_STAGE_SOLVED
18618  * - \ref SCIP_STAGE_EXITSOLVE
18619  * - \ref SCIP_STAGE_FREETRANS
18620  */
18621 extern
18623  SCIP* scip, /**< SCIP data structure */
18624  SCIP_ROW* row, /**< linear row to drop event for */
18625  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18626  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18627  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18628  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
18629  );
18630 
18631 /**@} */
18632 
18633 
18634 
18635 
18636 /*
18637  * tree methods
18638  */
18639 
18640 /**@addtogroup PublicTreeMethods
18641  *
18642  * @{
18643  */
18644 
18645 /** gets focus node in the tree
18646  *
18647  * if we are in probing/diving mode this method returns the node in the tree where the probing/diving mode was started.
18648  *
18649  * @return the current node of the search tree
18650  *
18651  * @pre This method can be called if @p scip is in one of the following stages:
18652  * - \ref SCIP_STAGE_INITPRESOLVE
18653  * - \ref SCIP_STAGE_PRESOLVING
18654  * - \ref SCIP_STAGE_EXITPRESOLVE
18655  * - \ref SCIP_STAGE_SOLVING
18656  */
18657 extern
18659  SCIP* scip /**< SCIP data structure */
18660  );
18661 
18662 /** gets current node in the tree
18663  *
18664  * @return the current node of the search tree
18665  *
18666  * @pre This method can be called if @p scip is in one of the following stages:
18667  * - \ref SCIP_STAGE_INITPRESOLVE
18668  * - \ref SCIP_STAGE_PRESOLVING
18669  * - \ref SCIP_STAGE_EXITPRESOLVE
18670  * - \ref SCIP_STAGE_SOLVING
18671  */
18672 extern
18674  SCIP* scip /**< SCIP data structure */
18675  );
18676 
18677 /** gets depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
18678  * such that the depth includes the probing path
18679  *
18680  * @return the depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
18681  * such that the depth includes the probing path
18682  *
18683  * @pre This method can be called if SCIP is in one of the following stages:
18684  * - \ref SCIP_STAGE_TRANSFORMED
18685  * - \ref SCIP_STAGE_INITPRESOLVE
18686  * - \ref SCIP_STAGE_PRESOLVING
18687  * - \ref SCIP_STAGE_EXITPRESOLVE
18688  * - \ref SCIP_STAGE_PRESOLVED
18689  * - \ref SCIP_STAGE_INITSOLVE
18690  * - \ref SCIP_STAGE_SOLVING
18691  * - \ref SCIP_STAGE_SOLVED
18692  * - \ref SCIP_STAGE_EXITSOLVE
18693  */
18694 extern
18695 int SCIPgetDepth(
18696  SCIP* scip /**< SCIP data structure */
18697  );
18698 
18699 /** gets depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
18700  * branching tree, excluding the nodes of the probing path
18701  *
18702  * @return the depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
18703  * branching tree, excluding the nodes of the probing path
18704  *
18705  * @pre This method can be called if SCIP is in one of the following stages:
18706  * - \ref SCIP_STAGE_TRANSFORMED
18707  * - \ref SCIP_STAGE_INITPRESOLVE
18708  * - \ref SCIP_STAGE_PRESOLVING
18709  * - \ref SCIP_STAGE_EXITPRESOLVE
18710  * - \ref SCIP_STAGE_PRESOLVED
18711  * - \ref SCIP_STAGE_INITSOLVE
18712  * - \ref SCIP_STAGE_SOLVING
18713  * - \ref SCIP_STAGE_SOLVED
18714  * - \ref SCIP_STAGE_EXITSOLVE
18715  */
18716 extern
18717 int SCIPgetFocusDepth(
18718  SCIP* scip /**< SCIP data structure */
18719  );
18720 
18721 /** gets current plunging depth (successive times, a child was selected as next node)
18722  *
18723  * @return the current plunging depth (successive times, a child was selected as next node)
18724  *
18725  * @pre This method can be called if SCIP is in one of the following stages:
18726  * - \ref SCIP_STAGE_PRESOLVED
18727  * - \ref SCIP_STAGE_SOLVING
18728  */
18729 extern
18730 int SCIPgetPlungeDepth(
18731  SCIP* scip /**< SCIP data structure */
18732  );
18733 
18734 /** gets the root node of the tree
18735  *
18736  * @return the root node of the search tree
18737  *
18738  * @pre This method can be called if @p scip is in one of the following stages:
18739  * - \ref SCIP_STAGE_INITPRESOLVE
18740  * - \ref SCIP_STAGE_PRESOLVING
18741  * - \ref SCIP_STAGE_EXITPRESOLVE
18742  * - \ref SCIP_STAGE_SOLVING
18743  */
18744 extern
18746  SCIP* scip /**< SCIP data structure */
18747  );
18748 
18749 /** gets the effective root depth, i.e., the depth of the deepest node which is part of all paths from the root node
18750  * to the unprocessed nodes.
18751  *
18752  * @return effective root depth
18753  *
18754  * @pre This method can be called if @p scip is in one of the following stages:
18755  * - \ref SCIP_STAGE_SOLVING
18756  */
18757 extern
18759  SCIP* scip /**< SCIP data structure */
18760  );
18761 
18762 /** returns whether the current node is already solved and only propagated again
18763  *
18764  * @return TRUE is returned if \SCIP performance repropagation, otherwise FALSE.
18765  *
18766  * @pre This method can be called if @p scip is in one of the following stages:
18767  * - \ref SCIP_STAGE_INITPRESOLVE
18768  * - \ref SCIP_STAGE_PRESOLVING
18769  * - \ref SCIP_STAGE_EXITPRESOLVE
18770  * - \ref SCIP_STAGE_SOLVING
18771  */
18772 extern
18774  SCIP* scip /**< SCIP data structure */
18775  );
18776 
18777 /** gets children of focus node along with the number of children
18778  *
18779  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18780  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18781  *
18782  * @pre This method can be called if @p scip is in one of the following stages:
18783  * - \ref SCIP_STAGE_SOLVING
18784  */
18785 extern
18787  SCIP* scip, /**< SCIP data structure */
18788  SCIP_NODE*** children, /**< pointer to store children array, or NULL if not needed */
18789  int* nchildren /**< pointer to store number of children, or NULL if not needed */
18790  );
18791 
18792 /** gets number of children of focus node
18793  *
18794  * @return number of children of the focus node
18795  *
18796  * @pre This method can be called if @p scip is in one of the following stages:
18797  * - \ref SCIP_STAGE_SOLVING
18798  */
18799 extern
18800 int SCIPgetNChildren(
18801  SCIP* scip /**< SCIP data structure */
18802  );
18803 
18804 /** gets siblings of focus node along with the number of siblings
18805  *
18806  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18807  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18808  *
18809  * @pre This method can be called if @p scip is in one of the following stages:
18810  * - \ref SCIP_STAGE_SOLVING
18811  */
18812 extern
18814  SCIP* scip, /**< SCIP data structure */
18815  SCIP_NODE*** siblings, /**< pointer to store siblings array, or NULL if not needed */
18816  int* nsiblings /**< pointer to store number of siblings, or NULL if not needed */
18817  );
18818 
18819 /** gets number of siblings of focus node
18820  *
18821  * @return the number of siblings of focus node
18822  *
18823  * @pre This method can be called if @p scip is in one of the following stages:
18824  * - \ref SCIP_STAGE_SOLVING
18825  */
18826 extern
18827 int SCIPgetNSiblings(
18828  SCIP* scip /**< SCIP data structure */
18829  );
18830 
18831 /** gets leaves of the tree along with the number of leaves
18832  *
18833  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18834  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18835  *
18836  * @pre This method can be called if @p scip is in one of the following stages:
18837  * - \ref SCIP_STAGE_SOLVING
18838  */
18839 extern
18841  SCIP* scip, /**< SCIP data structure */
18842  SCIP_NODE*** leaves, /**< pointer to store leaves array, or NULL if not needed */
18843  int* nleaves /**< pointer to store number of leaves, or NULL if not needed */
18844  );
18845 
18846 /** gets number of leaves in the tree
18847  *
18848  * @return the number of leaves in the tree
18849  *
18850  * @pre This method can be called if @p scip is in one of the following stages:
18851  * - \ref SCIP_STAGE_SOLVING
18852  */
18853 extern
18854 int SCIPgetNLeaves(
18855  SCIP* scip /**< SCIP data structure */
18856  );
18857 
18858 /** gets number of nodes left in the tree (children + siblings + leaves)
18859  *
18860  * @return the number of nodes left in the tree (children + siblings + leaves)
18861  *
18862  * @pre This method can be called if SCIP is in one of the following stages:
18863  * - \ref SCIP_STAGE_PRESOLVED
18864  * - \ref SCIP_STAGE_SOLVING
18865  * - \ref SCIP_STAGE_SOLVED
18866  */
18867 extern
18868 int SCIPgetNNodesLeft(
18869  SCIP* scip /**< SCIP data structure */
18870  );
18871 
18872 /** gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
18873  *
18874  * @return the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
18875  *
18876  * @pre This method can be called if @p scip is in one of the following stages:
18877  * - \ref SCIP_STAGE_SOLVING
18878  */
18879 extern
18881  SCIP* scip /**< SCIP data structure */
18882  );
18883 
18884 /** gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
18885  *
18886  * @return the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
18887  *
18888  * @pre This method can be called if @p scip is in one of the following stages:
18889  * - \ref SCIP_STAGE_SOLVING
18890  */
18891 extern
18893  SCIP* scip /**< SCIP data structure */
18894  );
18895 
18896 /** gets the best child of the focus node w.r.t. the node selection strategy
18897  *
18898  * @return the best child of the focus node w.r.t. the node selection strategy
18899  *
18900  * @pre This method can be called if @p scip is in one of the following stages:
18901  * - \ref SCIP_STAGE_SOLVING
18902  */
18903 extern
18905  SCIP* scip /**< SCIP data structure */
18906  );
18907 
18908 /** gets the best sibling of the focus node w.r.t. the node selection strategy
18909  *
18910  * @return the best sibling of the focus node w.r.t. the node selection strategy
18911  *
18912  * @pre This method can be called if @p scip is in one of the following stages:
18913  * - \ref SCIP_STAGE_SOLVING
18914  */
18915 extern
18917  SCIP* scip /**< SCIP data structure */
18918  );
18919 
18920 /** gets the best leaf from the node queue w.r.t. the node selection strategy
18921  *
18922  * @return the best leaf from the node queue w.r.t. the node selection strategy
18923  *
18924  * @pre This method can be called if @p scip is in one of the following stages:
18925  * - \ref SCIP_STAGE_SOLVING
18926  */
18927 extern
18929  SCIP* scip /**< SCIP data structure */
18930  );
18931 
18932 /** gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
18933  *
18934  * @return the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
18935  *
18936  * @pre This method can be called if @p scip is in one of the following stages:
18937  * - \ref SCIP_STAGE_SOLVING
18938  */
18939 extern
18941  SCIP* scip /**< SCIP data structure */
18942  );
18943 
18944 /** gets the node with smallest lower bound from the tree (child, sibling, or leaf)
18945  *
18946  * @return the node with smallest lower bound from the tree (child, sibling, or leaf)
18947  *
18948  * @pre This method can be called if @p scip is in one of the following stages:
18949  * - \ref SCIP_STAGE_SOLVING
18950  */
18951 extern
18953  SCIP* scip /**< SCIP data structure */
18954  );
18955 
18956 /** access to all data of open nodes (leaves, children, and siblings)
18957  *
18958  * @pre This method can be called if @p scip is in one of the following stages:
18959  * - \ref SCIP_STAGE_SOLVING
18960  */
18961 extern
18963  SCIP* scip, /**< SCIP data structure */
18964  SCIP_NODE*** leaves, /**< pointer to store the leaves, or NULL if not needed */
18965  SCIP_NODE*** children, /**< pointer to store the children, or NULL if not needed */
18966  SCIP_NODE*** siblings, /**< pointer to store the siblings, or NULL if not needed */
18967  int* nleaves, /**< pointer to store the number of leaves, or NULL */
18968  int* nchildren, /**< pointer to store the number of children, or NULL */
18969  int* nsiblings /**< pointer to store the number of siblings, or NULL */
18970  );
18971 
18972 /** cuts off node and whole sub tree from branch and bound tree
18973  *
18974  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18975  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18976  *
18977  * @pre This method can be called if @p scip is in one of the following stages:
18978  * - \ref SCIP_STAGE_SOLVING
18979  */
18980 extern
18982  SCIP* scip, /**< SCIP data structure */
18983  SCIP_NODE* node /**< node that should be cut off */
18984  );
18985 
18986 /** marks the given node to be propagated again the next time a node of its subtree is processed
18987  *
18988  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18989  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18990  *
18991  * @pre This method can be called if @p scip is in one of the following stages:
18992  * - \ref SCIP_STAGE_SOLVING
18993  */
18994 extern
18996  SCIP* scip, /**< SCIP data structure */
18997  SCIP_NODE* node /**< node that should be propagated again */
18998  );
18999 
19000 /** returns depth of first node in active path that is marked being cutoff
19001  *
19002  * @return depth of first node in active path that is marked being cutoff
19003  *
19004  * @pre This method can be called if @p scip is in one of the following stages:
19005  * - \ref SCIP_STAGE_SOLVING
19006  */
19007 extern
19008 int SCIPgetCutoffdepth(
19009  SCIP* scip /**< SCIP data structure */
19010  );
19011 
19012 /** returns depth of first node in active path that has to be propagated again
19013  *
19014  * @return depth of first node in active path that has to be propagated again
19015  *
19016  * @pre This method can be called if @p scip is in one of the following stages:
19017  * - \ref SCIP_STAGE_SOLVING
19018  */
19019 extern
19020 int SCIPgetRepropdepth(
19021  SCIP* scip /**< SCIP data structure */
19022  );
19023 
19024 /** prints all branching decisions on variables from the root to the given node
19025  *
19026  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19027  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19028  *
19029  * @pre This method can be called if @p scip is in one of the following stages:
19030  * - \ref SCIP_STAGE_SOLVING
19031  */
19032 extern
19034  SCIP* scip, /**< SCIP data structure */
19035  SCIP_NODE* node, /**< node data */
19036  FILE* file /**< output file (or NULL for standard output) */
19037  );
19038 
19039 /** sets whether the LP should be solved at the focus node
19040  *
19041  * @note In order to have an effect, this method needs to be called after a node is focused but before the LP is
19042  * solved.
19043  *
19044  * @pre This method can be called if @p scip is in one of the following stages:
19045  * - \ref SCIP_STAGE_SOLVING
19046  */
19047 extern
19048 void SCIPsetFocusnodeLP(
19049  SCIP* scip, /**< SCIP data structure */
19050  SCIP_Bool solvelp /**< should the LP be solved? */
19051  );
19052 
19053 /**@} */
19054 
19055 
19056 /*
19057  * parallel interface methods
19058  */
19059 
19060 /**@addtogroup PublicParallelMethods
19061  *
19062  * @{
19063  */
19064 
19065 /** Constructs the parallel interface to execute processes concurrently.
19066  *
19067  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19068  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19069  *
19070  * @pre This method can be called if @p scip is in one of the following stages:
19071  * - \ref SCIP_STAGE_PROBLEM
19072  * - \ref SCIP_STAGE_TRANSFORMING
19073  * - \ref SCIP_STAGE_TRANSFORMED
19074  * - \ref SCIP_STAGE_INITPRESOLVE
19075  * - \ref SCIP_STAGE_PRESOLVING
19076  * - \ref SCIP_STAGE_EXITPRESOLVE
19077  * - \ref SCIP_STAGE_PRESOLVED
19078  * - \ref SCIP_STAGE_INITSOLVE
19079  * - \ref SCIP_STAGE_SOLVING
19080  * - \ref SCIP_STAGE_SOLVED
19081  * - \ref SCIP_STAGE_EXITSOLVE
19082  * - \ref SCIP_STAGE_FREETRANS
19083  *
19084  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19085  */
19086 extern
19088  SCIP* scip /**< SCIP data structure */
19089  );
19090 
19091 /** releases the current synchronization store
19092  *
19093  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19094  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19095  *
19096  * @pre This method can be called if @p scip is in one of the following stages:
19097  * - \ref SCIP_STAGE_PROBLEM
19098  * - \ref SCIP_STAGE_TRANSFORMING
19099  * - \ref SCIP_STAGE_TRANSFORMED
19100  * - \ref SCIP_STAGE_INITPRESOLVE
19101  * - \ref SCIP_STAGE_PRESOLVING
19102  * - \ref SCIP_STAGE_EXITPRESOLVE
19103  * - \ref SCIP_STAGE_PRESOLVED
19104  * - \ref SCIP_STAGE_INITSOLVE
19105  * - \ref SCIP_STAGE_SOLVING
19106  * - \ref SCIP_STAGE_SOLVED
19107  * - \ref SCIP_STAGE_EXITSOLVE
19108  * - \ref SCIP_STAGE_FREETRANS
19109  * - \ref SCIP_STAGE_FREE
19110  *
19111  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19112  */
19114  SCIP* scip /**< SCIP data structure */
19115  );
19116 
19117 /** Gets the synchronization store.
19118  *
19119  * @return the \ref SCIP_SYNCSTORE parallel interface pointer to submit jobs for concurrent processing.
19120  *
19121  * @pre This method can be called if @p scip is in one of the following stages:
19122  * - \ref SCIP_STAGE_INIT
19123  * - \ref SCIP_STAGE_PROBLEM
19124  * - \ref SCIP_STAGE_TRANSFORMING
19125  * - \ref SCIP_STAGE_TRANSFORMED
19126  * - \ref SCIP_STAGE_INITPRESOLVE
19127  * - \ref SCIP_STAGE_PRESOLVING
19128  * - \ref SCIP_STAGE_EXITPRESOLVE
19129  * - \ref SCIP_STAGE_PRESOLVED
19130  * - \ref SCIP_STAGE_INITSOLVE
19131  * - \ref SCIP_STAGE_SOLVING
19132  * - \ref SCIP_STAGE_SOLVED
19133  * - \ref SCIP_STAGE_EXITSOLVE
19134  * - \ref SCIP_STAGE_FREETRANS
19135  *
19136  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19137  */
19138 extern
19140  SCIP* scip /**< SCIP data structure */
19141  );
19142 
19143 /**@} */
19144 
19145 
19146 
19147 /*
19148  * reoptimization methods
19149  */
19150 
19151 /**@addtogroup PublicReoptimizationMethods
19152  *
19153  * @{
19154  */
19155 
19156 /** return the ids of child nodes stored in the reoptimization tree
19157  *
19158  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19159  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19160  *
19161  * @pre This method can be called if @p scip is in one of the following stages:
19162  * - \ref SCIP_STAGE_PRESOLVED
19163  * - \ref SCIP_STAGE_SOLVING
19164  * - \ref SCIP_STAGE_SOLVED
19165  */
19166 extern
19168  SCIP* scip, /**< SCIP data structure */
19169  SCIP_NODE* node, /**< node of the search tree */
19170  unsigned int* ids, /**< array to store the ids of child nodes */
19171  int mem, /**< allocated memory */
19172  int* nids /**< number of child nodes */
19173  );
19174 
19175 /** return the ids of all leave nodes store in the reoptimization tree induced by the given node
19176  *
19177  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19178  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19179  *
19180  * @pre This method can be called if @p scip is in one of the following stages:
19181  * - \ref SCIP_STAGE_PRESOLVED
19182  * - \ref SCIP_STAGE_SOLVING
19183  * - \ref SCIP_STAGE_SOLVED
19184  */
19185 extern
19187  SCIP* scip, /**< SCIP data strcuture */
19188  SCIP_NODE* node, /**< node of the search tree */
19189  unsigned int* ids, /**< array of ids */
19190  int mem, /**< allocated memory */
19191  int* nids /**< number of child nodes */
19192  );
19193 
19194 /** returns the number of nodes in the reoptimization tree induced by @p node; if @p node == NULL, the method
19195  * returns the number of nodes of the whole reoptimization tree.
19196  */
19197 extern
19198 int SCIPgetNReoptnodes(
19199  SCIP* scip, /**< SCIP data structure */
19200  SCIP_NODE* node /**< node of the search tree */
19201  );
19202 
19203 /** returns the number of leave nodes of the subtree induced by @p node; if @p node == NULL, the method
19204  * returns the number of leaf nodes of the whole reoptimization tree.
19205  */
19206 extern
19208  SCIP* scip, /**< SCIP data structure */
19209  SCIP_NODE* node /**< node of the search tree */
19210  );
19211 
19212 /** gets the node of the reoptimization tree corresponding to the unique @p id */
19214  SCIP* scip, /**< SCIP data structure */
19215  unsigned int id /**< unique id */
19216  );
19217 
19218 /** add a variable bound change to a given reoptnode
19219  *
19220  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19221  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19222  *
19223  * @pre This method can be called if @p scip is in one of the following stages:
19224  * - \ref SCIP_STAGE_PRESOLVED
19225  * - \ref SCIP_STAGE_SOLVING
19226  * - \ref SCIP_STAGE_SOLVED
19227  */
19228 extern
19230  SCIP* scip, /**< SCIP data structure */
19231  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
19232  SCIP_VAR* var, /**< variable pointer */
19233  SCIP_Real bound, /**< variable bound to add */
19234  SCIP_BOUNDTYPE boundtype /**< bound type of the variable value */
19235  );
19236 
19237 /** set the @p representation as the new search frontier
19238  *
19239  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19240  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19241  *
19242  * @pre This method can be called if @p scip is in one of the following stages:
19243  * - \ref SCIP_STAGE_PRESOLVED
19244  */
19245 extern
19247  SCIP* scip, /**< SCIP data structure */
19248  SCIP_REOPTNODE** representation, /**< array of representatives */
19249  int nrepresentatives, /**< number of representatives */
19250  SCIP_Bool* success /**< pointer to store the result */
19251  );
19252 
19253 /** add stored constraint to a reoptimization node
19254  *
19255  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19256  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19257  *
19258  * @pre This method can be called if @p scip is in one of the following stages:
19259  * - \ref SCIP_STAGE_PRESOLVED
19260  */
19261 extern
19263  SCIP* scip, /**< SCIP data structure */
19264  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
19265  SCIP_VAR** vars, /**< array of variables */
19266  SCIP_Real* vals, /**< array of variable bounds */
19267  SCIP_BOUNDTYPE* boundtypes, /**< array of variable boundtypes */
19268  SCIP_Real lhs, /**< lhs of the constraint */
19269  SCIP_Real rhs, /**< rhs of the constraint */
19270  int nvars, /**< number of variables */
19271  REOPT_CONSTYPE constype, /**< type of the constraint */
19272  SCIP_Bool linear /**< the given constraint has a linear representation */
19273  );
19274 
19275 /** return the branching path stored in the reoptree at ID id */
19276 extern
19278  SCIP* scip, /**< SCIP data structure */
19279  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
19280  SCIP_VAR** vars, /**< array of variables */
19281  SCIP_Real* vals, /**< array of variable bounds */
19282  SCIP_BOUNDTYPE* boundtypes, /**< array of bound types */
19283  int mem, /**< allocated memory */
19284  int* nvars, /**< number of variables */
19285  int* nafterdualvars /**< number of variables directly after the first based on dual information */
19286  );
19287 
19288 /** initialize a set of empty reoptimization nodes
19289  *
19290  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19291  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19292  *
19293  * @pre This method can be called if @p scip is in one of the following stages:
19294  * - \ref SCIP_STAGE_PRESOLVED
19295  */
19296 extern
19298  SCIP* scip, /**< SCIP data structure */
19299  SCIP_REOPTNODE** representatives, /**< array of representatives */
19300  int nrepresentatives /**< number of representatives */
19301  );
19302 
19303 /** reset a set of initialized reoptimization nodes
19304  *
19305  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19306  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19307  *
19308  * @pre This method can be called if @p scip is in one of the following stages:
19309  * - \ref SCIP_STAGE_PRESOLVED
19310  */
19312  SCIP* scip, /**< SCIP data structure */
19313  SCIP_REOPTNODE** representatives, /**< array of representatives */
19314  int nrepresentatives /**< number of representatives */
19315  );
19316 
19317 /** free a set of initialized reoptimization nodes
19318  *
19319  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19320  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19321  *
19322  * @pre This method can be called if @p scip is in one of the following stages:
19323  * - \ref SCIP_STAGE_PRESOLVED
19324  */
19325 extern
19327  SCIP* scip, /**< SCIP data structure */
19328  SCIP_REOPTNODE** representatives, /**< array of representatives */
19329  int nrepresentatives /**< number of representatives */
19330  );
19331 
19332 /** reactivate the given @p reoptnode and split them into several nodes if necessary
19333  *
19334  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19335  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19336  *
19337  * @pre This method can be called if @p scip is in one of the following stages:
19338  * - \ref SCIP_STAGE_SOLVING
19339  * - \ref SCIP_STAGE_SOLVED
19340  */
19341 extern
19343  SCIP* scip, /**< SCIP data structure */
19344  SCIP_REOPTNODE* reoptnode, /**< node to reactivate */
19345  unsigned int id, /**< unique id of the reoptimization node */
19346  SCIP_Real estimate, /**< estimate of the child nodes that should be created */
19347  SCIP_NODE** childnodes, /**< array to store the created child nodes */
19348  int* ncreatedchilds, /**< pointer to store number of created child nodes */
19349  int* naddedconss, /**< pointer to store number of generated constraints */
19350  int childnodessize, /**< available size of childnodes array */
19351  SCIP_Bool* success /**< pointer store the result*/
19352  );
19353 
19354 /** remove the stored information about bound changes based in dual information
19355  *
19356  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19357  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19358  *
19359  * @pre This method can be called if @p scip is in one of the following stages:
19360  * - \ref SCIP_STAGE_SOLVING
19361  * - \ref SCIP_STAGE_SOLVED
19362  */
19363 extern
19365  SCIP* scip, /**< SCIP data structure */
19366  SCIP_NODE* node /**< node of the search tree */
19367  );
19368 
19369 /** splits the root into several nodes and moves the child nodes of the root to one of the created nodes
19370  *
19371  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19372  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19373  *
19374  * @pre This method can be called if @p scip is in one of the following stages:
19375  * - \ref SCIP_STAGE_TRANSFORMED
19376  * - \ref SCIP_STAGE_SOLVING
19377  */
19378 extern
19380  SCIP* scip, /**< SCIP data structure */
19381  int* ncreatedchilds, /**< pointer to store the number of created nodes */
19382  int* naddedconss /**< pointer to store the number added constraints */
19383  );
19384 
19385 /** returns if a node should be reoptimized */
19386 extern
19388  SCIP* scip, /**< SCIP data structure */
19389  SCIP_NODE* node /**< node of the search tree */
19390  );
19391 
19392 /** deletes the given reoptimization node
19393  *
19394  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19395  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19396  *
19397  * @pre This method can be called if @p scip is in one of the following stages:
19398  * - \ref SCIP_STAGE_SOLVING
19399  */
19400 extern
19402  SCIP* scip, /**< SCIP data structure */
19403  SCIP_REOPTNODE** reoptnode /**< node of the reoptimization tree */
19404  );
19405 
19406 /** return the similarity between two objective functions */
19407 extern
19409  SCIP* scip, /**< SCIP data structure */
19410  int run1, /**< number of run */
19411  int run2 /**< number of run */
19412  );
19413 
19414 /** check the changes of the variable coefficient in the objective function */
19415 extern
19416 void SCIPgetVarCoefChg(
19417  SCIP* scip, /**< SCIP data structure */
19418  int varidx, /**< index of variable */
19419  SCIP_Bool* negated, /**< coefficient changed the sign */
19420  SCIP_Bool* entering, /**< coefficient gets non-zero coefficient */
19421  SCIP_Bool* leaving /**< coefficient gets zero coefficient */
19422  );
19423 
19424 /* @} */
19425 
19426 /*
19427  * statistic methods
19428  */
19429 
19430 /**@addtogroup PublicSolvingStatsMethods
19431  *
19432  * @{
19433  */
19434 
19435 /** gets number of branch and bound runs performed, including the current run
19436  *
19437  * @return the number of branch and bound runs performed, including the current run
19438  *
19439  * @pre This method can be called if SCIP is in one of the following stages:
19440  * - \ref SCIP_STAGE_PROBLEM
19441  * - \ref SCIP_STAGE_TRANSFORMING
19442  * - \ref SCIP_STAGE_TRANSFORMED
19443  * - \ref SCIP_STAGE_INITPRESOLVE
19444  * - \ref SCIP_STAGE_PRESOLVING
19445  * - \ref SCIP_STAGE_EXITPRESOLVE
19446  * - \ref SCIP_STAGE_PRESOLVED
19447  * - \ref SCIP_STAGE_INITSOLVE
19448  * - \ref SCIP_STAGE_SOLVING
19449  * - \ref SCIP_STAGE_SOLVED
19450  * - \ref SCIP_STAGE_EXITSOLVE
19451  * - \ref SCIP_STAGE_FREETRANS
19452  */
19453 extern
19454 int SCIPgetNRuns(
19455  SCIP* scip /**< SCIP data structure */
19456  );
19457 
19458 /** gets number of reoptimization runs performed, including the current run
19459  *
19460  * @return the number of reoptimization runs performed, including the current run
19461  *
19462  * @pre This method can be called if SCIP is in one of the following stages:
19463  * - \ref SCIP_STAGE_PROBLEM
19464  * - \ref SCIP_STAGE_TRANSFORMING
19465  * - \ref SCIP_STAGE_TRANSFORMED
19466  * - \ref SCIP_STAGE_INITPRESOLVE
19467  * - \ref SCIP_STAGE_PRESOLVING
19468  * - \ref SCIP_STAGE_EXITPRESOLVE
19469  * - \ref SCIP_STAGE_PRESOLVED
19470  * - \ref SCIP_STAGE_INITSOLVE
19471  * - \ref SCIP_STAGE_SOLVING
19472  * - \ref SCIP_STAGE_SOLVED
19473  * - \ref SCIP_STAGE_EXITSOLVE
19474  * - \ref SCIP_STAGE_FREETRANS
19475  */
19476 extern
19477 int SCIPgetNReoptRuns(
19478  SCIP* scip /**< SCIP data structure */
19479  );
19480 
19481 /** add given number to the number of processed nodes in current run and in all runs, including the focus node
19482  *
19483  * @return the number of processed nodes in current run, including the focus node
19484  *
19485  * @pre This method can be called if SCIP is in one of the following stages:
19486  * - \ref SCIP_STAGE_PROBLEM
19487  * - \ref SCIP_STAGE_TRANSFORMING
19488  * - \ref SCIP_STAGE_TRANSFORMED
19489  * - \ref SCIP_STAGE_INITPRESOLVE
19490  * - \ref SCIP_STAGE_PRESOLVING
19491  * - \ref SCIP_STAGE_EXITPRESOLVE
19492  * - \ref SCIP_STAGE_PRESOLVED
19493  * - \ref SCIP_STAGE_INITSOLVE
19494  * - \ref SCIP_STAGE_SOLVING
19495  * - \ref SCIP_STAGE_SOLVED
19496  * - \ref SCIP_STAGE_EXITSOLVE
19497  * - \ref SCIP_STAGE_FREETRANS
19498  */
19499 extern
19500 void SCIPaddNNodes(
19501  SCIP* scip, /**< SCIP data structure */
19502  SCIP_Longint nnodes /**< number of processed nodes to add to the statistics */
19503  );
19504 
19505 /** gets number of processed nodes in current run, including the focus node
19506  *
19507  * @return the number of processed nodes in current run, including the focus node
19508  *
19509  * @pre This method can be called if SCIP is in one of the following stages:
19510  * - \ref SCIP_STAGE_PROBLEM
19511  * - \ref SCIP_STAGE_TRANSFORMING
19512  * - \ref SCIP_STAGE_TRANSFORMED
19513  * - \ref SCIP_STAGE_INITPRESOLVE
19514  * - \ref SCIP_STAGE_PRESOLVING
19515  * - \ref SCIP_STAGE_EXITPRESOLVE
19516  * - \ref SCIP_STAGE_PRESOLVED
19517  * - \ref SCIP_STAGE_INITSOLVE
19518  * - \ref SCIP_STAGE_SOLVING
19519  * - \ref SCIP_STAGE_SOLVED
19520  * - \ref SCIP_STAGE_EXITSOLVE
19521  * - \ref SCIP_STAGE_FREETRANS
19522  */
19523 extern
19525  SCIP* scip /**< SCIP data structure */
19526  );
19527 
19528 /** gets total number of processed nodes in all runs, including the focus node
19529  *
19530  * @return the total number of processed nodes in all runs, including the focus node
19531  *
19532  * @pre This method can be called if SCIP is in one of the following stages:
19533  * - \ref SCIP_STAGE_PROBLEM
19534  * - \ref SCIP_STAGE_TRANSFORMING
19535  * - \ref SCIP_STAGE_TRANSFORMED
19536  * - \ref SCIP_STAGE_INITPRESOLVE
19537  * - \ref SCIP_STAGE_PRESOLVING
19538  * - \ref SCIP_STAGE_EXITPRESOLVE
19539  * - \ref SCIP_STAGE_PRESOLVED
19540  * - \ref SCIP_STAGE_INITSOLVE
19541  * - \ref SCIP_STAGE_SOLVING
19542  * - \ref SCIP_STAGE_SOLVED
19543  * - \ref SCIP_STAGE_EXITSOLVE
19544  * - \ref SCIP_STAGE_FREETRANS
19545  */
19546 extern
19548  SCIP* scip /**< SCIP data structure */
19549  );
19550 
19551 /** gets number of leaf nodes processed with feasible relaxation solution
19552  *
19553  * @return number of leaf nodes processed with feasible relaxation solution
19554  *
19555  * @pre This method can be called if SCIP is in one of the following stages:
19556  * - \ref SCIP_STAGE_PROBLEM
19557  * - \ref SCIP_STAGE_TRANSFORMING
19558  * - \ref SCIP_STAGE_TRANSFORMED
19559  * - \ref SCIP_STAGE_INITPRESOLVE
19560  * - \ref SCIP_STAGE_PRESOLVING
19561  * - \ref SCIP_STAGE_EXITPRESOLVE
19562  * - \ref SCIP_STAGE_PRESOLVED
19563  * - \ref SCIP_STAGE_INITSOLVE
19564  * - \ref SCIP_STAGE_SOLVING
19565  * - \ref SCIP_STAGE_SOLVED
19566  * - \ref SCIP_STAGE_EXITSOLVE
19567  * - \ref SCIP_STAGE_FREETRANS
19568  */
19569 extern
19571  SCIP* scip /**< SCIP data structure */
19572  );
19573 
19574 /** gets number of infeasible leaf nodes processed
19575  *
19576  * @return number of infeasible leaf nodes processed
19577  *
19578  * @pre This method can be called if SCIP is in one of the following stages:
19579  * - \ref SCIP_STAGE_PROBLEM
19580  * - \ref SCIP_STAGE_TRANSFORMING
19581  * - \ref SCIP_STAGE_TRANSFORMED
19582  * - \ref SCIP_STAGE_INITPRESOLVE
19583  * - \ref SCIP_STAGE_PRESOLVING
19584  * - \ref SCIP_STAGE_EXITPRESOLVE
19585  * - \ref SCIP_STAGE_PRESOLVED
19586  * - \ref SCIP_STAGE_INITSOLVE
19587  * - \ref SCIP_STAGE_SOLVING
19588  * - \ref SCIP_STAGE_SOLVED
19589  * - \ref SCIP_STAGE_EXITSOLVE
19590  * - \ref SCIP_STAGE_FREETRANS
19591  */
19592 extern
19594  SCIP* scip /**< SCIP data structure */
19595  );
19596 
19597 /** gets number of processed leaf nodes that hit LP objective limit
19598  *
19599  * @return number of processed leaf nodes that hit LP objective limit
19600  *
19601  * @pre This method can be called if SCIP is in one of the following stages:
19602  * - \ref SCIP_STAGE_PROBLEM
19603  * - \ref SCIP_STAGE_TRANSFORMING
19604  * - \ref SCIP_STAGE_TRANSFORMED
19605  * - \ref SCIP_STAGE_INITPRESOLVE
19606  * - \ref SCIP_STAGE_PRESOLVING
19607  * - \ref SCIP_STAGE_EXITPRESOLVE
19608  * - \ref SCIP_STAGE_PRESOLVED
19609  * - \ref SCIP_STAGE_INITSOLVE
19610  * - \ref SCIP_STAGE_SOLVING
19611  * - \ref SCIP_STAGE_SOLVED
19612  * - \ref SCIP_STAGE_EXITSOLVE
19613  * - \ref SCIP_STAGE_FREETRANS
19614  */
19615 extern
19617  SCIP* scip /**< SCIP data structure */
19618  );
19619 
19620 /** gets number of times a selected node was from a cut off subtree
19621  *
19622  * @return number of times a selected node was from a cut off subtree
19623  *
19624  * @pre This method can be called if SCIP is in one of the following stages:
19625  * - \ref SCIP_STAGE_PROBLEM
19626  * - \ref SCIP_STAGE_TRANSFORMING
19627  * - \ref SCIP_STAGE_TRANSFORMED
19628  * - \ref SCIP_STAGE_INITPRESOLVE
19629  * - \ref SCIP_STAGE_PRESOLVING
19630  * - \ref SCIP_STAGE_EXITPRESOLVE
19631  * - \ref SCIP_STAGE_PRESOLVED
19632  * - \ref SCIP_STAGE_INITSOLVE
19633  * - \ref SCIP_STAGE_SOLVING
19634  * - \ref SCIP_STAGE_SOLVED
19635  * - \ref SCIP_STAGE_EXITSOLVE
19636  * - \ref SCIP_STAGE_FREETRANS
19637  */
19638 extern
19640  SCIP* scip /**< SCIP data structure */
19641  );
19642 
19643 /** gets total number of LPs solved so far
19644  *
19645  * @return the total number of LPs solved so far
19646  *
19647  * @pre This method can be called if SCIP is in one of the following stages:
19648  * - \ref SCIP_STAGE_PROBLEM
19649  * - \ref SCIP_STAGE_TRANSFORMING
19650  * - \ref SCIP_STAGE_TRANSFORMED
19651  * - \ref SCIP_STAGE_INITPRESOLVE
19652  * - \ref SCIP_STAGE_PRESOLVING
19653  * - \ref SCIP_STAGE_EXITPRESOLVE
19654  * - \ref SCIP_STAGE_PRESOLVED
19655  * - \ref SCIP_STAGE_INITSOLVE
19656  * - \ref SCIP_STAGE_SOLVING
19657  * - \ref SCIP_STAGE_SOLVED
19658  * - \ref SCIP_STAGE_EXITSOLVE
19659  * - \ref SCIP_STAGE_FREETRANS
19660  */
19661 extern
19663  SCIP* scip /**< SCIP data structure */
19664  );
19665 
19666 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
19667  *
19668  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
19669  *
19670  * @pre This method can be called if SCIP is in one of the following stages:
19671  * - \ref SCIP_STAGE_PRESOLVING
19672  * - \ref SCIP_STAGE_PRESOLVED
19673  * - \ref SCIP_STAGE_SOLVING
19674  * - \ref SCIP_STAGE_SOLVED
19675  */
19676 extern
19678  SCIP* scip /**< SCIP data structure */
19679  );
19680 
19681 /** gets number of active non-zeros in the current transformed problem
19682  *
19683  * @return the number of active non-zeros in the current transformed problem
19684  *
19685  * @pre This method can be called if SCIP is in one of the following stages:
19686  * - \ref SCIP_STAGE_PROBLEM
19687  * - \ref SCIP_STAGE_TRANSFORMING
19688  * - \ref SCIP_STAGE_TRANSFORMED
19689  * - \ref SCIP_STAGE_INITPRESOLVE
19690  * - \ref SCIP_STAGE_PRESOLVING
19691  * - \ref SCIP_STAGE_EXITPRESOLVE
19692  * - \ref SCIP_STAGE_PRESOLVED
19693  * - \ref SCIP_STAGE_INITSOLVE
19694  * - \ref SCIP_STAGE_SOLVING
19695  * - \ref SCIP_STAGE_SOLVED
19696  * - \ref SCIP_STAGE_EXITSOLVE
19697  */
19698 extern
19700  SCIP* scip /**< SCIP data structure */
19701  );
19702 
19703 
19704 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
19705  *
19706  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
19707  *
19708  * @pre This method can be called if SCIP is in one of the following stages:
19709  * - \ref SCIP_STAGE_PRESOLVED
19710  * - \ref SCIP_STAGE_SOLVING
19711  * - \ref SCIP_STAGE_SOLVED
19712  */
19713 extern
19715  SCIP* scip /**< SCIP data structure */
19716  );
19717 
19718 /** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
19719  * node
19720  *
19721  * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
19722  *
19723  * @pre This method can be called if SCIP is in one of the following stages:
19724  * - \ref SCIP_STAGE_PRESOLVED
19725  * - \ref SCIP_STAGE_SOLVING
19726  * - \ref SCIP_STAGE_SOLVED
19727  */
19728 extern
19730  SCIP* scip /**< SCIP data structure */
19731  );
19732 
19733 /** gets total number of primal LPs solved so far
19734  *
19735  * @return the total number of primal LPs solved so far
19736  *
19737  * @pre This method can be called if SCIP is in one of the following stages:
19738  * - \ref SCIP_STAGE_PRESOLVED
19739  * - \ref SCIP_STAGE_SOLVING
19740  * - \ref SCIP_STAGE_SOLVED
19741  */
19742 extern
19744  SCIP* scip /**< SCIP data structure */
19745  );
19746 
19747 /** gets total number of iterations used so far in primal simplex
19748  *
19749  * @return total number of iterations used so far in primal simplex
19750  *
19751  * @pre This method can be called if SCIP is in one of the following stages:
19752  * - \ref SCIP_STAGE_PRESOLVED
19753  * - \ref SCIP_STAGE_SOLVING
19754  * - \ref SCIP_STAGE_SOLVED
19755  */
19756 extern
19758  SCIP* scip /**< SCIP data structure */
19759  );
19760 
19761 /** gets total number of dual LPs solved so far
19762  *
19763  * @return the total number of dual LPs solved so far
19764  *
19765  * @pre This method can be called if SCIP is in one of the following stages:
19766  * - \ref SCIP_STAGE_PRESOLVED
19767  * - \ref SCIP_STAGE_SOLVING
19768  * - \ref SCIP_STAGE_SOLVED
19769  */
19770 extern
19772  SCIP* scip /**< SCIP data structure */
19773  );
19774 
19775 /** gets total number of iterations used so far in dual simplex
19776  *
19777  * @return the total number of iterations used so far in dual simplex
19778  *
19779  * @pre This method can be called if SCIP is in one of the following stages:
19780  * - \ref SCIP_STAGE_PRESOLVED
19781  * - \ref SCIP_STAGE_SOLVING
19782  * - \ref SCIP_STAGE_SOLVED
19783  */
19784 extern
19786  SCIP* scip /**< SCIP data structure */
19787  );
19788 
19789 /** gets total number of barrier LPs solved so far
19790  *
19791  * @return the total number of barrier LPs solved so far
19792  *
19793  * @pre This method can be called if SCIP is in one of the following stages:
19794  * - \ref SCIP_STAGE_PRESOLVED
19795  * - \ref SCIP_STAGE_SOLVING
19796  * - \ref SCIP_STAGE_SOLVED
19797  */
19798 extern
19800  SCIP* scip /**< SCIP data structure */
19801  );
19802 
19803 /** gets total number of iterations used so far in barrier algorithm
19804  *
19805  * @return the total number of iterations used so far in barrier algorithm
19806  *
19807  * @pre This method can be called if SCIP is in one of the following stages:
19808  * - \ref SCIP_STAGE_PRESOLVED
19809  * - \ref SCIP_STAGE_SOLVING
19810  * - \ref SCIP_STAGE_SOLVED
19811  */
19812 extern
19814  SCIP* scip /**< SCIP data structure */
19815  );
19816 
19817 /** gets total number of LPs solved so far that were resolved from an advanced start basis
19818  *
19819  * @return the total number of LPs solved so far that were resolved from an advanced start basis
19820  *
19821  * @pre This method can be called if SCIP is in one of the following stages:
19822  * - \ref SCIP_STAGE_PRESOLVED
19823  * - \ref SCIP_STAGE_SOLVING
19824  * - \ref SCIP_STAGE_SOLVED
19825  */
19826 extern
19828  SCIP* scip /**< SCIP data structure */
19829  );
19830 
19831 /** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
19832  * was available
19833  *
19834  * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
19835  * basis was available
19836  *
19837  * @pre This method can be called if SCIP is in one of the following stages:
19838  * - \ref SCIP_STAGE_PRESOLVED
19839  * - \ref SCIP_STAGE_SOLVING
19840  * - \ref SCIP_STAGE_SOLVED
19841  */
19842 extern
19844  SCIP* scip /**< SCIP data structure */
19845  );
19846 
19847 /** gets total number of primal LPs solved so far that were resolved from an advanced start basis
19848  *
19849  * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
19850  *
19851  * @pre This method can be called if SCIP is in one of the following stages:
19852  * - \ref SCIP_STAGE_PRESOLVED
19853  * - \ref SCIP_STAGE_SOLVING
19854  * - \ref SCIP_STAGE_SOLVED
19855  */
19856 extern
19858  SCIP* scip /**< SCIP data structure */
19859  );
19860 
19861 /** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
19862  * was available
19863  *
19864  * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
19865  * basis was available
19866  *
19867  * @pre This method can be called if SCIP is in one of the following stages:
19868  * - \ref SCIP_STAGE_PRESOLVED
19869  * - \ref SCIP_STAGE_SOLVING
19870  * - \ref SCIP_STAGE_SOLVED
19871  */
19872 extern
19874  SCIP* scip /**< SCIP data structure */
19875  );
19876 
19877 /** gets total number of dual LPs solved so far that were resolved from an advanced start basis
19878  *
19879  * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
19880  *
19881  * @pre This method can be called if SCIP is in one of the following stages:
19882  * - \ref SCIP_STAGE_PRESOLVED
19883  * - \ref SCIP_STAGE_SOLVING
19884  * - \ref SCIP_STAGE_SOLVED
19885  */
19886 extern
19888  SCIP* scip /**< SCIP data structure */
19889  );
19890 
19891 /** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
19892  * was available
19893  *
19894  * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
19895  * basis was available
19896  *
19897  * @pre This method can be called if SCIP is in one of the following stages:
19898  * - \ref SCIP_STAGE_PRESOLVED
19899  * - \ref SCIP_STAGE_SOLVING
19900  * - \ref SCIP_STAGE_SOLVED
19901  */
19902 extern
19904  SCIP* scip /**< SCIP data structure */
19905  );
19906 
19907 /** gets total number of LPs solved so far for node relaxations
19908  *
19909  * @return the total number of LPs solved so far for node relaxations
19910  *
19911  * @pre This method can be called if SCIP is in one of the following stages:
19912  * - \ref SCIP_STAGE_PRESOLVED
19913  * - \ref SCIP_STAGE_SOLVING
19914  * - \ref SCIP_STAGE_SOLVED
19915  */
19916 extern
19918  SCIP* scip /**< SCIP data structure */
19919  );
19920 
19921 /** gets total number of simplex iterations used so far for node relaxations
19922  *
19923  * @return the total number of simplex iterations used so far for node relaxations
19924  *
19925  * @pre This method can be called if SCIP is in one of the following stages:
19926  * - \ref SCIP_STAGE_PRESOLVED
19927  * - \ref SCIP_STAGE_SOLVING
19928  * - \ref SCIP_STAGE_SOLVED
19929  */
19930 extern
19932  SCIP* scip /**< SCIP data structure */
19933  );
19934 
19935 /** gets total number of LPs solved so far for initial LP in node relaxations
19936  *
19937  * @return the total number of LPs solved so far for initial LP in node relaxations
19938  *
19939  * @pre This method can be called if SCIP is in one of the following stages:
19940  * - \ref SCIP_STAGE_PRESOLVED
19941  * - \ref SCIP_STAGE_SOLVING
19942  * - \ref SCIP_STAGE_SOLVED
19943  */
19944 extern
19946  SCIP* scip /**< SCIP data structure */
19947  );
19948 
19949 /** gets total number of simplex iterations used so far for initial LP in node relaxations
19950  *
19951  * @return the total number of simplex iterations used so far for initial LP in node relaxations
19952  *
19953  * @pre This method can be called if SCIP is in one of the following stages:
19954  * - \ref SCIP_STAGE_PRESOLVED
19955  * - \ref SCIP_STAGE_SOLVING
19956  * - \ref SCIP_STAGE_SOLVED
19957  */
19958 extern
19960  SCIP* scip /**< SCIP data structure */
19961  );
19962 
19963 /** gets total number of LPs solved so far during diving and probing
19964  *
19965  * @return total number of LPs solved so far during diving and probing
19966  *
19967  * @pre This method can be called if SCIP is in one of the following stages:
19968  * - \ref SCIP_STAGE_PRESOLVED
19969  * - \ref SCIP_STAGE_SOLVING
19970  * - \ref SCIP_STAGE_SOLVED
19971  */
19972 extern
19974  SCIP* scip /**< SCIP data structure */
19975  );
19976 
19977 /** gets total number of simplex iterations used so far during diving and probing
19978  *
19979  * @return the total number of simplex iterations used so far during diving and probing
19980  *
19981  * @pre This method can be called if SCIP is in one of the following stages:
19982  * - \ref SCIP_STAGE_PRESOLVED
19983  * - \ref SCIP_STAGE_SOLVING
19984  * - \ref SCIP_STAGE_SOLVED
19985  */
19986 extern
19988  SCIP* scip /**< SCIP data structure */
19989  );
19990 
19991 /** gets total number of times, strong branching was called (each call represents solving two LPs)
19992  *
19993  * @return the total number of times, strong branching was called (each call represents solving two LPs)
19994  *
19995  * @pre This method can be called if SCIP is in one of the following stages:
19996  * - \ref SCIP_STAGE_PRESOLVED
19997  * - \ref SCIP_STAGE_SOLVING
19998  * - \ref SCIP_STAGE_SOLVED
19999  */
20000 extern
20002  SCIP* scip /**< SCIP data structure */
20003  );
20004 
20005 /** gets total number of simplex iterations used so far in strong branching
20006  *
20007  * @return the total number of simplex iterations used so far in strong branching
20008  *
20009  * @pre This method can be called if SCIP is in one of the following stages:
20010  * - \ref SCIP_STAGE_PRESOLVED
20011  * - \ref SCIP_STAGE_SOLVING
20012  * - \ref SCIP_STAGE_SOLVED
20013  */
20014 extern
20016  SCIP* scip /**< SCIP data structure */
20017  );
20018 
20019 /** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
20020  *
20021  * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
20022  *
20023  * @pre This method can be called if SCIP is in one of the following stages:
20024  * - \ref SCIP_STAGE_PRESOLVED
20025  * - \ref SCIP_STAGE_SOLVING
20026  * - \ref SCIP_STAGE_SOLVED
20027  */
20028 extern
20030  SCIP* scip /**< SCIP data structure */
20031  );
20032 
20033 /** gets total number of simplex iterations used so far in strong branching at the root node
20034  *
20035  * @return the total number of simplex iterations used so far in strong branching at the root node
20036  *
20037  * @pre This method can be called if SCIP is in one of the following stages:
20038  * - \ref SCIP_STAGE_PRESOLVED
20039  * - \ref SCIP_STAGE_SOLVING
20040  * - \ref SCIP_STAGE_SOLVED
20041  */
20042 extern
20044  SCIP* scip /**< SCIP data structure */
20045  );
20046 
20047 /** gets number of pricing rounds performed so far at the current node
20048  *
20049  * @return the number of pricing rounds performed so far at the current node
20050  *
20051  * @pre This method can be called if SCIP is in one of the following stages:
20052  * - \ref SCIP_STAGE_SOLVING
20053  */
20054 extern
20056  SCIP* scip /**< SCIP data structure */
20057  );
20058 
20059 /** get current number of variables in the pricing store
20060  *
20061  * @return the current number of variables in the pricing store
20062  *
20063  * @pre This method can be called if SCIP is in one of the following stages:
20064  * - \ref SCIP_STAGE_PRESOLVED
20065  * - \ref SCIP_STAGE_SOLVING
20066  * - \ref SCIP_STAGE_SOLVED
20067  */
20068 extern
20069 int SCIPgetNPricevars(
20070  SCIP* scip /**< SCIP data structure */
20071  );
20072 
20073 /** get total number of pricing variables found so far
20074  *
20075  * @return the total number of pricing variables found so far
20076  *
20077  * @pre This method can be called if SCIP is in one of the following stages:
20078  * - \ref SCIP_STAGE_PRESOLVED
20079  * - \ref SCIP_STAGE_SOLVING
20080  * - \ref SCIP_STAGE_SOLVED
20081  */
20082 extern
20084  SCIP* scip /**< SCIP data structure */
20085  );
20086 
20087 /** get total number of pricing variables applied to the LPs
20088  *
20089  * @return the total number of pricing variables applied to the LPs
20090  *
20091  * @pre This method can be called if SCIP is in one of the following stages:
20092  * - \ref SCIP_STAGE_PRESOLVED
20093  * - \ref SCIP_STAGE_SOLVING
20094  * - \ref SCIP_STAGE_SOLVED
20095  */
20096 extern
20098  SCIP* scip /**< SCIP data structure */
20099  );
20100 
20101 /** gets number of separation rounds performed so far at the current node
20102  *
20103  * @return the number of separation rounds performed so far at the current node
20104  *
20105  * @pre This method can be called if SCIP is in one of the following stages:
20106  * - \ref SCIP_STAGE_SOLVING
20107  */
20108 extern
20109 int SCIPgetNSepaRounds(
20110  SCIP* scip /**< SCIP data structure */
20111  );
20112 
20113 /** get total number of cuts found so far
20114  *
20115  * @return the total number of cuts found so far
20116  *
20117  * @pre This method can be called if SCIP is in one of the following stages:
20118  * - \ref SCIP_STAGE_PRESOLVED
20119  * - \ref SCIP_STAGE_SOLVING
20120  * - \ref SCIP_STAGE_SOLVED
20121  */
20122 extern
20123 int SCIPgetNCutsFound(
20124  SCIP* scip /**< SCIP data structure */
20125  );
20126 
20127 /** get number of cuts found so far in current separation round
20128  *
20129  * @return the number of cuts found so far in current separation round
20130  *
20131  * @pre This method can be called if SCIP is in one of the following stages:
20132  * - \ref SCIP_STAGE_PRESOLVED
20133  * - \ref SCIP_STAGE_SOLVING
20134  * - \ref SCIP_STAGE_SOLVED
20135  */
20136 extern
20138  SCIP* scip /**< SCIP data structure */
20139  );
20140 
20141 /** get total number of cuts applied to the LPs
20142  *
20143  * @return the total number of cuts applied to the LPs
20144  *
20145  * @pre This method can be called if SCIP is in one of the following stages:
20146  * - \ref SCIP_STAGE_PRESOLVED
20147  * - \ref SCIP_STAGE_SOLVING
20148  * - \ref SCIP_STAGE_SOLVED
20149  */
20150 extern
20152  SCIP* scip /**< SCIP data structure */
20153  );
20154 
20155 /** get total number of constraints found in conflict analysis (conflict and reconvergence constraints)
20156  *
20157  * @return the total number of constraints found in conflict analysis (conflict and reconvergence constraints)
20158  *
20159  * @pre This method can be called if SCIP is in one of the following stages:
20160  * - \ref SCIP_STAGE_TRANSFORMED
20161  * - \ref SCIP_STAGE_INITPRESOLVE
20162  * - \ref SCIP_STAGE_PRESOLVING
20163  * - \ref SCIP_STAGE_EXITPRESOLVE
20164  * - \ref SCIP_STAGE_PRESOLVED
20165  * - \ref SCIP_STAGE_INITSOLVE
20166  * - \ref SCIP_STAGE_SOLVING
20167  * - \ref SCIP_STAGE_SOLVED
20168  * - \ref SCIP_STAGE_EXITSOLVE
20169  */
20170 extern
20172  SCIP* scip /**< SCIP data structure */
20173  );
20174 
20175 /** get number of conflict constraints found so far at the current node
20176  *
20177  * @return the number of conflict constraints found so far at the current node
20178  *
20179  * @pre This method can be called if SCIP is in one of the following stages:
20180  * - \ref SCIP_STAGE_TRANSFORMED
20181  * - \ref SCIP_STAGE_INITPRESOLVE
20182  * - \ref SCIP_STAGE_PRESOLVING
20183  * - \ref SCIP_STAGE_EXITPRESOLVE
20184  * - \ref SCIP_STAGE_PRESOLVED
20185  * - \ref SCIP_STAGE_INITSOLVE
20186  * - \ref SCIP_STAGE_SOLVING
20187  * - \ref SCIP_STAGE_SOLVED
20188  * - \ref SCIP_STAGE_EXITSOLVE
20189  */
20190 extern
20192  SCIP* scip /**< SCIP data structure */
20193  );
20194 
20195 /** get total number of conflict constraints added to the problem
20196  *
20197  * @return the total number of conflict constraints added to the problem
20198  *
20199  * @pre This method can be called if SCIP is in one of the following stages:
20200  * - \ref SCIP_STAGE_TRANSFORMED
20201  * - \ref SCIP_STAGE_INITPRESOLVE
20202  * - \ref SCIP_STAGE_PRESOLVING
20203  * - \ref SCIP_STAGE_EXITPRESOLVE
20204  * - \ref SCIP_STAGE_PRESOLVED
20205  * - \ref SCIP_STAGE_INITSOLVE
20206  * - \ref SCIP_STAGE_SOLVING
20207  * - \ref SCIP_STAGE_SOLVED
20208  * - \ref SCIP_STAGE_EXITSOLVE
20209  */
20210 extern
20212  SCIP* scip /**< SCIP data structure */
20213  );
20214 
20215 /** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
20216  *
20217  * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
20218  *
20219  * @pre This method can be called if SCIP is in one of the following stages:
20220  * - \ref SCIP_STAGE_TRANSFORMED
20221  * - \ref SCIP_STAGE_INITPRESOLVE
20222  * - \ref SCIP_STAGE_PRESOLVING
20223  * - \ref SCIP_STAGE_EXITPRESOLVE
20224  * - \ref SCIP_STAGE_PRESOLVED
20225  * - \ref SCIP_STAGE_INITSOLVE
20226  * - \ref SCIP_STAGE_SOLVING
20227  * - \ref SCIP_STAGE_SOLVED
20228  * - \ref SCIP_STAGE_EXITSOLVE
20229  */
20230 extern
20231 int SCIPgetMaxDepth(
20232  SCIP* scip /**< SCIP data structure */
20233  );
20234 
20235 /** gets maximal depth of all processed nodes over all branch and bound runs
20236  *
20237  * @return the maximal depth of all processed nodes over all branch and bound runs
20238  *
20239  * @pre This method can be called if SCIP is in one of the following stages:
20240  * - \ref SCIP_STAGE_TRANSFORMED
20241  * - \ref SCIP_STAGE_INITPRESOLVE
20242  * - \ref SCIP_STAGE_PRESOLVING
20243  * - \ref SCIP_STAGE_EXITPRESOLVE
20244  * - \ref SCIP_STAGE_PRESOLVED
20245  * - \ref SCIP_STAGE_INITSOLVE
20246  * - \ref SCIP_STAGE_SOLVING
20247  * - \ref SCIP_STAGE_SOLVED
20248  * - \ref SCIP_STAGE_EXITSOLVE
20249  */
20250 extern
20252  SCIP* scip /**< SCIP data structure */
20253  );
20254 
20255 /** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
20256  *
20257  * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
20258  *
20259  * @pre This method can be called if SCIP is in one of the following stages:
20260  * - \ref SCIP_STAGE_TRANSFORMED
20261  * - \ref SCIP_STAGE_INITPRESOLVE
20262  * - \ref SCIP_STAGE_PRESOLVING
20263  * - \ref SCIP_STAGE_EXITPRESOLVE
20264  * - \ref SCIP_STAGE_PRESOLVED
20265  * - \ref SCIP_STAGE_INITSOLVE
20266  * - \ref SCIP_STAGE_SOLVING
20267  * - \ref SCIP_STAGE_SOLVED
20268  * - \ref SCIP_STAGE_EXITSOLVE
20269  */
20270 extern
20272  SCIP* scip /**< SCIP data structure */
20273  );
20274 
20275 /** gets total number of active constraints at the current node
20276  *
20277  * @return the total number of active constraints at the current node
20278  *
20279  * @pre This method can be called if SCIP is in one of the following stages:
20280  * - \ref SCIP_STAGE_INITPRESOLVE
20281  * - \ref SCIP_STAGE_PRESOLVING
20282  * - \ref SCIP_STAGE_EXITPRESOLVE
20283  * - \ref SCIP_STAGE_PRESOLVED
20284  * - \ref SCIP_STAGE_SOLVING
20285  */
20286 extern
20288  SCIP* scip /**< SCIP data structure */
20289  );
20290 
20291 /** gets total number of enabled constraints at the current node
20292  *
20293  * @return the total number of enabled constraints at the current node
20294  *
20295  * @pre This method can be called if SCIP is in one of the following stages:
20296  * - \ref SCIP_STAGE_PRESOLVED
20297  * - \ref SCIP_STAGE_SOLVING
20298  */
20299 extern
20301  SCIP* scip /**< SCIP data structure */
20302  );
20303 
20304 /** gets average dual bound of all unprocessed nodes for original problem */
20305 extern
20307  SCIP* scip /**< SCIP data structure */
20308  );
20309 
20310 /** gets average lower (dual) bound of all unprocessed nodes in transformed problem
20311  *
20312  * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
20313  *
20314  * @pre This method can be called if SCIP is in one of the following stages:
20315  * - \ref SCIP_STAGE_PRESOLVED
20316  * - \ref SCIP_STAGE_SOLVING
20317  * - \ref SCIP_STAGE_SOLVED
20318  */
20319 extern
20321  SCIP* scip /**< SCIP data structure */
20322  );
20323 
20324 /** gets global dual bound
20325  *
20326  * @return the global dual bound
20327  *
20328  * @pre This method can be called if SCIP is in one of the following stages:
20329  * - \ref SCIP_STAGE_PRESOLVING
20330  * - \ref SCIP_STAGE_EXITPRESOLVE
20331  * - \ref SCIP_STAGE_PRESOLVED
20332  * - \ref SCIP_STAGE_INITSOLVE
20333  * - \ref SCIP_STAGE_SOLVING
20334  * - \ref SCIP_STAGE_SOLVED
20335  */
20336 extern
20338  SCIP* scip /**< SCIP data structure */
20339  );
20340 
20341 /** gets global lower (dual) bound in transformed problem
20342  *
20343  * @return the global lower (dual) bound in transformed problem
20344  *
20345  * @pre This method can be called if SCIP is in one of the following stages:
20346  * - \ref SCIP_STAGE_PRESOLVING
20347  * - \ref SCIP_STAGE_EXITPRESOLVE
20348  * - \ref SCIP_STAGE_PRESOLVED
20349  * - \ref SCIP_STAGE_INITSOLVE
20350  * - \ref SCIP_STAGE_SOLVING
20351  * - \ref SCIP_STAGE_SOLVED
20352  */
20353 extern
20355  SCIP* scip /**< SCIP data structure */
20356  );
20357 
20358 /** gets dual bound of the root node for the original problem
20359  *
20360  * @return the dual bound of the root node for the original problem
20361  *
20362  * @pre This method can be called if SCIP is in one of the following stages:
20363  * - \ref SCIP_STAGE_PRESOLVING
20364  * - \ref SCIP_STAGE_EXITPRESOLVE
20365  * - \ref SCIP_STAGE_PRESOLVED
20366  * - \ref SCIP_STAGE_INITSOLVE
20367  * - \ref SCIP_STAGE_SOLVING
20368  * - \ref SCIP_STAGE_SOLVED
20369  */
20370 extern
20372  SCIP* scip /**< SCIP data structure */
20373  );
20374 
20375 /** gets lower (dual) bound in transformed problem of the root node
20376  *
20377  * @return the lower (dual) bound in transformed problem of the root node
20378  *
20379  * @pre This method can be called if SCIP is in one of the following stages:
20380  * - \ref SCIP_STAGE_PRESOLVING
20381  * - \ref SCIP_STAGE_EXITPRESOLVE
20382  * - \ref SCIP_STAGE_PRESOLVED
20383  * - \ref SCIP_STAGE_INITSOLVE
20384  * - \ref SCIP_STAGE_SOLVING
20385  * - \ref SCIP_STAGE_SOLVED
20386  */
20387 extern
20389  SCIP* scip /**< SCIP data structure */
20390  );
20391 
20392 /** gets dual bound for the original problem obtained by the first LP solve at the root node
20393  *
20394  * @return the dual bound for the original problem of the first LP solve at the root node
20395  *
20396  * @pre This method can be called if SCIP is in one of the following stages:
20397  * - \ref SCIP_STAGE_PRESOLVING
20398  * - \ref SCIP_STAGE_EXITPRESOLVE
20399  * - \ref SCIP_STAGE_PRESOLVED
20400  * - \ref SCIP_STAGE_INITSOLVE
20401  * - \ref SCIP_STAGE_SOLVING
20402  * - \ref SCIP_STAGE_SOLVED
20403  */
20404 extern
20406  SCIP* scip /**< SCIP data structure */
20407  );
20408 
20409 /** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
20410  *
20411  * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
20412  *
20413  * @pre This method can be called if SCIP is in one of the following stages:
20414  * - \ref SCIP_STAGE_PRESOLVING
20415  * - \ref SCIP_STAGE_EXITPRESOLVE
20416  * - \ref SCIP_STAGE_PRESOLVED
20417  * - \ref SCIP_STAGE_INITSOLVE
20418  * - \ref SCIP_STAGE_SOLVING
20419  * - \ref SCIP_STAGE_SOLVED
20420  */
20421 extern
20423  SCIP* scip /**< SCIP data structure */
20424  );
20425 
20426 
20427 /** the primal bound of the very first solution */
20428 extern
20430  SCIP* scip /**< SCIP data structure */
20431  );
20432 
20433 /** gets global primal bound (objective value of best solution or user objective limit) for the original problem
20434  *
20435  * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
20436  *
20437  * @pre This method can be called if SCIP is in one of the following stages:
20438  * - \ref SCIP_STAGE_TRANSFORMED
20439  * - \ref SCIP_STAGE_INITPRESOLVE
20440  * - \ref SCIP_STAGE_PRESOLVING
20441  * - \ref SCIP_STAGE_EXITPRESOLVE
20442  * - \ref SCIP_STAGE_PRESOLVED
20443  * - \ref SCIP_STAGE_INITSOLVE
20444  * - \ref SCIP_STAGE_SOLVING
20445  * - \ref SCIP_STAGE_SOLVED
20446  * - \ref SCIP_STAGE_EXITSOLVE
20447  */
20448 extern
20450  SCIP* scip /**< SCIP data structure */
20451  );
20452 
20453 /** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
20454  *
20455  * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
20456  *
20457  * @pre This method can be called if SCIP is in one of the following stages:
20458  * - \ref SCIP_STAGE_TRANSFORMED
20459  * - \ref SCIP_STAGE_INITPRESOLVE
20460  * - \ref SCIP_STAGE_PRESOLVING
20461  * - \ref SCIP_STAGE_EXITPRESOLVE
20462  * - \ref SCIP_STAGE_PRESOLVED
20463  * - \ref SCIP_STAGE_INITSOLVE
20464  * - \ref SCIP_STAGE_SOLVING
20465  * - \ref SCIP_STAGE_SOLVED
20466  * - \ref SCIP_STAGE_EXITSOLVE
20467  */
20468 extern
20470  SCIP* scip /**< SCIP data structure */
20471  );
20472 
20473 /** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
20474  * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
20475  * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
20476  * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
20477  *
20478  * @return global cutoff bound in transformed problem
20479  *
20480  * @pre This method can be called if SCIP is in one of the following stages:
20481  * - \ref SCIP_STAGE_TRANSFORMED
20482  * - \ref SCIP_STAGE_INITPRESOLVE
20483  * - \ref SCIP_STAGE_PRESOLVING
20484  * - \ref SCIP_STAGE_EXITPRESOLVE
20485  * - \ref SCIP_STAGE_PRESOLVED
20486  * - \ref SCIP_STAGE_INITSOLVE
20487  * - \ref SCIP_STAGE_SOLVING
20488  * - \ref SCIP_STAGE_SOLVED
20489  * - \ref SCIP_STAGE_EXITSOLVE
20490  */
20491 extern
20493  SCIP* scip /**< SCIP data structure */
20494  );
20495 
20496 /** updates the cutoff bound
20497  *
20498  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20499  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20500  *
20501  * @note using this method in the solving stage can lead to an erroneous SCIP solving status; in particular,
20502  * if a solution not respecting the cutoff bound was found before installing a cutoff bound which
20503  * renders the remaining problem infeasible, this solution may be reported as optimal
20504  *
20505  * @pre This method can be called if SCIP is in one of the following stages:
20506  * - \ref SCIP_STAGE_TRANSFORMED
20507  * - \ref SCIP_STAGE_PRESOLVING
20508  * - \ref SCIP_STAGE_PRESOLVED
20509  * - \ref SCIP_STAGE_INITSOLVE
20510  * - \ref SCIP_STAGE_SOLVING
20511  *
20512  * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
20513  */
20514 extern
20516  SCIP* scip, /**< SCIP data structure */
20517  SCIP_Real cutoffbound /**< new cutoff bound */
20518  );
20519 
20520 /** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
20521  * was set from the user as objective limit
20522  *
20523  * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
20524  *
20525  * @pre This method can be called if SCIP is in one of the following stages:
20526  * - \ref SCIP_STAGE_TRANSFORMED
20527  * - \ref SCIP_STAGE_INITPRESOLVE
20528  * - \ref SCIP_STAGE_PRESOLVING
20529  * - \ref SCIP_STAGE_EXITPRESOLVE
20530  * - \ref SCIP_STAGE_PRESOLVED
20531  * - \ref SCIP_STAGE_INITSOLVE
20532  * - \ref SCIP_STAGE_SOLVING
20533  * - \ref SCIP_STAGE_SOLVED
20534  * - \ref SCIP_STAGE_EXITSOLVE
20535  */
20536 extern
20538  SCIP* scip /**< SCIP data structure */
20539  );
20540 
20541 /** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
20542  * or infinity, if they have opposite sign
20543  *
20544  * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
20545  * or infinity, if they have opposite sign
20546  *
20547  * @pre This method can be called if SCIP is in one of the following stages:
20548  * - \ref SCIP_STAGE_PRESOLVED
20549  * - \ref SCIP_STAGE_SOLVING
20550  * - \ref SCIP_STAGE_SOLVED
20551  */
20552 extern
20554  SCIP* scip /**< SCIP data structure */
20555  );
20556 
20557 /** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
20558  * have same sign, or infinity, if they have opposite sign
20559  *
20560  * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
20561  * have same sign, or infinity, if they have opposite sign
20562  *
20563  * @pre This method can be called if SCIP is in one of the following stages:
20564  * - \ref SCIP_STAGE_PRESOLVED
20565  * - \ref SCIP_STAGE_SOLVING
20566  * - \ref SCIP_STAGE_SOLVED
20567  */
20568 extern
20570  SCIP* scip /**< SCIP data structure */
20571  );
20572 
20573 /** gets number of feasible primal solutions found so far
20574  *
20575  * @return the number of feasible primal solutions found so far
20576  *
20577  * @pre This method can be called if SCIP is in one of the following stages:
20578  * - \ref SCIP_STAGE_TRANSFORMED
20579  * - \ref SCIP_STAGE_INITPRESOLVE
20580  * - \ref SCIP_STAGE_PRESOLVING
20581  * - \ref SCIP_STAGE_EXITPRESOLVE
20582  * - \ref SCIP_STAGE_PRESOLVED
20583  * - \ref SCIP_STAGE_INITSOLVE
20584  * - \ref SCIP_STAGE_SOLVING
20585  * - \ref SCIP_STAGE_SOLVED
20586  * - \ref SCIP_STAGE_EXITSOLVE
20587  */
20588 extern
20590  SCIP* scip /**< SCIP data structure */
20591  );
20592 
20593 /** gets number of feasible primal solutions respecting the objective limit found so far
20594  *
20595  * @return the number of feasible primal solutions respecting the objective limit found so far
20596  *
20597  * @pre This method can be called if SCIP is in one of the following stages:
20598  * - \ref SCIP_STAGE_INIT
20599  * - \ref SCIP_STAGE_PROBLEM
20600  * - \ref SCIP_STAGE_TRANSFORMING
20601  * - \ref SCIP_STAGE_TRANSFORMED
20602  * - \ref SCIP_STAGE_INITPRESOLVE
20603  * - \ref SCIP_STAGE_PRESOLVING
20604  * - \ref SCIP_STAGE_EXITPRESOLVE
20605  * - \ref SCIP_STAGE_PRESOLVED
20606  * - \ref SCIP_STAGE_INITSOLVE
20607  * - \ref SCIP_STAGE_SOLVING
20608  * - \ref SCIP_STAGE_SOLVED
20609  * - \ref SCIP_STAGE_EXITSOLVE
20610  */
20611 extern
20613  SCIP* scip /**< SCIP data structure */
20614  );
20615 
20616 /** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
20617  *
20618  * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
20619  *
20620  * @pre This method can be called if SCIP is in one of the following stages:
20621  * - \ref SCIP_STAGE_TRANSFORMED
20622  * - \ref SCIP_STAGE_INITPRESOLVE
20623  * - \ref SCIP_STAGE_PRESOLVING
20624  * - \ref SCIP_STAGE_EXITPRESOLVE
20625  * - \ref SCIP_STAGE_PRESOLVED
20626  * - \ref SCIP_STAGE_INITSOLVE
20627  * - \ref SCIP_STAGE_SOLVING
20628  * - \ref SCIP_STAGE_SOLVED
20629  * - \ref SCIP_STAGE_EXITSOLVE
20630  */
20631 extern
20633  SCIP* scip /**< SCIP data structure */
20634  );
20635 
20636 /** gets the average pseudo cost value for the given direction over all variables
20637  *
20638  * @return the average pseudo cost value for the given direction over all variables
20639  *
20640  * @pre This method can be called if SCIP is in one of the following stages:
20641  * - \ref SCIP_STAGE_SOLVING
20642  * - \ref SCIP_STAGE_SOLVED
20643  */
20644 extern
20646  SCIP* scip, /**< SCIP data structure */
20647  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
20648  );
20649 
20650 /** gets the average pseudo cost value for the given direction over all variables,
20651  * only using the pseudo cost information of the current run
20652  *
20653  * @return the average pseudo cost value for the given direction over all variables,
20654  * only using the pseudo cost information of the current run
20655  *
20656  * @pre This method can be called if SCIP is in one of the following stages:
20657  * - \ref SCIP_STAGE_SOLVING
20658  * - \ref SCIP_STAGE_SOLVED
20659  */
20660 extern
20662  SCIP* scip, /**< SCIP data structure */
20663  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
20664  );
20665 
20666 /** gets the average number of pseudo cost updates for the given direction over all variables
20667  *
20668  * @return the average number of pseudo cost updates for the given direction over all variables
20669  *
20670  * @pre This method can be called if SCIP is in one of the following stages:
20671  * - \ref SCIP_STAGE_SOLVING
20672  * - \ref SCIP_STAGE_SOLVED
20673  */
20674 extern
20676  SCIP* scip, /**< SCIP data structure */
20677  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20678  );
20679 
20680 /** gets the average number of pseudo cost updates for the given direction over all variables,
20681  * only using the pseudo cost information of the current run
20682  *
20683  * @return the average number of pseudo cost updates for the given direction over all variables,
20684  * only using the pseudo cost information of the current run
20685  *
20686  * @pre This method can be called if SCIP is in one of the following stages:
20687  * - \ref SCIP_STAGE_SOLVING
20688  * - \ref SCIP_STAGE_SOLVED
20689  */
20690 extern
20692  SCIP* scip, /**< SCIP data structure */
20693  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20694  );
20695 
20696 /** gets the number of pseudo cost updates for the given direction over all variables
20697  *
20698  * @return the number of pseudo cost updates for the given direction over all variables
20699  *
20700  * @pre This method can be called if SCIP is in one of the following stages:
20701  * - \ref SCIP_STAGE_SOLVING
20702  * - \ref SCIP_STAGE_SOLVED
20703  */
20704 extern
20706  SCIP* scip, /**< SCIP data structure */
20707  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
20708  SCIP_Bool onlycurrentrun /**< use only history of current run? */
20709  );
20710 
20711 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
20712  *
20713  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
20714  *
20715  * @pre This method can be called if SCIP is in one of the following stages:
20716  * - \ref SCIP_STAGE_SOLVING
20717  * - \ref SCIP_STAGE_SOLVED
20718  */
20719 extern
20721  SCIP* scip /**< SCIP data structure */
20722  );
20723 
20724 /** returns the variance of pseudo costs for all variables in the requested direction
20725  *
20726  * @return the variance of pseudo costs for all variables in the requested direction
20727  *
20728  * @pre This method can be called if SCIP is in one of the following stages:
20729  * - \ref SCIP_STAGE_SOLVING
20730  * - \ref SCIP_STAGE_SOLVED
20731  */
20732 extern
20734  SCIP* scip, /**< SCIP data structure */
20735  SCIP_BRANCHDIR branchdir, /**< the branching direction, up or down */
20736  SCIP_Bool onlycurrentrun /**< use only history of current run? */
20737  );
20738 
20739 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
20740  * only using the pseudo cost information of the current run
20741  *
20742  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
20743  * only using the pseudo cost information of the current run
20744  *
20745  * @pre This method can be called if SCIP is in one of the following stages:
20746  * - \ref SCIP_STAGE_SOLVING
20747  * - \ref SCIP_STAGE_SOLVED
20748  */
20749 extern
20751  SCIP* scip /**< SCIP data structure */
20752  );
20753 
20754 /** gets the average conflict score value over all variables */
20755 extern
20757  SCIP* scip /**< SCIP data structure */
20758  );
20759 
20760 /** gets the average conflict score value over all variables, only using the conflict information of the current run
20761  *
20762  * @return the average conflict score value over all variables, only using the conflict information of the current run
20763  *
20764  * @pre This method can be called if SCIP is in one of the following stages:
20765  * - \ref SCIP_STAGE_SOLVING
20766  * - \ref SCIP_STAGE_SOLVED
20767  */
20768 extern
20770  SCIP* scip /**< SCIP data structure */
20771  );
20772 
20773 /** gets the average inference score value over all variables
20774  *
20775  * @return the average inference score value over all variables
20776  *
20777  * @pre This method can be called if SCIP is in one of the following stages:
20778  * - \ref SCIP_STAGE_SOLVING
20779  * - \ref SCIP_STAGE_SOLVED
20780  */
20781 extern
20783  SCIP* scip /**< SCIP data structure */
20784  );
20785 
20786 /** gets the average conflictlength score value over all variables, only using the conflictlength information of the
20787  * current run
20788  *
20789  * @return the average conflictlength score value over all variables, only using the conflictlength information of the
20790  * current run
20791  *
20792  * @pre This method can be called if SCIP is in one of the following stages:
20793  * - \ref SCIP_STAGE_SOLVING
20794  * - \ref SCIP_STAGE_SOLVED
20795  */
20796 extern
20798  SCIP* scip /**< SCIP data structure */
20799  );
20800 
20801 /** returns the average number of inferences found after branching in given direction over all variables
20802  *
20803  * @return the average number of inferences found after branching in given direction over all variables
20804  *
20805  * @pre This method can be called if SCIP is in one of the following stages:
20806  * - \ref SCIP_STAGE_SOLVING
20807  * - \ref SCIP_STAGE_SOLVED
20808  */
20809 extern
20811  SCIP* scip, /**< SCIP data structure */
20812  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20813  );
20814 
20815 /** returns the average number of inferences found after branching in given direction over all variables,
20816  * only using the inference information of the current run
20817  *
20818  * @return the average number of inferences found after branching in given direction over all variables,
20819  * only using the inference information of the current run
20820  *
20821  * @pre This method can be called if SCIP is in one of the following stages:
20822  * - \ref SCIP_STAGE_SOLVING
20823  * - \ref SCIP_STAGE_SOLVED
20824  */
20825 extern
20827  SCIP* scip, /**< SCIP data structure */
20828  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20829  );
20830 
20831 /** gets the average inference score value over all variables
20832  *
20833  * @return the average inference score value over all variables
20834  *
20835  * @pre This method can be called if SCIP is in one of the following stages:
20836  * - \ref SCIP_STAGE_SOLVING
20837  * - \ref SCIP_STAGE_SOLVED
20838  */
20839 extern
20841  SCIP* scip /**< SCIP data structure */
20842  );
20843 
20844 /** gets the average inference score value over all variables, only using the inference information of the
20845  * current run
20846  *
20847  * @return the average inference score value over all variables, only using the inference information of the
20848  * current run
20849  *
20850  * @pre This method can be called if SCIP is in one of the following stages:
20851  * - \ref SCIP_STAGE_SOLVING
20852  * - \ref SCIP_STAGE_SOLVED
20853  */
20854 extern
20856  SCIP* scip /**< SCIP data structure */
20857  );
20858 
20859 /** returns the average number of cutoffs found after branching in given direction over all variables
20860  *
20861  * @return the average number of cutoffs found after branching in given direction over all variables
20862  *
20863  * @pre This method can be called if SCIP is in one of the following stages:
20864  * - \ref SCIP_STAGE_SOLVING
20865  * - \ref SCIP_STAGE_SOLVED
20866  */
20867 extern
20869  SCIP* scip, /**< SCIP data structure */
20870  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20871  );
20872 
20873 /** returns the average number of cutoffs found after branching in given direction over all variables,
20874  * only using the cutoff information of the current run
20875  *
20876  * @return the average number of cutoffs found after branching in given direction over all variables,
20877  * only using the cutoff information of the current run
20878  *
20879  * @pre This method can be called if SCIP is in one of the following stages:
20880  * - \ref SCIP_STAGE_SOLVING
20881  * - \ref SCIP_STAGE_SOLVED
20882  */
20883 extern
20885  SCIP* scip, /**< SCIP data structure */
20886  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20887  );
20888 
20889 /** gets the average cutoff score value over all variables
20890  *
20891  * @return the average cutoff score value over all variables
20892  *
20893  * @pre This method can be called if SCIP is in one of the following stages:
20894  * - \ref SCIP_STAGE_SOLVING
20895  * - \ref SCIP_STAGE_SOLVED
20896  */
20897 extern
20899  SCIP* scip /**< SCIP data structure */
20900  );
20901 
20902 /** gets the average cutoff score value over all variables, only using the cutoff information of the current run
20903  *
20904  * @return the average cutoff score value over all variables, only using the cutoff information of the current run
20905  *
20906  * @pre This method can be called if SCIP is in one of the following stages:
20907  * - \ref SCIP_STAGE_SOLVING
20908  * - \ref SCIP_STAGE_SOLVED
20909  */
20910 extern
20912  SCIP* scip /**< SCIP data structure */
20913  );
20914 
20915 /** gets deterministic time number of LPs solved so far
20916  *
20917  * @return the total number of LPs solved so far
20918  *
20919  * @pre This method can be called if SCIP is in one of the following stages:
20920  * - \ref SCIP_STAGE_PRESOLVED
20921  * - \ref SCIP_STAGE_SOLVING
20922  * - \ref SCIP_STAGE_SOLVED
20923  */
20924 extern
20926  SCIP* scip /**< SCIP data structure */
20927  );
20928 
20929 /** outputs original problem to file stream
20930  *
20931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20933  *
20934  * @pre This method can be called if SCIP is in one of the following stages:
20935  * - \ref SCIP_STAGE_PROBLEM
20936  * - \ref SCIP_STAGE_TRANSFORMING
20937  * - \ref SCIP_STAGE_TRANSFORMED
20938  * - \ref SCIP_STAGE_INITPRESOLVE
20939  * - \ref SCIP_STAGE_PRESOLVING
20940  * - \ref SCIP_STAGE_EXITPRESOLVE
20941  * - \ref SCIP_STAGE_PRESOLVED
20942  * - \ref SCIP_STAGE_INITSOLVE
20943  * - \ref SCIP_STAGE_SOLVING
20944  * - \ref SCIP_STAGE_SOLVED
20945  * - \ref SCIP_STAGE_EXITSOLVE
20946  * - \ref SCIP_STAGE_FREETRANS
20947  */
20948 extern
20950  SCIP* scip, /**< SCIP data structure */
20951  FILE* file, /**< output file (or NULL for standard output) */
20952  const char* extension, /**< file format (or NULL for default CIP format)*/
20953  SCIP_Bool genericnames /**< using generic variable and constraint names? */
20954  );
20955 
20956 /** outputs transformed problem of the current node to file stream
20957  *
20958  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20959  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20960  *
20961  * @pre This method can be called if SCIP is in one of the following stages:
20962  * - \ref SCIP_STAGE_TRANSFORMED
20963  * - \ref SCIP_STAGE_INITPRESOLVE
20964  * - \ref SCIP_STAGE_PRESOLVING
20965  * - \ref SCIP_STAGE_EXITPRESOLVE
20966  * - \ref SCIP_STAGE_PRESOLVED
20967  * - \ref SCIP_STAGE_INITSOLVE
20968  * - \ref SCIP_STAGE_SOLVING
20969  * - \ref SCIP_STAGE_SOLVED
20970  * - \ref SCIP_STAGE_EXITSOLVE
20971  * - \ref SCIP_STAGE_FREETRANS
20972  */
20973 extern
20975  SCIP* scip, /**< SCIP data structure */
20976  FILE* file, /**< output file (or NULL for standard output) */
20977  const char* extension, /**< file format (or NULL for default CIP format)*/
20978  SCIP_Bool genericnames /**< using generic variable and constraint names? */
20979  );
20980 
20981 /** outputs status statistics
20982  *
20983  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
20984  * thus may to correspond to the original status.
20985  *
20986  * @pre This method can be called if SCIP is in one of the following stages:
20987  * - \ref SCIP_STAGE_INIT
20988  * - \ref SCIP_STAGE_PROBLEM
20989  * - \ref SCIP_STAGE_TRANSFORMED
20990  * - \ref SCIP_STAGE_INITPRESOLVE
20991  * - \ref SCIP_STAGE_PRESOLVING
20992  * - \ref SCIP_STAGE_EXITPRESOLVE
20993  * - \ref SCIP_STAGE_PRESOLVED
20994  * - \ref SCIP_STAGE_SOLVING
20995  * - \ref SCIP_STAGE_SOLVED
20996  */
20997 extern
20999  SCIP* scip, /**< SCIP data structure */
21000  FILE* file /**< output file */
21001  );
21002 
21003 /** outputs timing statistics
21004  *
21005  * @pre This method can be called if SCIP is in one of the following stages:
21006  * - \ref SCIP_STAGE_PROBLEM
21007  * - \ref SCIP_STAGE_TRANSFORMED
21008  * - \ref SCIP_STAGE_INITPRESOLVE
21009  * - \ref SCIP_STAGE_PRESOLVING
21010  * - \ref SCIP_STAGE_EXITPRESOLVE
21011  * - \ref SCIP_STAGE_PRESOLVED
21012  * - \ref SCIP_STAGE_SOLVING
21013  * - \ref SCIP_STAGE_SOLVED
21014  */
21015 extern
21017  SCIP* scip, /**< SCIP data structure */
21018  FILE* file /**< output file */
21019  );
21020 
21021 /** outputs statistics for original problem
21022  *
21023  * @pre This method can be called if SCIP is in one of the following stages:
21024  * - \ref SCIP_STAGE_PROBLEM
21025  * - \ref SCIP_STAGE_TRANSFORMED
21026  * - \ref SCIP_STAGE_INITPRESOLVE
21027  * - \ref SCIP_STAGE_PRESOLVING
21028  * - \ref SCIP_STAGE_EXITPRESOLVE
21029  * - \ref SCIP_STAGE_PRESOLVED
21030  * - \ref SCIP_STAGE_SOLVING
21031  * - \ref SCIP_STAGE_SOLVED
21032  */
21033 extern
21035  SCIP* scip, /**< SCIP data structure */
21036  FILE* file /**< output file (or NULL for standard output) */
21037  );
21038 
21039 /** outputs statistics for transformed problem
21040  *
21041  * @pre This method can be called if SCIP is in one of the following stages:
21042  * - \ref SCIP_STAGE_PROBLEM
21043  * - \ref SCIP_STAGE_TRANSFORMED
21044  * - \ref SCIP_STAGE_INITPRESOLVE
21045  * - \ref SCIP_STAGE_PRESOLVING
21046  * - \ref SCIP_STAGE_EXITPRESOLVE
21047  * - \ref SCIP_STAGE_PRESOLVED
21048  * - \ref SCIP_STAGE_SOLVING
21049  * - \ref SCIP_STAGE_SOLVED
21050  */
21051 extern
21053  SCIP* scip, /**< SCIP data structure */
21054  FILE* file /**< output file */
21055  );
21056 
21057 /** outputs presolver statistics
21058  *
21059  * @pre This method can be called if SCIP is in one of the following stages:
21060  * - \ref SCIP_STAGE_TRANSFORMED
21061  * - \ref SCIP_STAGE_INITPRESOLVE
21062  * - \ref SCIP_STAGE_PRESOLVING
21063  * - \ref SCIP_STAGE_EXITPRESOLVE
21064  * - \ref SCIP_STAGE_PRESOLVED
21065  * - \ref SCIP_STAGE_SOLVING
21066  * - \ref SCIP_STAGE_SOLVED
21067  */
21068 extern
21070  SCIP* scip, /**< SCIP data structure */
21071  FILE* file /**< output file */
21072  );
21073 
21074 /** outputs constraint statistics
21075  *
21076  * @pre This method can be called if SCIP is in one of the following stages:
21077  * - \ref SCIP_STAGE_TRANSFORMED
21078  * - \ref SCIP_STAGE_INITPRESOLVE
21079  * - \ref SCIP_STAGE_PRESOLVING
21080  * - \ref SCIP_STAGE_EXITPRESOLVE
21081  * - \ref SCIP_STAGE_PRESOLVED
21082  * - \ref SCIP_STAGE_SOLVING
21083  * - \ref SCIP_STAGE_SOLVED
21084  */
21085 extern
21087  SCIP* scip, /**< SCIP data structure */
21088  FILE* file /**< output file */
21089  );
21090 
21091 /** outputs constraint timing statistics
21092  *
21093  * @pre This method can be called if SCIP is in one of the following stages:
21094  * - \ref SCIP_STAGE_TRANSFORMED
21095  * - \ref SCIP_STAGE_INITPRESOLVE
21096  * - \ref SCIP_STAGE_PRESOLVING
21097  * - \ref SCIP_STAGE_EXITPRESOLVE
21098  * - \ref SCIP_STAGE_PRESOLVED
21099  * - \ref SCIP_STAGE_SOLVING
21100  * - \ref SCIP_STAGE_SOLVED
21101  */
21102 extern
21104  SCIP* scip, /**< SCIP data structure */
21105  FILE* file /**< output file */
21106  );
21107 
21108 /** outputs propagator statistics
21109  *
21110  * @pre This method can be called if SCIP is in one of the following stages:
21111  * - \ref SCIP_STAGE_TRANSFORMED
21112  * - \ref SCIP_STAGE_INITPRESOLVE
21113  * - \ref SCIP_STAGE_PRESOLVING
21114  * - \ref SCIP_STAGE_EXITPRESOLVE
21115  * - \ref SCIP_STAGE_PRESOLVED
21116  * - \ref SCIP_STAGE_SOLVING
21117  * - \ref SCIP_STAGE_SOLVED
21118  */
21119 extern
21121  SCIP* scip, /**< SCIP data structure */
21122  FILE* file /**< output file */
21123  );
21124 
21125 /** outputs conflict statistics
21126  *
21127  * @pre This method can be called if SCIP is in one of the following stages:
21128  * - \ref SCIP_STAGE_TRANSFORMED
21129  * - \ref SCIP_STAGE_INITPRESOLVE
21130  * - \ref SCIP_STAGE_PRESOLVING
21131  * - \ref SCIP_STAGE_EXITPRESOLVE
21132  * - \ref SCIP_STAGE_PRESOLVED
21133  * - \ref SCIP_STAGE_SOLVING
21134  * - \ref SCIP_STAGE_SOLVED
21135  */
21136 extern
21138  SCIP* scip, /**< SCIP data structure */
21139  FILE* file /**< output file */
21140  );
21141 
21142 /** outputs separator statistics
21143  *
21144  * @pre This method can be called if SCIP is in one of the following stages:
21145  * - \ref SCIP_STAGE_SOLVING
21146  * - \ref SCIP_STAGE_SOLVED
21147  */
21148 extern
21150  SCIP* scip, /**< SCIP data structure */
21151  FILE* file /**< output file */
21152  );
21153 
21154 /** outputs pricer statistics
21155  *
21156  * @pre This method can be called if SCIP is in one of the following stages:
21157  * - \ref SCIP_STAGE_SOLVING
21158  * - \ref SCIP_STAGE_SOLVED
21159  */
21160 extern
21162  SCIP* scip, /**< SCIP data structure */
21163  FILE* file /**< output file */
21164  );
21165 
21166 /** outputs branching rule statistics
21167  *
21168  * @pre This method can be called if SCIP is in one of the following stages:
21169  * - \ref SCIP_STAGE_SOLVING
21170  * - \ref SCIP_STAGE_SOLVED
21171  */
21172 extern
21174  SCIP* scip, /**< SCIP data structure */
21175  FILE* file /**< output file */
21176  );
21177 
21178 /** outputs heuristics statistics
21179  *
21180  * @pre This method can be called if SCIP is in one of the following stages:
21181  * - \ref SCIP_STAGE_PRESOLVING
21182  * - \ref SCIP_STAGE_EXITPRESOLVE
21183  * - \ref SCIP_STAGE_PRESOLVED
21184  * - \ref SCIP_STAGE_SOLVING
21185  * - \ref SCIP_STAGE_SOLVED
21186  */
21187 extern
21189  SCIP* scip, /**< SCIP data structure */
21190  FILE* file /**< output file */
21191  );
21192 
21193 /** outputs compression statistics
21194  *
21195  * @pre This method can be called if SCIP is in one of the following stages:
21196  * - \ref SCIP_STAGE_PRESOLVING
21197  * - \ref SCIP_STAGE_EXITPRESOLVE
21198  * - \ref SCIP_STAGE_PRESOLVED
21199  * - \ref SCIP_STAGE_SOLVING
21200  * - \ref SCIP_STAGE_SOLVED
21201  */
21202 extern
21204  SCIP* scip, /**< SCIP data structure */
21205  FILE* file /**< output file */
21206  );
21207 
21208 /** outputs LP statistics
21209  *
21210  * @pre This method can be called if SCIP is in one of the following stages:
21211  * - \ref SCIP_STAGE_SOLVING
21212  * - \ref SCIP_STAGE_SOLVED
21213  */
21214 extern
21216  SCIP* scip, /**< SCIP data structure */
21217  FILE* file /**< output file */
21218  );
21219 
21220 /** outputs NLP statistics
21221  *
21222  * @pre This method can be called if SCIP is in one of the following stages:
21223  * - \ref SCIP_STAGE_SOLVING
21224  * - \ref SCIP_STAGE_SOLVED
21225  */
21226 extern
21228  SCIP* scip, /**< SCIP data structure */
21229  FILE* file /**< output file */
21230  );
21231 
21232 /** outputs relaxator statistics
21233  *
21234  * @pre This method can be called if SCIP is in one of the following stages:
21235  * - \ref SCIP_STAGE_SOLVING
21236  * - \ref SCIP_STAGE_SOLVED
21237  */
21238 extern
21240  SCIP* scip, /**< SCIP data structure */
21241  FILE* file /**< output file */
21242  );
21243 
21244 /** outputs tree statistics
21245  *
21246  * @pre This method can be called if SCIP is in one of the following stages:
21247  * - \ref SCIP_STAGE_SOLVING
21248  * - \ref SCIP_STAGE_SOLVED
21249  */
21250 extern
21252  SCIP* scip, /**< SCIP data structure */
21253  FILE* file /**< output file */
21254  );
21255 
21256 /** outputs root statistics
21257  *
21258  * @pre This method can be called if SCIP is in one of the following stages:
21259  * - \ref SCIP_STAGE_SOLVING
21260  * - \ref SCIP_STAGE_SOLVED
21261  */
21262 extern
21264  SCIP* scip, /**< SCIP data structure */
21265  FILE* file /**< output file */
21266  );
21267 
21268 /** outputs solution statistics
21269  *
21270  * @pre This method can be called if SCIP is in one of the following stages:
21271  * - \ref SCIP_STAGE_PRESOLVING
21272  * - \ref SCIP_STAGE_EXITPRESOLVE
21273  * - \ref SCIP_STAGE_PRESOLVED
21274  * - \ref SCIP_STAGE_SOLVING
21275  * - \ref SCIP_STAGE_SOLVED
21276  */
21277 extern
21279  SCIP* scip, /**< SCIP data structure */
21280  FILE* file /**< output file */
21281  );
21282 
21283 /** outputs concurrent solver statistics
21284  *
21285  * @pre This method can be called if SCIP is in one of the following stages:
21286  * - \ref SCIP_STAGE_TRANSFORMED
21287  * - \ref SCIP_STAGE_INITPRESOLVE
21288  * - \ref SCIP_STAGE_PRESOLVING
21289  * - \ref SCIP_STAGE_EXITPRESOLVE
21290  * - \ref SCIP_STAGE_PRESOLVED
21291  * - \ref SCIP_STAGE_SOLVING
21292  * - \ref SCIP_STAGE_SOLVED
21293  */
21294 extern
21296  SCIP* scip, /**< SCIP data structure */
21297  FILE* file /**< output file */
21298  );
21299 
21300 /** outputs solving statistics
21301  *
21302  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21303  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21304  *
21305  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
21306  * thus may to correspond to the original status.
21307  *
21308  * @pre This method can be called if SCIP is in one of the following stages:
21309  * - \ref SCIP_STAGE_INIT
21310  * - \ref SCIP_STAGE_PROBLEM
21311  * - \ref SCIP_STAGE_TRANSFORMED
21312  * - \ref SCIP_STAGE_INITPRESOLVE
21313  * - \ref SCIP_STAGE_PRESOLVING
21314  * - \ref SCIP_STAGE_EXITPRESOLVE
21315  * - \ref SCIP_STAGE_PRESOLVED
21316  * - \ref SCIP_STAGE_SOLVING
21317  * - \ref SCIP_STAGE_SOLVED
21318  */
21319 extern
21321  SCIP* scip, /**< SCIP data structure */
21322  FILE* file /**< output file (or NULL for standard output) */
21323  );
21324 
21325 /** outputs reoptimization statistics
21326  *
21327  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21328  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21329  *
21330  * @pre This method can be called if SCIP is in one of the following stages:
21331  * - \ref SCIP_STAGE_INIT
21332  * - \ref SCIP_STAGE_PROBLEM
21333  * - \ref SCIP_STAGE_TRANSFORMED
21334  * - \ref SCIP_STAGE_INITPRESOLVE
21335  * - \ref SCIP_STAGE_PRESOLVING
21336  * - \ref SCIP_STAGE_EXITPRESOLVE
21337  * - \ref SCIP_STAGE_PRESOLVED
21338  * - \ref SCIP_STAGE_SOLVING
21339  * - \ref SCIP_STAGE_SOLVED
21340  */
21341 extern
21343  SCIP* scip, /**< SCIP data structure */
21344  FILE* file /**< output file (or NULL for standard output) */
21345  );
21346 
21347 /** outputs history statistics about branchings on variables
21348  *
21349  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21350  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21351  *
21352  * @pre This method can be called if SCIP is in one of the following stages:
21353  * - \ref SCIP_STAGE_INIT
21354  * - \ref SCIP_STAGE_PROBLEM
21355  * - \ref SCIP_STAGE_TRANSFORMED
21356  * - \ref SCIP_STAGE_INITPRESOLVE
21357  * - \ref SCIP_STAGE_PRESOLVING
21358  * - \ref SCIP_STAGE_EXITPRESOLVE
21359  * - \ref SCIP_STAGE_PRESOLVED
21360  * - \ref SCIP_STAGE_SOLVING
21361  * - \ref SCIP_STAGE_SOLVED
21362  */
21363 extern
21365  SCIP* scip, /**< SCIP data structure */
21366  FILE* file /**< output file (or NULL for standard output) */
21367  );
21368 
21369 /** outputs node information display line
21370  *
21371  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21372  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21373  *
21374  * @pre This method can be called if SCIP is in one of the following stages:
21375  * - \ref SCIP_STAGE_SOLVING
21376  */
21377 extern
21379  SCIP* scip, /**< SCIP data structure */
21380  FILE* file, /**< output file (or NULL for standard output) */
21381  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
21382  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
21383  );
21384 
21385 /** gets total number of implications between variables that are stored in the implication graph
21386  *
21387  * @return the total number of implications between variables that are stored in the implication graph
21388  *
21389  * @pre This method can be called if SCIP is in one of the following stages:
21390  * - \ref SCIP_STAGE_INITPRESOLVE
21391  * - \ref SCIP_STAGE_PRESOLVING
21392  * - \ref SCIP_STAGE_EXITPRESOLVE
21393  * - \ref SCIP_STAGE_PRESOLVED
21394  * - \ref SCIP_STAGE_INITSOLVE
21395  * - \ref SCIP_STAGE_SOLVING
21396  * - \ref SCIP_STAGE_SOLVED
21397  */
21398 extern
21400  SCIP* scip /**< SCIP data structure */
21401  );
21402 
21403 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
21404  *
21405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21407  *
21408  * @pre This method can be called if SCIP is in one of the following stages:
21409  * - \ref SCIP_STAGE_TRANSFORMED
21410  * - \ref SCIP_STAGE_INITPRESOLVE
21411  * - \ref SCIP_STAGE_PRESOLVING
21412  * - \ref SCIP_STAGE_EXITPRESOLVE
21413  * - \ref SCIP_STAGE_PRESOLVED
21414  * - \ref SCIP_STAGE_INITSOLVE
21415  * - \ref SCIP_STAGE_SOLVING
21416  * - \ref SCIP_STAGE_SOLVED
21417  * - \ref SCIP_STAGE_EXITSOLVE
21418  *
21419  * @deprecated because binary implications are now stored as cliques
21420  */
21421 extern
21423  SCIP* scip, /**< SCIP data structure */
21424  const char* filename /**< file name, or NULL for stdout */
21425  );
21426 
21427 
21428 /** update statistical information when a new solution was found */
21429 extern
21431  SCIP* scip /**< SCIP data structure */
21432  );
21433 
21434 /**@} */
21435 
21436 /*
21437  * timing methods
21438  */
21439 
21440 
21441 /**@addtogroup PublicTimingMethods
21442  *
21443  * @{
21444  */
21445 
21446 /** gets current time of day in seconds (standard time zone)
21447  *
21448  * @return the current time of day in seconds (standard time zone).
21449  */
21450 extern
21452  SCIP* scip /**< SCIP data structure */
21453  );
21454 
21455 /** creates a clock using the default clock type
21456  *
21457  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21458  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21459  */
21460 extern
21462  SCIP* scip, /**< SCIP data structure */
21463  SCIP_CLOCK** clck /**< pointer to clock timer */
21464  );
21465 
21466 /** creates a clock counting the CPU user seconds
21467  *
21468  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21469  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21470  */
21471 extern
21473  SCIP* scip, /**< SCIP data structure */
21474  SCIP_CLOCK** clck /**< pointer to clock timer */
21475  );
21476 
21477 /** creates a clock counting the wall clock seconds
21478  *
21479  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21480  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21481  */
21482 extern
21484  SCIP* scip, /**< SCIP data structure */
21485  SCIP_CLOCK** clck /**< pointer to clock timer */
21486  );
21487 
21488 /** frees a clock
21489  *
21490  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21491  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21492  */
21493 extern
21495  SCIP* scip, /**< SCIP data structure */
21496  SCIP_CLOCK** clck /**< pointer to clock timer */
21497  );
21498 
21499 /** resets the time measurement of a clock to zero and completely stops the clock
21500  *
21501  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21502  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21503  */
21504 extern
21506  SCIP* scip, /**< SCIP data structure */
21507  SCIP_CLOCK* clck /**< clock timer */
21508  );
21509 
21510 /** starts the time measurement of a clock
21511  *
21512  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21513  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21514  */
21515 extern
21517  SCIP* scip, /**< SCIP data structure */
21518  SCIP_CLOCK* clck /**< clock timer */
21519  );
21520 
21521 /** stops the time measurement of a clock
21522  *
21523  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21524  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21525  */
21526 extern
21528  SCIP* scip, /**< SCIP data structure */
21529  SCIP_CLOCK* clck /**< clock timer */
21530  );
21531 
21532 /** enables or disables all statistic clocks of SCIP concerning plugin statistics,
21533  * LP execution time, strong branching time, etc.
21534  *
21535  * Method reads the value of the parameter timing/statistictiming. In order to disable statistic timing,
21536  * set the parameter to FALSE.
21537  *
21538  * @note: The (pre-)solving time clocks which are relevant for the output during (pre-)solving
21539  * are not affected by this method
21540  *
21541  * @see: For completely disabling all timing of SCIP, consider setting the parameter timing/enabled to FALSE
21542  *
21543  * @pre This method can be called if SCIP is in one of the following stages:
21544  * - \ref SCIP_STAGE_PROBLEM
21545  * - \ref SCIP_STAGE_TRANSFORMING
21546  * - \ref SCIP_STAGE_TRANSFORMED
21547  * - \ref SCIP_STAGE_INITPRESOLVE
21548  * - \ref SCIP_STAGE_PRESOLVING
21549  * - \ref SCIP_STAGE_EXITPRESOLVE
21550  * - \ref SCIP_STAGE_PRESOLVED
21551  * - \ref SCIP_STAGE_INITSOLVE
21552  * - \ref SCIP_STAGE_SOLVING
21553  * - \ref SCIP_STAGE_SOLVED
21554  * - \ref SCIP_STAGE_EXITSOLVE
21555  * - \ref SCIP_STAGE_FREETRANS
21556  *
21557  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21558  */
21559 extern
21561  SCIP* scip /**< SCIP data structure */
21562  );
21563 
21564 /** starts the current solving time
21565  *
21566  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21567  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21568  *
21569  * @pre This method can be called if SCIP is in one of the following stages:
21570  * - \ref SCIP_STAGE_PROBLEM
21571  * - \ref SCIP_STAGE_TRANSFORMING
21572  * - \ref SCIP_STAGE_TRANSFORMED
21573  * - \ref SCIP_STAGE_INITPRESOLVE
21574  * - \ref SCIP_STAGE_PRESOLVING
21575  * - \ref SCIP_STAGE_EXITPRESOLVE
21576  * - \ref SCIP_STAGE_PRESOLVED
21577  * - \ref SCIP_STAGE_INITSOLVE
21578  * - \ref SCIP_STAGE_SOLVING
21579  * - \ref SCIP_STAGE_SOLVED
21580  * - \ref SCIP_STAGE_EXITSOLVE
21581  * - \ref SCIP_STAGE_FREETRANS
21582  *
21583  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21584  */
21585 extern
21587  SCIP* scip /**< SCIP data structure */
21588  );
21589 
21590 /** stops the current solving time in seconds
21591  *
21592  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21593  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21594  *
21595  * @pre This method can be called if SCIP is in one of the following stages:
21596  * - \ref SCIP_STAGE_PROBLEM
21597  * - \ref SCIP_STAGE_TRANSFORMING
21598  * - \ref SCIP_STAGE_TRANSFORMED
21599  * - \ref SCIP_STAGE_INITPRESOLVE
21600  * - \ref SCIP_STAGE_PRESOLVING
21601  * - \ref SCIP_STAGE_EXITPRESOLVE
21602  * - \ref SCIP_STAGE_PRESOLVED
21603  * - \ref SCIP_STAGE_INITSOLVE
21604  * - \ref SCIP_STAGE_SOLVING
21605  * - \ref SCIP_STAGE_SOLVED
21606  * - \ref SCIP_STAGE_EXITSOLVE
21607  * - \ref SCIP_STAGE_FREETRANS
21608  *
21609  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21610  */
21611 extern
21613  SCIP* scip /**< SCIP data structure */
21614  );
21615 
21616 /** gets the measured time of a clock in seconds
21617  *
21618  * @return the measured time of a clock in seconds.
21619  */
21620 extern
21622  SCIP* scip, /**< SCIP data structure */
21623  SCIP_CLOCK* clck /**< clock timer */
21624  );
21625 
21626 /** sets the measured time of a clock to the given value in seconds
21627  *
21628  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21629  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21630  */
21631 extern
21633  SCIP* scip, /**< SCIP data structure */
21634  SCIP_CLOCK* clck, /**< clock timer */
21635  SCIP_Real sec /**< time in seconds to set the clock's timer to */
21636  );
21637 
21638 /** gets the current total SCIP time in seconds, possibly accumulated over several problems.
21639  *
21640  * @return the current total SCIP time in seconds, ie. the total time since the SCIP instance has been created
21641  */
21642 extern
21644  SCIP* scip /**< SCIP data structure */
21645  );
21646 
21647 /** gets the current solving time in seconds
21648  *
21649  * @return the current solving time in seconds.
21650  *
21651  * @pre This method can be called if SCIP is in one of the following stages:
21652  * - \ref SCIP_STAGE_PROBLEM
21653  * - \ref SCIP_STAGE_TRANSFORMING
21654  * - \ref SCIP_STAGE_TRANSFORMED
21655  * - \ref SCIP_STAGE_INITPRESOLVE
21656  * - \ref SCIP_STAGE_PRESOLVING
21657  * - \ref SCIP_STAGE_EXITPRESOLVE
21658  * - \ref SCIP_STAGE_PRESOLVED
21659  * - \ref SCIP_STAGE_INITSOLVE
21660  * - \ref SCIP_STAGE_SOLVING
21661  * - \ref SCIP_STAGE_SOLVED
21662  *
21663  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21664  */
21665 extern
21667  SCIP* scip /**< SCIP data structure */
21668  );
21669 
21670 /** gets the current reading time in seconds
21671  *
21672  * @return the current reading time in seconds.
21673  *
21674  * @pre This method can be called if SCIP is in one of the following stages:
21675  * - \ref SCIP_STAGE_PROBLEM
21676  * - \ref SCIP_STAGE_TRANSFORMING
21677  * - \ref SCIP_STAGE_TRANSFORMED
21678  * - \ref SCIP_STAGE_INITPRESOLVE
21679  * - \ref SCIP_STAGE_PRESOLVING
21680  * - \ref SCIP_STAGE_EXITPRESOLVE
21681  * - \ref SCIP_STAGE_PRESOLVED
21682  * - \ref SCIP_STAGE_INITSOLVE
21683  * - \ref SCIP_STAGE_SOLVING
21684  * - \ref SCIP_STAGE_SOLVED
21685  *
21686  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21687  */
21688 extern
21690  SCIP* scip /**< SCIP data structure */
21691  );
21692 
21693 /** gets the current presolving time in seconds
21694  *
21695  * @return the current presolving time in seconds.
21696  *
21697  * @pre This method can be called if SCIP is in one of the following stages:
21698  * - \ref SCIP_STAGE_INITPRESOLVE
21699  * - \ref SCIP_STAGE_PRESOLVING
21700  * - \ref SCIP_STAGE_EXITPRESOLVE
21701  * - \ref SCIP_STAGE_PRESOLVED
21702  * - \ref SCIP_STAGE_INITSOLVE
21703  * - \ref SCIP_STAGE_SOLVING
21704  * - \ref SCIP_STAGE_SOLVED
21705  *
21706  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21707  */
21708 extern
21710  SCIP* scip /**< SCIP data structure */
21711  );
21712 
21713 /** gets the time need to solve the first LP in the root node
21714  *
21715  * @return the solving time for the first LP in the root node in seconds.
21716  *
21717  * @pre This method can be called if SCIP is in one of the following stages:
21718  * - \ref SCIP_STAGE_TRANSFORMING
21719  * - \ref SCIP_STAGE_TRANSFORMED
21720  * - \ref SCIP_STAGE_INITPRESOLVE
21721  * - \ref SCIP_STAGE_PRESOLVING
21722  * - \ref SCIP_STAGE_EXITPRESOLVE
21723  * - \ref SCIP_STAGE_PRESOLVED
21724  * - \ref SCIP_STAGE_INITSOLVE
21725  * - \ref SCIP_STAGE_SOLVING
21726  * - \ref SCIP_STAGE_SOLVED
21727  *
21728  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21729  */
21730 extern
21732  SCIP* scip /**< SCIP data structure */
21733  );
21734 
21735 /**@} */
21736 
21737 /*
21738  * numeric values and comparisons
21739  */
21740 
21741 /**@addtogroup PublicToleranceMethods
21742  *
21743  * @{
21744  */
21745 
21746 /** returns value treated as zero
21747  *
21748  * @return value treated as zero
21749  */
21750 extern
21752  SCIP* scip /**< SCIP data structure */
21753  );
21754 
21755 /** returns value treated as zero for sums of floating point values
21756  *
21757  * @return value treated as zero for sums of floating point values
21758  */
21759 extern
21761  SCIP* scip /**< SCIP data structure */
21762  );
21763 
21764 /** returns feasibility tolerance for constraints
21765  *
21766  * @return feasibility tolerance for constraints
21767  */
21768 extern
21770  SCIP* scip /**< SCIP data structure */
21771  );
21772 
21773 /** returns primal feasibility tolerance of LP solver
21774  *
21775  * @return primal feasibility tolerance of LP solver
21776  */
21777 extern
21779  SCIP* scip /**< SCIP data structure */
21780  );
21781 
21782 /** returns feasibility tolerance for reduced costs
21783  *
21784  * @return feasibility tolerance for reduced costs
21785  */
21786 extern
21788  SCIP* scip /**< SCIP data structure */
21789  );
21790 
21791 /** returns convergence tolerance used in barrier algorithm
21792  *
21793  * @return convergence tolerance used in barrier algorithm
21794  */
21795 extern
21797  SCIP* scip /**< SCIP data structure */
21798  );
21799 
21800 /** return the cutoff bound delta
21801  *
21802  * @return cutoff bound data
21803  */
21804 extern
21806  SCIP* scip /**< SCIP data structure */
21807  );
21808 
21809 /** return the relaxation primal feasibility tolerance
21810  *
21811  * @see SCIPchgRelaxfeastol
21812  * @return relaxfeastol
21813  */
21814 extern
21816  SCIP* scip /**< SCIP data structure */
21817  );
21818 
21819 /** sets the feasibility tolerance for constraints
21820  *
21821  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21822  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21823  */
21824 extern
21826  SCIP* scip, /**< SCIP data structure */
21827  SCIP_Real feastol /**< new feasibility tolerance for constraints */
21828  );
21829 
21830 /** sets the primal feasibility tolerance of LP solver
21831  *
21832  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21833  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21834  */
21835 extern
21837  SCIP* scip, /**< SCIP data structure */
21838  SCIP_Real lpfeastol, /**< new primal feasibility tolerance of LP solver */
21839  SCIP_Bool printnewvalue /**< should "numerics/lpfeastol = ..." be printed? */
21840  );
21841 
21842 /** sets the feasibility tolerance for reduced costs
21843  *
21844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21846  */
21847 extern
21849  SCIP* scip, /**< SCIP data structure */
21850  SCIP_Real dualfeastol /**< new feasibility tolerance for reduced costs */
21851  );
21852 
21853 /** sets the convergence tolerance used in barrier algorithm
21854  *
21855  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21856  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21857  */
21858 extern
21860  SCIP* scip, /**< SCIP data structure */
21861  SCIP_Real barrierconvtol /**< new convergence tolerance used in barrier algorithm */
21862  );
21863 
21864 /** sets the primal feasibility tolerance of relaxations
21865  *
21866  * This tolerance value is used by the SCIP core and plugins to tighten then feasibility tolerance on relaxations
21867  * (especially the LP relaxation) during a solve. It is set to SCIP_INVALID initially, which means that only the
21868  * feasibility tolerance of the particular relaxation is taken into account. If set to a valid value, however,
21869  * then this value should be used to reduce the primal feasibility tolerance of a relaxation (thus, use the
21870  * minimum of relaxfeastol and the relaxations primal feastol).
21871  *
21872  * @pre The value of relaxfeastol is reset to SCIP_INVALID when initializing the solve (INITSOL).
21873  * Therefore, this method can only be called in one of the following stages of the SCIP solving process:
21874  * - \ref SCIP_STAGE_INITSOLVE
21875  * - \ref SCIP_STAGE_SOLVING
21876  *
21877  * @return previous value of relaxfeastol
21878  */
21879 extern
21881  SCIP* scip, /**< SCIP data structure */
21882  SCIP_Real relaxfeastol /**< new primal feasibility tolerance of relaxations */
21883  );
21884 
21885 /** marks that some limit parameter was changed */
21886 extern
21888  SCIP* scip /**< SCIP data structure */
21889  );
21890 
21891 /** returns value treated as infinity */
21892 extern
21894  SCIP* scip /**< SCIP data structure */
21895  );
21896 
21897 /** returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity
21898  * computation)
21899  */
21900 extern
21902  SCIP* scip /**< SCIP data structure */
21903  );
21904 
21905 /** checks, if values are in range of epsilon */
21906 extern
21908  SCIP* scip, /**< SCIP data structure */
21909  SCIP_Real val1, /**< first value to be compared */
21910  SCIP_Real val2 /**< second value to be compared */
21911  );
21912 
21913 /** checks, if val1 is (more than epsilon) lower than val2 */
21914 extern
21916  SCIP* scip, /**< SCIP data structure */
21917  SCIP_Real val1, /**< first value to be compared */
21918  SCIP_Real val2 /**< second value to be compared */
21919  );
21920 
21921 /** checks, if val1 is not (more than epsilon) greater than val2 */
21922 extern
21924  SCIP* scip, /**< SCIP data structure */
21925  SCIP_Real val1, /**< first value to be compared */
21926  SCIP_Real val2 /**< second value to be compared */
21927  );
21928 
21929 /** checks, if val1 is (more than epsilon) greater than val2 */
21930 extern
21932  SCIP* scip, /**< SCIP data structure */
21933  SCIP_Real val1, /**< first value to be compared */
21934  SCIP_Real val2 /**< second value to be compared */
21935  );
21936 
21937 /** checks, if val1 is not (more than epsilon) lower than val2 */
21938 extern
21940  SCIP* scip, /**< SCIP data structure */
21941  SCIP_Real val1, /**< first value to be compared */
21942  SCIP_Real val2 /**< second value to be compared */
21943  );
21944 
21945 /** checks, if value is (positive) infinite */
21946 extern
21948  SCIP* scip, /**< SCIP data structure */
21949  SCIP_Real val /**< value to be compared against infinity */
21950  );
21951 
21952 /** checks, if value is huge and should be handled separately (e.g., in activity computation) */
21953 extern
21955  SCIP* scip, /**< SCIP data structure */
21956  SCIP_Real val /**< value to be checked whether it is huge */
21957  );
21958 
21959 /** checks, if value is in range epsilon of 0.0 */
21960 extern
21962  SCIP* scip, /**< SCIP data structure */
21963  SCIP_Real val /**< value to process */
21964  );
21965 
21966 /** checks, if value is greater than epsilon */
21967 extern
21969  SCIP* scip, /**< SCIP data structure */
21970  SCIP_Real val /**< value to process */
21971  );
21972 
21973 /** checks, if value is lower than -epsilon */
21974 extern
21976  SCIP* scip, /**< SCIP data structure */
21977  SCIP_Real val /**< value to process */
21978  );
21979 
21980 /** checks, if value is integral within epsilon */
21981 extern
21983  SCIP* scip, /**< SCIP data structure */
21984  SCIP_Real val /**< value to process */
21985  );
21986 
21987 /** checks whether the product val * scalar is integral in epsilon scaled by scalar */
21988 extern
21990  SCIP* scip, /**< SCIP data structure */
21991  SCIP_Real val, /**< unscaled value to check for scaled integrality */
21992  SCIP_Real scalar /**< value to scale val with for checking for integrality */
21993  );
21994 
21995 /** checks, if given fractional part is smaller than epsilon */
21996 extern
21998  SCIP* scip, /**< SCIP data structure */
21999  SCIP_Real val /**< value to process */
22000  );
22001 
22002 /** rounds value + epsilon down to the next integer */
22003 extern
22005  SCIP* scip, /**< SCIP data structure */
22006  SCIP_Real val /**< value to process */
22007  );
22008 
22009 /** rounds value - epsilon up to the next integer */
22010 extern
22012  SCIP* scip, /**< SCIP data structure */
22013  SCIP_Real val /**< value to process */
22014  );
22015 
22016 /** rounds value to the nearest integer with epsilon tolerance */
22017 extern
22019  SCIP* scip, /**< SCIP data structure */
22020  SCIP_Real val /**< value to process */
22021  );
22022 
22023 /** returns fractional part of value, i.e. x - floor(x) in epsilon tolerance */
22024 extern
22026  SCIP* scip, /**< SCIP data structure */
22027  SCIP_Real val /**< value to return fractional part for */
22028  );
22029 
22030 /** checks, if values are in range of sumepsilon */
22031 extern
22033  SCIP* scip, /**< SCIP data structure */
22034  SCIP_Real val1, /**< first value to be compared */
22035  SCIP_Real val2 /**< second value to be compared */
22036  );
22037 
22038 /** checks, if val1 is (more than sumepsilon) lower than val2 */
22039 extern
22041  SCIP* scip, /**< SCIP data structure */
22042  SCIP_Real val1, /**< first value to be compared */
22043  SCIP_Real val2 /**< second value to be compared */
22044  );
22045 
22046 /** checks, if val1 is not (more than sumepsilon) greater than val2 */
22047 extern
22049  SCIP* scip, /**< SCIP data structure */
22050  SCIP_Real val1, /**< first value to be compared */
22051  SCIP_Real val2 /**< second value to be compared */
22052  );
22053 
22054 /** checks, if val1 is (more than sumepsilon) greater than val2 */
22055 extern
22057  SCIP* scip, /**< SCIP data structure */
22058  SCIP_Real val1, /**< first value to be compared */
22059  SCIP_Real val2 /**< second value to be compared */
22060  );
22061 
22062 /** checks, if val1 is not (more than sumepsilon) lower than val2 */
22063 extern
22065  SCIP* scip, /**< SCIP data structure */
22066  SCIP_Real val1, /**< first value to be compared */
22067  SCIP_Real val2 /**< second value to be compared */
22068  );
22069 
22070 /** checks, if value is in range sumepsilon of 0.0 */
22071 extern
22073  SCIP* scip, /**< SCIP data structure */
22074  SCIP_Real val /**< value to process */
22075  );
22076 
22077 /** checks, if value is greater than sumepsilon */
22078 extern
22080  SCIP* scip, /**< SCIP data structure */
22081  SCIP_Real val /**< value to process */
22082  );
22083 
22084 /** checks, if value is lower than -sumepsilon */
22085 extern
22087  SCIP* scip, /**< SCIP data structure */
22088  SCIP_Real val /**< value to process */
22089  );
22090 
22091 /** checks, if relative difference of values is in range of feasibility tolerance */
22092 extern
22094  SCIP* scip, /**< SCIP data structure */
22095  SCIP_Real val1, /**< first value to be compared */
22096  SCIP_Real val2 /**< second value to be compared */
22097  );
22098 
22099 /** checks, if relative difference val1 and val2 is lower than feasibility tolerance */
22100 extern
22102  SCIP* scip, /**< SCIP data structure */
22103  SCIP_Real val1, /**< first value to be compared */
22104  SCIP_Real val2 /**< second value to be compared */
22105  );
22106 
22107 /** checks, if relative difference of val1 and val2 is not greater than feasibility tolerance */
22108 extern
22110  SCIP* scip, /**< SCIP data structure */
22111  SCIP_Real val1, /**< first value to be compared */
22112  SCIP_Real val2 /**< second value to be compared */
22113  );
22114 
22115 /** checks, if relative difference of val1 and val2 is greater than feastol */
22116 extern
22118  SCIP* scip, /**< SCIP data structure */
22119  SCIP_Real val1, /**< first value to be compared */
22120  SCIP_Real val2 /**< second value to be compared */
22121  );
22122 
22123 /** checks, if relative difference of val1 and val2 is not lower than -feastol */
22124 extern
22126  SCIP* scip, /**< SCIP data structure */
22127  SCIP_Real val1, /**< first value to be compared */
22128  SCIP_Real val2 /**< second value to be compared */
22129  );
22130 
22131 /** checks, if value is in range feasibility tolerance of 0.0 */
22132 extern
22134  SCIP* scip, /**< SCIP data structure */
22135  SCIP_Real val /**< value to process */
22136  );
22137 
22138 /** checks, if value is greater than feasibility tolerance */
22139 extern
22141  SCIP* scip, /**< SCIP data structure */
22142  SCIP_Real val /**< value to process */
22143  );
22144 
22145 /** checks, if value is lower than -feasibility tolerance */
22146 extern
22148  SCIP* scip, /**< SCIP data structure */
22149  SCIP_Real val /**< value to process */
22150  );
22151 
22152 /** checks, if value is integral within the LP feasibility bounds */
22153 extern
22155  SCIP* scip, /**< SCIP data structure */
22156  SCIP_Real val /**< value to process */
22157  );
22158 
22159 /** checks, if given fractional part is smaller than feastol */
22160 extern
22162  SCIP* scip, /**< SCIP data structure */
22163  SCIP_Real val /**< value to process */
22164  );
22165 
22166 /** rounds value + feasibility tolerance down to the next integer */
22167 extern
22169  SCIP* scip, /**< SCIP data structure */
22170  SCIP_Real val /**< value to process */
22171  );
22172 
22173 /** rounds value - feasibility tolerance up to the next integer */
22174 extern
22176  SCIP* scip, /**< SCIP data structure */
22177  SCIP_Real val /**< value to process */
22178  );
22179 
22180 /** rounds value to the nearest integer in feasibility tolerance */
22181 extern
22183  SCIP* scip, /**< SCIP data structure */
22184  SCIP_Real val /**< value to process */
22185  );
22186 
22187 /** returns fractional part of value, i.e. x - floor(x) */
22188 extern
22190  SCIP* scip, /**< SCIP data structure */
22191  SCIP_Real val /**< value to process */
22192  );
22193 
22194 /** checks, if relative difference of values is in range of dual feasibility tolerance */
22195 extern
22197  SCIP* scip, /**< SCIP data structure */
22198  SCIP_Real val1, /**< first value to be compared */
22199  SCIP_Real val2 /**< second value to be compared */
22200  );
22201 
22202 /** checks, if relative difference val1 and val2 is lower than dual feasibility tolerance */
22203 extern
22205  SCIP* scip, /**< SCIP data structure */
22206  SCIP_Real val1, /**< first value to be compared */
22207  SCIP_Real val2 /**< second value to be compared */
22208  );
22209 
22210 /** checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance */
22211 extern
22213  SCIP* scip, /**< SCIP data structure */
22214  SCIP_Real val1, /**< first value to be compared */
22215  SCIP_Real val2 /**< second value to be compared */
22216  );
22217 
22218 /** checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance */
22219 extern
22221  SCIP* scip, /**< SCIP data structure */
22222  SCIP_Real val1, /**< first value to be compared */
22223  SCIP_Real val2 /**< second value to be compared */
22224  );
22225 
22226 /** checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance */
22227 extern
22229  SCIP* scip, /**< SCIP data structure */
22230  SCIP_Real val1, /**< first value to be compared */
22231  SCIP_Real val2 /**< second value to be compared */
22232  );
22233 
22234 /** checks, if value is in range dual feasibility tolerance of 0.0 */
22235 extern
22237  SCIP* scip, /**< SCIP data structure */
22238  SCIP_Real val /**< value to process */
22239  );
22240 
22241 /** checks, if value is greater than dual feasibility tolerance */
22242 extern
22244  SCIP* scip, /**< SCIP data structure */
22245  SCIP_Real val /**< value to process */
22246  );
22247 
22248 /** checks, if value is lower than -dual feasibility tolerance */
22249 extern
22251  SCIP* scip, /**< SCIP data structure */
22252  SCIP_Real val /**< value to process */
22253  );
22254 
22255 /** checks, if value is integral within the LP dual feasibility tolerance */
22256 extern
22258  SCIP* scip, /**< SCIP data structure */
22259  SCIP_Real val /**< value to process */
22260  );
22261 
22262 /** checks, if given fractional part is smaller than dual feasibility tolerance */
22263 extern
22265  SCIP* scip, /**< SCIP data structure */
22266  SCIP_Real val /**< value to process */
22267  );
22268 
22269 /** rounds value + dual feasibility tolerance down to the next integer */
22270 extern
22272  SCIP* scip, /**< SCIP data structure */
22273  SCIP_Real val /**< value to process */
22274  );
22275 
22276 /** rounds value - dual feasibility tolerance up to the next integer */
22277 extern
22279  SCIP* scip, /**< SCIP data structure */
22280  SCIP_Real val /**< value to process */
22281  );
22282 
22283 /** rounds value to the nearest integer in dual feasibility tolerance */
22284 extern
22286  SCIP* scip, /**< SCIP data structure */
22287  SCIP_Real val /**< value to process */
22288  );
22289 
22290 /** returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance */
22291 extern
22293  SCIP* scip, /**< SCIP data structure */
22294  SCIP_Real val /**< value to process */
22295  );
22296 
22297 /** checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
22298 extern
22300  SCIP* scip, /**< SCIP data structure */
22301  SCIP_Real newlb, /**< new lower bound */
22302  SCIP_Real oldlb, /**< old lower bound */
22303  SCIP_Real oldub /**< old upper bound */
22304  );
22305 
22306 /** checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
22308  SCIP* scip, /**< SCIP data structure */
22309  SCIP_Real newub, /**< new upper bound */
22310  SCIP_Real oldlb, /**< old lower bound */
22311  SCIP_Real oldub /**< old upper bound */
22312  );
22313 
22314 /** checks, if relative difference of values is in range of epsilon */
22315 extern
22317  SCIP* scip, /**< SCIP data structure */
22318  SCIP_Real val1, /**< first value to be compared */
22319  SCIP_Real val2 /**< second value to be compared */
22320  );
22321 
22322 /** checks, if relative difference of val1 and val2 is lower than epsilon */
22323 extern
22325  SCIP* scip, /**< SCIP data structure */
22326  SCIP_Real val1, /**< first value to be compared */
22327  SCIP_Real val2 /**< second value to be compared */
22328  );
22329 
22330 /** checks, if relative difference of val1 and val2 is not greater than epsilon */
22331 extern
22333  SCIP* scip, /**< SCIP data structure */
22334  SCIP_Real val1, /**< first value to be compared */
22335  SCIP_Real val2 /**< second value to be compared */
22336  );
22337 
22338 /** checks, if relative difference of val1 and val2 is greater than epsilon */
22339 extern
22341  SCIP* scip, /**< SCIP data structure */
22342  SCIP_Real val1, /**< first value to be compared */
22343  SCIP_Real val2 /**< second value to be compared */
22344  );
22345 
22346 /** checks, if relative difference of val1 and val2 is not lower than -epsilon */
22347 extern
22349  SCIP* scip, /**< SCIP data structure */
22350  SCIP_Real val1, /**< first value to be compared */
22351  SCIP_Real val2 /**< second value to be compared */
22352  );
22353 
22354 /** checks, if relative difference of values is in range of sumepsilon */
22355 extern
22357  SCIP* scip, /**< SCIP data structure */
22358  SCIP_Real val1, /**< first value to be compared */
22359  SCIP_Real val2 /**< second value to be compared */
22360  );
22361 
22362 /** checks, if relative difference of val1 and val2 is lower than sumepsilon */
22363 extern
22365  SCIP* scip, /**< SCIP data structure */
22366  SCIP_Real val1, /**< first value to be compared */
22367  SCIP_Real val2 /**< second value to be compared */
22368  );
22369 
22370 /** checks, if relative difference of val1 and val2 is not greater than sumepsilon */
22371 extern
22373  SCIP* scip, /**< SCIP data structure */
22374  SCIP_Real val1, /**< first value to be compared */
22375  SCIP_Real val2 /**< second value to be compared */
22376  );
22377 
22378 /** checks, if relative difference of val1 and val2 is greater than sumepsilon */
22379 extern
22381  SCIP* scip, /**< SCIP data structure */
22382  SCIP_Real val1, /**< first value to be compared */
22383  SCIP_Real val2 /**< second value to be compared */
22384  );
22385 
22386 /** checks, if relative difference of val1 and val2 is not lower than -sumepsilon */
22387 extern
22389  SCIP* scip, /**< SCIP data structure */
22390  SCIP_Real val1, /**< first value to be compared */
22391  SCIP_Real val2 /**< second value to be compared */
22392  );
22393 
22394 /** converts the given real number representing an integer to an int; in optimized mode the function gets inlined for
22395  * performance; in debug mode we check some additional conditions
22396  */
22397 extern
22399  SCIP* scip, /**< SCIP data structure */
22400  SCIP_Real real /**< double bound to convert */
22401  );
22402 
22403 /** converts the given real number representing an integer to a long integer; in optimized mode the function gets inlined for
22404  * performance; in debug mode we check some additional conditions
22405  */
22406 extern
22408  SCIP* scip, /**< SCIP data structure */
22409  SCIP_Real real /**< double bound to convert */
22410  );
22411 
22412 /** Checks, if an iteratively updated value is reliable or should be recomputed from scratch.
22413  * This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high
22414  * absolute value during the optimization process which is later reduced significantly. In this case, the last digits
22415  * were canceled out when increasing the value and are random after decreasing it.
22416  * We do not consider the cancellations which can occur during increasing the absolute value because they just cannot
22417  * be expressed using fixed precision floating point arithmetic, anymore.
22418  * In order to get more reliable values, the idea is to always store the last reliable value, where increasing the
22419  * absolute of the value is viewed as preserving reliability. Then, after each update, the new absolute value can be
22420  * compared against the last reliable one with this method, checking whether it was decreased by a factor of at least
22421  * "lp/recompfac" and should be recomputed.
22422  */
22423 extern
22425  SCIP* scip, /**< SCIP data structure */
22426  SCIP_Real newvalue, /**< new value after update */
22427  SCIP_Real oldvalue /**< old value, i.e., last reliable value */
22428  );
22429 
22430 #ifdef NDEBUG
22431 
22432 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
22433  * speed up the algorithms.
22434  */
22435 
22436 #define SCIPinfinity(scip) SCIPsetInfinity((scip)->set)
22437 #define SCIPisInfinity(scip, val) SCIPsetIsInfinity((scip)->set, val)
22438 #define SCIPisHugeValue(scip, val) SCIPsetIsHugeValue((scip)->set, val)
22439 #define SCIPgetHugeValue(scip) SCIPsetGetHugeValue((scip)->set)
22440 #define SCIPisEQ(scip, val1, val2) SCIPsetIsEQ((scip)->set, val1, val2)
22441 #define SCIPisLT(scip, val1, val2) SCIPsetIsLT((scip)->set, val1, val2)
22442 #define SCIPisLE(scip, val1, val2) SCIPsetIsLE((scip)->set, val1, val2)
22443 #define SCIPisGT(scip, val1, val2) SCIPsetIsGT((scip)->set, val1, val2)
22444 #define SCIPisGE(scip, val1, val2) SCIPsetIsGE((scip)->set, val1, val2)
22445 #define SCIPisZero(scip, val) SCIPsetIsZero((scip)->set, val)
22446 #define SCIPisPositive(scip, val) SCIPsetIsPositive((scip)->set, val)
22447 #define SCIPisNegative(scip, val) SCIPsetIsNegative((scip)->set, val)
22448 #define SCIPisIntegral(scip, val) SCIPsetIsIntegral((scip)->set, val)
22449 #define SCIPisScalingIntegral(scip, val, scalar) SCIPsetIsScalingIntegral((scip)->set, val, scalar)
22450 #define SCIPisFracIntegral(scip, val) SCIPsetIsFracIntegral((scip)->set, val)
22451 #define SCIPfloor(scip, val) SCIPsetFloor((scip)->set, val)
22452 #define SCIPceil(scip, val) SCIPsetCeil((scip)->set, val)
22453 #define SCIPround(scip, val) SCIPsetRound((scip)->set, val)
22454 #define SCIPfrac(scip, val) SCIPsetFrac((scip)->set, val)
22455 
22456 #define SCIPisSumEQ(scip, val1, val2) SCIPsetIsSumEQ((scip)->set, val1, val2)
22457 #define SCIPisSumLT(scip, val1, val2) SCIPsetIsSumLT((scip)->set, val1, val2)
22458 #define SCIPisSumLE(scip, val1, val2) SCIPsetIsSumLE((scip)->set, val1, val2)
22459 #define SCIPisSumGT(scip, val1, val2) SCIPsetIsSumGT((scip)->set, val1, val2)
22460 #define SCIPisSumGE(scip, val1, val2) SCIPsetIsSumGE((scip)->set, val1, val2)
22461 #define SCIPisSumZero(scip, val) SCIPsetIsSumZero((scip)->set, val)
22462 #define SCIPisSumPositive(scip, val) SCIPsetIsSumPositive((scip)->set, val)
22463 #define SCIPisSumNegative(scip, val) SCIPsetIsSumNegative((scip)->set, val)
22464 
22465 #define SCIPisFeasEQ(scip, val1, val2) SCIPsetIsFeasEQ((scip)->set, val1, val2)
22466 #define SCIPisFeasLT(scip, val1, val2) SCIPsetIsFeasLT((scip)->set, val1, val2)
22467 #define SCIPisFeasLE(scip, val1, val2) SCIPsetIsFeasLE((scip)->set, val1, val2)
22468 #define SCIPisFeasGT(scip, val1, val2) SCIPsetIsFeasGT((scip)->set, val1, val2)
22469 #define SCIPisFeasGE(scip, val1, val2) SCIPsetIsFeasGE((scip)->set, val1, val2)
22470 #define SCIPisFeasZero(scip, val) SCIPsetIsFeasZero((scip)->set, val)
22471 #define SCIPisFeasPositive(scip, val) SCIPsetIsFeasPositive((scip)->set, val)
22472 #define SCIPisFeasNegative(scip, val) SCIPsetIsFeasNegative((scip)->set, val)
22473 #define SCIPisFeasIntegral(scip, val) SCIPsetIsFeasIntegral((scip)->set, val)
22474 #define SCIPisFeasFracIntegral(scip, val) SCIPsetIsFeasFracIntegral((scip)->set, val)
22475 #define SCIPfeasFloor(scip, val) SCIPsetFeasFloor((scip)->set, val)
22476 #define SCIPfeasCeil(scip, val) SCIPsetFeasCeil((scip)->set, val)
22477 #define SCIPfeasRound(scip, val) SCIPsetFeasRound((scip)->set, val)
22478 #define SCIPfeasFrac(scip, val) SCIPsetFeasFrac((scip)->set, val)
22479 
22480 #define SCIPisDualfeasEQ(scip, val1, val2) SCIPsetIsDualfeasEQ((scip)->set, val1, val2)
22481 #define SCIPisDualfeasLT(scip, val1, val2) SCIPsetIsDualfeasLT((scip)->set, val1, val2)
22482 #define SCIPisDualfeasLE(scip, val1, val2) SCIPsetIsDualfeasLE((scip)->set, val1, val2)
22483 #define SCIPisDualfeasGT(scip, val1, val2) SCIPsetIsDualfeasGT((scip)->set, val1, val2)
22484 #define SCIPisDualfeasGE(scip, val1, val2) SCIPsetIsDualfeasGE((scip)->set, val1, val2)
22485 #define SCIPisDualfeasZero(scip, val) SCIPsetIsDualfeasZero((scip)->set, val)
22486 #define SCIPisDualfeasPositive(scip, val) SCIPsetIsDualfeasPositive((scip)->set, val)
22487 #define SCIPisDualfeasNegative(scip, val) SCIPsetIsDualfeasNegative((scip)->set, val)
22488 #define SCIPisDualfeasIntegral(scip, val) SCIPsetIsDualfeasIntegral((scip)->set, val)
22489 #define SCIPisDualfeasFracIntegral(scip, val) SCIPsetIsDualfeasFracIntegral((scip)->set, val)
22490 #define SCIPdualfeasFloor(scip, val) SCIPsetDualfeasFloor((scip)->set, val)
22491 #define SCIPdualfeasCeil(scip, val) SCIPsetDualfeasCeil((scip)->set, val)
22492 #define SCIPdualfeasRound(scip, val) SCIPsetDualfeasRound((scip)->set, val)
22493 #define SCIPdualfeasFrac(scip, val) SCIPsetDualfeasFrac((scip)->set, val)
22494 
22495 #define SCIPisLbBetter(scip, newlb, oldlb, oldub) SCIPsetIsLbBetter(scip->set, newlb, oldlb, oldub)
22496 #define SCIPisUbBetter(scip, newub, oldlb, oldub) SCIPsetIsUbBetter(scip->set, newub, oldlb, oldub)
22497 
22498 #define SCIPisRelEQ(scip, val1, val2) SCIPsetIsRelEQ((scip)->set, val1, val2)
22499 #define SCIPisRelLT(scip, val1, val2) SCIPsetIsRelLT((scip)->set, val1, val2)
22500 #define SCIPisRelLE(scip, val1, val2) SCIPsetIsRelLE((scip)->set, val1, val2)
22501 #define SCIPisRelGT(scip, val1, val2) SCIPsetIsRelGT((scip)->set, val1, val2)
22502 #define SCIPisRelGE(scip, val1, val2) SCIPsetIsRelGE((scip)->set, val1, val2)
22503 
22504 #define SCIPisSumRelEQ(scip, val1, val2) SCIPsetIsSumRelEQ((scip)->set, val1, val2)
22505 #define SCIPisSumRelLT(scip, val1, val2) SCIPsetIsSumRelLT((scip)->set, val1, val2)
22506 #define SCIPisSumRelLE(scip, val1, val2) SCIPsetIsSumRelLE((scip)->set, val1, val2)
22507 #define SCIPisSumRelGT(scip, val1, val2) SCIPsetIsSumRelGT((scip)->set, val1, val2)
22508 #define SCIPisSumRelGE(scip, val1, val2) SCIPsetIsSumRelGE((scip)->set, val1, val2)
22509 #define SCIPconvertRealToInt(scip, real) ((int)((real) < 0 ? ((real) - 0.5) : ((real) + 0.5)))
22510 #define SCIPconvertRealToLongint(scip, real) ((SCIP_Longint)((real) < 0 ? ((real) - 0.5) : ((real) + 0.5)))
22511 
22512 #define SCIPisUpdateUnreliable(scip, newval, oldval) SCIPsetIsUpdateUnreliable((scip)->set, newval, oldval)
22513 
22514 #define SCIPmarkConsPropagate(scip, cons) SCIPconsMarkPropagate(cons, (scip)->set)
22515 #define SCIPgetStage(scip) (((scip)->set)->stage)
22516 #define SCIPhasPerformedPresolve(scip) ((scip)->stat->performpresol)
22517 #define SCIPisStopped(scip) SCIPsolveIsStopped((scip)->set, (scip)->stat, 0)
22518 #endif
22519 
22520 /** outputs a real number, or "+infinity", or "-infinity" to a file */
22521 extern
22522 void SCIPprintReal(
22523  SCIP* scip, /**< SCIP data structure */
22524  FILE* file, /**< output file (or NULL for standard output) */
22525  SCIP_Real val, /**< value to print */
22526  int width, /**< width of the field */
22527  int precision /**< number of significant digits printed */
22528  );
22529 
22530 /** parse a real value that was written with SCIPprintReal() */
22531 extern
22533  SCIP* scip, /**< SCIP data structure */
22534  const char* str, /**< string to search */
22535  SCIP_Real* value, /**< pointer to store the parsed value */
22536  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
22537  );
22538 
22539 /**@} */
22540 
22541 
22542 
22543 
22544 /*
22545  * memory management
22546  */
22547 
22548 /**@name Standard Memory Management Macros */
22549 /**@{ */
22550 
22551 #define SCIPallocMemory(scip,ptr) ( (BMSallocMemory((ptr)) == NULL) \
22552  ? SCIP_NOMEMORY : SCIP_OKAY )
22553 #define SCIPallocMemoryArray(scip,ptr,num) ( (BMSallocMemoryArray((ptr), (num)) == NULL) \
22554  ? SCIP_NOMEMORY : SCIP_OKAY )
22555 #define SCIPallocClearMemoryArray(scip,ptr,num) ( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \
22556  ? SCIP_NOMEMORY : SCIP_OKAY )
22557 #define SCIPallocMemorySize(scip,ptr,size) ( (BMSallocMemorySize((ptr), (size)) == NULL) \
22558  ? SCIP_NOMEMORY : SCIP_OKAY )
22559 #define SCIPreallocMemoryArray(scip,ptr,newnum) ( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \
22560  ? SCIP_NOMEMORY : SCIP_OKAY )
22561 #define SCIPreallocMemorySize(scip,ptr,newsize) ( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \
22562  ? SCIP_NOMEMORY : SCIP_OKAY )
22563 #define SCIPduplicateMemory(scip, ptr, source) ( (BMSduplicateMemory((ptr), (source)) == NULL) \
22564  ? SCIP_NOMEMORY : SCIP_OKAY )
22565 #define SCIPduplicateMemoryArray(scip, ptr, source, num) ( (BMSduplicateMemoryArray((ptr), (source), (num)) == NULL) \
22566  ? SCIP_NOMEMORY : SCIP_OKAY )
22567 #define SCIPfreeMemory(scip,ptr) BMSfreeMemory(ptr)
22568 #define SCIPfreeMemoryNull(scip,ptr) BMSfreeMemoryNull(ptr)
22569 #define SCIPfreeMemoryArray(scip,ptr) BMSfreeMemoryArray(ptr)
22570 #define SCIPfreeMemoryArrayNull(scip,ptr) BMSfreeMemoryArrayNull(ptr)
22571 #define SCIPfreeMemorySize(scip,ptr) BMSfreeMemorySize(ptr)
22572 #define SCIPfreeMemorySizeNull(scip,ptr) BMSfreeMemorySizeNull(ptr)
22573 /**@} */
22574 
22575 
22576 /**@addtogroup PublicMemoryMethods
22577  *
22578  * @{
22579  */
22580 
22581 /**@name Block Memory Management Macros
22582  * @{
22583  */
22584 
22585 #define SCIPallocBlockMemory(scip,ptr) ( (BMSallocBlockMemory(SCIPblkmem(scip), (ptr)) == NULL) \
22586  ? SCIP_NOMEMORY : SCIP_OKAY )
22587 #define SCIPallocBlockMemoryArray(scip,ptr,num) ( (BMSallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
22588  ? SCIP_NOMEMORY : SCIP_OKAY )
22589 #define SCIPallocBlockMemorySize(scip,ptr,size) ( (BMSallocBlockMemorySize(SCIPblkmem(scip), (ptr), (size)) == NULL) \
22590  ? SCIP_NOMEMORY : SCIP_OKAY )
22591 #define SCIPallocClearBlockMemoryArray(scip,ptr,num) ( (BMSallocClearBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
22592  ? SCIP_NOMEMORY : SCIP_OKAY )
22593 #define SCIPreallocBlockMemoryArray(scip,ptr,oldnum,newnum) ( (BMSreallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (oldnum), (newnum)) == NULL) \
22594  ? SCIP_NOMEMORY : SCIP_OKAY )
22595 #define SCIPreallocBlockMemorySize(scip,ptr,oldsize,newsize) ( (BMSreallocBlockMemorySize(SCIPblkmem(scip), (ptr), (oldsize), (newsize)) == NULL) \
22596  ? SCIP_NOMEMORY : SCIP_OKAY )
22597 #define SCIPduplicateBlockMemory(scip, ptr, source) ( (BMSduplicateBlockMemory(SCIPblkmem(scip), (ptr), (source)) == NULL) \
22598  ? SCIP_NOMEMORY : SCIP_OKAY )
22599 #define SCIPduplicateBlockMemoryArray(scip, ptr, source, num) ( (BMSduplicateBlockMemoryArray(SCIPblkmem(scip), (ptr), (source), (num)) == NULL) \
22600  ? SCIP_NOMEMORY : SCIP_OKAY )
22601 #define SCIPensureBlockMemoryArray(scip,ptr,arraysizeptr,minsize) ( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), (arraysizeptr), (minsize))) )
22602 #define SCIPfreeBlockMemory(scip,ptr) BMSfreeBlockMemory(SCIPblkmem(scip), (ptr))
22603 #define SCIPfreeBlockMemoryNull(scip,ptr) BMSfreeBlockMemoryNull(SCIPblkmem(scip), (ptr))
22604 #define SCIPfreeBlockMemoryArray(scip,ptr,num) BMSfreeBlockMemoryArray(SCIPblkmem(scip), (ptr), (num))
22605 #define SCIPfreeBlockMemoryArrayNull(scip,ptr,num) BMSfreeBlockMemoryArrayNull(SCIPblkmem(scip), (ptr), (num))
22606 #define SCIPfreeBlockMemorySize(scip,ptr,size) BMSfreeBlockMemorySize(SCIPblkmem(scip), (ptr), (size))
22607 #define SCIPfreeBlockMemorySizeNull(scip,ptr,size) BMSfreeBlockMemorySizeNull(SCIPblkmem(scip), (ptr), (size))
22608 
22609 /**@} */
22610 
22611 
22612 /**@name Buffer Memory Management Macros
22613  *
22614  * @{
22615  */
22616 
22617 
22618 #define SCIPallocBuffer(scip,ptr) ( (BMSallocBufferMemory(SCIPbuffer(scip), (ptr)) == NULL) \
22619  ? SCIP_NOMEMORY : SCIP_OKAY )
22620 #define SCIPallocBufferArray(scip,ptr,num) ( (BMSallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
22621  ? SCIP_NOMEMORY : SCIP_OKAY )
22622 #define SCIPallocClearBufferArray(scip,ptr,num) ( (BMSallocClearBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
22623  ? SCIP_NOMEMORY : SCIP_OKAY )
22624 #define SCIPreallocBufferArray(scip,ptr,num) ( (BMSreallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
22625  ? SCIP_NOMEMORY : SCIP_OKAY )
22626 #define SCIPduplicateBuffer(scip,ptr,source) ( (BMSduplicateBufferMemory(SCIPbuffer(scip), (ptr), (source), (size_t)sizeof(**(ptr))) \
22627  ? SCIP_NOMEMORY : SCIP_OKAY )
22628 #define SCIPduplicateBufferArray(scip,ptr,source,num) ( (BMSduplicateBufferMemoryArray(SCIPbuffer(scip), (ptr), (source), (num)) == NULL) \
22629  ? SCIP_NOMEMORY : SCIP_OKAY )
22630 #define SCIPfreeBuffer(scip,ptr) BMSfreeBufferMemorySize(SCIPbuffer(scip), (ptr))
22631 #define SCIPfreeBufferNull(scip,ptr) BMSfreeBufferMemoryNull(SCIPbuffer(scip), (ptr))
22632 #define SCIPfreeBufferArray(scip,ptr) BMSfreeBufferMemoryArray(SCIPbuffer(scip), (ptr))
22633 #define SCIPfreeBufferArrayNull(scip,ptr) BMSfreeBufferMemoryArrayNull(SCIPbuffer(scip), (ptr))
22634 
22635 
22636 #define SCIPallocCleanBuffer(scip,ptr) ( (BMSallocBufferMemory(SCIPcleanbuffer(scip), (ptr)) == NULL) \
22637  ? SCIP_NOMEMORY : SCIP_OKAY )
22638 #define SCIPallocCleanBufferArray(scip,ptr,num) ( (BMSallocBufferMemoryArray(SCIPcleanbuffer(scip), (ptr), (num)) == NULL) \
22639  ? SCIP_NOMEMORY : SCIP_OKAY )
22640 #define SCIPfreeCleanBuffer(scip,ptr) BMSfreeBufferMemorySize(SCIPcleanbuffer(scip), (ptr))
22641 #define SCIPfreeCleanBufferNull(scip,ptr) BMSfreeBufferMemoryNull(SCIPcleanbuffer(scip), (ptr))
22642 #define SCIPfreeCleanBufferArray(scip,ptr) BMSfreeBufferMemoryArray(SCIPcleanbuffer(scip), (ptr))
22643 #define SCIPfreeCleanBufferArrayNull(scip,ptr) BMSfreeBufferMemoryArrayNull(SCIPcleanbuffer(scip), (ptr))
22644 
22645 /**@} */
22646 
22647 
22648 /**@name Memory Management Functions
22649  *
22650  * @{
22651  */
22652 
22653 /** returns block memory to use at the current time
22654  *
22655  * @return the block memory to use at the current time.
22656  */
22657 extern
22659  SCIP* scip /**< SCIP data structure */
22660  );
22661 
22662 /** returns buffer memory for short living temporary objects
22663  *
22664  * @return the buffer memory for short living temporary objects
22665  */
22666 extern
22668  SCIP* scip /**< SCIP data structure */
22669  );
22670 
22671 /** returns clean buffer memory for short living temporary objects initialized to all zero
22672  *
22673  * @return the buffer memory for short living temporary objects initialized to all zero
22674  */
22675 extern
22677  SCIP* scip /**< SCIP data structure */
22678  );
22679 
22680 /** returns the total number of bytes used in block and buffer memory
22681  *
22682  * @return the total number of bytes used in block and buffer memory.
22683  */
22684 extern
22686  SCIP* scip /**< SCIP data structure */
22687  );
22688 
22689 /** returns the total number of bytes in block and buffer memory
22690  *
22691  * @return the total number of bytes in block and buffer memory.
22692  */
22693 extern
22695  SCIP* scip /**< SCIP data structure */
22696  );
22697 
22698 /** returns the estimated number of bytes used by external software, e.g., the LP solver
22699  *
22700  * @return the estimated number of bytes used by external software, e.g., the LP solver.
22701  */
22702 extern
22704  SCIP* scip /**< SCIP data structure */
22705  );
22706 
22707 /** calculate memory size for dynamically allocated arrays
22708  *
22709  * @return the memory size for dynamically allocated arrays.
22710  */
22711 extern
22713  SCIP* scip, /**< SCIP data structure */
22714  int num /**< minimum number of entries to store */
22715  );
22716 
22717 /** extends a dynamically allocated block memory array to be able to store at least the given number of elements;
22718  * use SCIPensureBlockMemoryArray() define to call this method!
22719  *
22720  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22721  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22722  */
22723 extern
22725  SCIP* scip, /**< SCIP data structure */
22726  void** arrayptr, /**< pointer to dynamically sized array */
22727  size_t elemsize, /**< size in bytes of each element in array */
22728  int* arraysize, /**< pointer to current array size */
22729  int minsize /**< required minimal array size */
22730  );
22731 
22732 /** prints output about used memory */
22733 extern
22735  SCIP* scip /**< SCIP data structure */
22736  );
22737 
22738 /* @} */
22739 
22740 /* @} */
22741 
22742 
22743 /*
22744  * dynamic arrays
22745  */
22746 
22747 /**@defgroup PublicDynamicArrayMethods Dynamic Arrays
22748  * @ingroup DataStructures
22749  * @brief methods for the creation and access of dynamic arrays
22750  *
22751  * @{
22752  */
22753 
22754 /** creates a dynamic array of real values
22755  *
22756  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22757  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22758  */
22759 extern
22761  SCIP* scip, /**< SCIP data structure */
22762  SCIP_REALARRAY** realarray /**< pointer to store the real array */
22763  );
22764 
22765 /** frees a dynamic array of real values
22766  *
22767  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22768  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22769  */
22770 extern
22772  SCIP* scip, /**< SCIP data structure */
22773  SCIP_REALARRAY** realarray /**< pointer to the real array */
22774  );
22775 
22776 /** extends dynamic array to be able to store indices from minidx to maxidx
22777  *
22778  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22779  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22780  */
22781 extern
22783  SCIP* scip, /**< SCIP data structure */
22784  SCIP_REALARRAY* realarray, /**< dynamic real array */
22785  int minidx, /**< smallest index to allocate storage for */
22786  int maxidx /**< largest index to allocate storage for */
22787  );
22788 
22789 /** clears a dynamic real array
22790  *
22791  * @return clears a dynamic real array
22792  */
22793 extern
22795  SCIP* scip, /**< SCIP data structure */
22796  SCIP_REALARRAY* realarray /**< dynamic real array */
22797  );
22798 
22799 /** gets value of entry in dynamic array */
22800 extern
22802  SCIP* scip, /**< SCIP data structure */
22803  SCIP_REALARRAY* realarray, /**< dynamic real array */
22804  int idx /**< array index to get value for */
22805  );
22806 
22807 /** sets value of entry in dynamic array
22808  *
22809  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22810  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22811  */
22812 extern
22814  SCIP* scip, /**< SCIP data structure */
22815  SCIP_REALARRAY* realarray, /**< dynamic real array */
22816  int idx, /**< array index to set value for */
22817  SCIP_Real val /**< value to set array index to */
22818  );
22819 
22820 /** increases value of entry in dynamic array
22821  *
22822  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22823  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22824  */
22825 extern
22827  SCIP* scip, /**< SCIP data structure */
22828  SCIP_REALARRAY* realarray, /**< dynamic real array */
22829  int idx, /**< array index to increase value for */
22830  SCIP_Real incval /**< value to increase array index */
22831  );
22832 
22833 /** returns the minimal index of all stored non-zero elements
22834  *
22835  * @return the minimal index of all stored non-zero elements
22836  */
22837 extern
22839  SCIP* scip, /**< SCIP data structure */
22840  SCIP_REALARRAY* realarray /**< dynamic real array */
22841  );
22842 
22843 /** returns the maximal index of all stored non-zero elements
22844  *
22845  * @return the maximal index of all stored non-zero elements
22846  */
22847 extern
22849  SCIP* scip, /**< SCIP data structure */
22850  SCIP_REALARRAY* realarray /**< dynamic real array */
22851  );
22852 
22853 /** creates a dynamic array of int values
22854  *
22855  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22856  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22857  */
22858 extern
22860  SCIP* scip, /**< SCIP data structure */
22861  SCIP_INTARRAY** intarray /**< pointer to store the int array */
22862  );
22863 
22864 /** frees a dynamic array of int values
22865  *
22866  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22867  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22868  */
22869 extern
22871  SCIP* scip, /**< SCIP data structure */
22872  SCIP_INTARRAY** intarray /**< pointer to the int array */
22873  );
22874 
22875 /** extends dynamic array to be able to store indices from minidx to maxidx
22876  *
22877  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22878  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22879  */
22880 extern
22882  SCIP* scip, /**< SCIP data structure */
22883  SCIP_INTARRAY* intarray, /**< dynamic int array */
22884  int minidx, /**< smallest index to allocate storage for */
22885  int maxidx /**< largest index to allocate storage for */
22886  );
22887 
22888 /** clears a dynamic int array
22889  *
22890  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22891  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22892  */
22893 extern
22895  SCIP* scip, /**< SCIP data structure */
22896  SCIP_INTARRAY* intarray /**< dynamic int array */
22897  );
22898 
22899 /** gets value of entry in dynamic array
22900  *
22901  * @return value of entry in dynamic array
22902  */
22903 extern
22904 int SCIPgetIntarrayVal(
22905  SCIP* scip, /**< SCIP data structure */
22906  SCIP_INTARRAY* intarray, /**< dynamic int array */
22907  int idx /**< array index to get value for */
22908  );
22909 
22910 /** sets value of entry in dynamic array
22911  *
22912  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22913  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22914  */
22915 extern
22917  SCIP* scip, /**< SCIP data structure */
22918  SCIP_INTARRAY* intarray, /**< dynamic int array */
22919  int idx, /**< array index to set value for */
22920  int val /**< value to set array index to */
22921  );
22922 
22923 /** increases value of entry in dynamic array
22924  *
22925  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22926  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22927  */
22928 extern
22930  SCIP* scip, /**< SCIP data structure */
22931  SCIP_INTARRAY* intarray, /**< dynamic int array */
22932  int idx, /**< array index to increase value for */
22933  int incval /**< value to increase array index */
22934  );
22935 
22936 /** returns the minimal index of all stored non-zero elements
22937  *
22938  * @return the minimal index of all stored non-zero elements
22939  */
22940 extern
22942  SCIP* scip, /**< SCIP data structure */
22943  SCIP_INTARRAY* intarray /**< dynamic int array */
22944  );
22945 
22946 /** returns the maximal index of all stored non-zero elements
22947  *
22948  * @return the maximal index of all stored non-zero elements
22949  */
22950 extern
22952  SCIP* scip, /**< SCIP data structure */
22953  SCIP_INTARRAY* intarray /**< dynamic int array */
22954  );
22955 
22956 /** creates a dynamic array of bool values
22957  *
22958  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22959  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22960  */
22961 extern
22963  SCIP* scip, /**< SCIP data structure */
22964  SCIP_BOOLARRAY** boolarray /**< pointer to store the bool array */
22965  );
22966 
22967 /** frees a dynamic array of bool values
22968  *
22969  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22970  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22971  */
22972 extern
22974  SCIP* scip, /**< SCIP data structure */
22975  SCIP_BOOLARRAY** boolarray /**< pointer to the bool array */
22976  );
22977 
22978 /** extends dynamic array to be able to store indices from minidx to maxidx
22979  *
22980  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22981  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22982  */
22983 extern
22985  SCIP* scip, /**< SCIP data structure */
22986  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
22987  int minidx, /**< smallest index to allocate storage for */
22988  int maxidx /**< largest index to allocate storage for */
22989  );
22990 
22991 /** clears a dynamic bool array
22992  *
22993  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22994  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22995  */
22996 extern
22998  SCIP* scip, /**< SCIP data structure */
22999  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
23000  );
23001 
23002 /** gets value of entry in dynamic array
23003  *
23004  * @return value of entry in dynamic array at position idx
23005  */
23006 extern
23008  SCIP* scip, /**< SCIP data structure */
23009  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
23010  int idx /**< array index to get value for */
23011  );
23012 
23013 /** sets value of entry in dynamic array
23014  *
23015  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
23016  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
23017  */
23018 extern
23020  SCIP* scip, /**< SCIP data structure */
23021  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
23022  int idx, /**< array index to set value for */
23023  SCIP_Bool val /**< value to set array index to */
23024  );
23025 
23026 /** returns the minimal index of all stored non-zero elements
23027  *
23028  * @return the minimal index of all stored non-zero elements
23029  */
23030 extern
23032  SCIP* scip, /**< SCIP data structure */
23033  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
23034  );
23035 
23036 /** returns the maximal index of all stored non-zero elements
23037  *
23038  * @return the maximal index of all stored non-zero elements
23039  */
23040 extern
23042  SCIP* scip, /**< SCIP data structure */
23043  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
23044  );
23045 
23046 /** creates a dynamic array of pointers
23047  *
23048  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
23049  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
23050  */
23051 extern
23053  SCIP* scip, /**< SCIP data structure */
23054  SCIP_PTRARRAY** ptrarray /**< pointer to store the int array */
23055  );
23056 
23057 /** frees a dynamic array of pointers
23058  *
23059  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
23060  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
23061  */
23062 extern
23064  SCIP* scip, /**< SCIP data structure */
23065  SCIP_PTRARRAY** ptrarray /**< pointer to the int array */
23066  );
23067 
23068 /** extends dynamic array to be able to store indices from minidx to maxidx
23069  *
23070  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
23071  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
23072  */
23073 extern
23075  SCIP* scip, /**< SCIP data structure */
23076  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
23077  int minidx, /**< smallest index to allocate storage for */
23078  int maxidx /**< largest index to allocate storage for */
23079  );
23080 
23081 /** clears a dynamic pointer array
23082  *
23083  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
23084  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
23085  */
23086 extern
23088  SCIP* scip, /**< SCIP data structure */
23089  SCIP_PTRARRAY* ptrarray /**< dynamic int array */
23090  );
23091 
23092 /** gets value of entry in dynamic array */
23093 extern
23094 void* SCIPgetPtrarrayVal(
23095  SCIP* scip, /**< SCIP data structure */
23096  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
23097  int idx /**< array index to get value for */
23098  );
23099 
23100 /** sets value of entry in dynamic array
23101  *
23102  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
23103  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
23104  */
23105 extern
23107  SCIP* scip, /**< SCIP data structure */
23108  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
23109  int idx, /**< array index to set value for */
23110  void* val /**< value to set array index to */
23111  );
23112 
23113 /** returns the minimal index of all stored non-zero elements
23114  *
23115  * @return the minimal index of all stored non-zero elements
23116  */
23117 extern
23119  SCIP* scip, /**< SCIP data structure */
23120  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
23121  );
23122 
23123 /** returns the maximal index of all stored non-zero elements
23124  *
23125  * @return the maximal index of all stored non-zero elements
23126  */
23127 extern
23129  SCIP* scip, /**< SCIP data structure */
23130  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
23131  );
23132 
23133 /**@} */
23134 
23135 /**@addtogroup DisjointSet
23136  *
23137  * @{
23138  */
23139 
23140 /** creates a disjoint set (union find) structure \p uf for \p ncomponents many components (of size one) */
23141 extern
23143  SCIP* scip, /**< SCIP data structure */
23144  SCIP_DISJOINTSET** djset, /**< disjoint set (union find) data structure */
23145  int ncomponents /**< number of components */
23146  );
23147 
23148 /** frees the disjoint set (union find) data structure */
23149 extern
23150 void SCIPfreeDisjointset(
23151  SCIP* scip, /**< SCIP data structure */
23152  SCIP_DISJOINTSET** djset /**< pointer to disjoint set (union find) data structure */
23153  );
23154 
23155 /* @} */
23156 
23157 /**@addtogroup DirectedGraph
23158  *
23159  * @{
23160  */
23161 
23162 /** creates directed graph structure */
23163 extern
23165  SCIP* scip, /**< SCIP data structure */
23166  SCIP_DIGRAPH** digraph, /**< pointer to store the created directed graph */
23167  int nnodes /**< number of nodes */
23168  );
23169 
23170 /** copies directed graph structure
23171  *
23172  * The copying procedure uses the memory of the passed SCIP instance. The user must ensure that the digraph lives
23173  * as most as long as the SCIP instance.
23174  *
23175  * @note The data in nodedata is copied verbatim. This possibly has to be adapted by the user.
23176  */
23177 extern
23179  SCIP* scip, /**< SCIP data structure */
23180  SCIP_DIGRAPH** targetdigraph, /**< pointer to store the copied directed graph */
23181  SCIP_DIGRAPH* sourcedigraph /**< source directed graph */
23182  );
23183 
23184 /**@} */
23185 
23186 /**@defgroup PublicValidationMethods Validation
23187  * @ingroup PUBLICCOREAPI
23188  * @brief methods for validating the correctness of a solving process
23189  *
23190  * @{
23191  */
23192 
23193 /** validate the result of the solve
23194  *
23195  * the validation includes
23196  *
23197  * - checking the feasibility of the incumbent solution in the original problem (using SCIPcheckSolOrig())
23198  *
23199  * - checking if the objective bounds computed by SCIP agree with external primal and dual reference bounds.
23200  *
23201  * All external reference bounds the original problem space and the original objective sense.
23202  *
23203  * For infeasible problems, +/-SCIPinfinity() should be passed as reference bounds depending on the objective sense
23204  * of the original problem.
23205  */
23206 extern
23208  SCIP* scip, /**< SCIP data structure */
23209  SCIP_Real primalreference, /**< external primal reference value for the problem, or SCIP_UNKNOWN */
23210  SCIP_Real dualreference, /**< external dual reference value for the problem, or SCIP_UNKNOWN */
23211  SCIP_Real reftol, /**< relative tolerance for acceptable violation of reference values */
23212  SCIP_Bool quiet, /**< TRUE if no status line should be printed */
23213  SCIP_Bool* feasible, /**< pointer to store if the best solution is feasible in the original problem,
23214  * or NULL */
23215  SCIP_Bool* primalboundcheck, /**< pointer to store if the primal bound respects the given dual reference
23216  * value, or NULL */
23217  SCIP_Bool* dualboundcheck /**< pointer to store if the dual bound respects the given primal reference
23218  * value, or NULL */
23219  );
23220 
23221 /**@} */
23222 
23223 /**@addtogroup RandomNumbers
23224  *
23225  * @{
23226  */
23227 
23228 /** creates and initializes a random number generator
23229  *
23230  * @note The initial seed is changed using SCIPinitializeRandomSeed()
23231  */
23232 extern
23234  SCIP* scip, /**< SCIP data structure */
23235  SCIP_RANDNUMGEN** randnumgen, /**< random number generator */
23236  unsigned int initialseed /**< initial random seed */
23237  );
23238 
23239 /** frees a random number generator */
23240 extern
23241 void SCIPfreeRandom(
23242  SCIP* scip, /**< SCIP data structure */
23243  SCIP_RANDNUMGEN** randnumgen /**< random number generator */
23244  );
23245 
23246 /** initializes a random number generator with a given seed
23247  *
23248  * @note The seed is changed using SCIPinitializeRandomSeed()
23249  */
23250 extern
23251 void SCIPsetRandomSeed(
23252  SCIP* scip, /**< SCIP data structure */
23253  SCIP_RANDNUMGEN* randnumgen, /**< random number generator */
23254  unsigned int seed /**< new random seed */
23255  );
23256 
23257 /**@} */
23258 
23259 #ifdef __cplusplus
23260 }
23261 #endif
23262 
23263 #endif
SCIP_RETCODE SCIPrespropCons(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
Definition: scip.c:28920
SCIP_RETCODE SCIPaddLinearCoefsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:32408
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_RETCODE SCIPclearConflictStore(SCIP *scip, SCIP_EVENT *event)
Definition: scip.c:13103
SCIP_RETCODE SCIPsetNodeselCopy(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELCOPY((*nodeselcopy)))
Definition: scip.c:8861
SCIP_Real SCIPdualfeasRound(SCIP *scip, SCIP_Real val)
Definition: scip.c:47614
SCIP_RETCODE SCIPcreatePartialSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:38049
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
Definition: scip.c:8209
SCIP_RETCODE SCIPsetPropPresol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPPRESOL((*proppresol)), int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming)
Definition: scip.c:7823
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45698
SCIP_RETCODE SCIPprintBestSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39942
SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
Definition: scip.c:36995
void SCIPfreeRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen)
Definition: scip.c:48620
SCIP_RETCODE SCIPsetPricerPriority(SCIP *scip, SCIP_PRICER *pricer, int priority)
Definition: scip.c:5729
#define SCIP_DECL_RELAXFREE(x)
Definition: type_relax.h:55
SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)
Definition: scip.c:30734
SCIP_RETCODE SCIPincludePresolBasic(SCIP *scip, SCIP_PRESOL **presolptr, const char *name, const char *desc, int priority, int maxrounds, SCIP_PRESOLTIMING timing, SCIP_DECL_PRESOLEXEC((*presolexec)), SCIP_PRESOLDATA *presoldata)
Definition: scip.c:6917
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43743
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
Definition: scip.c:29669
SCIP_RETCODE SCIPclearCuts(SCIP *scip)
Definition: scip.c:35207
int SCIPgetNIntVars(SCIP *scip)
Definition: scip.c:11896
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
Definition: scip.c:43374
SCIP_RETCODE SCIPcreateRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip.c:30298
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:47357
SCIP_RETCODE SCIPcreateEmptyRow(SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip.c:30485
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
Definition: scip.c:5178
SCIP_RETCODE SCIPgetStringParam(SCIP *scip, const char *name, char **value)
Definition: scip.c:4527
int SCIPgetNPrioPseudoBranchBins(SCIP *scip)
Definition: scip.c:37396
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28366
int SCIPgetFocusDepth(SCIP *scip)
Definition: scip.c:43065
SCIP_RETCODE SCIPsetRelaxCopy(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXCOPY((*relaxcopy)))
Definition: scip.c:7182
int SCIPgetNCheckConss(SCIP *scip)
Definition: scip.c:12998
SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
Definition: scip.c:28337
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19205
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
Definition: scip.c:4508
SCIP_Bool SCIPinRepropagation(SCIP *scip)
Definition: scip.c:41453
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: scip.c:6291
#define SCIP_DECL_NODESELCOMP(x)
Definition: type_nodesel.h:126
int SCIPgetNNLPNlRows(SCIP *scip)
Definition: scip.c:31456
SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29778
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:22276
SCIP_RETCODE SCIPlinkLPSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38570
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip.c:46300
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
Definition: scip.c:42371
struct SCIP_PresolData SCIP_PRESOLDATA
Definition: type_presol.h:37
#define SCIP_DECL_HEURINITSOL(x)
Definition: type_heur.h:97
void SCIPprintSeparatorStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44811
SCIP_RETCODE SCIPgetNlRowPseudoActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudoactivity)
Definition: scip.c:32799
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
Definition: scip.c:43836
SCIP_RETCODE SCIPdisableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28506
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5158
SCIP_RETCODE SCIPincludeBranchrule(SCIP *scip, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_DECL_BRANCHCOPY((*branchcopy)), SCIP_DECL_BRANCHFREE((*branchfree)), SCIP_DECL_BRANCHINIT((*branchinit)), SCIP_DECL_BRANCHEXIT((*branchexit)), SCIP_DECL_BRANCHINITSOL((*branchinitsol)), SCIP_DECL_BRANCHEXITSOL((*branchexitsol)), SCIP_DECL_BRANCHEXECLP((*branchexeclp)), SCIP_DECL_BRANCHEXECEXT((*branchexecext)), SCIP_DECL_BRANCHEXECPS((*branchexecps)), SCIP_BRANCHRULEDATA *branchruledata)
Definition: scip.c:9038
SCIP_RETCODE SCIPincIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int incval)
Definition: scip.c:48113
SCIP_RETCODE SCIPsetComprFree(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRFREE((*comprfree)))
Definition: scip.c:8379
struct SCIP_ConcSolverTypeData SCIP_CONCSOLVERTYPEDATA
#define SCIP_DECL_DISPINITSOL(x)
Definition: type_disp.h:106
SCIP_Bool SCIPisDualfeasIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:47566
enum SCIP_NlpTermStat SCIP_NLPTERMSTAT
Definition: type_nlpi.h:84
SCIP_Real SCIPfeastol(SCIP *scip)
Definition: scip.c:46437
#define SCIP_DECL_TABLEINITSOL(x)
Definition: type_table.h:88
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26630
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26884
SCIP_RETCODE SCIPcomputeLPRelIntPoint(SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)
Definition: scip.c:30134
int SCIPgetPlungeDepth(SCIP *scip)
Definition: scip.c:43154
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
Definition: scip.c:31227
int SCIPgetNDelayedPoolCuts(SCIP *scip)
Definition: scip.c:35099
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22517
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30607
SCIP_Bool SCIPisDualfeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47504
SCIP_Bool SCIPisSumRelLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47746
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19643
SCIP_RETCODE SCIPlinkCurrentSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38675
SCIP_RETCODE SCIPcopyOrig(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip.c:3960
SCIP_RETCODE SCIPsetPresolFree(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLFREE((*presolfree)))
Definition: scip.c:6968
SCIP_RETCODE SCIPincludeTable(SCIP *scip, const char *name, const char *desc, SCIP_Bool active, SCIP_DECL_TABLECOPY((*tablecopy)), SCIP_DECL_TABLEFREE((*tablefree)), SCIP_DECL_TABLEINIT((*tableinit)), SCIP_DECL_TABLEEXIT((*tableexit)), SCIP_DECL_TABLEINITSOL((*tableinitsol)), SCIP_DECL_TABLEEXITSOL((*tableexitsol)), SCIP_DECL_TABLEOUTPUT((*tableoutput)), SCIP_TABLEDATA *tabledata, int position, SCIP_STAGE earlieststage)
Definition: scip.c:9452
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47292
public methods for branching and inference history structure
SCIP_RETCODE SCIPsetEventhdlrInitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINITSOL((*eventinitsol)))
Definition: scip.c:8699
SCIP_VAR ** SCIPgetNLPVars(SCIP *scip)
Definition: scip.c:31294
void SCIPprintConstraintStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44495
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition: scip.c:41398
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip.c:821
int SCIPgetSolRunnum(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:39174
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
Definition: scip.c:43361
#define SCIP_DECL_CONCSOLVERSYNCREAD(x)
SCIP_RETCODE SCIPextendBoolarray(SCIP *scip, SCIP_BOOLARRAY *boolarray, int minidx, int maxidx)
Definition: scip.c:48194
SCIP_RETCODE SCIPchgBarrierconvtol(SCIP *scip, SCIP_Real barrierconvtol)
Definition: scip.c:46592
SCIP_NODESEL ** SCIPgetNodesels(SCIP *scip)
Definition: scip.c:8970
struct SCIP_DispData SCIP_DISPDATA
Definition: type_disp.h:62
SCIP_RETCODE SCIPincSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real incval)
Definition: scip.c:38862
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: scip.c:6314
public methods for branch and bound tree
SCIP_RETCODE SCIPgetNLPIntPar(SCIP *scip, SCIP_NLPPARAM type, int *ival)
Definition: scip.c:31761
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
Definition: scip.c:19109
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
Definition: scip.c:35958
SCIP_RETCODE SCIPsetBranchruleExecPs(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECPS((*branchexecps)))
Definition: scip.c:9253
internal methods for branch and bound tree
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
Definition: scip.c:42327
SCIP_RETCODE SCIPcopyOrigProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name)
Definition: scip.c:1792
type definitions for miscellaneous datastructures
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip.c:27001
int SCIPgetNRelaxs(SCIP *scip)
Definition: scip.c:7305
timing definitions for SCIP
SCIP_RETCODE SCIPcreateEmptyRowUnspec(SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip.c:30454
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47305
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
Definition: scip.c:21896
SCIP_RETCODE SCIPrecalcRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30935
SCIP_Bool SCIPisSumGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47243
void SCIPdialogMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip.c:1326
SCIP_Bool SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47668
#define SCIP_DECL_COMPREXEC(x)
Definition: type_compr.h:111
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19503
type definitions for NLP management
SCIP_RETCODE SCIPbranchVarHole(SCIP *scip, SCIP_VAR *var, SCIP_Real left, SCIP_Real right, SCIP_NODE **downchild, SCIP_NODE **upchild)
Definition: scip.c:37645
SCIP_RETCODE SCIPcreateBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
Definition: scip.c:48160
SCIP_RETCODE SCIPgetNLPNlRowsData(SCIP *scip, SCIP_NLROW ***nlrows, int *nnlrows)
Definition: scip.c:31406
SCIP_RETCODE SCIPgetSolVarsData(SCIP *scip, SCIP_SOL *sol, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip.c:12435
SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
Definition: scip.c:46256
#define SCIP_DECL_DIALOGCOPY(x)
Definition: type_dialog.h:53
SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)
Definition: scip.c:11108
SCIP_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)
Definition: scip.c:9827
SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26658
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
Definition: scip.c:43292
SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip, SCIP_Bool includeslp)
Definition: scip.c:20066
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:41220
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
Definition: scip.c:6604
int SCIPgetProbingDepth(SCIP *scip)
Definition: scip.c:35931
SCIP_RETCODE SCIPsetPresolExit(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXIT((*presolexit)))
Definition: scip.c:7000
SCIP_Real SCIPgetReadingTime(SCIP *scip)
Definition: scip.c:46327
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
Definition: scip.c:43447
SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
Definition: scip.c:29941
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26545
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30630
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
Definition: scip.c:43396
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:129
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
Definition: scip.c:47655
SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:36672
SCIP_RETCODE SCIPcreateNlpiProb(SCIP *scip, SCIP_NLPI *nlpi, SCIP_NLROW **nlrows, int nnlrows, SCIP_NLPIPROBLEM *nlpiprob, SCIP_HASHMAP *var2idx, SCIP_Real *nlscore, SCIP_Real cutoffbound, SCIP_Bool setobj, SCIP_Bool onlyconvex)
Definition: scip.c:34026
#define SCIP_DECL_PROBINITSOL(x)
Definition: type_prob.h:97
public methods for implications, variable bounds, and cliques
int SCIPgetIntarrayMaxIdx(SCIP *scip, SCIP_INTARRAY *intarray)
Definition: scip.c:48145
SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)
#define infinity
Definition: gastrans.c:71
SCIP_RETCODE SCIPadjustImplicitSolVals(SCIP *scip, SCIP_SOL *sol, SCIP_Bool uselprows)
Definition: scip.c:39276
SCIP_Real * SCIPgetNLPVarsUbDualsol(SCIP *scip)
Definition: scip.c:31384
SCIP_Bool SCIPisFeasFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:47405
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
Definition: scip.c:7873
int SCIPgetNEventhdlrs(SCIP *scip)
Definition: scip.c:8765
SCIP_RETCODE SCIPcreateRowUnspec(SCIP *scip, SCIP_ROW **row, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip.c:30332
#define SCIP_DECL_BRANCHEXECPS(x)
Definition: type_branch.h:161
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
Definition: scip.c:6544
SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)
Definition: scip.c:13363
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip.c:4489
SCIP_RETCODE SCIPsetComprInit(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINIT((*comprinit)))
Definition: scip.c:8395
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
Definition: scip.c:43475
SCIP_RETCODE SCIPgetLeaves(SCIP *scip, SCIP_NODE ***leaves, int *nleaves)
Definition: scip.c:41555
SCIP_SEPA * SCIPfindSepa(SCIP *scip, const char *name)
Definition: scip.c:7523
SCIP_RETCODE SCIPsetMessagehdlr(SCIP *scip, SCIP_MESSAGEHDLR *messagehdlr)
Definition: scip.c:1200
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip.c:26025
#define SCIP_DECL_PROBDELORIG(x)
Definition: type_prob.h:55
#define SCIP_DECL_CONSINITPRE(x)
Definition: type_cons.h:140
SCIP_RETCODE SCIPsetProbCopy(SCIP *scip, SCIP_DECL_PROBCOPY((*probcopy)))
Definition: scip.c:10123
SCIP_RETCODE SCIPsetEventhdlrExitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXITSOL((*eventexitsol)))
Definition: scip.c:8713
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
Definition: scip.c:46677
int SCIPgetNPrioPseudoBranchImpls(SCIP *scip)
Definition: scip.c:37432
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
Definition: scip.c:43613
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
Definition: scip.c:42480
SCIP_RETCODE SCIPaddSolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool *stored)
Definition: scip.c:40584
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
Definition: scip.c:6036
SCIP_RETCODE SCIPcreateRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed)
Definition: scip.c:48602
unsigned int SCIP_HEURTIMING
Definition: type_timing.h:97
SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)
Definition: scip.c:9936
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28394
SCIP_RETCODE SCIPchgConsName(SCIP *scip, SCIP_CONS *cons, const char *name)
Definition: scip.c:27806
SCIP_RETCODE SCIPsetParam(SCIP *scip, const char *name, void *value)
Definition: scip.c:4585
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition: type_cons.h:900
#define SCIP_DECL_CONSPRESOL(x)
Definition: type_cons.h:544
SCIP_RETCODE SCIPsetEventhdlrExit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXIT((*eventexit)))
Definition: scip.c:8685
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:12657
void SCIPsetRandomSeed(SCIP *scip, SCIP_RANDNUMGEN *randnumgen, unsigned int seed)
Definition: scip.c:48635
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
Definition: scip.c:8177
SCIP_RETCODE SCIPsetRelaxInit(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINIT((*relaxinit)))
Definition: scip.c:7214
int SCIPcalcMemGrowSize(SCIP *scip, int num)
Definition: scip.c:46807
static long bound
SCIP_Bool SCIPisSumPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:47268
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:30662
SCIP_RETCODE SCIPrecomputeSolObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:39066
SCIP_RETCODE SCIPcreateCPUClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:46024
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19375
SCIP_RETCODE SCIPevalExprtreeGlobalBounds(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
Definition: scip.c:33160
SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
Definition: scip.c:27953
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:76
void SCIPprintConcsolverStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45455
SCIP_Real SCIPgetRowPseudoFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:31025
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:47082
SCIP_Bool SCIPisSumRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47733
SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
Definition: scip.c:19072
int SCIPgetNOrigVars(SCIP *scip)
Definition: scip.c:12246
#define SCIP_DECL_NODESELINITSOL(x)
Definition: type_nodesel.h:83
int SCIPgetNSiblings(SCIP *scip)
Definition: scip.c:41537
SCIP_Bool SCIPisStringParamValid(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip.c:4935
SCIP_Bool SCIPisUpdateUnreliable(SCIP *scip, SCIP_Real newvalue, SCIP_Real oldvalue)
Definition: scip.c:47840
SCIP_RETCODE SCIPgetVarStrongbranchLast(SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
Definition: scip.c:21511
SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)
Definition: scip.c:30194
SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
Definition: scip.c:35083
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:27382
SCIP_RETCODE SCIPchgNlRowRhs(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real rhs)
Definition: scip.c:32338
SCIP_RELAX ** SCIPgetRelaxs(SCIP *scip)
Definition: scip.c:7292
int SCIPgetNPseudoBranchCands(SCIP *scip)
Definition: scip.c:37359
SCIP_RETCODE SCIPincludeNodeselBasic(SCIP *scip, SCIP_NODESEL **nodesel, const char *name, const char *desc, int stdpriority, int memsavepriority, SCIP_DECL_NODESELSELECT((*nodeselselect)), SCIP_DECL_NODESELCOMP((*nodeselcomp)), SCIP_NODESELDATA *nodeseldata)
Definition: scip.c:8825
void SCIPdeactivateSolViolationUpdates(SCIP *scip)
Definition: scip.c:13816
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47009
char ** SCIPgetExternalCodeDescriptions(SCIP *scip)
Definition: scip.c:9659
SCIP_RETCODE SCIPinferVarLbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23205
SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28563
#define SCIP_DECL_COMPREXITSOL(x)
Definition: type_compr.h:95
SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
Definition: scip.c:6406
int SCIPgetNLeaves(SCIP *scip)
Definition: scip.c:41579
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:22180
SCIP_Bool SCIPreoptimizeNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:17453
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
Definition: scip.c:44104
SCIP_Bool SCIPisDualfeasFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:47578
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
Definition: scip.c:8611
SCIP_RETCODE SCIPdelConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)
Definition: scip.c:13241
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
Definition: type_branch.h:43
SCIP_RETCODE SCIPcreateRealarray(SCIP *scip, SCIP_REALARRAY **realarray)
Definition: scip.c:47858
SCIP_NLPSOLSTAT SCIPgetNLPSolstat(SCIP *scip)
Definition: scip.c:31610
SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:26270
enum SCIP_DispMode SCIP_DISPMODE
Definition: type_disp.h:59
#define SCIP_DECL_PRESOLINITPRE(x)
Definition: type_presol.h:84
SCIP_RETCODE SCIPcopyPlugins(SCIP *sourcescip, SCIP *targetscip, SCIP_Bool copyreaders, SCIP_Bool copypricers, SCIP_Bool copyconshdlrs, SCIP_Bool copyconflicthdlrs, SCIP_Bool copypresolvers, SCIP_Bool copyrelaxators, SCIP_Bool copyseparators, SCIP_Bool copypropagators, SCIP_Bool copyheuristics, SCIP_Bool copyeventhdlrs, SCIP_Bool copynodeselectors, SCIP_Bool copybranchrules, SCIP_Bool copydisplays, SCIP_Bool copydialogs, SCIP_Bool copytables, SCIP_Bool copynlpis, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip.c:1568
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
Definition: scip.c:43859
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip.c:18951
SCIP_DECL_READERFREE(ReaderTSP::scip_free)
Definition: ReaderTSP.cpp:137
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip.c:44256
SCIP_RETCODE SCIPcatchRowEvent(SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:41306
SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip.c:34941
SCIP_Real SCIPfeasRound(SCIP *scip, SCIP_Real val)
Definition: scip.c:47441
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
Definition: scip.c:28106
SCIP_RETCODE SCIPsetNlRowExprtreeParam(SCIP *scip, SCIP_NLROW *nlrow, int paramidx, SCIP_Real paramval)
Definition: scip.c:32648
SCIP_DECL_EVENTEXIT(EventhdlrNewSol::scip_exit)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
Definition: scip.c:18032
SCIP_RETCODE SCIPsetBranchruleInitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINITSOL((*branchinitsol)))
Definition: scip.c:9187
SCIP_RETCODE SCIPextendIntarray(SCIP *scip, SCIP_INTARRAY *intarray, int minidx, int maxidx)
Definition: scip.c:48043
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
Definition: scip.c:42444
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip.c:18760
interface methods for specific LP solvers
struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA
Definition: type_event.h:138
SCIP_RETCODE SCIPchgVarObjDiveNLP(SCIP *scip, SCIP_VAR *var, SCIP_Real coef)
Definition: scip.c:32060
SCIP_Real SCIPgetBranchingPoint(SCIP *scip, SCIP_VAR *var, SCIP_Real suggestion)
Definition: scip.c:37498
SCIP_TABLE * SCIPfindTable(SCIP *scip, const char *name)
Definition: scip.c:9490
SCIP_RETCODE SCIPgetOpenNodesData(SCIP *scip, SCIP_NODE ***leaves, SCIP_NODE ***children, SCIP_NODE ***siblings, int *nleaves, int *nchildren, int *nsiblings)
Definition: scip.c:41705
#define SCIP_DECL_PRICEREXIT(x)
Definition: type_pricer.h:70
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
Definition: scip.c:6205
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:46109
SCIP_RETCODE SCIPaddRowDive(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:35503
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:47381
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip.c:30025
SCIP_RETCODE SCIPsetBranchruleExit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))
Definition: scip.c:9171
SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:35045
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
Definition: scip.c:22483
SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
SCIP_RETCODE SCIPincRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real incval)
Definition: scip.c:47962
SCIP_Real SCIPdualfeastol(SCIP *scip)
Definition: scip.c:46465
SCIP_RETCODE SCIPsetRelaxExitsol(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXITSOL((*relaxexitsol)))
Definition: scip.c:7262
int SCIPgetMaxDepth(SCIP *scip)
Definition: scip.c:43089
SCIP_RETCODE SCIPconvertCutsToConss(SCIP *scip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
Definition: scip.c:3005
void SCIPprintStatusStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44299
SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip.c:28207
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26161
SCIP_RETCODE SCIPsetNlRowExprtree(SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPRTREE *exprtree)
Definition: scip.c:32622
#define SCIP_DECL_PROBDELTRANS(x)
Definition: type_prob.h:86
SCIP_RETCODE SCIPchgNlRowLinearCoef(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real coef)
Definition: scip.c:32445
void SCIPgetDiveBoundChangeData(SCIP *scip, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
Definition: scip.c:36935
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip.c:26352
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47344
SCIP_RETCODE SCIPextendRealarray(SCIP *scip, SCIP_REALARRAY *realarray, int minidx, int maxidx)
Definition: scip.c:47892
SCIP_RETCODE SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
Definition: scip.c:9139
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
Definition: scip.c:45875
#define SCIP_DECL_BRANCHFREE(x)
Definition: type_branch.h:60
int SCIPmajorVersion(void)
Definition: scip.c:567
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip.c:11680
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
Definition: scip.c:42554
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:595
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5106
SCIP_RETCODE SCIPsetProbExitsol(SCIP *scip, SCIP_DECL_PROBEXITSOL((*probexitsol)))
Definition: scip.c:10102
#define SCIP_DECL_CONCSOLVEREXEC(x)
SCIP_Bool SCIPisSumNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:47280
void SCIPprintTransProblemStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44352
SCIP_RETCODE SCIPchgReoptObjective(SCIP *scip, SCIP_OBJSENSE objsense, SCIP_VAR **vars, SCIP_Real *coefs, int nvars)
Definition: scip.c:10937
SCIP_SOL ** SCIPgetSols(SCIP *scip)
Definition: scip.c:39826
void SCIPprintTimingStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45569
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
Definition: scip.c:21979
#define SCIP_DECL_PRESOLCOPY(x)
Definition: type_presol.h:46
SCIP_Real SCIPgetDeterministicTime(SCIP *scip)
Definition: scip.c:44129
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
Definition: scip.c:42738
SCIP_RETCODE SCIPsetNodeselMemsavePriority(SCIP *scip, SCIP_NODESEL *nodesel, int priority)
Definition: scip.c:9007
void SCIPsetSubscipDepth(SCIP *scip, int newdepth)
Definition: scip.c:3563
methods for the aggregation rows
#define SCIP_DECL_PRICERINIT(x)
Definition: type_pricer.h:62
SCIP_RETCODE SCIPbranchVarValNary(SCIP *scip, SCIP_VAR *var, SCIP_Real val, int n, SCIP_Real minwidth, SCIP_Real widthfactor, int *nchildren)
Definition: scip.c:37743
SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26388
SCIP_RETCODE SCIPaddLongintParam(SCIP *scip, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip.c:4293
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:98
SCIP_RETCODE SCIPincludeCompr(SCIP *scip, const char *name, const char *desc, int priority, int minnnodes, SCIP_DECL_COMPRCOPY((*comprcopy)), SCIP_DECL_COMPRFREE((*comprfree)), SCIP_DECL_COMPRINIT((*comprinit)), SCIP_DECL_COMPREXIT((*comprexit)), SCIP_DECL_COMPRINITSOL((*comprinitsol)), SCIP_DECL_COMPREXITSOL((*comprexitsol)), SCIP_DECL_COMPREXEC((*comprexec)), SCIP_COMPRDATA *comprdata)
Definition: scip.c:8282
SCIP_Bool SCIPhasNLPContinuousNonlinearity(SCIP *scip)
Definition: scip.c:31242
SCIP_RETCODE SCIPincludeRelaxBasic(SCIP *scip, SCIP_RELAX **relaxptr, const char *name, const char *desc, int priority, int freq, SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)
Definition: scip.c:7148
SCIP_RETCODE SCIPinferBinvarProp(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23428
#define SCIP_DECL_RELAXINIT(x)
Definition: type_relax.h:63
SCIP_RETCODE SCIPcopyLimits(SCIP *sourcescip, SCIP *targetscip)
Definition: scip.c:4192
SCIP_NODE * SCIPgetBestSibling(SCIP *scip)
Definition: scip.c:41643
#define SCIP_DECL_RELAXINITSOL(x)
Definition: type_relax.h:82
struct SCIP_LPiNorms SCIP_LPINORMS
Definition: type_lpi.h:98
int SCIPgetSubscipDepth(SCIP *scip)
Definition: scip.c:3542
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
Definition: scip.c:5894
int SCIPgetNPartialSols(SCIP *scip)
Definition: scip.c:40947
SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34786
SCIP_Bool SCIPisIntParamValid(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip.c:4703
SCIP_RETCODE SCIPparseCons(SCIP *scip, SCIP_CONS **cons, const char *str, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool *success)
Definition: scip.c:27662
int SCIPgetNActivePricers(SCIP *scip)
Definition: scip.c:5718
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23899
SCIP_COMPR * SCIPfindCompr(SCIP *scip, const char *name)
Definition: scip.c:8459
SCIP_RETCODE SCIPaddQuadElementToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelem)
Definition: scip.c:32532
SCIP_RETCODE SCIPsetNodeselExit(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXIT((*nodeselexit)))
Definition: scip.c:8909
SCIP_RETCODE SCIPpropagateProbingImplications(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:36414
void SCIPprintExternalCodes(SCIP *scip, FILE *file)
Definition: scip.c:9684
#define SCIP_DECL_TABLEFREE(x)
Definition: type_table.h:61
SCIP_RETCODE SCIPcopyConsCompression(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip.c:3884
SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:41741
SCIP_Real SCIPinfinity(SCIP *scip)
Definition: scip.c:47022
SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip.c:26053
SCIP_VERBLEVEL SCIPgetVerbLevel(SCIP *scip)
Definition: scip.c:1384
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:47094
SCIP_RETCODE SCIPenableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28478
SCIP_Bool SCIPexistsDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9748
SCIP_PRICER * SCIPfindPricer(SCIP *scip, const char *name)
Definition: scip.c:5681
void SCIPclearExternBranchCands(SCIP *scip)
Definition: scip.c:37290
SCIP_RETCODE SCIPincludeComprBasic(SCIP *scip, SCIP_COMPR **compr, const char *name, const char *desc, int priority, int minnnodes, SCIP_DECL_COMPREXEC((*comprexec)), SCIP_COMPRDATA *comprdata)
Definition: scip.c:8325
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28624
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:27468
SCIP_RETCODE SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
Definition: scip.c:9123
#define SCIP_DECL_HEURCOPY(x)
Definition: type_heur.h:62
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)
Definition: scip.c:13402
#define SCIP_DECL_PROPEXITPRE(x)
Definition: type_prop.h:100
#define SCIP_DECL_HEUREXEC(x)
Definition: type_heur.h:128
SCIP_Real SCIPgetSolTime(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:39147
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:27245
SCIP_RETCODE SCIPsolveNLP(SCIP *scip)
Definition: scip.c:31587
#define SCIP_DECL_CONSGETNVARS(x)
Definition: type_cons.h:865
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
Definition: scip.c:21654
methods commonly used by primal heuristics
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21555
SCIP_RETCODE SCIPcreateIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
Definition: scip.c:48009
SCIP_RETCODE SCIPincludeHeur(SCIP *scip, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEURCOPY((*heurcopy)), SCIP_DECL_HEURFREE((*heurfree)), SCIP_DECL_HEURINIT((*heurinit)), SCIP_DECL_HEUREXIT((*heurexit)), SCIP_DECL_HEURINITSOL((*heurinitsol)), SCIP_DECL_HEUREXITSOL((*heurexitsol)), SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
Definition: scip.c:8034
SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip.c:10426
SCIP_Real SCIPgetBranchScoreMultiple(SCIP *scip, SCIP_VAR *var, int nchildren, SCIP_Real *gains)
Definition: scip.c:37473
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5132
SCIP_RETCODE SCIPsetComprInitsol(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINITSOL((*comprinitsol)))
Definition: scip.c:8427
void SCIPprintHeuristicStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44935
int SCIPgetNReoptnodes(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:16816
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
Definition: scip.c:9269
char ** SCIPgetExternalCodeNames(SCIP *scip)
Definition: scip.c:9645
SCIP_RETCODE SCIPincludeRelax(SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_DECL_RELAXCOPY((*relaxcopy)), SCIP_DECL_RELAXFREE((*relaxfree)), SCIP_DECL_RELAXINIT((*relaxinit)), SCIP_DECL_RELAXEXIT((*relaxexit)), SCIP_DECL_RELAXINITSOL((*relaxinitsol)), SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)
Definition: scip.c:7106
SCIP_DECL_READERWRITE(ReaderTSP::scip_write)
Definition: ReaderTSP.cpp:472
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip.c:8238
SCIP_RETCODE SCIPsetProbData(SCIP *scip, SCIP_PROBDATA *probdata)
Definition: scip.c:10832
SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:35439
SCIP_RETCODE SCIPfreeIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
Definition: scip.c:48026
int SCIPgetNPrioPseudoBranchInts(SCIP *scip)
Definition: scip.c:37414
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
Definition: scip.c:43228
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
Definition: scip.c:42390
SCIP_RETCODE SCIPgetLPBInvCol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29813
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:172
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
Definition: scip.c:17693
SCIP_Longint SCIPgetNNZs(SCIP *scip)
Definition: scip.c:42353
SCIP_RETCODE SCIPisConflictVarUsed(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
Definition: scip.c:27416
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26912
SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
Definition: scip.c:34554
SCIP_Bool SCIPisDualfeasZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:47530
SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
Definition: scip.c:12219
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26420
SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip.c:4778
SCIP_BANDITVTABLE * SCIPfindBanditvtable(SCIP *scip, const char *name)
Definition: scip_bandit.c:64
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26969
struct SCIP_HeurData SCIP_HEURDATA
Definition: type_heur.h:51
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
Definition: scip.c:42792
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:200
public methods for displaying runtime statistics
int SCIPgetNActiveConss(SCIP *scip)
Definition: scip.c:43174
int SCIPgetNNodesLeft(SCIP *scip)
Definition: scip.c:42172
public methods for problem variables
SCIP_RETCODE SCIPevalExprtreeSol(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_SOL *sol, SCIP_Real *val)
Definition: scip.c:33105
void SCIPdebugMessagePrint(SCIP *scip, const char *formatstr,...)
Definition: scip.c:1310
SCIP_RETCODE SCIPsetSepaPriority(SCIP *scip, SCIP_SEPA *sepa, int priority)
Definition: scip.c:7560
static GRAPHNODE ** active
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
Definition: scip.c:27212
SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
Definition: scip.c:36909
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:26289
struct SCIP_DialogData SCIP_DIALOGDATA
Definition: type_dialog.h:42
SCIP_RETCODE SCIPsetConflicthdlrExitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)))
Definition: scip.c:6800
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
Definition: scip.c:27149
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip)
Definition: scip.c:19883
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
Definition: scip.c:43137
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22633
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
Definition: scip.c:42720
#define SCIP_DECL_BRANCHEXECEXT(x)
Definition: type_branch.h:140
SCIP_Real SCIPgetRelaxSolObj(SCIP *scip)
Definition: scip.c:20139
SCIP_RETCODE SCIPincludeHeurBasic(SCIP *scip, SCIP_HEUR **heur, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
Definition: scip.c:8084
SCIP_RETCODE SCIPaddStringParam(SCIP *scip, const char *name, const char *desc, char **valueptr, SCIP_Bool isadvanced, const char *defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip.c:4376
SCIP_Bool SCIPgetVarWasFixedAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19801
SCIP_RETCODE SCIPenableOrDisableStatisticTiming(SCIP *scip)
Definition: scip.c:46149
SCIP_READER * SCIPfindReader(SCIP *scip, const char *name)
Definition: scip.c:5390
SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28533
void SCIPprintPresolverStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44377
SCIP_Bool SCIPallVarsInProb(SCIP *scip)
Definition: scip.c:12558
void SCIPaddBilinLinearization(SCIP *scip, SCIP_Real bilincoef, SCIP_Real refpointx, SCIP_Real refpointy, SCIP_Real *lincoefx, SCIP_Real *lincoefy, SCIP_Real *linconstant, SCIP_Bool *success)
Definition: scip.c:33403
SCIP_RETCODE SCIPinitRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:16979
type definitions for return codes for SCIP methods
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26079
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
Definition: scip.c:5948
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:36034
SCIP_RETCODE SCIPrecalcRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:31043
#define SCIP_DECL_PRICEREXITSOL(x)
Definition: type_pricer.h:92
int SCIPgetPtrarrayMaxIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
Definition: scip.c:48406
SCIP_RETCODE SCIPgetOrigVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip.c:12171
unsigned int SCIP_DIVETYPE
Definition: type_heur.h:48
SCIP_RETCODE SCIPgetNlRowSolActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Real *activity)
Definition: scip.c:32929
SCIP_RETCODE SCIPwriteParam(SCIP *scip, SCIP_PARAM *param, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip.c:4970
public methods for branching rules
SCIP_RETCODE SCIPgetNLPVarsNonlinearity(SCIP *scip, int *nlcount)
Definition: scip.c:31338
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
Definition: scip.c:8741
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
Definition: scip.c:1235
SCIP_RETCODE SCIPincludeBranchruleBasic(SCIP *scip, SCIP_BRANCHRULE **branchruleptr, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_BRANCHRULEDATA *branchruledata)
Definition: scip.c:9086
void SCIPprintReal(SCIP *scip, FILE *file, SCIP_Real val, int width, int precision)
Definition: scip.c:46650
SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
SCIP_RETCODE SCIPsetPricerExit(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXIT((*pricerexit)))
Definition: scip.c:5617
#define SCIP_DECL_SEPAEXECLP(x)
Definition: type_sepa.h:116
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:22224
SCIP_RETCODE SCIPwriteVarsPolynomial(SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
Definition: scip.c:17903
void SCIPresetReoptSolMarks(SCIP *scip)
Definition: scip.c:17393
SCIP_RETCODE SCIPsetPricerExitsol(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXITSOL((*pricerexitsol)))
Definition: scip.c:5665
SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23869
#define SCIP_DECL_PROBCOPY(x)
Definition: type_prob.h:140
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:46058
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip.c:46725
SCIP_RETCODE SCIPflushNLP(SCIP *scip)
Definition: scip.c:31502
int SCIPgetNCutsFoundRound(SCIP *scip)
Definition: scip.c:42914
enum SCIP_NlpParam SCIP_NLPPARAM
Definition: type_nlpi.h:56
SCIP_CONS ** SCIPgetConss(SCIP *scip)
Definition: scip.c:12902
type definitions for presolvers
SCIP_RETCODE SCIPsetNLPIntPar(SCIP *scip, SCIP_NLPPARAM type, int ival)
Definition: scip.c:31789
SCIP_RETCODE SCIPcreateRow(SCIP *scip, SCIP_ROW **row, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip.c:30366
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:22010
SCIP_Bool SCIPisLPDualReliable(SCIP *scip)
Definition: scip.c:29326
int SCIPgetNPresols(SCIP *scip)
Definition: scip.c:7074
SCIP_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:47453
SCIP_RETCODE SCIPsetNLPStringPar(SCIP *scip, SCIP_NLPPARAM type, const char *sval)
Definition: scip.c:31901
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46957
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip.c:23969
SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:29243
SCIP_RETCODE SCIPgetExternBranchCands(SCIP *scip, SCIP_VAR ***externcands, SCIP_Real **externcandssol, SCIP_Real **externcandsscore, int *nexterncands, int *nprioexterncands, int *nprioexternbins, int *nprioexternints, int *nprioexternimpls)
Definition: scip.c:37111
#define SCIP_DECL_BRANCHEXITSOL(x)
Definition: type_branch.h:98
SCIP_RETCODE SCIPcaptureDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9763
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37914
SCIP_RETCODE SCIPmarkRelaxSolInvalid(SCIP *scip)
Definition: scip.c:20089
SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
Definition: scip.c:21947
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
SCIP_RETCODE SCIPcreate(SCIP **scip)
Definition: scip.c:748
SCIP_RETCODE SCIPaddCurrentSol(SCIP *scip, SCIP_HEUR *heur, SCIP_Bool *stored)
Definition: scip.c:40654
SCIP_RETCODE SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
Definition: scip.c:6688
#define SCIP_DECL_PROPEXEC(x)
Definition: type_prop.h:203
SCIP_Bool SCIPisTransformed(SCIP *scip)
Definition: scip.c:1017
int SCIPgetNLPBranchCands(SCIP *scip)
Definition: scip.c:37028
SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
Definition: scip.c:29556
SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip.c:24028
SCIP_Bool SCIPpressedCtrlC(SCIP *scip)
Definition: scip.c:1132
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
Definition: scip.c:7427
SCIP_RETCODE SCIPsetConshdlrDelvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: scip.c:6475
SCIP_RETCODE SCIPdropRowEvent(SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:41346
#define SCIP_DECL_PRICERCOPY(x)
Definition: type_pricer.h:46
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
Definition: scip.c:4804
#define SCIP_DECL_DIVESETGETSCORE(x)
Definition: type_heur.h:149
SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip.c:4894
void SCIPcomputeBilinEnvelope2(SCIP *scip, SCIP_Real bilincoef, SCIP_Real lbx, SCIP_Real ubx, SCIP_Real refpointx, SCIP_Real lby, SCIP_Real uby, SCIP_Real refpointy, SCIP_Bool overestimate, SCIP_Real alpha1, SCIP_Real beta1, SCIP_Real gamma1, SCIP_Real alpha2, SCIP_Real beta2, SCIP_Real gamma2, SCIP_Real *RESTRICT lincoefx, SCIP_Real *RESTRICT lincoefy, SCIP_Real *RESTRICT linconstant, SCIP_Bool *RESTRICT success)
Definition: scip.c:33893
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: scip.c:6337
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
Definition: scip.c:41417
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip.c:1267
SCIP_SOL ** SCIPgetPartialSols(SCIP *scip)
Definition: scip.c:40924
int SCIPgetNPrioExternBranchImpls(SCIP *scip)
Definition: scip.c:37224
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:22363
#define SCIP_DECL_NODESELEXITSOL(x)
Definition: type_nodesel.h:94
#define SCIP_DECL_CONFLICTEXIT(x)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip.c:4265
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip.c:18992
#define SCIP_DECL_COMPRINIT(x)
Definition: type_compr.h:65
SCIP_RETCODE SCIPcopyParamSettings(SCIP *sourcescip, SCIP *targetscip)
Definition: scip.c:3501
SCIP_Bool SCIPisRootLPRelax(SCIP *scip)
Definition: scip.c:29470
SCIP_Bool SCIPisSumZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:47256
int SCIPgetIntarrayMinIdx(SCIP *scip, SCIP_INTARRAY *intarray)
Definition: scip.c:48131
SCIP_RETCODE SCIPaddLinearCoefToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:32384
SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
Definition: scip.c:34807
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: scip.c:6521
SCIP_RETCODE SCIPfreeReoptSolve(SCIP *scip)
Definition: scip.c:17183
void SCIPprintBranchruleStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44892
SCIP_Real SCIPgetPresolvingTime(SCIP *scip)
Definition: scip.c:46364
#define SCIP_DECL_CONSINITLP(x)
Definition: type_cons.h:243
SCIP_RETCODE SCIPensureBlockMemoryArray_call(SCIP *scip, void **arrayptr, size_t elemsize, int *arraysize, int minsize)
Definition: scip.c:46823
#define SCIP_DECL_CONCSOLVERDESTROYINST(x)
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45645
type definitions for branching rules
SCIP_RETCODE SCIPactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:29017
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:44043
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip.c:1343
int SCIPgetNContVars(SCIP *scip)
Definition: scip.c:11986
SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:31085
#define SCIP_DECL_DISPCOPY(x)
Definition: type_disp.h:71
SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: scip.c:27578
SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)
Definition: scip.c:9997
SCIP_Real SCIPgetObjNorm(SCIP *scip)
Definition: scip.c:11459
SCIP_NLROW ** SCIPgetNLPNlRows(SCIP *scip)
Definition: scip.c:31434
SCIP_RETCODE SCIPcreateDigraph(SCIP *scip, SCIP_DIGRAPH **digraph, int nnodes)
Definition: scip.c:48562
SCIP_DISP * SCIPfindDisp(SCIP *scip, const char *name)
Definition: scip.c:9393
SCIP_Real SCIPepsilon(SCIP *scip)
Definition: scip.c:46409
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
Definition: scip.c:18208
SCIP_DECL_EVENTINITSOL(EventhdlrNewSol::scip_initsol)
SCIP_RETCODE SCIPcreateOrigSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:38109
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: scip.c:23917
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:27178
SCIP_RETCODE SCIPgetSiblings(SCIP *scip, SCIP_NODE ***siblings, int *nsiblings)
Definition: scip.c:41513
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
Definition: scip.c:43316
SCIP_Real SCIPbarrierconvtol(SCIP *scip)
Definition: scip.c:46479
SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30883
SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23792
SCIP_RETCODE SCIPdeleteReoptnode(SCIP *scip, SCIP_REOPTNODE **reoptnode)
Definition: scip.c:17493
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
Definition: scip.c:47429
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23813
SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30917
SCIP_Real SCIPrelaxfeastol(SCIP *scip)
Definition: scip.c:46508
SCIP_RETCODE SCIPrepropagateNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:41762
SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip.c:18901
SCIP_RETCODE SCIPcreateNlRowFromRow(SCIP *scip, SCIP_NLROW **nlrow, SCIP_ROW *row)
Definition: scip.c:32247
SCIP_RETCODE SCIPsetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx, SCIP_Bool val)
Definition: scip.c:48245
#define SCIP_DECL_COMPRFREE(x)
Definition: type_compr.h:57
SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip.c:26314
SCIP_Bool SCIPisRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47707
SCIP_RETCODE SCIPchgChildPrio(SCIP *scip, SCIP_NODE *child, SCIP_Real priority)
Definition: scip.c:13608
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
Definition: scip.c:25220
enum SCIP_ParamSetting SCIP_PARAMSETTING
Definition: type_paramset.h:56
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:47417
SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
Definition: scip.c:9221
#define SCIP_DECL_NODESELINIT(x)
Definition: type_nodesel.h:64
SCIP_RETCODE SCIPconstructSyncstore(SCIP *scip)
Definition: scip.c:41946
public methods for expressions, expression trees, expression graphs, and related stuff ...
SCIP_RETCODE SCIPclearRealarray(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:47911
int SCIPgetNConshdlrs(SCIP *scip)
Definition: scip.c:6628
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:142
type definitions for LP management
void SCIPupdateSolBoundViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
Definition: scip.c:13760
#define SCIP_DECL_SEPACOPY(x)
Definition: type_sepa.h:47
SCIP_Bool SCIPisRelLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47681
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45760
SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)
SCIP_RETCODE SCIPfreeRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:17038
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
Definition: scip.c:42612
const char * SCIPgetProbName(SCIP *scip)
Definition: scip.c:10885
SCIP_RETCODE SCIPclearPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray)
Definition: scip.c:48345
SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:46041
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: scip.c:25991
SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition: scip.c:37450
#define SCIP_DECL_DIALOGDESC(x)
Definition: type_dialog.h:73
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
Definition: scip.c:27127
SCIP_RETCODE SCIPsetHeurPriority(SCIP *scip, SCIP_HEUR *heur, int priority)
Definition: scip.c:8262
SCIP_RETCODE SCIPcopyOrigConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip.c:2872
SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19783
SCIP_RETCODE SCIPlinkNLPSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38596
int SCIPgetNFixedVars(SCIP *scip)
Definition: scip.c:12123
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIP_DECL_EVENTINIT(EventhdlrNewSol::scip_init)
#define SCIP_DECL_CONSINITSOL(x)
Definition: type_cons.h:185
SCIP_Bool SCIPisLPConstructed(SCIP *scip)
Definition: scip.c:29220
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
Definition: scip.c:47640
SCIP_Bool SCIPisLPRelax(SCIP *scip)
Definition: scip.c:29344
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
Definition: scip.c:12500
SCIP_RETCODE SCIPsetConflicthdlrInit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)))
Definition: scip.c:6752
void * SCIPgetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx)
Definition: scip.c:48358
SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28419
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
Definition: scip.c:12080
SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
Definition: scip.c:27878
SCIP_RETCODE SCIPsetReoptCompression(SCIP *scip, SCIP_REOPTNODE **representation, int nrepresentatives, SCIP_Bool *success)
Definition: scip.c:16894
SCIP_Bool SCIPisCharParamValid(SCIP *scip, SCIP_PARAM *param, const char value)
Definition: scip.c:4877
void SCIPclearDiveBoundChanges(SCIP *scip)
Definition: scip.c:36962
int SCIPgetNPrioLPBranchCands(SCIP *scip)
Definition: scip.c:37066
#define SCIP_DECL_CONCSOLVERSTOP(x)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip.c:25473
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
Definition: scip.c:43340
struct SCIP_NodeselData SCIP_NODESELDATA
Definition: type_nodesel.h:38
SCIP_RETCODE SCIPresetParams(SCIP *scip)
Definition: scip.c:5033
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip.c:24216
SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
Definition: scip.c:29731
SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)
Definition: scip.c:9813
void SCIPcomputeBilinEnvelope1(SCIP *scip, SCIP_Real bilincoef, SCIP_Real lbx, SCIP_Real ubx, SCIP_Real refpointx, SCIP_Real lby, SCIP_Real uby, SCIP_Real refpointy, SCIP_Bool overestimate, SCIP_Real xcoef, SCIP_Real ycoef, SCIP_Real constant, SCIP_Real *RESTRICT lincoefx, SCIP_Real *RESTRICT lincoefy, SCIP_Real *RESTRICT linconstant, SCIP_Bool *RESTRICT success)
Definition: scip.c:33659
SCIP_RETCODE SCIPenableConsCompression(SCIP *scip)
Definition: scip.c:1830
SCIP_READER ** SCIPgetReaders(SCIP *scip)
Definition: scip.c:5403
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: scip.c:6157
#define SCIP_DECL_PRESOLEXEC(x)
Definition: type_presol.h:153
SCIP_RETCODE SCIPsetRelaxFree(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXFREE((*relaxfree)))
Definition: scip.c:7198
SCIP_DECL_EVENTFREE(EventhdlrNewSol::scip_free)
SCIP_RETCODE SCIPincludeDialog(SCIP *scip, SCIP_DIALOG **dialog, SCIP_DECL_DIALOGCOPY((*dialogcopy)), SCIP_DECL_DIALOGEXEC((*dialogexec)), SCIP_DECL_DIALOGDESC((*dialogdesc)), SCIP_DECL_DIALOGFREE((*dialogfree)), const char *name, const char *desc, SCIP_Bool issubmenu, SCIP_DIALOGDATA *dialogdata)
Definition: scip.c:9715
void SCIPprintMemoryDiagnostic(SCIP *scip)
Definition: scip.c:46849
#define SCIP_DECL_BRANCHINIT(x)
Definition: type_branch.h:68
SCIP_RETCODE SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
Definition: scip.c:25812
SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
Definition: scip.c:11604
#define SCIP_DECL_DISPINIT(x)
Definition: type_disp.h:87
public methods for handling parameter settings
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip.c:34522
public methods for managing constraints
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
Definition: scip.c:11060
SCIP_Bool SCIPisBoolParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip.c:4645
SCIP_RETCODE SCIPsetPropExitpre(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITPRE((*propexitpre)))
Definition: scip.c:7807
SCIP_RETCODE SCIPchgRowLhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)
Definition: scip.c:35542
SCIP_RETCODE SCIPaddReoptDualBndchg(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_Real oldbound)
Definition: scip.c:16668
SCIP_RETCODE SCIPincludeConcsolverType(SCIP *scip, const char *name, SCIP_Real prefpriodefault, SCIP_DECL_CONCSOLVERCREATEINST((*concsolvercreateinst)), SCIP_DECL_CONCSOLVERDESTROYINST((*concsolverdestroyinst)), SCIP_DECL_CONCSOLVERINITSEEDS((*concsolverinitseeds)), SCIP_DECL_CONCSOLVEREXEC((*concsolverexec)), SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA((*concsolvercopysolvdata)), SCIP_DECL_CONCSOLVERSTOP((*concsolverstop)), SCIP_DECL_CONCSOLVERSYNCWRITE((*concsolversyncwrite)), SCIP_DECL_CONCSOLVERSYNCREAD((*concsolversyncread)), SCIP_DECL_CONCSOLVERTYPEFREEDATA((*concsolvertypefreedata)), SCIP_CONCSOLVERTYPEDATA *data)
Definition: scip.c:7948
SCIP_RETCODE SCIPsolveProbingRelax(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:36701
#define SCIP_DECL_RELAXEXIT(x)
Definition: type_relax.h:71
SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
Definition: scip.c:18109
int SCIPgetNNLPVars(SCIP *scip)
Definition: scip.c:31316
SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: scip.c:6590
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
Definition: scip.c:38162
SCIP_NLPTERMSTAT SCIPgetNLPTermstat(SCIP *scip)
Definition: scip.c:31632
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
Definition: scip.c:46740
SCIP_RETCODE SCIPincludeSepa(SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPACOPY((*sepacopy)), SCIP_DECL_SEPAFREE((*sepafree)), SCIP_DECL_SEPAINIT((*sepainit)), SCIP_DECL_SEPAEXIT((*sepaexit)), SCIP_DECL_SEPAINITSOL((*sepainitsol)), SCIP_DECL_SEPAEXITSOL((*sepaexitsol)), SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
Definition: scip.c:7337
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
Definition: scip.c:1054
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:44
SCIP_RETCODE SCIPdelRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip.c:34964
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)
Definition: scip.c:6829
SCIP_Real SCIPgetLPLooseObjval(SCIP *scip)
Definition: scip.c:29402
SCIP_Bool SCIPisSumRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47772
SCIP_RETCODE SCIPsetObjIntegral(SCIP *scip)
Definition: scip.c:11337
SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:35665
SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
Definition: scip.c:28056
#define SCIP_DECL_CONFLICTINITSOL(x)
SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
Definition: scip.c:34867
SCIP_RETCODE SCIPcopyOrigConsCompression(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip.c:4042
int SCIPgetNCutsApplied(SCIP *scip)
Definition: scip.c:42932
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
Definition: scip.c:8193
void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30829
SCIP_RETCODE SCIPsolve(SCIP *scip)
Definition: scip.c:16109
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: scip.c:6060
SCIP_PROP ** SCIPgetProps(SCIP *scip)
Definition: scip.c:7886
public methods for displaying statistic tables
#define SCIP_DECL_BRANCHCOPY(x)
Definition: type_branch.h:52
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:46007
#define SCIP_DECL_CONFLICTEXEC(x)
SCIP_Bool SCIPisRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47720
SCIP_RETCODE SCIPsetNodeselExitsol(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)))
Definition: scip.c:8941
void SCIPaddBilinMcCormick(SCIP *scip, SCIP_Real bilincoef, SCIP_Real lbx, SCIP_Real ubx, SCIP_Real refpointx, SCIP_Real lby, SCIP_Real uby, SCIP_Real refpointy, SCIP_Bool overestimate, SCIP_Real *lincoefx, SCIP_Real *lincoefy, SCIP_Real *linconstant, SCIP_Bool *success)
Definition: scip.c:33450
SCIP_RETCODE SCIPdeactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
Definition: scip.c:5775
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
Definition: scip.c:8225
SCIP_RETCODE SCIPsetComprCopy(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRCOPY((*comprcopy)))
Definition: scip.c:8363
SCIP_RETCODE SCIPbranchVar(SCIP *scip, SCIP_VAR *var, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
Definition: scip.c:37604
SCIP_RETCODE SCIPsetNlRowExprtreeParams(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *paramvals)
Definition: scip.c:32672
SCIP_Real SCIPdualfeasCeil(SCIP *scip, SCIP_Real val)
Definition: scip.c:47602
SCIP_RETCODE SCIPsolveDiveNLP(SCIP *scip)
Definition: scip.c:32151
SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
Definition: scip.c:34898
void SCIPupdateSolLPRowViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
Definition: scip.c:13772
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip.c:26187
type definitions for variable pricers
SCIP_Bool SCIPisSumRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47759
SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30865
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
Definition: scip.c:19156
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
Definition: scip.c:42630
SCIP_RETCODE SCIPchgNlRowQuadElement(SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelement)
Definition: scip.c:32599
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
Definition: scip.c:4401
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
Definition: scip.c:29170
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:12585
SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
Definition: scip.c:6617
#define SCIP_DECL_PRESOLFREE(x)
Definition: type_presol.h:54
void SCIPstoreSolutionGap(SCIP *scip)
Definition: scip.c:45944
int SCIPgetCutoffdepth(SCIP *scip)
Definition: scip.c:41781
SCIP_RETCODE SCIPgetReoptChildIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
Definition: scip.c:16759
SCIP_RETCODE SCIPincludePricerBasic(SCIP *scip, SCIP_PRICER **pricerptr, const char *name, const char *desc, int priority, SCIP_Bool delay, SCIP_DECL_PRICERREDCOST((*pricerredcost)), SCIP_DECL_PRICERFARKAS((*pricerfarkas)), SCIP_PRICERDATA *pricerdata)
Definition: scip.c:5497
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
Definition: scip.c:22450
SCIP_RETCODE SCIPsetEventhdlrFree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))
Definition: scip.c:8657
SCIP_RETCODE SCIPrecalcNlRowPseudoActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32778
SCIP_RETCODE SCIPsetEventhdlrCopy(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTCOPY((*eventcopy)))
Definition: scip.c:8643
SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:35698
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: scip.c:8145
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46970
SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
Definition: scip.c:13210
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:31478
SCIP_RETCODE SCIPwriteNLP(SCIP *scip, const char *filename)
Definition: scip.c:31929
#define SCIP_DECL_PRICERFARKAS(x)
Definition: type_pricer.h:165
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:25862
type definitions for primal heuristics
SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
Definition: scip.c:34985
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
Definition: scip.c:36308
#define SCIP_DECL_COMPRCOPY(x)
Definition: type_compr.h:49
#define SCIP_DECL_CONSPARSE(x)
Definition: type_cons.h:825
enum SCIP_NlpSolStat SCIP_NLPSOLSTAT
Definition: type_nlpi.h:69
SCIP_RETCODE SCIPtryCurrentSol(SCIP *scip, SCIP_HEUR *heur, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
Definition: scip.c:40881
SCIP_RETCODE SCIPfreeProb(SCIP *scip)
Definition: scip.c:10519
SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)
Definition: scip.c:10156
int SCIPgetNCutsFound(SCIP *scip)
Definition: scip.c:42896
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:13291
SCIP_RETCODE SCIPsetSepaExit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))
Definition: scip.c:7475
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:38942
SCIP_RETCODE SCIPaddDialogHistoryLine(SCIP *scip, const char *inputline)
Definition: scip.c:9865
SCIP_RETCODE SCIPinferVarFixCons(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22744
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
Definition: scip.c:36151
SCIP_Bool SCIPisFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:47131
SCIP_RETCODE SCIPrecalcRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30989
int SCIPgetNConflicthdlrs(SCIP *scip)
Definition: scip.c:6842
SCIP_RETCODE SCIPreadSol(SCIP *scip, const char *filename)
Definition: scip.c:40112
SCIP_RETCODE SCIPinitVarBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real downpscost, SCIP_Real uppscost, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip.c:26748
SCIP_RETCODE SCIPlinkPseudoSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38655
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:686
SCIP_RETCODE SCIPgetChildren(SCIP *scip, SCIP_NODE ***children, int *nchildren)
Definition: scip.c:41471
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
Definition: scip.c:32293
SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)
Definition: scip.c:4836
SCIP_Real SCIPgetDualbound(SCIP *scip)
Definition: scip.c:43250
#define SCIP_DECL_PRESOLEXIT(x)
Definition: type_presol.h:70
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: scip.c:19305
type definitions for SCIP&#39;s main datastructure
SCIP_RETCODE SCIPpresolCons(SCIP *scip, SCIP_CONS *cons, int nrounds, SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
Definition: scip.c:28955
SCIP_Bool SCIPisDualfeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47517
SCIP_RETCODE SCIPcopyVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global)
Definition: scip.c:2341
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip.c:24088
SCIP_RETCODE SCIPchgCutoffboundDive(SCIP *scip, SCIP_Real newcutoffbound)
Definition: scip.c:35368
SCIP_Bool SCIPisDualSolAvailable(SCIP *scip, SCIP_Bool printreason)
Definition: scip.c:39645
#define SCIP_DECL_BANDITRESET(x)
Definition: type_bandit.h:73
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
Definition: scip.c:4630
SCIP_STATUS SCIPgetStatus(SCIP *scip)
Definition: scip.c:928
SCIP_RETCODE SCIPpresolve(SCIP *scip)
Definition: scip.c:15948
SCIP_CONS * SCIPfindOrigCons(SCIP *scip, const char *name)
Definition: scip.c:12712
SCIP_Real SCIPversion(void)
Definition: scip.c:556
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
Definition: scip.c:34540
#define SCIP_DECL_BRANCHINITSOL(x)
Definition: type_branch.h:87
SCIP_RETCODE SCIPcopyCuts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
Definition: scip.c:3065
SCIP_Real SCIPgetTransGap(SCIP *scip)
Definition: scip.c:43561
int SCIPgetNDisps(SCIP *scip)
Definition: scip.c:9417
SCIP_RETCODE SCIPgetReoptSolsRun(SCIP *scip, int run, SCIP_SOL **sols, int allocmem, int *nsols)
Definition: scip.c:17367
SCIP_RETCODE SCIPsetEventhdlrInit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINIT((*eventinit)))
Definition: scip.c:8671
SCIP_RETCODE SCIPchgVarBoundsDiveNLP(SCIP *scip, SCIP_VAR *var, SCIP_Real lb, SCIP_Real ub)
Definition: scip.c:32090
SCIP_RETCODE SCIPcheckCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
Definition: scip.c:28684
SCIP_Bool SCIPisReoptEnabled(SCIP *scip)
Definition: scip.c:17357
SCIP_RETCODE SCIPprintTransSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39401
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:27444
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
Definition: scip.c:42536
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip.c:21782
#define SCIP_DECL_PROPEXITSOL(x)
Definition: type_prop.h:127
SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
Definition: scip.c:27928
void SCIPprintConflictStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44678
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:22100
#define SCIP_DECL_PROPCOPY(x)
Definition: type_prop.h:47
SCIP_RETCODE SCIPsetPresolInit(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINIT((*presolinit)))
Definition: scip.c:6984
SCIP_RETCODE SCIPsetConsDynamic(SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: scip.c:28031
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:26209
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
Definition: scip.c:41031
#define SCIP_DECL_BRANCHEXECLP(x)
Definition: type_branch.h:119
void SCIPprintCompressionStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45031
SCIP_RETCODE SCIPprintStage(SCIP *scip, FILE *file)
Definition: scip.c:843
SCIP_RETCODE SCIPgetNLPRealPar(SCIP *scip, SCIP_NLPPARAM type, SCIP_Real *dval)
Definition: scip.c:31817
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:25926
int SCIPgetNChildren(SCIP *scip)
Definition: scip.c:41495
SCIP_Real SCIPdualfeasFloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:47590
SCIP_RETCODE SCIPsumLPRows(SCIP *scip, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
Definition: scip.c:29916
SCIP_RETCODE SCIPendProbing(SCIP *scip)
Definition: scip.c:35993
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:155
SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)
Definition: scip.c:12975
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: scip.c:6085
SCIP_PRESOL * SCIPfindPresol(SCIP *scip, const char *name)
Definition: scip.c:7048
#define SCIP_DECL_PARAMCHGD(x)
Definition: type_paramset.h:91
SCIP_RETCODE SCIPgetNlRowActivityBounds(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *minactivity, SCIP_Real *maxactivity)
Definition: scip.c:32998
SCIP_RETCODE SCIPmergeVariableStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **sourcevars, SCIP_VAR **targetvars, int nvars)
Definition: scip.c:2428
SCIP_DECL_CONSTRANS(ConshdlrSubtour::scip_trans)
SCIP_RETCODE SCIPincludePresol(SCIP *scip, const char *name, const char *desc, int priority, int maxrounds, SCIP_PRESOLTIMING timing, SCIP_DECL_PRESOLCOPY((*presolcopy)), SCIP_DECL_PRESOLFREE((*presolfree)), SCIP_DECL_PRESOLINIT((*presolinit)), SCIP_DECL_PRESOLEXIT((*presolexit)), SCIP_DECL_PRESOLINITPRE((*presolinitpre)), SCIP_DECL_PRESOLEXITPRE((*presolexitpre)), SCIP_DECL_PRESOLEXEC((*presolexec)), SCIP_PRESOLDATA *presoldata)
Definition: scip.c:6874
struct SCIP_LPiState SCIP_LPISTATE
Definition: type_lpi.h:97
SCIP_RETCODE SCIPsetBranchruleMaxbounddist(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_Real maxbounddist)
Definition: scip.c:9336
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23536
void SCIPprintDebugMessage(SCIP *scip, const char *sourcefile, int sourceline, const char *formatstr,...)
Definition: scip.c:1283
SCIP_Real SCIPgetNodeDualbound(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:13422
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip.c:4432
void SCIPprintLPStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45068
SCIP_RETCODE SCIPaddNlpiProbRows(SCIP *scip, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *nlpiprob, SCIP_HASHMAP *var2idx, SCIP_ROW **rows, int nrows)
Definition: scip.c:34401
SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
Definition: scip.c:12761
SCIP_Bool SCIPisNLPEnabled(SCIP *scip)
Definition: scip.c:31189
SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip.c:28773
SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)
Definition: scip.c:42281
internal miscellaneous methods
#define SCIP_DECL_NODESELFREE(x)
Definition: type_nodesel.h:56
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip.c:44212
void SCIPprintPropagatorStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44615
SCIP_RETCODE SCIPgetVarStrongbranchInt(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip.c:21186
SCIP_RETCODE SCIPgetExprtreeTransformedVars(SCIP *scip, SCIP_EXPRTREE *tree)
Definition: scip.c:33066
#define SCIP_DECL_RELAXCOPY(x)
Definition: type_relax.h:47
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28596
void SCIPupdateSolIntegralityViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol)
Definition: scip.c:13749
type definitions for bandit selection algorithms
SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26514
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:39035
SCIP_RETCODE SCIPseparateSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
Definition: scip.c:35139
SCIP_RETCODE SCIPsetNLPInitialGuess(SCIP *scip, SCIP_Real *initialguess)
Definition: scip.c:31528
SCIP_Bool SCIPisObjChangedProbing(SCIP *scip)
Definition: scip.c:36285
SCIP_RETCODE SCIPclearBoolarray(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:48213
int SCIPgetNNlpis(SCIP *scip)
Definition: scip.c:9602
int SCIPgetNPrioExternBranchCands(SCIP *scip)
Definition: scip.c:37163
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:716
SCIP_RETCODE SCIPchgDualfeastol(SCIP *scip, SCIP_Real dualfeastol)
Definition: scip.c:46567
SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
Definition: scip.c:13383
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
Definition: scip.c:4451
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
Definition: scip.c:4567
SCIP_RETCODE SCIPsetNLPInitialGuessSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:31555
void SCIPupdateDivesetLPStats(SCIP *scip, SCIP_DIVESET *diveset, SCIP_Longint niterstoadd)
Definition: scip.c:36794
SCIP_PARAM * SCIPgetParam(SCIP *scip, const char *name)
Definition: scip.c:4416
SCIP_RETCODE SCIPsetPresolPriority(SCIP *scip, SCIP_PRESOL *presol, int priority)
Definition: scip.c:7085
SCIP_RETCODE SCIPsetBranchrulePriority(SCIP *scip, SCIP_BRANCHRULE *branchrule, int priority)
Definition: scip.c:9306
SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip.c:28166
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26715
SCIP_RETCODE SCIPaddConflictRelaxedBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
Definition: scip.c:27348
int SCIPgetEffectiveRootDepth(SCIP *scip)
Definition: scip.c:41434
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
Definition: scip.c:37571
SCIP_RETCODE SCIPsetSepaInitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
Definition: scip.c:7491
int SCIPgetNLPRows(SCIP *scip)
Definition: scip.c:29690
SCIP_RETCODE SCIPfreeBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
Definition: scip.c:48177
public methods for primal CIP solutions
SCIP_Bool SCIPareSolsEqual(SCIP *scip, SCIP_SOL *sol1, SCIP_SOL *sol2)
Definition: scip.c:39256
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
Definition: scip.c:35115
SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))
Definition: scip.c:6736
SCIP_Bool SCIPisSumEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47191
SCIP_RETCODE SCIPcopyOrigVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars)
Definition: scip.c:2398
SCIP_Real SCIPgetSepaMinEfficacy(SCIP *scip)
Definition: scip.c:7583
SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:36121
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
Definition: type_conflict.h:40
internal methods for global SCIP settings
SCIP_DECL_CONSDELVARS(ConshdlrSubtour::scip_delvars)
SCIP_RETCODE SCIPsetPropPriority(SCIP *scip, SCIP_PROP *prop, int priority)
Definition: scip.c:7910
SCIP_RETCODE SCIPgetNLPI(SCIP *scip, SCIP_NLPI **nlpi, SCIP_NLPIPROBLEM **nlpiproblem)
Definition: scip.c:31966
SCIP_Real SCIPgetLowerbound(SCIP *scip)
Definition: scip.c:43271
SCIP_SOL * SCIPgetReoptLastOptSol(SCIP *scip)
Definition: scip.c:16686
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
Definition: scip.c:43507
SCIP_RETCODE SCIPrecalcNlRowActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32843
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:52
SCIP main data structure.
SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
Definition: scip.c:35226
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip.c:43704
SCIP_Bool SCIPsignificantVarPscostDifference(SCIP *scip, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
Definition: scip.c:26240
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
Definition: scip.c:42154
int SCIPgetNTotalVars(SCIP *scip)
Definition: scip.c:12383
#define SCIP_DECL_CONCSOLVERINITSEEDS(x)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47331
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:36544
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23834
int SCIPgetNOrigConss(SCIP *scip)
Definition: scip.c:12948
SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)
Definition: scip.c:951
SCIP_RETCODE SCIPinferVarUbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23319
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
Definition: scip.c:19249
SCIP_RETCODE SCIPbranchVarVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
Definition: scip.c:37680
SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26576
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:25158
#define SCIP_DECL_PROPINITPRE(x)
Definition: type_prop.h:85
struct SCIP_ComprData SCIP_COMPRDATA
Definition: type_compr.h:40
SCIP_NODE * SCIPgetBestboundNode(SCIP *scip)
Definition: scip.c:41691
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
Definition: scip.c:23940
type definitions for problem variables
#define SCIP_DECL_CONSENABLE(x)
Definition: type_cons.h:701
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: scip.c:5061
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21589
int SCIPgetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx)
Definition: scip.c:48078
void SCIPupdateSolLPConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
Definition: scip.c:13796
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47318
SCIP_NODESEL * SCIPgetNodesel(SCIP *scip)
Definition: scip.c:9022
#define SCIP_DECL_CONFLICTCOPY(x)
Definition: type_conflict.h:77
void SCIPmarkLimitChanged(SCIP *scip)
Definition: scip.c:46639
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
Definition: scip.c:27529
BMS_BUFMEM * SCIPcleanbuffer(SCIP *scip)
Definition: scip.c:46754
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
Definition: scip.c:1360
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
Definition: scip.c:42498
SCIP_RETCODE SCIPgetNLPStringPar(SCIP *scip, SCIP_NLPPARAM type, const char **sval)
Definition: scip.c:31873
SCIP_RETCODE SCIPfreeRealarray(SCIP *scip, SCIP_REALARRAY **realarray)
Definition: scip.c:47875
type definitions for relaxators
SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30954
SCIP_RETCODE SCIPcreateRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip.c:30264
SCIP_RETCODE SCIPsetPricerInit(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINIT((*pricerinit)))
Definition: scip.c:5593
SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip.c:28256
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:27720
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip.c:34655
SCIP_Bool SCIPisLongintParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip.c:4761
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
Definition: scip.c:42574
void SCIPprintRootStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45504
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: scip.c:6360
SCIP_RETCODE SCIPcreateDisjointset(SCIP *scip, SCIP_DISJOINTSET **djset, int ncomponents)
Definition: scip.c:48651
SCIP_RETCODE SCIPsetRelaxPriority(SCIP *scip, SCIP_RELAX *relax, int priority)
Definition: scip.c:7316
SCIP_RETCODE SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)
Definition: scip.c:4470
SCIP_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip.c:34632
SCIP_RETCODE SCIPcopyImplicationsCliques(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *infeasible, int *nbdchgs, int *ncopied)
Definition: scip.c:3317
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:50
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28453
SCIP_RETCODE SCIPgetPseudoBranchCands(SCIP *scip, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
Definition: scip.c:37334
SCIP_RETCODE SCIPsetPresolInitpre(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINITPRE((*presolinitpre)))
Definition: scip.c:7016
type definitions for conflict analysis
SCIP_RETCODE SCIPsetConflicthdlrInitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)))
Definition: scip.c:6784
int SCIPgetNPrioExternBranchBins(SCIP *scip)
Definition: scip.c:37183
int SCIPgetNPrioExternBranchInts(SCIP *scip)
Definition: scip.c:37204
int SCIPgetRealarrayMaxIdx(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:47994
SCIP_RETCODE SCIPsetConflicthdlrExit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)))
Definition: scip.c:6768
type definitions for managing events
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: scip.c:29126
SCIP_RETCODE SCIPsetRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real val)
Definition: scip.c:47943
SCIP_Bool SCIPisDualfeasNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:47554
SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26133
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip.c:29202
SCIP_Bool SCIPhasPrimalRay(SCIP *scip)
Definition: scip.c:41069
void SCIPaddSquareSecant(SCIP *scip, SCIP_Real sqrcoef, SCIP_Real lb, SCIP_Real ub, SCIP_Real refpoint, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)
Definition: scip.c:33353
SCIP_RETCODE SCIPstopSolvingTime(SCIP *scip)
Definition: scip.c:46225
int SCIPgetBoolarrayMinIdx(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:48263
SCIP_RETCODE SCIPgetLPBInvACol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29883
SCIP_Longint SCIPgetLastDivenode(SCIP *scip)
Definition: scip.c:35766
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
Definition: scip.c:42648
SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26107
public methods for NLP management
SCIP_RETCODE SCIPsetRelaxExit(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXIT((*relaxexit)))
Definition: scip.c:7230
public methods for node selectors
SCIP_RETCODE SCIPchgNlRowLhs(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real lhs)
Definition: scip.c:32315
wrapper functions to map file i/o to standard or zlib file i/o
SCIP_NODE * SCIPgetBestNode(SCIP *scip)
Definition: scip.c:41675
#define SCIP_DECL_COMPRINITSOL(x)
Definition: type_compr.h:84
SCIP_RETCODE SCIPcopyConflicts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip.c:3157
methods commonly used for presolving
SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
Definition: scip.c:2533
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
Definition: scip.c:47045
SCIP_RETCODE SCIPincludeSepaBasic(SCIP *scip, SCIP_SEPA **sepa, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
Definition: scip.c:7385
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
Definition: scip.c:13140
#define SCIP_DECL_PROBTRANS(x)
Definition: type_prob.h:74
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:21847
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43977
internal methods for problem variables
SCIP_RETCODE SCIPsetNLPRealPar(SCIP *scip, SCIP_NLPPARAM type, SCIP_Real dval)
Definition: scip.c:31845
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:847
SCIP_RETCODE SCIPactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
Definition: scip.c:5754
SCIP_RETCODE SCIPpropCons(SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: scip.c:28889
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:120
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
Definition: scip.c:20169
struct SCIP_ReaderData SCIP_READERDATA
Definition: type_reader.h:37
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:38765
SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29849
SCIP_RETCODE SCIPgetNlRowFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
Definition: scip.c:32900
SCIP_RETCODE SCIPresetReoptnodeDualcons(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:17545
SCIP_RETCODE SCIPclearSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38706
SCIP_RETCODE SCIPsetPropInit(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINIT((*propinit)))
Definition: scip.c:7727
SCIP_RETCODE SCIPcheckReoptRestart(SCIP *scip, SCIP_NODE *node, SCIP_Bool *restart)
Definition: scip.c:17417
public data structures and miscellaneous methods
SCIP_COMPR ** SCIPgetComprs(SCIP *scip)
Definition: scip.c:8472
SCIP_Bool SCIPisSumGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47230
int SCIPgetNPrioExternBranchConts(SCIP *scip)
Definition: scip.c:37244
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
Definition: scip.c:17246
SCIP_RETCODE SCIPpermuteProb(SCIP *scip, unsigned int randseed, SCIP_Bool permuteconss, SCIP_Bool permutebinvars, SCIP_Bool permuteintvars, SCIP_Bool permuteimplvars, SCIP_Bool permutecontvars)
Definition: scip.c:10599
SCIP_RETCODE SCIPincludeNlpi(SCIP *scip, SCIP_NLPI *nlpi)
Definition: scip.c:9540
SCIP_RETCODE SCIPsetSepaExitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
Definition: scip.c:7507
SCIP_RETCODE SCIPcheckSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)
Definition: scip.c:40974
int SCIPgetNExternalCodes(SCIP *scip)
Definition: scip.c:9670
#define SCIP_Bool
Definition: def.h:61
SCIP_RETCODE SCIPsetProbTrans(SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))
Definition: scip.c:10038
SCIP_RETCODE SCIPgetNLPStatistics(SCIP *scip, SCIP_NLPSTATISTICS *statistics)
Definition: scip.c:31657
#define SCIP_DECL_SEPAINIT(x)
Definition: type_sepa.h:63
SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
Definition: scip.c:30579
SCIP_RETCODE SCIPinferVarFixProp(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23136
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:41152
#define SCIP_DECL_PRICERINITSOL(x)
Definition: type_pricer.h:81
int SCIPgetMaxTotalDepth(SCIP *scip)
Definition: scip.c:43113
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip.c:29287
SCIP_RETCODE SCIPfreeSyncstore(SCIP *scip)
Definition: scip.c:41979
SCIP_RETCODE SCIPsetConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)
Definition: scip.c:27980
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
int SCIPgetNImplVars(SCIP *scip)
Definition: scip.c:11941
SCIP_RETCODE SCIPincludeDisp(SCIP *scip, const char *name, const char *desc, const char *header, SCIP_DISPSTATUS dispstatus, SCIP_DECL_DISPCOPY((*dispcopy)), SCIP_DECL_DISPFREE((*dispfree)), SCIP_DECL_DISPINIT((*dispinit)), SCIP_DECL_DISPEXIT((*dispexit)), SCIP_DECL_DISPINITSOL((*dispinitsol)), SCIP_DECL_DISPEXITSOL((*dispexitsol)), SCIP_DECL_DISPOUTPUT((*dispoutput)), SCIP_DISPDATA *dispdata, int width, int priority, int position, SCIP_Bool stripline)
Definition: scip.c:9351
#define SCIP_DECL_PRESOLEXITPRE(x)
Definition: type_presol.h:102
SCIP_Real SCIPgetObjlimit(SCIP *scip)
Definition: scip.c:11310
#define SCIP_DECL_PROBEXITSOL(x)
Definition: type_prob.h:110
SCIP_RETCODE SCIPincludeReaderBasic(SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)
Definition: scip.c:5264
SCIP_RETCODE SCIPcreateSolCopyOrig(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
Definition: scip.c:38202
#define SCIP_DECL_NODESELEXIT(x)
Definition: type_nodesel.h:72
SCIP_Real SCIPgetRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:31008
SCIP_Real SCIPgetOrigObjscale(SCIP *scip)
Definition: scip.c:11162
SCIP_RETCODE SCIPchgNlRowConstant(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real constant)
Definition: scip.c:32361
public methods for storing cuts in a cut pool
void SCIPprintVersion(SCIP *scip, FILE *file)
Definition: scip.c:611
type definitions for input file readers
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip.c:10473
void SCIPprintRelaxatorStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45200
SCIP_Bool SCIPisSumLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47217
int SCIPgetNCliquesCreated(SCIP *scip)
Definition: scip.c:24900
void SCIPprintTreeStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45235
SCIP_RETCODE SCIPrecalcNlRowNLPActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32695
SCIP_RETCODE SCIPprintRay(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39741
SCIP_RETCODE SCIPvalidateSolve(SCIP *scip, SCIP_Real primalreference, SCIP_Real dualreference, SCIP_Real reftol, SCIP_Bool quiet, SCIP_Bool *feasible, SCIP_Bool *primalboundcheck, SCIP_Bool *dualboundcheck)
Definition: scip.c:48429
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:41
SCIP_RETCODE SCIPprintBestTransSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39982
enum SCIP_Status SCIP_STATUS
Definition: type_stat.h:57
#define SCIP_DECL_DISPFREE(x)
Definition: type_disp.h:79
SCIP_RETCODE SCIPsetComprExitsol(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPREXITSOL((*comprexitsol)))
Definition: scip.c:8443
void SCIPprintSolutionStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45285
#define SCIP_DECL_PROPFREE(x)
Definition: type_prop.h:55
SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip.c:30396
SCIP_RETCODE SCIProundSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *success)
Definition: scip.c:40018
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
Definition: scip.c:11240
SCIP_RETCODE SCIPautoselectDisps(SCIP *scip)
Definition: scip.c:9428
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:46241
SCIP_RETCODE SCIPupdateNlpiProb(SCIP *scip, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *nlpiprob, SCIP_HASHMAP *var2nlpiidx, SCIP_VAR **nlpivars, int nlpinvars, SCIP_Real cutoffbound)
Definition: scip.c:34349
int SCIPgetNPricers(SCIP *scip)
Definition: scip.c:5707
#define SCIP_DECL_TABLECOPY(x)
Definition: type_table.h:53
SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
Definition: scip.c:43785
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
Definition: scip.c:42011
int SCIPgetDepth(SCIP *scip)
Definition: scip.c:43039
SCIP_RETCODE SCIPaddReoptnodeCons(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, SCIP_Real lhs, SCIP_Real rhs, int nvars, REOPT_CONSTYPE constype, SCIP_Bool linear)
Definition: scip.c:16922
SCIP_Real SCIPlpfeastol(SCIP *scip)
Definition: scip.c:46451
SCIP_RETCODE SCIPupdateNodeDualbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip.c:13552
SCIP_RETCODE SCIPincludeEventhdlr(SCIP *scip, const char *name, const char *desc, SCIP_DECL_EVENTCOPY((*eventcopy)), SCIP_DECL_EVENTFREE((*eventfree)), SCIP_DECL_EVENTINIT((*eventinit)), SCIP_DECL_EVENTEXIT((*eventexit)), SCIP_DECL_EVENTINITSOL((*eventinitsol)), SCIP_DECL_EVENTEXITSOL((*eventexitsol)), SCIP_DECL_EVENTDELETE((*eventdelete)), SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
Definition: scip.c:8569
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip.c:13574
SCIP_Real SCIPgetGap(SCIP *scip)
Definition: scip.c:43530
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
Definition: scip.c:43934
int SCIPgetRowNumIntCols(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30847
SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:35471
SCIP_RETCODE SCIPcopyConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip.c:2669
SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip.c:4720
int SCIPgetNPrioPseudoBranchCands(SCIP *scip)
Definition: scip.c:37378
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
Definition: scip.c:29085
SCIP_RETCODE SCIPcaptureRow(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30512
SCIP_RETCODE SCIPstartSolvingTime(SCIP *scip)
Definition: scip.c:46192
SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)
Definition: scip.c:20856
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
Definition: scip.c:45933
SCIP_RETCODE SCIPgetNLPVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars)
Definition: scip.c:31264
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:164
SCIP_Bool SCIPisLPPrimalReliable(SCIP *scip)
Definition: scip.c:29308
SCIP_RETCODE SCIPchgVarsBoundsDiveNLP(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *lbs, SCIP_Real *ubs)
Definition: scip.c:32121
public methods for variable pricers
SCIP_RETCODE SCIPtrySolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
Definition: scip.c:40788
void SCIPsetMessagehdlrQuiet(SCIP *scip, SCIP_Bool quiet)
Definition: scip.c:1255
#define SCIP_DECL_PRESOLINIT(x)
Definition: type_presol.h:62
SCIP_RETCODE SCIPgetDiveBoundChanges(SCIP *scip, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
Definition: scip.c:36847
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
Definition: scip.c:42408
void SCIPactivateSolViolationUpdates(SCIP *scip)
Definition: scip.c:13808
SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Bool includeslp)
Definition: scip.c:19960
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34766
SCIP_RETCODE SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip.c:24553
SCIP_RETCODE SCIPgetNlRowPseudoFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudofeasibility)
Definition: scip.c:32821
SCIP_RETCODE SCIPgetNlRowActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
Definition: scip.c:32871
methods for debugging
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
Definition: scip.c:27280
SCIP_RETCODE SCIPaddConflictBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:27313
SCIP_RETCODE SCIPincludeReader(SCIP *scip, const char *name, const char *desc, const char *extension, SCIP_DECL_READERCOPY((*readercopy)), SCIP_DECL_READERFREE((*readerfree)), SCIP_DECL_READERREAD((*readerread)), SCIP_DECL_READERWRITE((*readerwrite)), SCIP_READERDATA *readerdata)
Definition: scip.c:5222
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
Definition: scip.c:4688
public methods for LP management
SCIP_RETCODE SCIPcreateDiveset(SCIP *scip, SCIP_DIVESET **diveset, SCIP_HEUR *heur, const char *name, SCIP_Real minreldepth, SCIP_Real maxreldepth, SCIP_Real maxlpiterquot, SCIP_Real maxdiveubquot, SCIP_Real maxdiveavgquot, SCIP_Real maxdiveubquotnosol, SCIP_Real maxdiveavgquotnosol, SCIP_Real lpresolvedomchgquot, int lpsolvefreq, int maxlpiterofs, unsigned int initialseed, SCIP_Bool backtrack, SCIP_Bool onlylpbranchcands, SCIP_Bool specificsos1score, SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)))
Definition: scip.c:8521
int SCIPsubversion(void)
Definition: scip.c:600
SCIP_RETCODE SCIPcreateEmptyRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition: scip.c:30425
SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
Definition: scip.c:30555
unsigned int SCIPinitializeRandomSeed(SCIP *scip, int initialseedvalue)
Definition: scip.c:25899
#define SCIP_DECL_PROPINITSOL(x)
Definition: type_prop.h:115
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip.c:34499
SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: scip.c:6452
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip.c:25009
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:41186
SCIP_RETCODE SCIPsetRelaxSolValsSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool includeslp)
Definition: scip.c:20000
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
Definition: scip.c:38529
SCIP_RETCODE SCIPsetBranchruleExitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))
Definition: scip.c:9203
void SCIPenableVarHistory(SCIP *scip)
Definition: scip.c:25952
SCIP_RETCODE SCIPsetPricerFree(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERFREE((*pricerfree)))
Definition: scip.c:5569
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23771
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip.c:27045
public methods for bandit algorithms
SCIP_RETCODE SCIPsetBranchruleExecExt(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECEXT((*branchexecext)))
Definition: scip.c:9237
SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPCOPY((*propcopy)))
Definition: scip.c:7695
#define SCIP_DECL_TABLEEXIT(x)
Definition: type_table.h:77
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:41266
SCIP_RETCODE SCIPgetVarsStrongbranchesInt(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip.c:21384
SCIP_RETCODE SCIPsetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int val)
Definition: scip.c:48094
static const unsigned int randseed
Definition: circle.c:46
SCIP_RETCODE SCIPincludeConflicthdlr(SCIP *scip, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTCOPY((*conflictcopy)), SCIP_DECL_CONFLICTFREE((*conflictfree)), SCIP_DECL_CONFLICTINIT((*conflictinit)), SCIP_DECL_CONFLICTEXIT((*conflictexit)), SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)), SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)), SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
Definition: scip.c:6645
SCIP_RETCODE SCIPaddReoptnodeBndchg(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR *var, SCIP_Real bound, SCIP_BOUNDTYPE boundtype)
Definition: scip.c:16866
SCIP_Real SCIPcalcNodeselPriority(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
Definition: scip.c:37521
SCIP_Real SCIPgetLPRootLooseObjval(SCIP *scip)
Definition: scip.c:29537
SCIP_RETCODE SCIPsetBranchruleMaxdepth(SCIP *scip, SCIP_BRANCHRULE *branchrule, int maxdepth)
Definition: scip.c:9321
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition: scip.c:17613
void SCIPmarkColNotRemovableLocal(SCIP *scip, SCIP_COL *col)
Definition: scip.c:30241
SCIP_Real SCIPgetReoptSimilarity(SCIP *scip, int run1, int run2)
Definition: scip.c:17436
SCIP_RETCODE SCIPprintDualSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39708
SCIP_RETCODE SCIPaddExternBranchCand(SCIP *scip, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
Definition: scip.c:37266
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
Definition: scip.c:42956
#define SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA(x)
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:44063
SCIP_RETCODE SCIPsetStringParam(SCIP *scip, const char *name, const char *value)
Definition: scip.c:4920
type definitions for branch and bound tree
int SCIPgetNSols(SCIP *scip)
Definition: scip.c:39777
void SCIPprintNLPStatistics(SCIP *scip, FILE *file)
Definition: scip.c:45174
SCIP_RETCODE SCIPsetReaderWrite(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERWRITE((*readerwrite)))
Definition: scip.c:5374
SCIP_RETCODE SCIPsetNodeselInitsol(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELINITSOL((*nodeselinitsol)))
Definition: scip.c:8925
SCIP_RETCODE SCIPgetDualSolVal(SCIP *scip, SCIP_CONS *cons, SCIP_Real *dualsolval, SCIP_Bool *boundconstraint)
Definition: scip.c:39501
SCIP_Real SCIPgetLPRootColumnObjval(SCIP *scip)
Definition: scip.c:29514
SCIP_RETCODE SCIPretransformSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:40054
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
Definition: scip.c:42592
SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip.c:28859
SCIP_RETCODE SCIPupdateLocalDualbound(SCIP *scip, SCIP_Real newbound)
Definition: scip.c:13463
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip.c:25569
#define SCIP_DECL_DIALOGFREE(x)
Definition: type_dialog.h:61
#define SCIP_DECL_COMPREXIT(x)
Definition: type_compr.h:73
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
Definition: scip.c:42462
int SCIPgetNRuns(SCIP *scip)
Definition: scip.c:42044
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip.c:25279
void SCIPgetReoptnodePath(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int mem, int *nvars, int *nafterdualvars)
Definition: scip.c:16950
SCIP_RETCODE SCIPsetPropPresolPriority(SCIP *scip, SCIP_PROP *prop, int presolpriority)
Definition: scip.c:7925
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip.c:21708
SCIP_RETCODE SCIPcreateEmptyNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real lhs, SCIP_Real rhs)
Definition: scip.c:32221
SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
Definition: scip.c:29750
SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip.c:28743
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38988
int SCIPtechVersion(void)
Definition: scip.c:589
SCIP_RETCODE SCIPcaptureNlRow(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32270
SCIP_COL ** SCIPgetLPCols(SCIP *scip)
Definition: scip.c:29591
SCIP_RETCODE SCIPstartInteraction(SCIP *scip)
Definition: scip.c:9898
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: scip.c:6498
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
Definition: scip.c:46523
SCIP_RETCODE SCIPsetConflicthdlrCopy(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)))
Definition: scip.c:6720
SCIP_RETCODE SCIPfixParam(SCIP *scip, const char *name)
Definition: scip.c:4549
SCIP_RETCODE SCIPflushLP(SCIP *scip)
Definition: scip.c:29267
SCIP_RETCODE SCIPcreateUnknownSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:38077
int SCIPgetNObjVars(SCIP *scip)
Definition: scip.c:12034
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
Definition: scip.c:43013
datastructures for problem statistics
SCIP_Bool SCIPisRealParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip.c:4819
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
Definition: scip.c:34612
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
Definition: scip.c:42253
#define SCIP_DECL_SEPAEXITSOL(x)
Definition: type_sepa.h:93
SCIP_Real SCIPdualfeasFrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:47626
SCIP_Bool SCIPisSumRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47785
#define SCIP_DECL_SEPAEXECSOL(x)
Definition: type_sepa.h:140
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
Definition: scip.c:47033
SCIP_Real SCIPgetTimeOfDay(SCIP *scip)
Definition: scip.c:45993
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip.c:31105
#define SCIP_DECL_CONCSOLVERTYPEFREEDATA(x)
type definitions for clocks and timing issues
int SCIPconvertRealToInt(SCIP *scip, SCIP_Real real)
Definition: scip.c:47800
SCIP_RETCODE SCIPchgLpfeastol(SCIP *scip, SCIP_Real lpfeastol, SCIP_Bool printnewvalue)
Definition: scip.c:46541
SCIP_Longint SCIPconvertRealToLongint(SCIP *scip, SCIP_Real real)
Definition: scip.c:47816
SCIP_RETCODE SCIPcreateRelaxSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37977
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22813
int SCIPgetNOrigContVars(SCIP *scip)
Definition: scip.c:12354
SCIP_RETCODE SCIPtrySol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
Definition: scip.c:40694
SCIP_Bool SCIPisCutNew(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34748
SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: scip.c:6429
SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))
Definition: scip.c:5302
SCIP_NODE * SCIPgetFocusNode(SCIP *scip)
Definition: scip.c:41379
void SCIPchgDispMode(SCIP_DISP *disp, SCIP_DISPMODE mode)
Definition: scip.c:9441
SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
Definition: scip.c:37548
SCIP_Real * SCIPgetNLPVarsLbDualsol(SCIP *scip)
Definition: scip.c:31362
SCIP_EVENTHDLR ** SCIPgetEventhdlrs(SCIP *scip)
Definition: scip.c:8754
SCIP_RETCODE SCIPextendPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray, int minidx, int maxidx)
Definition: scip.c:48326
int SCIPgetNConcsolverTypes(SCIP *scip)
Definition: scip.c:8011
SCIP_RETCODE SCIPcreatePseudoSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:38004
SCIP_Real SCIPgetTransObjscale(SCIP *scip)
Definition: scip.c:11208
SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITSOL((*propexitsol)))
Definition: scip.c:7775
int SCIPgetNBinVars(SCIP *scip)
Definition: scip.c:11851
SCIP_RETCODE SCIPsetPricerInitsol(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINITSOL((*pricerinitsol)))
Definition: scip.c:5641
type definitions for storing and manipulating the main problem
SCIP_Bool SCIPinProbing(SCIP *scip)
Definition: scip.c:35830
void SCIPprintPricerStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44854
SCIP_CONCSOLVERTYPE ** SCIPgetConcsolverTypes(SCIP *scip)
Definition: scip.c:8000
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
Definition: scip.c:4862
SCIP_NODE * SCIPgetPrioSibling(SCIP *scip)
Definition: scip.c:41611
#define SCIP_DECL_READERCOPY(x)
Definition: type_reader.h:46
int SCIPgetNVars(SCIP *scip)
Definition: scip.c:11806
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
Definition: type_paramset.h:73
SCIP_RETCODE SCIPsetComprPriority(SCIP *scip, SCIP_COMPR *compr, int priority)
Definition: scip.c:8496
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23884
SCIP_RETCODE SCIPfreeBandit(SCIP *scip, SCIP_BANDIT **bandit)
Definition: scip_bandit.c:91
SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:35064
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
Definition: scip.c:17842
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:109
void SCIPenableNLP(SCIP *scip)
Definition: scip.c:31212
SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)
Definition: scip.c:13513
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
Definition: scip.c:43209
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
Definition: scip.c:7061
SCIP_RETCODE SCIPaddPricedVar(SCIP *scip, SCIP_VAR *var, SCIP_Real score)
Definition: scip.c:11551
int SCIPgetBoolarrayMaxIdx(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:48277
SCIP_RETCODE SCIPaddSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *stored)
Definition: scip.c:40494
SCIP_Bool SCIPinDive(SCIP *scip)
Definition: scip.c:35796
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
Definition: scip.c:42516
type definitions for propagators
SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip.c:34919
#define SCIP_DECL_DIALOGEXEC(x)
Definition: type_dialog.h:87
SCIP_Bool SCIPhasNLPSolution(SCIP *scip)
Definition: scip.c:31705
SCIP_RETCODE SCIPgetReoptOldObjCoef(SCIP *scip, SCIP_VAR *var, int run, SCIP_Real *objcoef)
Definition: scip.c:16713
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: scip.c:6229
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
Definition: scip.c:44081
SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
Definition: scip.c:24927
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26602
enum SCIP_ExprCurv SCIP_EXPRCURV
Definition: type_expr.h:93
SCIP_Real SCIPgetTransObjoffset(SCIP *scip)
Definition: scip.c:11185
SCIP_RETCODE SCIPprintNodeRootPath(SCIP *scip, SCIP_NODE *node, FILE *file)
Definition: scip.c:41814
SCIP_RETCODE SCIPsetProbInitsol(SCIP *scip, SCIP_DECL_PROBINITSOL((*probinitsol)))
Definition: scip.c:10080
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
Definition: scip.c:25248
int SCIPgetNHeurs(SCIP *scip)
Definition: scip.c:8251
SCIP_Bool SCIPisDualfeasPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:47542
SCIP_RETCODE SCIPresetBandit(SCIP *scip, SCIP_BANDIT *bandit, SCIP_Real *priorities, unsigned int seed)
Definition: scip_bandit.c:75
SCIP_RETCODE SCIPsetConsStickingAtNode(SCIP *scip, SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: scip.c:28081
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
Definition: scip.c:21489
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
Definition: scip.c:30534
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
Definition: scip.c:11380
SCIP_RETCODE SCIPcopyProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, const char *name)
Definition: scip.c:1739
public methods for presolvers
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
Definition: scip.c:17791
public methods for managing events
#define SCIP_DECL_DISPEXITSOL(x)
Definition: type_disp.h:117
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
Definition: scip.c:42684
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
Definition: scip.c:42666
SCIP_RETCODE SCIPreadSolFile(SCIP *scip, const char *filename, SCIP_SOL *sol, SCIP_Bool xml, SCIP_Bool *partial, SCIP_Bool *error)
Definition: scip.c:40454
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
Definition: scip.c:46781
SCIP_RETCODE SCIPcreateNLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37942
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
Definition: scip.c:43909
SCIP_RETCODE SCIPcreatePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
Definition: scip.c:48292
SCIP_RETCODE SCIPaddQuadVarToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var)
Definition: scip.c:32473
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
Definition: scip.c:7443
SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)
Definition: scip.c:30061
int SCIPgetNOrigIntVars(SCIP *scip)
Definition: scip.c:12300
SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPRESPROP((*propresprop)))
Definition: scip.c:7856
SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip.c:29366
SCIP_RETCODE SCIPsetSepaInit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
Definition: scip.c:7459
SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
Definition: scip.c:29975
SCIP_RETCODE SCIPbranchPseudo(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:37836
SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:19929
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition: scip.c:39876
SCIP_RETCODE SCIPaddQuadVarsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars)
Definition: scip.c:32498
struct SCIP_RelaxData SCIP_RELAXDATA
Definition: type_relax.h:38
the type definitions for the synchronization store
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46996
#define SCIP_DECL_RELAXEXEC(x)
Definition: type_relax.h:118
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:66
#define SCIP_DECL_TABLEINIT(x)
Definition: type_table.h:69
struct SCIP_ProbData SCIP_PROBDATA
Definition: type_prob.h:44
SCIP_RETCODE SCIPsetProbName(SCIP *scip, const char *name)
Definition: scip.c:10913
SCIP_RETCODE SCIPsolveProbingLPWithPricing(SCIP *scip, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:36568
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:47106
SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:35398
SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
Definition: scip.c:19420
SCIP_RETCODE SCIPaddCharParam(SCIP *scip, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip.c:4349
SCIP_RETCODE SCIPgetNlRowSolFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Real *feasibility)
Definition: scip.c:32963
SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: scip.c:28712
SCIP_TABLE ** SCIPgetTables(SCIP *scip)
Definition: scip.c:9503
SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
Definition: scip.c:28832
SCIP_RETCODE SCIPsolveConcurrent(SCIP *scip)
Definition: scip.c:16425
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
Definition: scip.c:18670
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
Definition: scip.c:46768
SCIP_RETCODE SCIPprintMIPStart(SCIP *scip, SCIP_SOL *sol, FILE *file)
Definition: scip.c:39458
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
Definition: scip.c:42756
static const SCIP_Real scalars[]
Definition: lp.c:5618
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
Definition: scip.c:1920
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:11486
SCIP_NLPI * SCIPfindNlpi(SCIP *scip, const char *name)
Definition: scip.c:9576
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22926
int SCIPgetNNodesels(SCIP *scip)
Definition: scip.c:8981
SCIP_RETCODE SCIPgetVarsStrongbranchesFrac(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip.c:21273
internal methods for main solving loop and node processing
type definitions for tree compression
SCIP_RETCODE SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
Definition: scip.c:6109
SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)
Definition: scip.c:10782
SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:19846
SCIP_Real SCIPtransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip.c:39095
int SCIPgetNReoptRuns(SCIP *scip)
Definition: scip.c:42071
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
Definition: scip.c:42702
SCIP_RETCODE SCIPsetEventhdlrDelete(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTDELETE((*eventdelete)))
Definition: scip.c:8727
SCIP_Real SCIPgetHugeValue(SCIP *scip)
Definition: scip.c:47059
SCIP_RETCODE SCIPrestartSolve(SCIP *scip)
Definition: scip.c:17344
SCIP_Real SCIPgetRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx)
Definition: scip.c:47927
SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
Definition: scip.c:27903
int SCIPgetNReaders(SCIP *scip)
Definition: scip.c:5414
SCIP_RETCODE SCIPendDiveNLP(SCIP *scip)
Definition: scip.c:32034
#define SCIP_DECL_SEPAEXIT(x)
Definition: type_sepa.h:71
int SCIPgetNBranchrules(SCIP *scip)
Definition: scip.c:9295
SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
Definition: scip.c:6133
#define SCIP_DECL_BANDITFREE(x)
Definition: type_bandit.h:54
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:46075
int SCIPgetNPricevars(SCIP *scip)
Definition: scip.c:42826
public methods for conflict analysis handlers
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
Definition: scip.c:42426
int SCIPgetNConss(SCIP *scip)
Definition: scip.c:12856
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:100
SCIP_BRANCHRULE ** SCIPgetBranchrules(SCIP *scip)
Definition: scip.c:9284
SCIP_Bool SCIPisConsCompressionEnabled(SCIP *scip)
Definition: scip.c:1870
public methods for tree compressions
void SCIPsetMessagehdlrLogfile(SCIP *scip, const char *filename)
Definition: scip.c:1243
type definitions for separators
SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)
Definition: scip.c:20228
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip.c:27755
SCIP_RETCODE SCIPsetComprExit(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPREXIT((*comprexit)))
Definition: scip.c:8411
#define SCIP_DECL_DISPEXIT(x)
Definition: type_disp.h:95
SCIP_RETCODE SCIPreadParams(SCIP *scip, const char *filename)
Definition: scip.c:4952
SCIP_RETCODE SCIPsetPresolCopy(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLCOPY((*presolcopy)))
Definition: scip.c:6952
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43722
int SCIPgetRealarrayMinIdx(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:47980
#define SCIP_DECL_SEPAINITSOL(x)
Definition: type_sepa.h:82
SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
Definition: scip.c:20046
#define SCIP_DECL_PROPRESPROP(x)
Definition: type_prop.h:244
#define SCIP_DECL_HEUREXIT(x)
Definition: type_heur.h:86
SCIP_RETCODE SCIPclearIntarray(SCIP *scip, SCIP_INTARRAY *intarray)
Definition: scip.c:48062
SCIP_Bool SCIPallowDualReds(SCIP *scip)
Definition: scip.c:25879
int SCIPgetNCuts(SCIP *scip)
Definition: scip.c:35190
int SCIPgetNPriceRounds(SCIP *scip)
Definition: scip.c:42808
SCIP_RETCODE SCIPsetNodeselFree(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELFREE((*nodeselfree)))
Definition: scip.c:8877
int SCIPgetRepropdepth(SCIP *scip)
Definition: scip.c:41797
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: scip.c:6253
SCIP_RETCODE SCIPcopy(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip.c:3795
SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:36632
public methods for message output
#define SCIP_DECL_HEURINIT(x)
Definition: type_heur.h:78
int SCIPgetNUpgrConss(SCIP *scip)
Definition: scip.c:12814
int SCIPgetNCliques(SCIP *scip)
Definition: scip.c:24873
SCIP_RETCODE SCIPsplitReoptRoot(SCIP *scip, int *ncreatedchilds, int *naddedconss)
Definition: scip.c:17518
void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
Definition: scip.c:13784
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30971
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
Definition: scip.c:8161
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
Definition: scip.c:25353
#define SCIP_DECL_CONSINIT(x)
Definition: type_cons.h:110
SCIP_RETCODE SCIPincludeBanditvtable(SCIP *scip, SCIP_BANDITVTABLE **banditvtable, const char *name, SCIP_DECL_BANDITFREE((*banditfree)), SCIP_DECL_BANDITSELECT((*banditselect)), SCIP_DECL_BANDITUPDATE((*banditupdate)), SCIP_DECL_BANDITRESET((*banditreset)))
Definition: scip_bandit.c:32
#define SCIP_DECL_PROPPRESOL(x)
Definition: type_prop.h:179
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip.c:39120
SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
SCIP_DECL_EVENTEXEC(EventhdlrNewSol::scip_exec)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:47369
int SCIPgetNImplications(SCIP *scip)
Definition: scip.c:45905
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
Definition: scip.c:44020
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
Definition: scip.c:46794
SCIP_NODESEL * SCIPfindNodesel(SCIP *scip, const char *name)
Definition: scip.c:8957
SCIP_VAR ** SCIPgetVars(SCIP *scip)
Definition: scip.c:11761
SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITSOL((*propinitsol)))
Definition: scip.c:7759
SCIP_RETCODE SCIPgetNLPFracVars(SCIP *scip, SCIP_VAR ***fracvars, SCIP_Real **fracvarssol, SCIP_Real **fracvarsfrac, int *nfracvars, int *npriofracvars)
Definition: scip.c:31730
SCIP_RETCODE SCIPapplyReopt(SCIP *scip, SCIP_REOPTNODE *reoptnode, unsigned int id, SCIP_Real estimate, SCIP_NODE **childnodes, int *ncreatedchilds, int *naddedconss, int childnodessize, SCIP_Bool *success)
Definition: scip.c:17072
SCIP_HEUR * SCIPgetSolHeur(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:39228
type definitions for handling parameter settings
struct SCIP_LPi SCIP_LPI
Definition: type_lpi.h:96
enum SCIP_DispStatus SCIP_DISPSTATUS
Definition: type_disp.h:50
SCIP_RETCODE SCIPupdatePrimalRay(SCIP *scip, SCIP_SOL *primalray)
Definition: scip.c:41114
SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip.c:24773
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
Definition: scip.c:25678
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:372
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
Definition: scip.c:43667
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:18726
#define SCIP_Real
Definition: def.h:149
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:30688
int SCIPgetNPricevarsFound(SCIP *scip)
Definition: scip.c:42844
SCIP_RETCODE SCIPgetNlRowNLPFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
Definition: scip.c:32750
type definitions for user interface dialog
enum SCIP_Stage SCIP_STAGE
Definition: type_set.h:50
public methods for relaxation handlers
SCIP_RETCODE SCIPsolveParallel(SCIP *scip)
Definition: scip.c:16395
struct SCIP_PropData SCIP_PROPDATA
Definition: type_prop.h:38
SCIP_Bool SCIPisStopped(SCIP *scip)
Definition: scip.c:1145
SCIP_DECL_CONSPRINT(ConshdlrSubtour::scip_print)
result codes for SCIP callback methods
type definitions for branching and inference history
enum SCIP_ConflictType SCIP_CONFTYPE
Definition: type_conflict.h:56
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip.c:25384
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: scip.c:6567
SCIP_RETCODE SCIPincludeProp(SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_Bool delay, SCIP_PROPTIMING timingmask, int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_PROPCOPY((*propcopy)), SCIP_DECL_PROPFREE((*propfree)), SCIP_DECL_PROPINIT((*propinit)), SCIP_DECL_PROPEXIT((*propexit)), SCIP_DECL_PROPINITPRE((*propinitpre)), SCIP_DECL_PROPEXITPRE((*propexitpre)), SCIP_DECL_PROPINITSOL((*propinitsol)), SCIP_DECL_PROPEXITSOL((*propexitsol)), SCIP_DECL_PROPPRESOL((*proppresol)), SCIP_DECL_PROPEXEC((*propexec)), SCIP_DECL_PROPRESPROP((*propresprop)), SCIP_PROPDATA *propdata)
Definition: scip.c:7605
SCIP_RETCODE SCIPincludePricer(SCIP *scip, const char *name, const char *desc, int priority, SCIP_Bool delay, SCIP_DECL_PRICERCOPY((*pricercopy)), SCIP_DECL_PRICERFREE((*pricerfree)), SCIP_DECL_PRICERINIT((*pricerinit)), SCIP_DECL_PRICEREXIT((*pricerexit)), SCIP_DECL_PRICERINITSOL((*pricerinitsol)), SCIP_DECL_PRICEREXITSOL((*pricerexitsol)), SCIP_DECL_PRICERREDCOST((*pricerredcost)), SCIP_DECL_PRICERFARKAS((*pricerfarkas)), SCIP_PRICERDATA *pricerdata)
Definition: scip.c:5439
SCIP_Bool SCIPisScalingIntegral(SCIP *scip, SCIP_Real val, SCIP_Real scalar)
Definition: scip.c:47118
public methods for input file readers
SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30900
SCIP_DECL_EVENTEXITSOL(EventhdlrNewSol::scip_exitsol)
SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
Definition: scip.c:24957
#define SCIP_DECL_EVENTCOPY(x)
Definition: type_event.h:165
#define SCIP_DECL_NODESELCOPY(x)
Definition: type_nodesel.h:47
SCIP_RETCODE SCIPsetBranchruleInit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINIT((*branchinit)))
Definition: scip.c:9155
void SCIPprintConstraintTimingStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44554
SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
Definition: scip.c:29427
#define SCIP_DECL_HEURFREE(x)
Definition: type_heur.h:70
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
Definition: scip.c:25842
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip.c:34825
SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip.c:18861
SCIP_RETCODE SCIPgetReoptLeaveIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
Definition: scip.c:16791
#define SCIP_DECL_CONFLICTINIT(x)
Definition: type_conflict.h:93
SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)
Definition: scip.c:13344
internal methods for constraints and constraint handlers
SCIP_RETCODE SCIPsetPropFree(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPFREE((*propfree)))
Definition: scip.c:7711
SCIP_DECL_READERREAD(ReaderTSP::scip_read)
Definition: ReaderTSP.cpp:150
int SCIPgetNConflictConssFoundNode(SCIP *scip)
Definition: scip.c:42989
SCIP_Bool SCIPisDualfeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47491
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
Definition: scip.c:31154
SCIP_RETCODE SCIPcalcRowIntegralScalar(SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Real *intscalar, SCIP_Bool *success)
Definition: scip.c:30776
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:671
SCIP_RETCODE SCIPsetConsModifiable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: scip.c:28006
SCIP_RETCODE SCIPlinkRelaxSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38628
SCIP_RETCODE SCIPprintNlRow(SCIP *scip, SCIP_NLROW *nlrow, FILE *file)
Definition: scip.c:33022
SCIP_RETCODE SCIPaddConsLocks(SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
Definition: scip.c:28654
#define SCIP_DECL_BANDITUPDATE(x)
Definition: type_bandit.h:66
SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)
Definition: scip.c:11137
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))
Definition: scip.c:5350
int SCIPgetNCompr(SCIP *scip)
Definition: scip.c:8485
SCIP_Real SCIPcutoffbounddelta(SCIP *scip)
Definition: scip.c:46493
SCIP_RETCODE SCIPcreateCurrentSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:38027
#define SCIP_Longint
Definition: def.h:134
SCIP_Bool SCIPallColsInLP(SCIP *scip)
Definition: scip.c:29713
void SCIPgetVarCoefChg(SCIP *scip, int varidx, SCIP_Bool *negated, SCIP_Bool *entering, SCIP_Bool *leaving)
#define SCIP_DECL_PROPEXIT(x)
Definition: type_prop.h:71
SCIP_RETCODE SCIPsetNodeselInit(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELINIT((*nodeselinit)))
Definition: scip.c:8893
SCIP_Real SCIPgetTotalTime(SCIP *scip)
Definition: scip.c:46273
SCIP_Real SCIPchgRelaxfeastol(SCIP *scip, SCIP_Real relaxfeastol)
Definition: scip.c:46625
SCIP_NODE * SCIPgetPrioChild(SCIP *scip)
Definition: scip.c:41595
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip.c:31128
SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:35636
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38734
SCIP_RETCODE SCIPbranchLP(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:37788
SCIP_RETCODE SCIPsetProbingLPState(SCIP *scip, SCIP_LPISTATE **lpistate, SCIP_LPINORMS **lpinorms, SCIP_Bool primalfeas, SCIP_Bool dualfeas)
Definition: scip.c:36601
SCIP_NODE * SCIPgetBestChild(SCIP *scip)
Definition: scip.c:41627
SCIP_Real SCIPfrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:47179
SCIP_RETCODE SCIPcheckCopyLimits(SCIP *sourcescip, SCIP_Bool *success)
Definition: scip.c:4156
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
Definition: scip.c:11043
SCIP_RETCODE SCIPreleaseDialog(SCIP *scip, SCIP_DIALOG **dialog)
Definition: scip.c:9780
SCIP_RETCODE SCIPstartDive(SCIP *scip)
Definition: scip.c:35262
SCIP_RETCODE SCIPincludeExternalCodeInformation(SCIP *scip, const char *name, const char *description)
Definition: scip.c:9628
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:38807
SCIP_RETCODE SCIPparseVarsPolynomial(SCIP *scip, const char *str, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int *nmonomials, char **endptr, SCIP_Bool *success)
Definition: scip.c:18318
SCIP_Real SCIPgetNodeLowerbound(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:13439
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
Definition: scip.c:13929
SCIP_RETCODE SCIPsetNlpiPriority(SCIP *scip, SCIP_NLPI *nlpi, int priority)
Definition: scip.c:9613
SCIP_Bool SCIPgetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx)
Definition: scip.c:48229
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:47070
SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
Definition: scip.c:25852
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26483
struct SCIP_PricerData SCIP_PRICERDATA
Definition: type_pricer.h:36
SCIP_RETCODE SCIPbranchExtern(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:37812
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition: scip.c:7536
SCIP_Real SCIPgetNLPObjval(SCIP *scip)
Definition: scip.c:31681
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46983
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition: type_cons.h:92
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:60
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:49
SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)
Definition: scip.c:43762
SCIP_Real SCIPgetLPRootObjval(SCIP *scip)
Definition: scip.c:29491
SCIP_DECL_EVENTDELETE(EventhdlrNewSol::scip_delete)
SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19826
SCIP_RETCODE SCIPstartDiveNLP(SCIP *scip)
Definition: scip.c:32006
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
Definition: scip.c:43640
enum Reopt_ConsType REOPT_CONSTYPE
Definition: type_reopt.h:67
#define SCIP_DECL_PRICERFREE(x)
Definition: type_pricer.h:54
int SCIPgetNOrigImplVars(SCIP *scip)
Definition: scip.c:12327
SCIP_RETCODE SCIPsetProbDeltrans(SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))
Definition: scip.c:10059
SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)
Definition: scip.c:30219
int SCIPgetNLPCols(SCIP *scip)
Definition: scip.c:29612
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: scip.c:8129
SCIP_RETCODE SCIPsetPricerCopy(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERCOPY((*pricercopy)))
Definition: scip.c:5545
#define SCIP_DECL_BANDITSELECT(x)
Definition: type_bandit.h:60
#define nnodes
Definition: gastrans.c:65
SCIP_Bool SCIPhasPerformedPresolve(SCIP *scip)
Definition: scip.c:1116
int SCIPgetPtrarrayMinIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
Definition: scip.c:48392
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23854
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
Definition: scip.c:35898
SCIP_RETCODE SCIPgetDivesetScore(SCIP *scip, SCIP_DIVESET *diveset, SCIP_DIVETYPE divetype, SCIP_VAR *divecand, SCIP_Real divecandsol, SCIP_Real divecandfrac, SCIP_Real *candscore, SCIP_Bool *roundup)
Definition: scip.c:36769
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:47393
SCIP_Bool SCIPisDualfeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47465
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip.c:4993
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23656
int SCIPgetNPricevarsApplied(SCIP *scip)
Definition: scip.c:42862
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip.c:43684
SCIP_Real SCIPsumepsilon(SCIP *scip)
Definition: scip.c:46423
#define SCIP_DECL_RELAXEXITSOL(x)
Definition: type_relax.h:93
SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)
Definition: scip.c:17318
SCIP_NLPI ** SCIPgetNlpis(SCIP *scip)
Definition: scip.c:9589
SCIP_Real SCIPgetUpperbound(SCIP *scip)
Definition: scip.c:43420
SCIP_NODE * SCIPgetBestLeaf(SCIP *scip)
Definition: scip.c:41659
SCIP_RETCODE SCIPinitVarValueBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real value, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
Definition: scip.c:26819
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
Definition: scip.c:35852
public methods for separators
SCIP_RETCODE SCIPincludeConshdlr(SCIP *scip, const char *name, const char *desc, int sepapriority, int enfopriority, int chckpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_CONSHDLRDATA *conshdlrdata)
Definition: scip.c:5801
SCIP_DISP ** SCIPgetDisps(SCIP *scip)
Definition: scip.c:9406
SCIP_RETCODE SCIPgetVarStrongbranchFrac(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
Definition: scip.c:20403
SCIP_Bool SCIPisSumLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47204
public methods for primal heuristics
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
Definition: scip.c:29634
int SCIPgetNSepas(SCIP *scip)
Definition: scip.c:7549
SCIP_RETCODE SCIPgetTransformedConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip.c:28296
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
Definition: scip.c:6383
int SCIPgetNExternBranchCands(SCIP *scip)
Definition: scip.c:37143
int SCIPgetNOrigBinVars(SCIP *scip)
Definition: scip.c:12273
SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip.c:25320
SCIP_RETCODE SCIPsetProbDelorig(SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))
Definition: scip.c:10017
#define SCIP_DECL_DISPOUTPUT(x)
Definition: type_disp.h:126
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
Definition: scip.c:29452
SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadvars, SCIP_VAR **quadvars, int nquadelems, SCIP_QUADELEM *quadelems, SCIP_EXPRTREE *expression, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)
Definition: scip.c:32185
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:419
void SCIPdisableDebugSol(SCIP *scip)
Definition: scip.c:1175
SCIP_RETCODE SCIPendDive(SCIP *scip)
Definition: scip.c:35311
void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)
Definition: scip.c:42098
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
Definition: scip.c:13043
#define SCIP_DECL_CONFLICTFREE(x)
Definition: type_conflict.h:85
SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
Definition: scip.c:34843
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
Definition: scip.c:47155
void SCIPprintError(SCIP_RETCODE retcode)
Definition: scip.c:676
SCIP_RETCODE SCIPsetPropInitpre(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITPRE((*propinitpre)))
Definition: scip.c:7791
SCIP_RETCODE SCIPfreeSolve(SCIP *scip, SCIP_Bool restart)
Definition: scip.c:17116
void SCIPfreeDisjointset(SCIP *scip, SCIP_DISJOINTSET **djset)
Definition: scip.c:48666
type definitions for node selectors
SCIP_RETCODE SCIPchgRowRhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)
Definition: scip.c:35575
int SCIPgetNEnabledConss(SCIP *scip)
Definition: scip.c:43191
SCIP_REOPTNODE * SCIPgetReoptnode(SCIP *scip, unsigned int id)
Definition: scip.c:16844
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
Definition: scip.c:24830
SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19465
SCIP_Bool SCIPisDualfeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47478
SCIP_RETCODE SCIPgetNlRowNLPActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
Definition: scip.c:32722
SCIP_RETCODE SCIPsetConflicthdlrPriority(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)
Definition: scip.c:6853
SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip.c:4662
#define SCIP_DECL_CONCSOLVERSYNCWRITE(x)
int SCIPgetNReoptLeaves(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:16831
SCIP_RETCODE SCIPresetParam(SCIP *scip, const char *name)
Definition: scip.c:5015
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: scip.c:6181
SCIP_Longint SCIPgetNNodes(SCIP *scip)
Definition: scip.c:42127
SCIP_RETCODE SCIPsetPropExit(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXIT((*propexit)))
Definition: scip.c:7743
SCIP_Longint SCIPgetNLPs(SCIP *scip)
Definition: scip.c:42308
SCIP_RETCODE SCIPresetRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:17009
SCIP_ROW ** SCIPgetCuts(SCIP *scip)
Definition: scip.c:35172
SCIP_RETCODE SCIPsetRootDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9797
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
Definition: scip.c:17729
#define SCIP_DECL_PRICERREDCOST(x)
Definition: type_pricer.h:130
SCIP_Real SCIPround(SCIP *scip, SCIP_Real val)
Definition: scip.c:47167
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
Definition: scip.c:42226
#define SCIP_DECL_HEUREXITSOL(x)
Definition: type_heur.h:108
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21621
SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: scip.c:19341
#define SCIP_DECL_NODESELSELECT(x)
Definition: type_nodesel.h:109
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:36078
#define SCIP_DECL_CONCSOLVERCREATEINST(x)
int SCIPminorVersion(void)
Definition: scip.c:578
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
Definition: scip.c:43884
int SCIPgetNParams(SCIP *scip)
Definition: scip.c:5192
void SCIPprintOrigProblemStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44326
SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)
Definition: scip.c:42199
void SCIPupdateDivesetStats(SCIP *scip, SCIP_DIVESET *diveset, int nprobingnodes, int nbacktracks, SCIP_Longint nsolsfound, SCIP_Longint nbestsolsfound, SCIP_Bool leavewassol)
Definition: scip.c:36807
SCIP_RETCODE SCIPmakeRowIntegral(SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)
Definition: scip.c:30805
void SCIPdisableVarHistory(SCIP *scip)
Definition: scip.c:25971
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:46092
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition: scip.c:38905
double real
SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26684
SCIP_RETCODE SCIPaddObjoffset(SCIP *scip, SCIP_Real addval)
Definition: scip.c:11086
SCIP_Real SCIPgetVarObjDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:35607
SCIP_RETCODE SCIPdeactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:29046
SCIP_Bool SCIPisInRestart(SCIP *scip)
Definition: scip.c:17576
void SCIPprintBuildOptions(SCIP *scip, FILE *file)
Definition: scip.c:646
SCIP_Bool SCIPisExactSolve(SCIP *scip)
Definition: scip.c:1032
public methods for user interface dialog
#define SCIP_DECL_BRANCHEXIT(x)
Definition: type_branch.h:76
void SCIPsetFocusnodeLP(SCIP *scip, SCIP_Bool solvelp)
Definition: scip.c:41910
SCIP_RETCODE SCIPcopyDigraph(SCIP *scip, SCIP_DIGRAPH **targetdigraph, SCIP_DIGRAPH *sourcedigraph)
Definition: scip.c:48583
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip.c:4604
#define SCIP_DECL_TABLEOUTPUT(x)
Definition: type_table.h:108
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip.c:4321
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23033
SCIP_Bool SCIPisRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:47694
SCIP_RETCODE SCIPparseVar(SCIP *scip, SCIP_VAR **var, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
Definition: scip.c:17973
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
Definition: scip.c:42774
SCIP_CONCSOLVERTYPE * SCIPfindConcsolverType(SCIP *scip, const char *name)
Definition: scip.c:7987
SCIP_Real SCIPgetFirstLPTime(SCIP *scip)
Definition: scip.c:46390
int SCIPgetNProps(SCIP *scip)
Definition: scip.c:7899
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
Definition: scip.c:5083
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:47143
SCIP_RETCODE SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
Definition: scip.c:27498
SCIP_RETCODE SCIPsetRelaxInitsol(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINITSOL((*relaxinitsol)))
Definition: scip.c:7246
SCIP_RETCODE SCIPaddDialogInputLine(SCIP *scip, const char *inputline)
Definition: scip.c:9848
#define SCIP_DECL_TABLEEXITSOL(x)
Definition: type_table.h:99
#define SCIP_DECL_SEPAFREE(x)
Definition: type_sepa.h:55
SCIP_RETCODE SCIPsetNodeselStdPriority(SCIP *scip, SCIP_NODESEL *nodesel, int priority)
Definition: scip.c:8992
type definitions for displaying statistics tables
SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
Definition: scip.c:25192
SCIP_RETCODE SCIPaddQuadElementsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nquadelems, SCIP_QUADELEM *quadelems)
Definition: scip.c:32561
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip.c:27096
SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))
Definition: scip.c:5326
int SCIPgetNTables(SCIP *scip)
Definition: scip.c:9514
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
Definition: scip.c:4746
SCIP_Real SCIPgetPrimalRayVal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:41087
SCIP_RETCODE SCIPenableReoptimization(SCIP *scip, SCIP_Bool enable)
Definition: scip.c:16598
SCIP_RETCODE SCIPevalExprtreeLocalBounds(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
Definition: scip.c:33225
struct SCIP_SepaData SCIP_SEPADATA
Definition: type_sepa.h:38
SCIP_Bool SCIPallowObjProp(SCIP *scip)
Definition: scip.c:25889
SCIP_RETCODE SCIPsetPresolExitpre(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXITPRE((*presolexitpre)))
Definition: scip.c:7032
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
Definition: scip.c:43995
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
Definition: scip.c:19039
SCIP_RETCODE SCIPincludeNodesel(SCIP *scip, const char *name, const char *desc, int stdpriority, int memsavepriority, SCIP_DECL_NODESELCOPY((*nodeselcopy)), SCIP_DECL_NODESELFREE((*nodeselfree)), SCIP_DECL_NODESELINIT((*nodeselinit)), SCIP_DECL_NODESELEXIT((*nodeselexit)), SCIP_DECL_NODESELINITSOL((*nodeselinitsol)), SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)), SCIP_DECL_NODESELSELECT((*nodeselselect)), SCIP_DECL_NODESELCOMP((*nodeselcomp)), SCIP_NODESELDATA *nodeseldata)
Definition: scip.c:8781
SCIP_RETCODE SCIPinitlpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
Definition: scip.c:28805
SCIP_RETCODE SCIPsetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx, void *val)
Definition: scip.c:48374
type definitions for constraints and constraint handlers
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip.c:4239
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26452
int SCIPgetNSepaRounds(SCIP *scip)
Definition: scip.c:42878
SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip.c:43810
SCIP_Bool SCIPcontainsExternBranchCand(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:37310
SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:31065
public methods for propagators
SCIP_Real SCIPgetLPColumnObjval(SCIP *scip)
Definition: scip.c:29384
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43957
SCIP_RETCODE SCIPfree(SCIP **scip)
Definition: scip.c:780
SCIP_RETCODE SCIPcreateFiniteSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol, SCIP_Bool *success)
Definition: scip.c:38393
void SCIPaddSquareLinearization(SCIP *scip, SCIP_Real sqrcoef, SCIP_Real refpoint, SCIP_Bool isint, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)
Definition: scip.c:33285
SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:20110
#define SCIP_DECL_PROPINIT(x)
Definition: type_prop.h:63
SCIP_RELAX * SCIPfindRelax(SCIP *scip, const char *name)
Definition: scip.c:7279
struct SCIP_TableData SCIP_TABLEDATA
Definition: type_table.h:44
type definitions for specific NLP solver interfaces
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37872
SCIP_Longint SCIPgetSolNodenum(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:39201
SCIP_CONFLICTHDLR * SCIPfindConflicthdlr(SCIP *scip, const char *name)
Definition: scip.c:6816
uint64_t SCIP_EVENTTYPE
Definition: type_event.h:134
void SCIPenableDebugSol(SCIP *scip)
Definition: scip.c:1162
#define SCIP_DECL_CONFLICTEXITSOL(x)
SCIP_RETCODE SCIPincludePropBasic(SCIP *scip, SCIP_PROP **propptr, const char *name, const char *desc, int priority, int freq, SCIP_Bool delay, SCIP_PROPTIMING timingmask, SCIP_DECL_PROPEXEC((*propexec)), SCIP_PROPDATA *propdata)
Definition: scip.c:7658
SCIP_RETCODE SCIPfreePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
Definition: scip.c:48309
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
Definition: scip.c:5994
SCIP_PRICER ** SCIPgetPricers(SCIP *scip)
Definition: scip.c:5694
type definitions for concurrent solvers
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
Definition: scip.c:27853
SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
Definition: scip.c:18811
SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip.c:35015
type definitions for displaying runtime statistics
memory allocation routines
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:36207
SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26938
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39319