Scippy

SCIP

Solving Constraint Integer Programs

scip.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2017 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip.h
17  * @ingroup PUBLICCOREAPI
18  * @brief SCIP callable library
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  */
26 
27 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
28 
29 #ifndef __SCIP_SCIP_H__
30 #define __SCIP_SCIP_H__
31 
32 
33 #include <stdio.h>
34 
35 #include "scip/def.h"
36 #include "blockmemshell/memory.h"
37 #include "scip/type_retcode.h"
38 #include "scip/type_result.h"
39 #include "scip/type_clock.h"
40 #include "scip/type_misc.h"
41 #include "scip/type_timing.h"
42 #include "scip/type_paramset.h"
43 #include "scip/type_event.h"
44 #include "scip/type_lp.h"
45 #include "scip/type_nlp.h"
46 #include "scip/type_var.h"
47 #include "scip/type_prob.h"
48 #include "scip/type_tree.h"
49 #include "scip/type_scip.h"
50 
51 #include "scip/type_branch.h"
52 #include "scip/type_conflict.h"
53 #include "scip/type_cons.h"
54 #include "scip/type_dialog.h"
55 #include "scip/type_disp.h"
56 #include "scip/type_heur.h"
57 #include "scip/type_compr.h"
58 #include "scip/type_history.h"
59 #include "scip/type_nodesel.h"
60 #include "scip/type_presol.h"
61 #include "scip/type_pricer.h"
62 #include "scip/type_reader.h"
63 #include "scip/type_relax.h"
64 #include "scip/type_sepa.h"
65 #include "scip/type_prop.h"
66 #include "nlpi/type_nlpi.h"
67 #include "scip/type_concsolver.h"
68 #include "scip/type_syncstore.h"
69 
70 /* include public interfaces, s.t. the user only needs to include scip.h */
71 #include "scip/pub_branch.h"
72 #include "scip/pub_conflict.h"
73 #include "scip/pub_cons.h"
74 #include "scip/pub_cutpool.h"
75 #include "scip/pub_dialog.h"
76 #include "scip/pub_disp.h"
77 #include "scip/pub_event.h"
78 #include "scip/pub_fileio.h"
79 #include "scip/pub_heur.h"
80 #include "scip/pub_compr.h"
81 #include "scip/pub_history.h"
82 #include "scip/pub_implics.h"
83 #include "scip/pub_lp.h"
84 #include "scip/pub_nlp.h"
85 #include "scip/pub_message.h"
86 #include "scip/pub_misc.h"
87 #include "scip/pub_nodesel.h"
88 #include "scip/pub_paramset.h"
89 #include "scip/pub_presol.h"
90 #include "scip/pub_pricer.h"
91 #include "scip/pub_reader.h"
92 #include "scip/pub_relax.h"
93 #include "scip/pub_sepa.h"
94 #include "scip/pub_prop.h"
95 #include "scip/pub_sol.h"
96 #include "scip/pub_tree.h"
97 #include "scip/pub_var.h"
98 #include "lpi/lpi.h"
99 #include "nlpi/pub_expr.h"
100 
101 /* include global presolving, cuts, and heuristics methods */
102 #include "scip/presolve.h"
103 #include "scip/cuts.h"
104 #include "scip/heuristics.h"
105 
106 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
107  * this structure except the interface methods in scip.c.
108  * In optimized mode, the structure is included in scip.h, because some of the methods
109  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
110  * Additionally, the internal "set.h" is included, such that the defines in set.h are
111  * available in optimized mode.
112  */
113 #ifdef NDEBUG
114 #include "scip/struct_scip.h"
115 #include "scip/struct_stat.h"
116 #include "scip/set.h"
117 #include "scip/tree.h"
118 #include "scip/misc.h"
119 #include "scip/var.h"
120 #include "scip/cons.h"
121 #include "scip/solve.h"
122 #include "scip/debug.h"
123 #endif
124 
125 #ifdef __cplusplus
126 extern "C" {
127 #endif
128 
129 /*
130  * miscellaneous methods
131  */
132 
133 /**@addtogroup MiscellaneousMethods
134  *
135  * @{
136  */
137 
138 /** returns complete SCIP version number in the format "major . minor tech"
139  *
140  * @return complete SCIP version
141  */
142 extern
144  void
145  );
146 
147 /** returns SCIP major version
148  *
149  * @return major SCIP version
150  */
151 extern
152 int SCIPmajorVersion(
153  void
154  );
155 
156 /** returns SCIP minor version
157  *
158  * @return minor SCIP version
159  */
160 extern
161 int SCIPminorVersion(
162  void
163  );
164 
165 /** returns SCIP technical version
166  *
167  * @return technical SCIP version
168  */
169 extern
170 int SCIPtechVersion(
171  void
172  );
173 
174 /** returns SCIP sub version number
175  *
176  * @return subversion SCIP version
177  */
178 extern
179 int SCIPsubversion(
180  void
181  );
182 
183 /** prints a version information line to a file stream via the message handler system
184  *
185  * @note If the message handler is set to a NULL pointer nothing will be printed
186  */
187 extern
188 void SCIPprintVersion(
189  SCIP* scip, /**< SCIP data structure */
190  FILE* file /**< output file (or NULL for standard output) */
191  );
192 
193 /** prints detailed information on the compile-time flags
194  *
195  * @note If the message handler is set to a NULL pointer nothing will be printed
196  */
197 extern
199  SCIP* scip, /**< SCIP data structure */
200  FILE* file /**< output file (or NULL for standard output) */
201  );
202 
203 /** prints error message for the given SCIP_RETCODE via the error prints method */
204 extern
205 void SCIPprintError(
206  SCIP_RETCODE retcode /**< SCIP return code causing the error */
207  );
208 
209 /**@} */
210 
211 
212 
213 
214 /*
215  * general SCIP methods
216  */
217 
218 /**@addtogroup GeneralSCIPMethods
219  *
220  * @{
221  */
222 
223 /** creates and initializes SCIP data structures
224  *
225  * @note The SCIP default message handler is installed. Use the method SCIPsetMessagehdlr() to install your own
226  * message handler or SCIPsetMessagehdlrLogfile() and SCIPsetMessagehdlrQuiet() to write into a log
227  * file and turn off/on the display output, respectively.
228  *
229  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
230  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
231  *
232  * @post After calling this method @p scip reached the solving stage \ref SCIP_STAGE_INIT
233  *
234  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
235  */
236 extern
238  SCIP** scip /**< pointer to SCIP data structure */
239  );
240 
241 /** frees SCIP data structures
242  *
243  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
244  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
245  *
246  * @pre This method can be called if @p scip is in one of the following stages:
247  * - \ref SCIP_STAGE_INIT
248  * - \ref SCIP_STAGE_PROBLEM
249  * - \ref SCIP_STAGE_TRANSFORMED
250  * - \ref SCIP_STAGE_INITPRESOLVE
251  * - \ref SCIP_STAGE_PRESOLVING
252  * - \ref SCIP_STAGE_PRESOLVED
253  * - \ref SCIP_STAGE_EXITPRESOLVE
254  * - \ref SCIP_STAGE_SOLVING
255  * - \ref SCIP_STAGE_SOLVED
256  * - \ref SCIP_STAGE_FREE
257  *
258  * @post After calling this method \SCIP reached the solving stage \ref SCIP_STAGE_FREE
259  *
260  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
261  */
262 extern
264  SCIP** scip /**< pointer to SCIP data structure */
265  );
266 
267 /** returns current stage of SCIP
268  *
269  * @return the current SCIP stage
270  *
271  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
272  */
273 extern
275  SCIP* scip /**< SCIP data structure */
276  );
277 
278 /** outputs SCIP stage and solution status if applicable via the message handler
279  *
280  * @note If the message handler is set to a NULL pointer nothing will be printed
281  *
282  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
283  * thus may to correspond to the original status.
284  *
285  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
286  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
287  *
288  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
289  */
290 extern
292  SCIP* scip, /**< SCIP data structure */
293  FILE* file /**< output file (or NULL for standard output) */
294  );
295 
296 /** gets solution status
297  *
298  * @return SCIP solution status
299  *
300  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
301  */
302 extern
304  SCIP* scip /**< SCIP data structure */
305  );
306 
307 /** outputs solution status
308  *
309  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
310  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
311  *
312  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
313  */
314 extern
316  SCIP* scip, /**< SCIP data structure */
317  FILE* file /**< output file (or NULL for standard output) */
318  );
319 
320 /** returns whether the current stage belongs to the transformed problem space
321  *
322  * @return Returns TRUE if the \SCIP instance is transformed, otherwise FALSE
323  */
324 extern
326  SCIP* scip /**< SCIP data structure */
327  );
328 
329 /** returns whether the solution process should be probably correct
330  *
331  * @note This feature is not supported yet!
332  *
333  * @return Returns TRUE if \SCIP is exact solving mode, otherwise FALSE
334  */
335 extern
337  SCIP* scip /**< SCIP data structure */
338  );
339 
340 /** returns whether the presolving process would be finished given no more presolving reductions are found in this
341  * presolving round
342  *
343  * Checks whether the number of presolving rounds is not exceeded and the presolving reductions found in the current
344  * presolving round suffice to trigger another presolving round.
345  *
346  * @note if subsequent presolvers find more reductions, presolving might continue even if the method returns FALSE
347  * @note does not check whether infeasibility or unboundedness was already detected in presolving (which would result
348  * in presolving being stopped although the method returns TRUE)
349  *
350  * @return Returns TRUE if presolving is finished if no further reductions are detected
351  */
352 extern
354  SCIP* scip /**< SCIP data structure */
355  );
356 
357 /** returns whether SCIP has performed presolving during the last solve
358  *
359  * @return Returns TRUE if presolving was performed during the last solve
360  */
361 extern
363  SCIP* scip /**< SCIP data structure */
364  );
365 
366 /** returns whether the user pressed CTRL-C to interrupt the solving process
367  *
368  * @return Returns TRUE if Ctrl-C was pressed, otherwise FALSE.
369  */
370 extern
372  SCIP* scip /**< SCIP data structure */
373  );
374 
375 /** returns whether the solving process should be / was stopped before proving optimality;
376  * if the solving process should be / was stopped, the status returned by SCIPgetStatus() yields
377  * the reason for the premature abort
378  *
379  * @return Returns TRUE if solving process is stopped/interrupted, otherwise FALSE.
380  */
381 extern
383  SCIP* scip /**< SCIP data structure */
384  );
385 
386 /**@} */
387 
388 /*
389  * debug solution methods
390  */
391 
392 /**@addtogroup DebugSolutionMethods
393  *
394  * @{
395  */
396 
397 /** enable debug solution mechanism
398  *
399  * the debug solution mechanism allows to trace back the invalidation of
400  * a debug solution during the solution process of SCIP. It must be explicitly
401  * enabled for the SCIP data structure.
402  *
403  * @see debug.h for more information on debug solution mechanism
404  */
405 extern
406 void SCIPenableDebugSol(
407  SCIP* scip /**< SCIP data structure */
408  );
409 
410 /** disable solution debugging mechanism
411  *
412  * @see debug.h for more information on debug solution mechanism
413  */
414 extern
416  SCIP* scip /**< SCIP data structure */
417  );
418 
419 /**@} */
420 
421 
422 /*
423  * message output methods
424  */
425 
426 /**@addtogroup MessageOutputMethods
427  *
428  * @{
429  */
430 
431 /* if we have a C99 compiler */
432 #ifdef SCIP_HAVE_VARIADIC_MACROS
433 
434 /** prints a debugging message if SCIP_DEBUG flag is set */
435 #ifdef SCIP_DEBUG
436 #define SCIPdebugMsg(scip, ...) SCIPprintDebugMessage(scip, __FILE__, __LINE__, __VA_ARGS__)
437 #define SCIPdebugMsgPrint(scip, ...) SCIPdebugMessagePrint(scip, __VA_ARGS__)
438 #else
439 #define SCIPdebugMsg(scip, ...) while ( FALSE ) SCIPprintDebugMessage(scip, __FILE__, __LINE__, __VA_ARGS__)
440 #define SCIPdebugMsgPrint(scip, ...) while ( FALSE ) SCIPdebugMessagePrint(scip, __VA_ARGS__)
441 #endif
442 
443 #else
444 /* if we do not have a C99 compiler, use a workaround that prints a message, but not the file and linenumber */
445 
446 /** prints a debugging message if SCIP_DEBUG flag is set */
447 #ifdef SCIP_DEBUG
448 #define SCIPdebugMsg printf("debug: "), SCIPdebugMessagePrint
449 #define SCIPdebugMsgPrint SCIPdebugMessagePrint
450 #else
451 #define SCIPdebugMsg while ( FALSE ) SCIPdebugMessagePrint
452 #define SCIPdebugMsgPrint while ( FALSE ) SCIPdebugMessagePrint
453 #endif
454 
455 #endif
456 
457 
458 /** installs the given message handler, such that all messages are passed to this handler. A messages handler can be
459  * created via SCIPmessagehdlrCreate().
460  *
461  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
462  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
463  *
464  * @pre this method can be called in one of the following stages of the SCIP solving process:
465  * - \ref SCIP_STAGE_INIT
466  * - \ref SCIP_STAGE_PROBLEM
467  *
468  * @note The currently installed messages handler gets freed if this SCIP instance is its last user (w.r.t. capture/release).
469  */
470 extern
472  SCIP* scip, /**< SCIP data structure */
473  SCIP_MESSAGEHDLR* messagehdlr /**< message handler to install, or NULL to suppress all output */
474  );
475 
476 /** returns the currently installed message handler
477  *
478  * @return the currently installed message handler, or NULL if messages are currently suppressed
479  */
480 extern
482  SCIP* scip /**< SCIP data structure */
483  );
484 
485 /** sets the log file name for the currently installed message handler */
486 extern
488  SCIP* scip, /**< SCIP data structure */
489  const char* filename /**< name of log file, or NULL (no log) */
490  );
491 
492 /** sets the currently installed message handler to be quiet (or not) */
493 extern
495  SCIP* scip, /**< SCIP data structure */
496  SCIP_Bool quiet /**< should screen messages be suppressed? */
497  );
498 
499 /** prints a warning message via the message handler */
500 extern
501 void SCIPwarningMessage(
502  SCIP* scip, /**< SCIP data structure */
503  const char* formatstr, /**< format string like in printf() function */
504  ... /**< format arguments line in printf() function */
505  );
506 
507 /** prints a debug message */
508 extern
510  SCIP* scip, /**< SCIP data structure */
511  const char* sourcefile, /**< name of the source file that called the function */
512  int sourceline, /**< line in the source file where the function was called */
513  const char* formatstr, /**< format string like in printf() function */
514  ... /**< format arguments line in printf() function */
515  );
516 
517 /** prints a debug message without precode */
518 extern
520  SCIP* scip, /**< SCIP data structure */
521  const char* formatstr, /**< format string like in printf() function */
522  ... /**< format arguments line in printf() function */
523  );
524 
525 /** prints a dialog message that requests user interaction or is a direct response to a user interactive command */
526 extern
527 void SCIPdialogMessage(
528  SCIP* scip, /**< SCIP data structure */
529  FILE* file, /**< file stream to print into, or NULL for stdout */
530  const char* formatstr, /**< format string like in printf() function */
531  ... /**< format arguments line in printf() function */
532  );
533 
534 /** prints a message */
535 extern
536 void SCIPinfoMessage(
537  SCIP* scip, /**< SCIP data structure */
538  FILE* file, /**< file stream to print into, or NULL for stdout */
539  const char* formatstr, /**< format string like in printf() function */
540  ... /**< format arguments line in printf() function */
541  );
542 
543 /** prints a message depending on the verbosity level */
544 extern
545 void SCIPverbMessage(
546  SCIP* scip, /**< SCIP data structure */
547  SCIP_VERBLEVEL msgverblevel, /**< verbosity level of this message */
548  FILE* file, /**< file stream to print into, or NULL for stdout */
549  const char* formatstr, /**< format string like in printf() function */
550  ... /**< format arguments line in printf() function */
551  );
552 
553 /** returns the current message verbosity level
554  *
555  * @return message verbosity level of SCIP
556  *
557  * @see \ref SCIP_VerbLevel "SCIP_VERBLEVEL" for a list of all verbosity levels
558  */
559 extern
561  SCIP* scip /**< SCIP data structure */
562  );
563 
564 
565 /**@} */
566 
567 
568 
569 
570 /*
571  * SCIP copy methods
572  */
573 
574 /**@addtogroup CopyMethods
575  *
576  * @{
577  */
578 
579 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
580  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
581  * copied SCIP instance might not represent the same problem semantics as the original.
582  * Note that in this case dual reductions might be invalid.
583  *
584  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
585  * Also, 'passmessagehdlr' should be set to FALSE.
586  * @note Do not change the source SCIP environment during the copying process
587  *
588  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
589  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
590  *
591  * @pre This method can be called if sourcescip is in one of the following stages:
592  * - \ref SCIP_STAGE_PROBLEM
593  * - \ref SCIP_STAGE_TRANSFORMED
594  * - \ref SCIP_STAGE_INITPRESOLVE
595  * - \ref SCIP_STAGE_PRESOLVING
596  * - \ref SCIP_STAGE_EXITPRESOLVE
597  * - \ref SCIP_STAGE_PRESOLVED
598  * - \ref SCIP_STAGE_INITSOLVE
599  * - \ref SCIP_STAGE_SOLVING
600  * - \ref SCIP_STAGE_SOLVED
601  *
602  * @pre This method can be called if targetscip is in one of the following stages:
603  * - \ref SCIP_STAGE_INIT
604  * - \ref SCIP_STAGE_FREE
605  *
606  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
607  * process was interrupted:
608  * - \ref SCIP_STAGE_PROBLEM
609  *
610  * @note sourcescip stage does not get changed
611  *
612  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
613  */
614 extern
616  SCIP* sourcescip, /**< source SCIP data structure */
617  SCIP* targetscip, /**< target SCIP data structure */
618  SCIP_Bool copyreaders, /**< should the file readers be copied */
619  SCIP_Bool copypricers, /**< should the variable pricers be copied */
620  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
621  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
622  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
623  SCIP_Bool copyrelaxators, /**< should the relaxation handler be copied */
624  SCIP_Bool copyseparators, /**< should the separators be copied */
625  SCIP_Bool copypropagators, /**< should the propagators be copied */
626  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
627  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
628  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
629  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
630  SCIP_Bool copydisplays, /**< should the display columns be copied */
631  SCIP_Bool copydialogs, /**< should the dialogs be copied */
632  SCIP_Bool copynlpis, /**< should the NLPIs be copied */
633  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
634  SCIP_Bool* valid /**< pointer to store whether plugins, in particular all constraint
635  * handlers which do not need constraints were validly copied */
636  );
637 
638 /** create a problem by copying the problem data of the source SCIP
639  *
640  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
641  * @note Do not change the source SCIP environment during the copying process
642  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
643  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
644  *
645  * @pre This method can be called if sourcescip is in one of the following stages:
646  * - \ref SCIP_STAGE_PROBLEM
647  * - \ref SCIP_STAGE_TRANSFORMED
648  * - \ref SCIP_STAGE_INITPRESOLVE
649  * - \ref SCIP_STAGE_PRESOLVING
650  * - \ref SCIP_STAGE_EXITPRESOLVE
651  * - \ref SCIP_STAGE_PRESOLVED
652  * - \ref SCIP_STAGE_INITSOLVE
653  * - \ref SCIP_STAGE_SOLVING
654  * - \ref SCIP_STAGE_SOLVED
655  *
656  * @pre This method can be called if targetscip is in one of the following stages:
657  * - \ref SCIP_STAGE_INIT
658  * - \ref SCIP_STAGE_PROBLEM
659  * - \ref SCIP_STAGE_TRANSFORMED
660  * - \ref SCIP_STAGE_INITPRESOLVE
661  * - \ref SCIP_STAGE_PRESOLVING
662  * - \ref SCIP_STAGE_EXITPRESOLVE
663  * - \ref SCIP_STAGE_PRESOLVED
664  * - \ref SCIP_STAGE_INITSOLVE
665  * - \ref SCIP_STAGE_SOLVING
666  * - \ref SCIP_STAGE_SOLVED
667  * - \ref SCIP_STAGE_FREE
668  *
669  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
670  * process was interrupted:
671  * - \ref SCIP_STAGE_PROBLEM
672  *
673  * @note sourcescip stage does not get changed
674  *
675  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
676  */
677 extern
679  SCIP* sourcescip, /**< source SCIP data structure */
680  SCIP* targetscip, /**< target SCIP data structure */
681  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
682  * target variables, or NULL */
683  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
684  * target constraints, or NULL */
685  SCIP_Bool global, /**< create a global or a local copy? */
686  const char* name /**< problem name */
687  );
688 
689 /** create a problem by copying the original problem data of the source SCIP
690  *
691  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
692  * @note Do not change the source SCIP environment during the copying process
693  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
694  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
695  *
696  * @pre This method can be called if sourcescip is in one of the following stages:
697  * - \ref SCIP_STAGE_PROBLEM
698  * - \ref SCIP_STAGE_TRANSFORMED
699  * - \ref SCIP_STAGE_INITPRESOLVE
700  * - \ref SCIP_STAGE_PRESOLVING
701  * - \ref SCIP_STAGE_EXITPRESOLVE
702  * - \ref SCIP_STAGE_PRESOLVED
703  * - \ref SCIP_STAGE_INITSOLVE
704  * - \ref SCIP_STAGE_SOLVING
705  * - \ref SCIP_STAGE_SOLVED
706  *
707  * @pre This method can be called if targetscip is in one of the following stages:
708  * - \ref SCIP_STAGE_INIT
709  * - \ref SCIP_STAGE_FREE
710  *
711  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
712  * process was interrupted:
713  * - \ref SCIP_STAGE_PROBLEM
714  *
715  * @note sourcescip stage does not get changed
716  *
717  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
718  */
719 extern
721  SCIP* sourcescip, /**< source SCIP data structure */
722  SCIP* targetscip, /**< target SCIP data structure */
723  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
724  * target variables, or NULL */
725  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
726  * target constraints, or NULL */
727  const char* name /**< problem name of target */
728  );
729 
730 /** enables constraint compression.
731  *
732  * If constraint compression is enabled, fixed variables will be treated as constants
733  * by all constraints that are copied after calling this method.
734  *
735  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
736  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
737  *
738  * @pre This method can be called if scip is in one of the following stages:
739  * - \ref SCIP_STAGE_PROBLEM
740  *
741  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
742  */
743 extern
745  SCIP* scip /**< source SCIP data structure */
746  );
747 
748 /** is constraint compression enabled?
749  *
750  * If constraint compression is enabled, fixed variables can be treated as constants
751  * by all constraints that are copied after calling this method.
752  *
753  * @return TRUE if problem constraint compression is enabled, otherwise FALSE
754  *
755  * @pre This method can be called if scip is in one of the following stages:
756  * - \ref SCIP_STAGE_PROBLEM
757  * - \ref SCIP_STAGE_TRANSFORMING
758  * - \ref SCIP_STAGE_TRANSFORMED
759  * - \ref SCIP_STAGE_INITPRESOLVE
760  * - \ref SCIP_STAGE_PRESOLVING
761  * - \ref SCIP_STAGE_EXITPRESOLVE
762  * - \ref SCIP_STAGE_PRESOLVED
763  * - \ref SCIP_STAGE_INITSOLVE
764  * - \ref SCIP_STAGE_SOLVING
765  * - \ref SCIP_STAGE_SOLVED
766  * - \ref SCIP_STAGE_EXITSOLVE
767  * - \ref SCIP_STAGE_FREETRANS
768  *
769  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
770  */
771 extern
773  SCIP* scip /**< source SCIP data structure */
774  );
775 
776 /** returns copy of the source variable; if there already is a copy of the source variable in the variable hash map,
777  * it is just returned as target variable; elsewise a new variable will be created and added to the target SCIP; this
778  * created variable is added to the variable hash map and returned as target variable
779  *
780  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
781  * @note Do not change the source SCIP environment during the copying process
782  * @note if a new variable was created, this variable will be added to the target-SCIP, but it is not captured
783  *
784  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
785  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
786  *
787  * @pre This method can be called if sourcescip is in one of the following stages:
788  * - \ref SCIP_STAGE_PROBLEM
789  * - \ref SCIP_STAGE_TRANSFORMED
790  * - \ref SCIP_STAGE_INITPRESOLVE
791  * - \ref SCIP_STAGE_PRESOLVING
792  * - \ref SCIP_STAGE_EXITPRESOLVE
793  * - \ref SCIP_STAGE_PRESOLVED
794  * - \ref SCIP_STAGE_INITSOLVE
795  * - \ref SCIP_STAGE_SOLVING
796  * - \ref SCIP_STAGE_SOLVED
797  *
798  * @pre This method can be called if targetscip is in one of the following stages:
799  * - \ref SCIP_STAGE_PROBLEM
800  * - \ref SCIP_STAGE_TRANSFORMED
801  * - \ref SCIP_STAGE_INITPRESOLVE
802  * - \ref SCIP_STAGE_PRESOLVING
803  * - \ref SCIP_STAGE_EXITPRESOLVE
804  * - \ref SCIP_STAGE_SOLVING
805  *
806  * @note targetscip stage does not get changed
807  *
808  * @note sourcescip stage does not get changed
809  *
810  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
811  */
812 extern
814  SCIP* sourcescip, /**< source SCIP data structure */
815  SCIP* targetscip, /**< target SCIP data structure */
816  SCIP_VAR* sourcevar, /**< source variable */
817  SCIP_VAR** targetvar, /**< pointer to store the target variable */
818  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
819  * target variables, or NULL */
820  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
821  * target constraints, or NULL */
822  SCIP_Bool global, /**< should global or local bounds be used? */
823  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
824  );
825 
826 /** copies all active variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
827  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
828  * variables do not get copied
829  *
830  * @note the variables are added to the target-SCIP but not captured
831  *
832  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
833  * @note Do not change the source SCIP environment during the copying process
834  *
835  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
836  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
837  *
838  * @pre This method can be called if sourcescip is in one of the following stages:
839  * - \ref SCIP_STAGE_PROBLEM
840  * - \ref SCIP_STAGE_TRANSFORMED
841  * - \ref SCIP_STAGE_INITPRESOLVE
842  * - \ref SCIP_STAGE_PRESOLVING
843  * - \ref SCIP_STAGE_EXITPRESOLVE
844  * - \ref SCIP_STAGE_PRESOLVED
845  * - \ref SCIP_STAGE_INITSOLVE
846  * - \ref SCIP_STAGE_SOLVING
847  * - \ref SCIP_STAGE_SOLVED
848  *
849  * @pre This method can be called if targetscip is in one of the following stages:
850  * - \ref SCIP_STAGE_PROBLEM
851  *
852  * @note sourcescip stage does not get changed
853  *
854  * @note targetscip stage does not get changed
855  *
856  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
857  */
858 extern
860  SCIP* sourcescip, /**< source SCIP data structure */
861  SCIP* targetscip, /**< target SCIP data structure */
862  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
863  * target variables, or NULL */
864  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
865  * target constraints, or NULL */
866  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
867  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
868  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
869  SCIP_Bool global /**< should global or local bounds be used? */
870  );
871 
872 /** copies all original variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
873  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
874  * variables do not get copied
875  *
876  * @note the variables are added to the target-SCIP but not captured
877  *
878  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
879  * @note Do not change the source SCIP environment during the copying process
880  *
881  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
882  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
883  *
884  * @pre This method can be called if sourcescip is in one of the following stages:
885  * - \ref SCIP_STAGE_PROBLEM
886  * - \ref SCIP_STAGE_TRANSFORMED
887  * - \ref SCIP_STAGE_INITPRESOLVE
888  * - \ref SCIP_STAGE_PRESOLVING
889  * - \ref SCIP_STAGE_EXITPRESOLVE
890  * - \ref SCIP_STAGE_PRESOLVED
891  * - \ref SCIP_STAGE_INITSOLVE
892  * - \ref SCIP_STAGE_SOLVING
893  * - \ref SCIP_STAGE_SOLVED
894  *
895  * @pre This method can be called if targetscip is in one of the following stages:
896  * - \ref SCIP_STAGE_PROBLEM
897  *
898  * @note sourcescip stage does not get changed
899  *
900  * @note targetscip stage does not get changed
901  *
902  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
903  */
904 extern
906  SCIP* sourcescip, /**< source SCIP data structure */
907  SCIP* targetscip, /**< target SCIP data structure */
908  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
909  * target variables, or NULL */
910  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
911  * target constraints, or NULL */
912  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
913  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
914  int nfixedvars /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
915  );
916 
917 /** merges the histories of variables from a source SCIP into a target SCIP. The two data structures should point to
918  * different SCIP instances.
919  *
920  * @note the notion of source and target is inverted here; \p sourcescip usually denotes a copied SCIP instance, whereas
921  * \p targetscip denotes the original instance
922  */
923 
924 extern
926  SCIP* sourcescip, /**< source SCIP data structure */
927  SCIP* targetscip, /**< target SCIP data structure */
928  SCIP_VAR** sourcevars, /**< source variables for history merge */
929  SCIP_VAR** targetvars, /**< target variables for history merge */
930  int nvars /**< number of variables in both variable arrays */
931  );
932 
933 /** returns copy of the source constraint; if there already is a copy of the source constraint in the constraint hash
934  * map, it is just returned as target constraint; elsewise a new constraint will be created; this created constraint is
935  * added to the constraint hash map and returned as target constraint; the variable map is used to map the variables of
936  * the source SCIP to the variables of the target SCIP
937  *
938  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
939  * be declared feasible even if it violates this particular constraint. This constellation should only be
940  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
941  * to the variable's local bounds.
942  *
943  * @note The constraint is not added to the target SCIP. You can check whether a constraint is added by calling
944  * SCIPconsIsAdded(). (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add
945  * explicitly and what is already added.)
946  *
947  * @note The constraint is always captured, either during the creation of the copy or after finding the copy of the
948  * constraint in the constraint hash map
949  *
950  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
951  * @note Do not change the source SCIP environment during the copying process
952  *
953  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
954  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
955  *
956  * @pre This method can be called if sourcescip is in one of the following stages:
957  * - \ref SCIP_STAGE_PROBLEM
958  * - \ref SCIP_STAGE_TRANSFORMED
959  * - \ref SCIP_STAGE_INITPRESOLVE
960  * - \ref SCIP_STAGE_PRESOLVING
961  * - \ref SCIP_STAGE_EXITPRESOLVE
962  * - \ref SCIP_STAGE_PRESOLVED
963  * - \ref SCIP_STAGE_INITSOLVE
964  * - \ref SCIP_STAGE_SOLVING
965  * - \ref SCIP_STAGE_SOLVED
966  *
967  * @pre This method can be called if targetscip is in one of the following stages:
968  * - \ref SCIP_STAGE_PROBLEM
969  * - \ref SCIP_STAGE_TRANSFORMING
970  * - \ref SCIP_STAGE_INITPRESOLVE
971  * - \ref SCIP_STAGE_PRESOLVING
972  * - \ref SCIP_STAGE_EXITPRESOLVE
973  * - \ref SCIP_STAGE_PRESOLVED
974  * - \ref SCIP_STAGE_SOLVING
975  * - \ref SCIP_STAGE_EXITSOLVE
976  *
977  * @note sourcescip stage does not get changed
978  *
979  * @note targetscip stage does not get changed
980  *
981  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
982  */
983 extern
985  SCIP* sourcescip, /**< source SCIP data structure */
986  SCIP* targetscip, /**< target SCIP data structure */
987  SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
988  SCIP_CONS** targetcons, /**< pointer to store the created target constraint */
989  SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
990  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
991  * variables of the target SCIP, or NULL */
992  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
993  * target constraints, or NULL */
994  const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
995  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
996  SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
997  SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
998  SCIP_Bool check, /**< should the constraint be checked for feasibility? */
999  SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
1000  SCIP_Bool local, /**< is constraint only valid locally? */
1001  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
1002  SCIP_Bool dynamic, /**< is constraint subject to aging? */
1003  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
1004  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
1005  * if it may be moved to a more global node? */
1006  SCIP_Bool global, /**< create a global or a local copy? */
1007  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
1008  );
1009 
1010 /** copies constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
1011  * variables between the source and the target SCIP a hash map can be given; if the variable hash
1012  * map is NULL or necessary variable mapping is missing, the required variables are created in the
1013  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
1014  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
1015  * between the constraints of the source and target-SCIP is stored
1016  *
1017  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
1018  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
1019  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
1020  *
1021  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1022  * @note Do not change the source SCIP environment during the copying process
1023  *
1024  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1025  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1026  *
1027  * @pre This method can be called if sourcescip is in one of the following stages:
1028  * - \ref SCIP_STAGE_PROBLEM
1029  * - \ref SCIP_STAGE_TRANSFORMED
1030  * - \ref SCIP_STAGE_INITPRESOLVE
1031  * - \ref SCIP_STAGE_PRESOLVING
1032  * - \ref SCIP_STAGE_EXITPRESOLVE
1033  * - \ref SCIP_STAGE_PRESOLVED
1034  * - \ref SCIP_STAGE_INITSOLVE
1035  * - \ref SCIP_STAGE_SOLVING
1036  * - \ref SCIP_STAGE_SOLVED
1037  *
1038  * @pre This method can be called if targetscip is in one of the following stages:
1039  * - \ref SCIP_STAGE_PROBLEM
1040  *
1041  * @note sourcescip stage does not get changed
1042  *
1043  * @note targetscip stage does not get changed
1044  *
1045  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1046  */
1047 extern
1049  SCIP* sourcescip, /**< source SCIP data structure */
1050  SCIP* targetscip, /**< target SCIP data structure */
1051  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
1052  * variables of the target SCIP, or NULL */
1053  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1054  * target constraints, or NULL */
1055  SCIP_Bool global, /**< create a global or a local copy? */
1056  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
1057  * If TRUE, the modifiable flag of constraints will be copied. */
1058  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
1059  );
1060 
1061 /** copies all original constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
1062  * variables between the source and the target SCIP a hash map can be given; if the variable hash
1063  * map is NULL or necessary variable mapping is missing, the required variables are created in the
1064  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
1065  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
1066  * between the constraints of the source and target-SCIP is stored
1067  *
1068  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
1069  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
1070  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
1071  *
1072  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1073  * @note Do not change the source SCIP environment during the copying process
1074  *
1075  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1076  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1077  *
1078  * @pre This method can be called if sourcescip is in one of the following stages:
1079  * - \ref SCIP_STAGE_PROBLEM
1080  * - \ref SCIP_STAGE_TRANSFORMED
1081  * - \ref SCIP_STAGE_INITPRESOLVE
1082  * - \ref SCIP_STAGE_PRESOLVING
1083  * - \ref SCIP_STAGE_EXITPRESOLVE
1084  * - \ref SCIP_STAGE_PRESOLVED
1085  * - \ref SCIP_STAGE_INITSOLVE
1086  * - \ref SCIP_STAGE_SOLVING
1087  * - \ref SCIP_STAGE_SOLVED
1088  *
1089  * @pre This method can be called if targetscip is in one of the following stages:
1090  * - \ref SCIP_STAGE_PROBLEM
1091  *
1092  * @note sourcescip stage does not get changed
1093  *
1094  * @note targetscip stage does not get changed
1095  *
1096  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1097  */
1098 extern
1100  SCIP* sourcescip, /**< source SCIP data structure */
1101  SCIP* targetscip, /**< target SCIP data structure */
1102  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
1103  * variables of the target SCIP, or NULL */
1104  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1105  * target constraints, or NULL */
1106  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
1107  * If TRUE, the modifiable flag of constraints will be copied. */
1108  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
1109  );
1110 
1111 /** convert all active cuts from cutpool to linear constraints
1112  *
1113  * @note Do not change the source SCIP environment during the copying process
1114  *
1115  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1116  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1117  *
1118  * @pre This method can be called if SCIP is in one of the following stages:
1119  * - \ref SCIP_STAGE_PROBLEM
1120  * - \ref SCIP_STAGE_INITPRESOLVE
1121  * - \ref SCIP_STAGE_PRESOLVING
1122  * - \ref SCIP_STAGE_EXITPRESOLVE
1123  * - \ref SCIP_STAGE_PRESOLVED
1124  * - \ref SCIP_STAGE_SOLVING
1125  * - \ref SCIP_STAGE_EXITSOLVE
1126  *
1127  * @note SCIP stage does not get changed
1128  *
1129  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1130  */
1131 extern
1133  SCIP* scip, /**< SCIP data structure */
1134  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1135  * target variables, or NULL */
1136  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1137  * target constraints, or NULL */
1138  SCIP_Bool global, /**< create a global or a local copy? */
1139  int* ncutsadded /**< pointer to store number of added cuts, or NULL */
1140  );
1141 
1142 /** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip
1143  *
1144  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1145  * @note Do not change the source SCIP environment during the copying process
1146  *
1147  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1148  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1149  *
1150  * @pre This method can be called if sourcescip is in one of the following stages:
1151  * - \ref SCIP_STAGE_PROBLEM
1152  * - \ref SCIP_STAGE_TRANSFORMED
1153  * - \ref SCIP_STAGE_INITPRESOLVE
1154  * - \ref SCIP_STAGE_PRESOLVING
1155  * - \ref SCIP_STAGE_EXITPRESOLVE
1156  * - \ref SCIP_STAGE_PRESOLVED
1157  * - \ref SCIP_STAGE_SOLVING
1158  * - \ref SCIP_STAGE_SOLVED
1159  * - \ref SCIP_STAGE_EXITSOLVE
1160  *
1161  * @pre This method can be called if targetscip is in one of the following stages:
1162  * - \ref SCIP_STAGE_PROBLEM
1163  * - \ref SCIP_STAGE_INITPRESOLVE
1164  * - \ref SCIP_STAGE_PRESOLVING
1165  * - \ref SCIP_STAGE_EXITPRESOLVE
1166  * - \ref SCIP_STAGE_PRESOLVED
1167  * - \ref SCIP_STAGE_SOLVING
1168  * - \ref SCIP_STAGE_EXITSOLVE
1169  *
1170  * @note sourcescip stage does not get changed
1171  *
1172  * @note targetscip stage does not get changed
1173  *
1174  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1175  */
1176 extern
1178  SCIP* sourcescip, /**< source SCIP data structure */
1179  SCIP* targetscip, /**< target SCIP data structure */
1180  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1181  * target variables, or NULL */
1182  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1183  * target constraints, or NULL */
1184  SCIP_Bool global, /**< create a global or a local copy? */
1185  int* ncutsadded /**< pointer to store number of copied cuts, or NULL */
1186  );
1187 
1188 /** copies all active conflicts from the conflict pool of sourcescip and adds them as linear constraints to targetscip
1189  *
1190  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1191  * @note Do not change the source SCIP environment during the copying process
1192  *
1193  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1194  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1195  *
1196  * @pre This method can be called if sourcescip is in one of the following stages:
1197  * - \ref SCIP_STAGE_PROBLEM
1198  * - \ref SCIP_STAGE_TRANSFORMED
1199  * - \ref SCIP_STAGE_INITPRESOLVE
1200  * - \ref SCIP_STAGE_PRESOLVING
1201  * - \ref SCIP_STAGE_EXITPRESOLVE
1202  * - \ref SCIP_STAGE_PRESOLVED
1203  * - \ref SCIP_STAGE_SOLVING
1204  * - \ref SCIP_STAGE_SOLVED
1205  * - \ref SCIP_STAGE_EXITSOLVE
1206  *
1207  * @pre This method can be called if targetscip is in one of the following stages:
1208  * - \ref SCIP_STAGE_PROBLEM
1209  * - \ref SCIP_STAGE_INITPRESOLVE
1210  * - \ref SCIP_STAGE_PRESOLVING
1211  * - \ref SCIP_STAGE_EXITPRESOLVE
1212  * - \ref SCIP_STAGE_PRESOLVED
1213  * - \ref SCIP_STAGE_SOLVING
1214  * - \ref SCIP_STAGE_EXITSOLVE
1215  *
1216  * @note sourcescip stage does not change
1217  *
1218  * @note targetscip stage does not change
1219  *
1220  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1221  */
1222 extern
1224  SCIP* sourcescip, /**< source SCIP data structure */
1225  SCIP* targetscip, /**< target SCIP data structure */
1226  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1227  * target variables, or NULL */
1228  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1229  * target constraints, or NULL */
1230  SCIP_Bool global, /**< create a global or a local copy? */
1231  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
1232  * If TRUE, the modifiable flag of constraints will be copied. */
1233  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
1234  );
1235 
1236 /** copies implications and cliques of sourcescip to targetscip
1237  *
1238  * This function should be called for a targetscip in transformed stage. It can save time in presolving of the
1239  * targetscip, since implications and cliques are copied.
1240  *
1241  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1242  * @note Do not change the source SCIP environment during the copying process
1243  *
1244  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1245  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1246  *
1247  * @pre This method can be called if sourcescip is in one of the following stages:
1248  * - \ref SCIP_STAGE_TRANSFORMED
1249  * - \ref SCIP_STAGE_INITPRESOLVE
1250  * - \ref SCIP_STAGE_PRESOLVING
1251  * - \ref SCIP_STAGE_EXITPRESOLVE
1252  * - \ref SCIP_STAGE_PRESOLVED
1253  * - \ref SCIP_STAGE_SOLVING
1254  * - \ref SCIP_STAGE_SOLVED
1255  * - \ref SCIP_STAGE_EXITSOLVE
1256  *
1257  * @pre This method can be called if targetscip is in one of the following stages:
1258  * - \ref SCIP_STAGE_TRANSFORMED
1259  * - \ref SCIP_STAGE_INITPRESOLVE
1260  * - \ref SCIP_STAGE_PRESOLVING
1261  * - \ref SCIP_STAGE_EXITPRESOLVE
1262  * - \ref SCIP_STAGE_PRESOLVED
1263  * - \ref SCIP_STAGE_INITSOLVE
1264  * - \ref SCIP_STAGE_SOLVING
1265  *
1266  * @note sourcescip stage does not get changed
1267  *
1268  * @note targetscip stage does not get changed
1269  *
1270  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1271  */
1272 extern
1274  SCIP* sourcescip, /**< source SCIP data structure */
1275  SCIP* targetscip, /**< target SCIP data structure */
1276  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1277  * target variables, or NULL */
1278  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1279  * target constraints, or NULL */
1280  SCIP_Bool global, /**< create a global or a local copy? */
1281  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1282  int* nbdchgs, /**< pointer to store the number of performed bound changes, or NULL */
1283  int* ncopied /**< pointer to store number of copied implications and cliques, or NULL */
1284  );
1285 
1286 /** copies parameter settings from sourcescip to targetscip
1287  *
1288  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1289  * @note Do not change the source SCIP environment during the copying process
1290  *
1291  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1292  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1293  *
1294  * @pre This method can be called if sourcescip is in one of the following stages:
1295  * - \ref SCIP_STAGE_PROBLEM
1296  * - \ref SCIP_STAGE_TRANSFORMED
1297  * - \ref SCIP_STAGE_INITPRESOLVE
1298  * - \ref SCIP_STAGE_PRESOLVING
1299  * - \ref SCIP_STAGE_EXITPRESOLVE
1300  * - \ref SCIP_STAGE_PRESOLVED
1301  * - \ref SCIP_STAGE_INITSOLVE
1302  * - \ref SCIP_STAGE_SOLVING
1303  * - \ref SCIP_STAGE_SOLVED
1304  *
1305  * @pre This method can be called if targetscip is in one of the following stages:
1306  * - \ref SCIP_STAGE_INIT
1307  * - \ref SCIP_STAGE_PROBLEM
1308  * - \ref SCIP_STAGE_FREE
1309  *
1310  * @note sourcescip stage does not get changed
1311  *
1312  * @note targetscip stage does not get changed
1313  *
1314  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1315  */
1316 extern
1318  SCIP* sourcescip, /**< source SCIP data structure */
1319  SCIP* targetscip /**< target SCIP data structure */
1320  );
1321 
1322 /** gets depth of current scip instance (increased by each copy call)
1323  *
1324  * @return Depth of subscip of SCIP is returned.
1325  *
1326  * @pre This method can be called if SCIP is in one of the following stages:
1327  * - \ref SCIP_STAGE_PROBLEM
1328  * - \ref SCIP_STAGE_TRANSFORMING
1329  * - \ref SCIP_STAGE_TRANSFORMED
1330  * - \ref SCIP_STAGE_INITPRESOLVE
1331  * - \ref SCIP_STAGE_PRESOLVING
1332  * - \ref SCIP_STAGE_EXITPRESOLVE
1333  * - \ref SCIP_STAGE_PRESOLVED
1334  * - \ref SCIP_STAGE_INITSOLVE
1335  * - \ref SCIP_STAGE_SOLVING
1336  * - \ref SCIP_STAGE_SOLVED
1337  * - \ref SCIP_STAGE_EXITSOLVE
1338  * - \ref SCIP_STAGE_FREETRANS
1339  *
1340  * @note SCIP stage does not get changed
1341  *
1342  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1343  */
1344 extern
1346  SCIP* scip /**< SCIP data structure */
1347  );
1348 
1349 /** copies source SCIP to target SCIP; the copying process is done in the following order:
1350  * 1) copy the plugins
1351  * 2) copy the settings
1352  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1353  * 4) copy all active variables
1354  * 5) copy all constraints
1355  *
1356  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1357  *
1358  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1359  * Also, 'passmessagehdlr' should be set to FALSE.
1360  * @note Do not change the source SCIP environment during the copying process
1361  *
1362  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1363  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1364  *
1365  * @pre This method can be called if sourcescip is in one of the following stages:
1366  * - \ref SCIP_STAGE_PROBLEM
1367  * - \ref SCIP_STAGE_TRANSFORMED
1368  * - \ref SCIP_STAGE_INITPRESOLVE
1369  * - \ref SCIP_STAGE_PRESOLVING
1370  * - \ref SCIP_STAGE_EXITPRESOLVE
1371  * - \ref SCIP_STAGE_PRESOLVED
1372  * - \ref SCIP_STAGE_INITSOLVE
1373  * - \ref SCIP_STAGE_SOLVING
1374  * - \ref SCIP_STAGE_SOLVED
1375  *
1376  * @pre This method can be called if targetscip is in one of the following stages:
1377  * - \ref SCIP_STAGE_INIT
1378  * - \ref SCIP_STAGE_FREE
1379  *
1380  * @note sourcescip stage does not get changed
1381  *
1382  * @note targetscip stage does not get changed
1383  *
1384  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1385  */
1386 extern
1388  SCIP* sourcescip, /**< source SCIP data structure */
1389  SCIP* targetscip, /**< target SCIP data structure */
1390  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1391  * target variables, or NULL */
1392  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1393  * target constraints, or NULL */
1394  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1395  SCIP_Bool global, /**< create a global or a local copy? */
1396  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1397  * plugins will be copied and activated, and the modifiable flag of
1398  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1399  * there are pricers present */
1400  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1401  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1402  );
1403 
1404 /** copies source SCIP to target SCIP but compresses constraints
1405  *
1406  * constraint compression is performed by removing fixed variables immediately
1407  * during constraint creation if the involved constraint handlers support
1408  * compression
1409  *
1410  * the copying process is done in the following order:
1411  * 1) copy the plugins
1412  * 2) copy the settings
1413  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1414  * 4) copy all active variables
1415  * a) fix all variable copies specified by \p fixedvars, \p fixedvals, and \p nfixedvars
1416  * b) enable constraint compression
1417  * 5) copy all constraints
1418  *
1419  * @note: in case that a combination of local bounds and explicit fixing values should be used,
1420  * the fixing value of a variable is prefered if local bounds and fixing value disagree.
1421  *
1422  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1423  *
1424  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1425  * Also, 'passmessagehdlr' should be set to FALSE.
1426  * @note Do not change the source SCIP environment during the copying process
1427  *
1428  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1429  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1430  *
1431  * @pre This method can be called if sourcescip is in one of the following stages:
1432  * - \ref SCIP_STAGE_PROBLEM
1433  * - \ref SCIP_STAGE_TRANSFORMED
1434  * - \ref SCIP_STAGE_INITPRESOLVE
1435  * - \ref SCIP_STAGE_PRESOLVING
1436  * - \ref SCIP_STAGE_EXITPRESOLVE
1437  * - \ref SCIP_STAGE_PRESOLVED
1438  * - \ref SCIP_STAGE_INITSOLVE
1439  * - \ref SCIP_STAGE_SOLVING
1440  * - \ref SCIP_STAGE_SOLVED
1441  *
1442  * @pre This method can be called if targetscip is in one of the following stages:
1443  * - \ref SCIP_STAGE_INIT
1444  * - \ref SCIP_STAGE_FREE
1445  *
1446  * @note sourcescip stage does not get changed
1447  *
1448  * @note targetscip stage does not get changed
1449  *
1450  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1451  */
1452 extern
1454  SCIP* sourcescip, /**< source SCIP data structure */
1455  SCIP* targetscip, /**< target SCIP data structure */
1456  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1457  * target variables, or NULL */
1458  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1459  * target constraints, or NULL */
1460  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1461  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
1462  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
1463  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
1464  SCIP_Bool global, /**< create a global or a local copy? */
1465  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1466  * plugins will be copied and activated, and the modifiable flag of
1467  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1468  * there are pricers present */
1469  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1470  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1471  );
1472 
1473 /** copies source SCIP original problem to target SCIP; the copying process is done in the following order:
1474  * 1) copy the plugins
1475  * 2) copy the settings
1476  * 3) create problem data in target-SCIP and copy the original problem data of the source-SCIP
1477  * 4) copy all original variables
1478  * 5) copy all original constraints
1479  *
1480  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1481  *
1482  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1483  * Also, 'passmessagehdlr' should be set to FALSE.
1484  * @note Do not change the source SCIP environment during the copying process
1485  *
1486  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1487  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1488  *
1489  * @pre This method can be called if sourcescip is in one of the following stages:
1490  * - \ref SCIP_STAGE_PROBLEM
1491  * - \ref SCIP_STAGE_TRANSFORMED
1492  * - \ref SCIP_STAGE_INITPRESOLVE
1493  * - \ref SCIP_STAGE_PRESOLVING
1494  * - \ref SCIP_STAGE_EXITPRESOLVE
1495  * - \ref SCIP_STAGE_PRESOLVED
1496  * - \ref SCIP_STAGE_INITSOLVE
1497  * - \ref SCIP_STAGE_SOLVING
1498  * - \ref SCIP_STAGE_SOLVED
1499  *
1500  * @pre This method can be called if targetscip is in one of the following stages:
1501  * - \ref SCIP_STAGE_INIT
1502  * - \ref SCIP_STAGE_FREE
1503  *
1504  * @note sourcescip stage does not get changed
1505  *
1506  * @note targetscip stage does not get changed
1507  *
1508  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1509  */
1510 extern
1512  SCIP* sourcescip, /**< source SCIP data structure */
1513  SCIP* targetscip, /**< target SCIP data structure */
1514  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1515  * target variables, or NULL */
1516  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1517  * target constraints, or NULL */
1518  const char* suffix, /**< suffix which will be added to the names of the target SCIP, might be empty */
1519  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1520  * plugins will be copied and activated, and the modifiable flag of
1521  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1522  * there are pricers present */
1523  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1524  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1525  );
1526 
1527 /** copies source SCIP original problem to target SCIP but compresses constraints
1528  *
1529  * constraint compression is performed by removing fixed variables immediately
1530  * during constraint creation if the involved constraint handlers support
1531  * compression
1532  *
1533  * the copying process is done in the following order:
1534  * 1) copy the plugins
1535  * 2) copy the settings
1536  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1537  * 4) copy all original variables
1538  * a) fix all variable copies specified by \p fixedvars, \p fixedvals, and \p nfixedvars
1539  * b) enable constraint compression
1540  * 5) copy all constraints
1541  *
1542  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1543  *
1544  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1545  * Also, 'passmessagehdlr' should be set to FALSE.
1546  * @note Do not change the source SCIP environment during the copying process
1547  *
1548  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1549  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1550  *
1551  * @pre This method can be called if sourcescip is in one of the following stages:
1552  * - \ref SCIP_STAGE_PROBLEM
1553  * - \ref SCIP_STAGE_TRANSFORMED
1554  * - \ref SCIP_STAGE_INITPRESOLVE
1555  * - \ref SCIP_STAGE_PRESOLVING
1556  * - \ref SCIP_STAGE_EXITPRESOLVE
1557  * - \ref SCIP_STAGE_PRESOLVED
1558  * - \ref SCIP_STAGE_INITSOLVE
1559  * - \ref SCIP_STAGE_SOLVING
1560  * - \ref SCIP_STAGE_SOLVED
1561  *
1562  * @pre This method can be called if targetscip is in one of the following stages:
1563  * - \ref SCIP_STAGE_INIT
1564  * - \ref SCIP_STAGE_FREE
1565  *
1566  * @note sourcescip stage does not get changed
1567  *
1568  * @note targetscip stage does not get changed
1569  *
1570  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1571  */
1572 extern
1574  SCIP* sourcescip, /**< source SCIP data structure */
1575  SCIP* targetscip, /**< target SCIP data structure */
1576  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1577  * target variables, or NULL */
1578  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1579  * target constraints, or NULL */
1580  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1581  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
1582  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
1583  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
1584  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1585  * plugins will be copied and activated, and the modifiable flag of
1586  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1587  * there are pricers present */
1588  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1589  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1590  );
1591 
1592 /** checks if there is enough time and memory left for copying the sourcescip into a sub-SCIP and solve the sub-SCIP
1593  *
1594  * This is the case if the time and memory limit that would be passed to the sub-SCIP are larger than 0.0
1595  *
1596  * @pre This method can be called if sourcescip is in one of the following stages:
1597  * - \ref SCIP_STAGE_PROBLEM
1598  * - \ref SCIP_STAGE_TRANSFORMED
1599  * - \ref SCIP_STAGE_INITPRESOLVE
1600  * - \ref SCIP_STAGE_PRESOLVING
1601  * - \ref SCIP_STAGE_EXITPRESOLVE
1602  * - \ref SCIP_STAGE_PRESOLVED
1603  * - \ref SCIP_STAGE_INITSOLVE
1604  * - \ref SCIP_STAGE_SOLVING
1605  * - \ref SCIP_STAGE_SOLVED
1606  *
1607  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1608  */
1609 extern
1611  SCIP* sourcescip, /**< source SCIP data structure */
1612  SCIP_Bool* success /**< pointer to store whether there is time and memory left to copy the
1613  * problem and run the sub-SCIP */
1614  );
1615 
1616 /** copies limits from source SCIP to target SCIP
1617  *
1618  * @note time and memory limit are reduced by the amount already spent in the source SCIP before installing the limit
1619  * in the target SCIP
1620  * @note all other limits are disabled and need to be enabled afterwards, if needed
1621  *
1622  * @pre This method can be called if sourcescip is in one of the following stages:
1623  * - \ref SCIP_STAGE_PROBLEM
1624  * - \ref SCIP_STAGE_TRANSFORMED
1625  * - \ref SCIP_STAGE_INITPRESOLVE
1626  * - \ref SCIP_STAGE_PRESOLVING
1627  * - \ref SCIP_STAGE_EXITPRESOLVE
1628  * - \ref SCIP_STAGE_PRESOLVED
1629  * - \ref SCIP_STAGE_INITSOLVE
1630  * - \ref SCIP_STAGE_SOLVING
1631  * - \ref SCIP_STAGE_SOLVED
1632  *
1633  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1634  */
1635 extern
1637  SCIP* sourcescip, /**< source SCIP data structure */
1638  SCIP* targetscip /**< target SCIP data structure */
1639  );
1640 
1641 
1642 /**@} */
1643 
1644 /*
1645  * parameter settings
1646  */
1647 
1648 /**@addtogroup ParameterMethods
1649  *
1650  * @{
1651  */
1652 
1653 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
1654  *
1655  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1656  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1657  */
1658 extern
1660  SCIP* scip, /**< SCIP data structure */
1661  const char* name, /**< name of the parameter */
1662  const char* desc, /**< description of the parameter */
1663  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
1664  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1665  SCIP_Bool defaultvalue, /**< default value of the parameter */
1666  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1667  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1668  );
1669 
1670 /** creates a int parameter, sets it to its default value, and adds it to the parameter set
1671  *
1672  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1673  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1674  */
1675 extern
1677  SCIP* scip, /**< SCIP data structure */
1678  const char* name, /**< name of the parameter */
1679  const char* desc, /**< description of the parameter */
1680  int* valueptr, /**< pointer to store the current parameter value, or NULL */
1681  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1682  int defaultvalue, /**< default value of the parameter */
1683  int minvalue, /**< minimum value for parameter */
1684  int maxvalue, /**< maximum value for parameter */
1685  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1686  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1687  );
1688 
1689 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
1690  *
1691  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1692  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1693  */
1694 extern
1696  SCIP* scip, /**< SCIP data structure */
1697  const char* name, /**< name of the parameter */
1698  const char* desc, /**< description of the parameter */
1699  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
1700  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1701  SCIP_Longint defaultvalue, /**< default value of the parameter */
1702  SCIP_Longint minvalue, /**< minimum value for parameter */
1703  SCIP_Longint maxvalue, /**< maximum value for parameter */
1704  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1705  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1706  );
1707 
1708 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
1709  *
1710  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1711  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1712  */
1713 extern
1715  SCIP* scip, /**< SCIP data structure */
1716  const char* name, /**< name of the parameter */
1717  const char* desc, /**< description of the parameter */
1718  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
1719  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1720  SCIP_Real defaultvalue, /**< default value of the parameter */
1721  SCIP_Real minvalue, /**< minimum value for parameter */
1722  SCIP_Real maxvalue, /**< maximum value for parameter */
1723  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1724  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1725  );
1726 
1727 /** creates a char parameter, sets it to its default value, and adds it to the parameter set
1728  *
1729  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1730  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1731  */
1732 extern
1734  SCIP* scip, /**< SCIP data structure */
1735  const char* name, /**< name of the parameter */
1736  const char* desc, /**< description of the parameter */
1737  char* valueptr, /**< pointer to store the current parameter value, or NULL */
1738  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1739  char defaultvalue, /**< default value of the parameter */
1740  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
1741  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1742  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1743  );
1744 
1745 /** creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
1746  *
1747  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1748  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1749  */
1750 extern
1752  SCIP* scip, /**< SCIP data structure */
1753  const char* name, /**< name of the parameter */
1754  const char* desc, /**< description of the parameter */
1755  char** valueptr, /**< pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL */
1756  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1757  const char* defaultvalue, /**< default value of the parameter */
1758  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1759  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1760  );
1761 
1762 /** gets the fixing status of an existing parameter
1763  *
1764  * @return TRUE if the parameter is fixed to a value, otherwise FALSE.
1765  */
1766 extern
1768  SCIP* scip, /**< SCIP data structure */
1769  const char* name /**< name of the parameter */
1770  );
1771 
1772 /** returns the pointer to the SCIP parameter with the given name
1773  *
1774  * @return pointer to the parameter with the given name
1775  */
1776 extern
1778  SCIP* scip, /**< SCIP data structure */
1779  const char* name /**< name of the parameter */
1780  );
1781 
1782 /** gets the value of an existing SCIP_Bool parameter
1783  *
1784  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1785  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1786  */
1787 extern
1789  SCIP* scip, /**< SCIP data structure */
1790  const char* name, /**< name of the parameter */
1791  SCIP_Bool* value /**< pointer to store the parameter */
1792  );
1793 
1794 /** gets the value of an existing int parameter
1795  *
1796  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1797  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1798  */
1799 extern
1801  SCIP* scip, /**< SCIP data structure */
1802  const char* name, /**< name of the parameter */
1803  int* value /**< pointer to store the parameter */
1804  );
1805 
1806 /** gets the value of an existing SCIP_Longint parameter
1807  *
1808  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1809  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1810  */
1811 extern
1813  SCIP* scip, /**< SCIP data structure */
1814  const char* name, /**< name of the parameter */
1815  SCIP_Longint* value /**< pointer to store the parameter */
1816  );
1817 
1818 /** gets the value of an existing SCIP_Real parameter
1819  *
1820  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1821  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1822  */
1823 extern
1825  SCIP* scip, /**< SCIP data structure */
1826  const char* name, /**< name of the parameter */
1827  SCIP_Real* value /**< pointer to store the parameter */
1828  );
1829 
1830 /** gets the value of an existing char parameter
1831  *
1832  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1833  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1834  */
1835 extern
1837  SCIP* scip, /**< SCIP data structure */
1838  const char* name, /**< name of the parameter */
1839  char* value /**< pointer to store the parameter */
1840  );
1841 
1842 /** gets the value of an existing string(char*) parameter
1843  *
1844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1846  */
1847 extern
1849  SCIP* scip, /**< SCIP data structure */
1850  const char* name, /**< name of the parameter */
1851  char** value /**< pointer to store the parameter */
1852  );
1853 
1854 /** fixes the value of an existing parameter
1855  *
1856  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1857  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1858  *
1859  * @note: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because
1860  * they have to be changed for sub-SCIPs.
1861  */
1862 extern
1864  SCIP* scip, /**< SCIP data structure */
1865  const char* name /**< name of the parameter */
1866  );
1867 
1868 /** unfixes the value of an existing parameter
1869  *
1870  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1871  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1872  */
1873 extern
1875  SCIP* scip, /**< SCIP data structure */
1876  const char* name /**< name of the parameter */
1877  );
1878 
1879 /** changes the value of an existing parameter
1880  *
1881  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1882  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1883  */
1884 extern
1886  SCIP* scip, /**< SCIP data structure */
1887  const char* name, /**< name of the parameter */
1888  void* value /**< new value of the parameter */
1889  );
1890 
1891 /** changes the value of an existing SCIP_Bool parameter
1892  *
1893  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1894  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1895  */
1896 extern
1898  SCIP* scip, /**< SCIP data structure */
1899  SCIP_PARAM* param, /**< parameter */
1900  SCIP_Bool value /**< new value of the parameter */
1901  );
1902 
1903 /** changes the value of an existing SCIP_Bool parameter
1904  *
1905  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1906  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1907  */
1908 extern
1910  SCIP* scip, /**< SCIP data structure */
1911  const char* name, /**< name of the parameter */
1912  SCIP_Bool value /**< new value of the parameter */
1913  );
1914 
1915 /** checks whether the value of an existing SCIP_Bool parameter is valid */
1916 extern
1918  SCIP* scip, /**< SCIP data structure */
1919  SCIP_PARAM* param, /**< parameter */
1920  SCIP_Bool value /**< value to check */
1921  );
1922 
1923 /** changes the value of an existing int parameter
1924  *
1925  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1926  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1927  */
1928 extern
1930  SCIP* scip, /**< SCIP data structure */
1931  SCIP_PARAM* param, /**< parameter */
1932  int value /**< new value of the parameter */
1933  );
1934 
1935 /** changes the value of an existing int parameter
1936  *
1937  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1938  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1939  */
1940 extern
1942  SCIP* scip, /**< SCIP data structure */
1943  const char* name, /**< name of the parameter */
1944  int value /**< new value of the parameter */
1945  );
1946 
1947 /** checks whether the value of an existing int parameter is valid */
1948 extern
1950  SCIP* scip, /**< SCIP data structure */
1951  SCIP_PARAM* param, /**< parameter */
1952  int value /**< value to check */
1953  );
1954 
1955 /** changes the value of an existing SCIP_Longint parameter
1956  *
1957  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1958  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1959  */
1960 extern
1962  SCIP* scip, /**< SCIP data structure */
1963  SCIP_PARAM* param, /**< parameter */
1964  SCIP_Longint value /**< new value of the parameter */
1965  );
1966 
1967 /** changes the value of an existing SCIP_Longint parameter
1968  *
1969  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1970  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1971  */
1972 extern
1974  SCIP* scip, /**< SCIP data structure */
1975  const char* name, /**< name of the parameter */
1976  SCIP_Longint value /**< new value of the parameter */
1977  );
1978 
1979 /** checks whether parameter value of an existing SCIP_Longint paramter is valid */
1980 extern
1982  SCIP* scip, /**< SCIP data structure */
1983  SCIP_PARAM* param, /**< parameter */
1984  SCIP_Longint value /**< value to check */
1985  );
1986 
1987 /** changes the value of an existing SCIP_Real parameter
1988  *
1989  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1990  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1991  */
1992 extern
1994  SCIP* scip, /**< SCIP data structure */
1995  SCIP_PARAM* param, /**< parameter */
1996  SCIP_Real value /**< new value of the parameter */
1997  );
1998 
1999 /** changes the value of an existing SCIP_Real parameter
2000  *
2001  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2002  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2003  */
2004 extern
2006  SCIP* scip, /**< SCIP data structure */
2007  const char* name, /**< name of the parameter */
2008  SCIP_Real value /**< new value of the parameter */
2009  );
2010 
2011 /** checks whether parameter value of an existing SCIP_Real paramter is valid */
2012 extern
2014  SCIP* scip, /**< SCIP data structure */
2015  SCIP_PARAM* param, /**< parameter */
2016  SCIP_Real value /**< value to check */
2017  );
2018 
2019 /** changes the value of an existing char parameter
2020  *
2021  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2022  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2023  */
2024 extern
2026  SCIP* scip, /**< SCIP data structure */
2027  SCIP_PARAM* param, /**< parameter */
2028  char value /**< new value of the parameter */
2029  );
2030 
2031 /** changes the value of an existing char parameter
2032  *
2033  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2034  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2035  */
2036 extern
2038  SCIP* scip, /**< SCIP data structure */
2039  const char* name, /**< name of the parameter */
2040  char value /**< new value of the parameter */
2041  );
2042 
2043 /** checks whether parameter value for a given SCIP_Real parameter is valid */
2044 extern
2046  SCIP* scip, /**< SCIP data structure */
2047  SCIP_PARAM* param, /**< parameter */
2048  const char value /**< value to check */
2049  );
2050 
2051 /** changes the value of an existing string(char*) parameter
2052  *
2053  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2054  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2055  */
2056 extern
2058  SCIP* scip, /**< SCIP data structure */
2059  SCIP_PARAM* param, /**< parameter */
2060  const char* value /**< new value of the parameter */
2061  );
2062 
2063 /** changes the value of an existing string(char*) parameter
2064  *
2065  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2066  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2067  */
2068 extern
2070  SCIP* scip, /**< SCIP data structure */
2071  const char* name, /**< name of the parameter */
2072  const char* value /**< new value of the parameter */
2073  );
2074 
2075 /** checks whether parameter value for a given string parameter is valid */
2076 extern
2078  SCIP* scip, /**< SCIP data structure */
2079  SCIP_PARAM* param, /**< parameter */
2080  const char* value /**< value to check */
2081  );
2082 
2083 /** reads parameters from a file
2084  *
2085  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2086  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2087  */
2088 extern
2090  SCIP* scip, /**< SCIP data structure */
2091  const char* filename /**< file name */
2092  );
2093 
2094 /** writes a single parameter to a file
2095  *
2096  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2097  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2098  */
2099 extern
2101  SCIP* scip, /**< SCIP data structure */
2102  SCIP_PARAM* param, /**< parameter */
2103  const char* filename, /**< file name, or NULL for stdout */
2104  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
2105  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
2106  * default value?
2107  */
2108  );
2109 
2110 /** writes all parameters in the parameter set to a file
2111  *
2112  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2113  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2114  */
2115 extern
2117  SCIP* scip, /**< SCIP data structure */
2118  const char* filename, /**< file name, or NULL for stdout */
2119  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
2120  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
2121  * default value?
2122  */
2123  );
2124 
2125 /** resets a single parameter to its default value
2126  *
2127  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2128  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2129  */
2130 extern
2132  SCIP* scip, /**< SCIP data structure */
2133  const char* name /**< name of the parameter */
2134  );
2135 
2136 /** resets all parameters to their default values
2137  *
2138  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2139  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2140  */
2141 extern
2143  SCIP* scip /**< SCIP data structure */
2144  );
2145 
2146 /** sets parameters to
2147  *
2148  * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
2149  * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
2150  * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
2151  * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
2152  * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
2153  * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
2154  * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
2155  * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
2156  * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
2157  * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
2158  *
2159  *
2160  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2161  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2162  */
2163 extern
2165  SCIP* scip, /**< SCIP data structure */
2166  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
2167  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2168  );
2169 
2170 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
2171  * auxiliary SCIP instances to avoid recursion
2172  *
2173  * @note only deactivates plugins which could cause recursion, some plugins which use sub-SCIPs stay activated
2174  *
2175  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2176  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2177  */
2178 extern
2180  SCIP* scip, /**< (auxiliary) SCIP data structure */
2181  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2182  );
2183 
2184 /** sets heuristic parameters values to
2185  *
2186  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
2187  * - SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
2188  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
2189  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
2190  *
2191  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2192  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2193  */
2194 extern
2196  SCIP* scip, /**< SCIP data structure */
2197  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2198  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2199  );
2200 
2201 /** sets presolving parameters to
2202  *
2203  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
2204  * - SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
2205  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
2206  * - SCIP_PARAMSETTING_OFF which turn off all presolving
2207  *
2208  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2209  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2210  */
2211 extern
2213  SCIP* scip, /**< SCIP data structure */
2214  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2215  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2216  );
2217 
2218 /** sets separating parameters to
2219  *
2220  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
2221  * - SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
2222  * - SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
2223  * - SCIP_PARAMSETTING_OFF which turn off all separating
2224  *
2225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2227  */
2228 extern
2230  SCIP* scip, /**< SCIP data structure */
2231  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2232  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2233  );
2234 
2235 /** returns the array of all available SCIP parameters
2236  *
2237  * @return SCIP_PARAM* array, containing all SCIP parameters.
2238  */
2239 extern
2241  SCIP* scip /**< SCIP data structure */
2242  );
2243 
2244 /** returns the total number of all available SCIP parameters
2245  *
2246  * @return number of all SCIP parameters.
2247  */
2248 extern
2249 int SCIPgetNParams(
2250  SCIP* scip /**< SCIP data structure */
2251  );
2252 
2253 /**@} */
2254 
2255 
2256 /*
2257  * SCIP user functionality methods: managing plugins
2258  */
2259 
2260 /**@addtogroup PublicReaderMethods
2261  *
2262  * @{
2263  */
2264 
2265 /** creates a reader and includes it in SCIP
2266  *
2267  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2268  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2269  *
2270  * @pre This method can be called if SCIP is in one of the following stages:
2271  * - \ref SCIP_STAGE_INIT
2272  * - \ref SCIP_STAGE_PROBLEM
2273  *
2274  * @note method has all reader callbacks as arguments and is thus changed every time a new callback is added
2275  * in future releases; consider using SCIPincludeReaderBasic() and setter functions
2276  * if you seek for a method which is less likely to change in future releases
2277  */
2278 extern
2280  SCIP* scip, /**< SCIP data structure */
2281  const char* name, /**< name of reader */
2282  const char* desc, /**< description of reader */
2283  const char* extension, /**< file extension that reader processes */
2284  SCIP_DECL_READERCOPY ((*readercopy)), /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
2285  SCIP_DECL_READERFREE ((*readerfree)), /**< destructor of reader */
2286  SCIP_DECL_READERREAD ((*readerread)), /**< read method */
2287  SCIP_DECL_READERWRITE ((*readerwrite)), /**< write method */
2288  SCIP_READERDATA* readerdata /**< reader data */
2289  );
2290 
2291 /** creates a reader and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2292  * Optional callbacks can be set via specific setter functions, see
2293  * SCIPsetReaderCopy(), SCIPsetReaderFree(), SCIPsetReaderRead(), SCIPsetReaderWrite().
2294  *
2295  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2296  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2297  *
2298  * @pre This method can be called if SCIP is in one of the following stages:
2299  * - \ref SCIP_STAGE_INIT
2300  * - \ref SCIP_STAGE_PROBLEM
2301  *
2302  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeReader() instead
2303  */
2304 extern
2306  SCIP* scip, /**< SCIP data structure */
2307  SCIP_READER** readerptr, /**< reference to reader pointer, or NULL */
2308  const char* name, /**< name of reader */
2309  const char* desc, /**< description of reader */
2310  const char* extension, /**< file extension that reader processes */
2311  SCIP_READERDATA* readerdata /**< reader data */
2312  );
2313 
2314 /** set copy method of reader
2315  *
2316  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2317  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2318  *
2319  * @pre This method can be called if SCIP is in one of the following stages:
2320  * - \ref SCIP_STAGE_INIT
2321  * - \ref SCIP_STAGE_PROBLEM
2322  */
2323 extern
2325  SCIP* scip, /**< SCIP data structure */
2326  SCIP_READER* reader, /**< reader */
2327  SCIP_DECL_READERCOPY ((*readercopy)) /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
2328  );
2329 
2330 /** set deinitialization method of reader
2331  *
2332  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2333  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2334  *
2335  * @pre This method can be called if SCIP is in one of the following stages:
2336  * - \ref SCIP_STAGE_INIT
2337  * - \ref SCIP_STAGE_PROBLEM
2338  */
2339 extern
2341  SCIP* scip, /**< SCIP data structure */
2342  SCIP_READER* reader, /**< reader */
2343  SCIP_DECL_READERFREE ((*readerfree)) /**< destructor of reader */
2344  );
2345 
2346 /** set read method of reader
2347  *
2348  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2349  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2350  *
2351  * @pre This method can be called if SCIP is in one of the following stages:
2352  * - \ref SCIP_STAGE_INIT
2353  * - \ref SCIP_STAGE_PROBLEM
2354  */
2355 extern
2357  SCIP* scip, /**< SCIP data structure */
2358  SCIP_READER* reader, /**< reader */
2359  SCIP_DECL_READERREAD ((*readerread)) /**< read method of reader */
2360  );
2361 
2362 /** set write method of reader
2363  *
2364  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2365  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2366  *
2367  * @pre This method can be called if SCIP is in one of the following stages:
2368  * - \ref SCIP_STAGE_INIT
2369  * - \ref SCIP_STAGE_PROBLEM
2370  */
2371 extern
2373  SCIP* scip, /**< SCIP data structure */
2374  SCIP_READER* reader, /**< reader */
2375  SCIP_DECL_READERWRITE ((*readerwrite)) /**< write method of reader */
2376  );
2377 
2378 /** returns the reader of the given name, or NULL if not existing */
2379 extern
2381  SCIP* scip, /**< SCIP data structure */
2382  const char* name /**< name of reader */
2383  );
2384 
2385 /** returns the array of currently available readers */
2386 extern
2388  SCIP* scip /**< SCIP data structure */
2389  );
2390 
2391 /** returns the number of currently available readers */
2392 extern
2393 int SCIPgetNReaders(
2394  SCIP* scip /**< SCIP data structure */
2395  );
2396 
2397 /* @} */
2398 
2399 /**@addtogroup PublicPricerMethods
2400  *
2401  * @{
2402  */
2403 
2404 /** creates a variable pricer and includes it in SCIP
2405  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2406  * This should be done during the problem creation stage.
2407  *
2408  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2409  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2410  *
2411  * @pre This method can be called if SCIP is in one of the following stages:
2412  * - \ref SCIP_STAGE_INIT
2413  * - \ref SCIP_STAGE_PROBLEM
2414  *
2415  * @note method has all pricer callbacks as arguments and is thus changed every time a new callback is added
2416  * in future releases; consider using SCIPincludePricerBasic() and setter functions
2417  * if you seek for a method which is less likely to change in future releases
2418  */
2419 extern
2421  SCIP* scip, /**< SCIP data structure */
2422  const char* name, /**< name of variable pricer */
2423  const char* desc, /**< description of variable pricer */
2424  int priority, /**< priority of the variable pricer */
2425  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2426  * problem variables with negative reduced costs are found?
2427  * if this is set to FALSE it may happen that the pricer produces columns
2428  * that already exist in the problem (which are also priced in by the
2429  * default problem variable pricing in the same round) */
2430  SCIP_DECL_PRICERCOPY ((*pricercopy)), /**< copy method of variable pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2431  SCIP_DECL_PRICERFREE ((*pricerfree)), /**< destructor of variable pricer */
2432  SCIP_DECL_PRICERINIT ((*pricerinit)), /**< initialize variable pricer */
2433  SCIP_DECL_PRICEREXIT ((*pricerexit)), /**< deinitialize variable pricer */
2434  SCIP_DECL_PRICERINITSOL((*pricerinitsol)),/**< solving process initialization method of variable pricer */
2435  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)),/**< solving process deinitialization method of variable pricer */
2436  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2437  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2438  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2439  );
2440 
2441 /** creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL;
2442  * if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(),
2443  * SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(),
2444  * SCIPsetPricerFarkas();
2445  *
2446  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2447  * This should be done during the problem creation stage.
2448  *
2449  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2450  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2451  *
2452  * @pre This method can be called if SCIP is in one of the following stages:
2453  * - \ref SCIP_STAGE_INIT
2454  * - \ref SCIP_STAGE_PROBLEM
2455  *
2456  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePricer() instead
2457  */
2458 extern
2460  SCIP* scip, /**< SCIP data structure */
2461  SCIP_PRICER** pricerptr, /**< reference to a pricer, or NULL */
2462  const char* name, /**< name of variable pricer */
2463  const char* desc, /**< description of variable pricer */
2464  int priority, /**< priority of the variable pricer */
2465  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2466  * problem variables with negative reduced costs are found?
2467  * if this is set to FALSE it may happen that the pricer produces columns
2468  * that already exist in the problem (which are also priced in by the
2469  * default problem variable pricing in the same round) */
2470  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2471  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2472  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2473  );
2474 
2475 /** sets copy method of pricer
2476  *
2477  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2478  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2479  *
2480  * @pre This method can be called if SCIP is in one of the following stages:
2481  * - \ref SCIP_STAGE_INIT
2482  * - \ref SCIP_STAGE_PROBLEM
2483  */
2484 extern
2486  SCIP* scip, /**< SCIP data structure */
2487  SCIP_PRICER* pricer, /**< pricer */
2488  SCIP_DECL_PRICERCOPY ((*pricercopy)) /**< copy method of pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2489  );
2490 
2491 /** sets destructor method of pricer
2492  *
2493  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2494  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2495  *
2496  * @pre This method can be called if SCIP is in one of the following stages:
2497  * - \ref SCIP_STAGE_INIT
2498  * - \ref SCIP_STAGE_PROBLEM
2499  */
2500 extern
2502  SCIP* scip, /**< SCIP data structure */
2503  SCIP_PRICER* pricer, /**< pricer */
2504  SCIP_DECL_PRICERFREE ((*pricerfree)) /**< destructor of pricer */
2505  );
2506 
2507 /** sets initialization method of pricer
2508  *
2509  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2510  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2511  *
2512  * @pre This method can be called if SCIP is in one of the following stages:
2513  * - \ref SCIP_STAGE_INIT
2514  * - \ref SCIP_STAGE_PROBLEM
2515  */
2516 extern
2518  SCIP* scip, /**< SCIP data structure */
2519  SCIP_PRICER* pricer, /**< pricer */
2520  SCIP_DECL_PRICERINIT ((*pricerinit)) /**< initialize pricer */
2521  );
2522 
2523 /** sets deinitialization method of pricer
2524  *
2525  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2526  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2527  *
2528  * @pre This method can be called if SCIP is in one of the following stages:
2529  * - \ref SCIP_STAGE_INIT
2530  * - \ref SCIP_STAGE_PROBLEM
2531  */
2532 extern
2534  SCIP* scip, /**< SCIP data structure */
2535  SCIP_PRICER* pricer, /**< pricer */
2536  SCIP_DECL_PRICEREXIT ((*pricerexit)) /**< deinitialize pricer */
2537  );
2538 
2539 /** sets solving process initialization method of pricer
2540  *
2541  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2542  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2543  *
2544  * @pre This method can be called if SCIP is in one of the following stages:
2545  * - \ref SCIP_STAGE_INIT
2546  * - \ref SCIP_STAGE_PROBLEM
2547  */
2548 extern
2550  SCIP* scip, /**< SCIP data structure */
2551  SCIP_PRICER* pricer, /**< pricer */
2552  SCIP_DECL_PRICERINITSOL ((*pricerinitsol))/**< solving process initialization method of pricer */
2553  );
2554 
2555 /** sets solving process deinitialization method of pricer
2556  *
2557  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2558  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2559  *
2560  * @pre This method can be called if SCIP is in one of the following stages:
2561  * - \ref SCIP_STAGE_INIT
2562  * - \ref SCIP_STAGE_PROBLEM
2563  */
2564 extern
2566  SCIP* scip, /**< SCIP data structure */
2567  SCIP_PRICER* pricer, /**< pricer */
2568  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)) /**< solving process deinitialization method of pricer */
2569  );
2570 
2571 /** returns the variable pricer of the given name, or NULL if not existing */
2572 extern
2574  SCIP* scip, /**< SCIP data structure */
2575  const char* name /**< name of variable pricer */
2576  );
2577 
2578 /** returns the array of currently available variable pricers; active pricers are in the first slots of the array */
2579 extern
2581  SCIP* scip /**< SCIP data structure */
2582  );
2583 
2584 /** returns the number of currently available variable pricers */
2585 extern
2586 int SCIPgetNPricers(
2587  SCIP* scip /**< SCIP data structure */
2588  );
2589 
2590 /** returns the number of currently active variable pricers, that are used in the LP solving loop */
2591 extern
2593  SCIP* scip /**< SCIP data structure */
2594  );
2595 
2596 /** sets the priority of a variable pricer */
2597 extern
2599  SCIP* scip, /**< SCIP data structure */
2600  SCIP_PRICER* pricer, /**< variable pricer */
2601  int priority /**< new priority of the variable pricer */
2602  );
2603 
2604 /** activates pricer to be used for the current problem
2605  * This method should be called during the problem creation stage for all pricers that are necessary to solve
2606  * the problem model.
2607  * The pricers are automatically deactivated when the problem is freed.
2608  *
2609  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2610  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2611  *
2612  * @pre This method can be called if SCIP is in one of the following stages:
2613  * - \ref SCIP_STAGE_PROBLEM
2614  */
2615 extern
2617  SCIP* scip, /**< SCIP data structure */
2618  SCIP_PRICER* pricer /**< variable pricer */
2619  );
2620 
2621 /** deactivates pricer
2622  *
2623  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2624  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2625  *
2626  * @pre This method can be called if SCIP is in one of the following stages:
2627  * - \ref SCIP_STAGE_PROBLEM
2628  * - \ref SCIP_STAGE_EXITSOLVE
2629  */
2630 extern
2632  SCIP* scip, /**< SCIP data structure */
2633  SCIP_PRICER* pricer /**< variable pricer */
2634  );
2635 
2636 /* @} */
2637 
2638 /**@addtogroup PublicConshdlrMethods
2639  *
2640  * @{
2641  */
2642 
2643 /** creates a constraint handler and includes it in SCIP.
2644  *
2645  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2646  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2647  *
2648  * @pre This method can be called if SCIP is in one of the following stages:
2649  * - \ref SCIP_STAGE_INIT
2650  * - \ref SCIP_STAGE_PROBLEM
2651  *
2652  * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
2653  * callback is added
2654  * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
2655  * if you seek for a method which is less likely to change in future releases
2656  */
2657 extern
2659  SCIP* scip, /**< SCIP data structure */
2660  const char* name, /**< name of constraint handler */
2661  const char* desc, /**< description of constraint handler */
2662  int sepapriority, /**< priority of the constraint handler for separation */
2663  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2664  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2665  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2666  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2667  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2668  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2669  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2670  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
2671  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2672  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2673  SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
2674  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
2675  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2676  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
2677  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
2678  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
2679  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
2680  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
2681  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
2682  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
2683  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
2684  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
2685  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
2686  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2687  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2688  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2689  SCIP_DECL_CONSENFORELAX ((*consenforelax)), /**< enforcing constraints for relaxation solutions */
2690  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2691  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2692  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2693  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
2694  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
2695  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2696  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
2697  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
2698  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
2699  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
2700  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
2701  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
2702  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
2703  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
2704  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
2705  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
2706  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
2707  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2708  );
2709 
2710 /** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2711  * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
2712  * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
2713  * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
2714  * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
2715  * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
2716  * SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and
2717  * SCIPsetConshdlrGetDiveBdChgs().
2718  *
2719  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2720  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2721  *
2722  * @pre This method can be called if SCIP is in one of the following stages:
2723  * - \ref SCIP_STAGE_INIT
2724  * - \ref SCIP_STAGE_PROBLEM
2725  *
2726  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
2727  */
2728 extern
2730  SCIP* scip, /**< SCIP data structure */
2731  SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
2732  const char* name, /**< name of constraint handler */
2733  const char* desc, /**< description of constraint handler */
2734  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2735  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2736  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2737  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2738  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2739  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2740  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2741  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2742  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2743  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2744  );
2745 
2746 /** sets all separation related callbacks/parameters of the constraint handler
2747  *
2748  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2749  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2750  *
2751  * @pre This method can be called if SCIP is in one of the following stages:
2752  * - \ref SCIP_STAGE_INIT
2753  * - \ref SCIP_STAGE_PROBLEM
2754  */
2755 extern
2757  SCIP* scip, /**< SCIP data structure */
2758  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2759  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2760  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2761  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2762  int sepapriority, /**< priority of the constraint handler for separation */
2763  SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
2764  );
2765 
2766 /** sets both the propagation callback and the propagation frequency of the constraint handler
2767  *
2768  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2769  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2770  *
2771  * @pre This method can be called if SCIP is in one of the following stages:
2772  * - \ref SCIP_STAGE_INIT
2773  * - \ref SCIP_STAGE_PROBLEM
2774  */
2775 extern
2777  SCIP* scip, /**< SCIP data structure */
2778  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2779  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2780  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2781  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2782  SCIP_PROPTIMING proptiming /**< positions in the node solving loop where propagation should be executed */
2783  );
2784 
2785 /** sets relaxation enforcement method of the constraint handler
2786  *
2787  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2788  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2789  *
2790  * @pre This method can be called if SCIP is in one of the following stages:
2791  * - \ref SCIP_STAGE_INIT
2792  * - \ref SCIP_STAGE_PROBLEM
2793  */
2794 extern
2796  SCIP* scip, /**< SCIP data structure */
2797  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2798  SCIP_DECL_CONSENFORELAX ((*consenforelax)) /**< enforcement method for relaxation solution of constraint handler (might be NULL) */
2799  );
2800 
2801 /** sets copy method of both the constraint handler and each associated constraint
2802  *
2803  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2804  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2805  *
2806  * @pre This method can be called if SCIP is in one of the following stages:
2807  * - \ref SCIP_STAGE_INIT
2808  * - \ref SCIP_STAGE_PROBLEM
2809  */
2810 extern
2812  SCIP* scip, /**< SCIP data structure */
2813  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2814  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2815  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
2816  );
2817 
2818 /** sets destructor method of constraint handler
2819  *
2820  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2821  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2822  *
2823  * @pre This method can be called if SCIP is in one of the following stages:
2824  * - \ref SCIP_STAGE_INIT
2825  * - \ref SCIP_STAGE_PROBLEM
2826  */
2827 extern
2829  SCIP* scip, /**< SCIP data structure */
2830  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2831  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
2832  );
2833 
2834 /** sets initialization method of constraint handler
2835  *
2836  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2837  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2838  *
2839  * @pre This method can be called if SCIP is in one of the following stages:
2840  * - \ref SCIP_STAGE_INIT
2841  * - \ref SCIP_STAGE_PROBLEM
2842  */
2843 extern
2845  SCIP* scip, /**< SCIP data structure */
2846  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2847  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
2848  );
2849 
2850 /** sets deinitialization method of constraint handler
2851  *
2852  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2853  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2854  *
2855  * @pre This method can be called if SCIP is in one of the following stages:
2856  * - \ref SCIP_STAGE_INIT
2857  * - \ref SCIP_STAGE_PROBLEM
2858  */
2859 extern
2861  SCIP* scip, /**< SCIP data structure */
2862  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2863  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
2864  );
2865 
2866 /** sets solving process initialization method of constraint handler
2867  *
2868  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2869  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2870  *
2871  * @pre This method can be called if SCIP is in one of the following stages:
2872  * - \ref SCIP_STAGE_INIT
2873  * - \ref SCIP_STAGE_PROBLEM
2874  */
2875 extern
2877  SCIP* scip, /**< SCIP data structure */
2878  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2879  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
2880  );
2881 
2882 /** sets solving process deinitialization method of constraint handler
2883  *
2884  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2885  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2886  *
2887  * @pre This method can be called if SCIP is in one of the following stages:
2888  * - \ref SCIP_STAGE_INIT
2889  * - \ref SCIP_STAGE_PROBLEM
2890  */
2891 extern
2893  SCIP* scip, /**< SCIP data structure */
2894  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2895  SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
2896  );
2897 
2898 /** sets preprocessing initialization method of constraint handler
2899  *
2900  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2901  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2902  *
2903  * @pre This method can be called if SCIP is in one of the following stages:
2904  * - \ref SCIP_STAGE_INIT
2905  * - \ref SCIP_STAGE_PROBLEM
2906  */
2907 extern
2909  SCIP* scip, /**< SCIP data structure */
2910  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2911  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
2912  );
2913 
2914 /** sets preprocessing deinitialization method of constraint handler
2915  *
2916  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2917  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2918  *
2919  * @pre This method can be called if SCIP is in one of the following stages:
2920  * - \ref SCIP_STAGE_INIT
2921  * - \ref SCIP_STAGE_PROBLEM
2922  */
2923 extern
2925  SCIP* scip, /**< SCIP data structure */
2926  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2927  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
2928  );
2929 
2930 /** sets presolving method of constraint handler
2931  *
2932  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2933  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2934  *
2935  * @pre This method can be called if SCIP is in one of the following stages:
2936  * - \ref SCIP_STAGE_INIT
2937  * - \ref SCIP_STAGE_PROBLEM
2938  */
2939 extern
2941  SCIP* scip, /**< SCIP data structure */
2942  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2943  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
2944  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2945  SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
2946  );
2947 
2948 /** sets method of constraint handler to free specific constraint data
2949  *
2950  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2951  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2952  *
2953  * @pre This method can be called if SCIP is in one of the following stages:
2954  * - \ref SCIP_STAGE_INIT
2955  * - \ref SCIP_STAGE_PROBLEM
2956  */
2957 extern
2959  SCIP* scip, /**< SCIP data structure */
2960  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2961  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
2962  );
2963 
2964 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
2965  *
2966  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2967  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2968  *
2969  * @pre This method can be called if SCIP is in one of the following stages:
2970  * - \ref SCIP_STAGE_INIT
2971  * - \ref SCIP_STAGE_PROBLEM
2972  */
2973 extern
2975  SCIP* scip, /**< SCIP data structure */
2976  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2977  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
2978  );
2979 
2980 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
2981  *
2982  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2983  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2984  *
2985  * @pre This method can be called if SCIP is in one of the following stages:
2986  * - \ref SCIP_STAGE_INIT
2987  * - \ref SCIP_STAGE_PROBLEM
2988  */
2989 extern
2991  SCIP* scip, /**< SCIP data structure */
2992  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2993  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
2994  );
2995 
2996 /** sets propagation conflict resolving method of constraint handler
2997  *
2998  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2999  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3000  *
3001  * @pre This method can be called if SCIP is in one of the following stages:
3002  * - \ref SCIP_STAGE_INIT
3003  * - \ref SCIP_STAGE_PROBLEM
3004  */
3005 extern
3007  SCIP* scip, /**< SCIP data structure */
3008  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3009  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
3010  );
3011 
3012 /** sets activation notification method of constraint handler
3013  *
3014  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3015  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3016  *
3017  * @pre This method can be called if SCIP is in one of the following stages:
3018  * - \ref SCIP_STAGE_INIT
3019  * - \ref SCIP_STAGE_PROBLEM
3020  */
3021 extern
3023  SCIP* scip, /**< SCIP data structure */
3024  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3025  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
3026  );
3027 
3028 /** sets deactivation notification method of constraint handler
3029  *
3030  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3031  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3032  *
3033  * @pre This method can be called if SCIP is in one of the following stages:
3034  * - \ref SCIP_STAGE_INIT
3035  * - \ref SCIP_STAGE_PROBLEM
3036  */
3037 extern
3039  SCIP* scip, /**< SCIP data structure */
3040  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3041  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
3042  );
3043 
3044 /** sets enabling notification method of constraint handler
3045  *
3046  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3047  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3048  *
3049  * @pre This method can be called if SCIP is in one of the following stages:
3050  * - \ref SCIP_STAGE_INIT
3051  * - \ref SCIP_STAGE_PROBLEM
3052  */
3053 extern
3055  SCIP* scip, /**< SCIP data structure */
3056  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3057  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
3058  );
3059 
3060 /** sets disabling notification method of constraint handler
3061  *
3062  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3063  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3064  *
3065  * @pre This method can be called if SCIP is in one of the following stages:
3066  * - \ref SCIP_STAGE_INIT
3067  * - \ref SCIP_STAGE_PROBLEM
3068  */
3069 extern
3071  SCIP* scip, /**< SCIP data structure */
3072  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3073  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
3074  );
3075 
3076 /** sets variable deletion method of constraint handler
3077  *
3078  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3079  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3080  *
3081  * @pre This method can be called if SCIP is in one of the following stages:
3082  * - \ref SCIP_STAGE_INIT
3083  * - \ref SCIP_STAGE_PROBLEM
3084  */
3085 extern
3087  SCIP* scip, /**< SCIP data structure */
3088  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3089  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
3090  );
3091 
3092 /** sets constraint display method of constraint handler
3093  *
3094  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3095  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3096  *
3097  * @pre This method can be called if SCIP is in one of the following stages:
3098  * - \ref SCIP_STAGE_INIT
3099  * - \ref SCIP_STAGE_PROBLEM
3100  */
3101 extern
3103  SCIP* scip, /**< SCIP data structure */
3104  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3105  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
3106  );
3107 
3108 /** sets constraint parsing method of constraint handler
3109  *
3110  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3111  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3112  *
3113  * @pre This method can be called if SCIP is in one of the following stages:
3114  * - \ref SCIP_STAGE_INIT
3115  * - \ref SCIP_STAGE_PROBLEM
3116  */
3117 extern
3119  SCIP* scip, /**< SCIP data structure */
3120  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3121  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
3122  );
3123 
3124 /** sets constraint variable getter method of constraint handler
3125  *
3126  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3127  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3128  *
3129  * @pre This method can be called if SCIP is in one of the following stages:
3130  * - \ref SCIP_STAGE_INIT
3131  * - \ref SCIP_STAGE_PROBLEM
3132  */
3133 extern
3135  SCIP* scip, /**< SCIP data structure */
3136  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3137  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
3138  );
3139 
3140 /** sets constraint variable number getter method of constraint handler
3141  *
3142  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3143  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3144  *
3145  * @pre This method can be called if SCIP is in one of the following stages:
3146  * - \ref SCIP_STAGE_INIT
3147  * - \ref SCIP_STAGE_PROBLEM
3148  */
3149 extern
3151  SCIP* scip, /**< SCIP data structure */
3152  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3153  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
3154  );
3155 
3156 /** sets diving enforcement method of constraint handler
3157  *
3158  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3159  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3160  *
3161  * @pre This method can be called if SCIP is in one of the following stages:
3162  * - \ref SCIP_STAGE_INIT
3163  * - \ref SCIP_STAGE_PROBLEM
3164  */
3165 extern
3167  SCIP* scip, /**< SCIP data structure */
3168  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3169  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
3170  );
3171 
3172 /** returns the constraint handler of the given name, or NULL if not existing */
3173 extern
3175  SCIP* scip, /**< SCIP data structure */
3176  const char* name /**< name of constraint handler */
3177  );
3178 
3179 /** returns the array of currently available constraint handlers */
3180 extern
3182  SCIP* scip /**< SCIP data structure */
3183  );
3184 
3185 /** returns the number of currently available constraint handlers */
3186 extern
3187 int SCIPgetNConshdlrs(
3188  SCIP* scip /**< SCIP data structure */
3189  );
3190 
3191 /* @} */
3192 
3193 /**@addtogroup PublicConflictMethods
3194  *
3195  * @{
3196  */
3197 
3198 /** creates a conflict handler and includes it in SCIP
3199  *
3200  * @note method has all conflict handler callbacks as arguments and is thus changed every time a new
3201  * callback is added
3202  * in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions
3203  * if you seek for a method which is less likely to change in future releases
3204  */
3205 extern
3207  SCIP* scip, /**< SCIP data structure */
3208  const char* name, /**< name of conflict handler */
3209  const char* desc, /**< description of conflict handler */
3210  int priority, /**< priority of the conflict handler */
3211  SCIP_DECL_CONFLICTCOPY((*conflictcopy)), /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3212  SCIP_DECL_CONFLICTFREE((*conflictfree)), /**< destructor of conflict handler */
3213  SCIP_DECL_CONFLICTINIT((*conflictinit)), /**< initialize conflict handler */
3214  SCIP_DECL_CONFLICTEXIT((*conflictexit)), /**< deinitialize conflict handler */
3215  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
3216  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
3217  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
3218  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
3219  );
3220 
3221 /** creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3222  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3223  * Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(),
3224  * SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(),
3225  * and SCIPsetConflicthdlrExitsol()
3226  *
3227  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead
3228  */
3229 extern
3231  SCIP* scip, /**< SCIP data structure */
3232  SCIP_CONFLICTHDLR** conflicthdlrptr, /**< reference to a conflict handler pointer, or NULL */
3233  const char* name, /**< name of conflict handler */
3234  const char* desc, /**< description of conflict handler */
3235  int priority, /**< priority of the conflict handler */
3236  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
3237  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
3238  );
3239 
3240 /** set copy method of conflict handler */
3241 extern
3243  SCIP* scip, /**< SCIP data structure */
3244  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3245  SCIP_DECL_CONFLICTCOPY((*conflictcopy)) /**< copy method of conflict handler */
3246  );
3247 
3248 /** set destructor of conflict handler */
3249 extern
3251  SCIP* scip, /**< SCIP data structure */
3252  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3253  SCIP_DECL_CONFLICTFREE((*conflictfree)) /**< destructor of conflict handler */
3254  );
3255 
3256 /** set initialization method of conflict handler */
3257 extern
3259  SCIP* scip, /**< SCIP data structure */
3260  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3261  SCIP_DECL_CONFLICTINIT((*conflictinit)) /**< initialize conflict handler */
3262  );
3263 
3264 /** set deinitialization method of conflict handler */
3265 extern
3267  SCIP* scip, /**< SCIP data structure */
3268  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3269  SCIP_DECL_CONFLICTEXIT((*conflictexit)) /**< deinitialize conflict handler */
3270  );
3271 
3272 /** set solving process initialization method of conflict handler */
3273 extern
3275  SCIP* scip, /**< SCIP data structure */
3276  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3277  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
3278  );
3279 
3280 /** set solving process deinitialization method of conflict handler */
3281 extern
3283  SCIP* scip, /**< SCIP data structure */
3284  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3285  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
3286  );
3287 
3288 /** returns the conflict handler of the given name, or NULL if not existing */
3289 extern
3291  SCIP* scip, /**< SCIP data structure */
3292  const char* name /**< name of conflict handler */
3293  );
3294 
3295 /** returns the array of currently available conflict handlers */
3296 extern
3298  SCIP* scip /**< SCIP data structure */
3299  );
3300 
3301 /** returns the number of currently available conflict handlers */
3302 extern
3304  SCIP* scip /**< SCIP data structure */
3305  );
3306 
3307 /** sets the priority of a conflict handler */
3308 extern
3310  SCIP* scip, /**< SCIP data structure */
3311  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3312  int priority /**< new priority of the conflict handler */
3313  );
3314 
3315 /* @} */
3316 
3317 /**@addtogroup PublicPresolverMethods
3318  *
3319  * @{
3320  */
3321 
3322 /** creates a presolver and includes it in SCIP
3323  *
3324  * @note method has all presolver callbacks as arguments and is thus changed every time a new
3325  * callback is added
3326  * in future releases; consider using SCIPincludePresolBasic() and setter functions
3327  * if you seek for a method which is less likely to change in future releases
3328  */
3329 extern
3331  SCIP* scip, /**< SCIP data structure */
3332  const char* name, /**< name of presolver */
3333  const char* desc, /**< description of presolver */
3334  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
3335  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
3336  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
3337  SCIP_DECL_PRESOLCOPY ((*presolcopy)), /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
3338  SCIP_DECL_PRESOLFREE ((*presolfree)), /**< destructor of presolver to free user data (called when SCIP is exiting) */
3339  SCIP_DECL_PRESOLINIT ((*presolinit)), /**< initialization method of presolver (called after problem was transformed) */
3340  SCIP_DECL_PRESOLEXIT ((*presolexit)), /**< deinitialization method of presolver (called before transformed problem is freed) */
3341  SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
3342  SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
3343  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
3344  SCIP_PRESOLDATA* presoldata /**< presolver data */
3345  );
3346 
3347 /** Creates a presolver and includes it in SCIP with its fundamental callback. All non-fundamental (or optional)
3348  * callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter
3349  * functions. These are SCIPsetPresolCopy(), SCIPsetPresolFree(), SCIPsetPresolInit(), SCIPsetPresolExit(),
3350  * SCIPsetPresolInitpre(), and SCIPsetPresolExitPre().
3351  *
3352  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePresol() instead
3353  */
3354 extern
3356  SCIP* scip, /**< SCIP data structure */
3357  SCIP_PRESOL** presolptr, /**< reference to presolver, or NULL */
3358  const char* name, /**< name of presolver */
3359  const char* desc, /**< description of presolver */
3360  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
3361  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
3362  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
3363  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
3364  SCIP_PRESOLDATA* presoldata /**< presolver data */
3365  );
3366 
3367 /** sets copy method of presolver */
3368 extern
3370  SCIP* scip, /**< SCIP data structure */
3371  SCIP_PRESOL* presol, /**< presolver */
3372  SCIP_DECL_PRESOLCOPY ((*presolcopy)) /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
3373  );
3374 
3375 /** sets destructor method of presolver */
3376 extern
3378  SCIP* scip, /**< SCIP data structure */
3379  SCIP_PRESOL* presol, /**< presolver */
3380  SCIP_DECL_PRESOLFREE ((*presolfree)) /**< destructor of presolver */
3381  );
3382 
3383 /** sets initialization method of presolver */
3384 extern
3386  SCIP* scip, /**< SCIP data structure */
3387  SCIP_PRESOL* presol, /**< presolver */
3388  SCIP_DECL_PRESOLINIT ((*presolinit)) /**< initialize presolver */
3389  );
3390 
3391 /** sets deinitialization method of presolver */
3392 extern
3394  SCIP* scip, /**< SCIP data structure */
3395  SCIP_PRESOL* presol, /**< presolver */
3396  SCIP_DECL_PRESOLEXIT ((*presolexit)) /**< deinitialize presolver */
3397  );
3398 
3399 /** sets solving process initialization method of presolver */
3400 extern
3402  SCIP* scip, /**< SCIP data structure */
3403  SCIP_PRESOL* presol, /**< presolver */
3404  SCIP_DECL_PRESOLINITPRE ((*presolinitpre))/**< solving process initialization method of presolver */
3405  );
3406 
3407 /** sets solving process deinitialization method of presolver */
3409  SCIP* scip, /**< SCIP data structure */
3410  SCIP_PRESOL* presol, /**< presolver */
3411  SCIP_DECL_PRESOLEXITPRE ((*presolexitpre))/**< solving process deinitialization method of presolver */
3412  );
3413 
3414 /** returns the presolver of the given name, or NULL if not existing */
3415 extern
3417  SCIP* scip, /**< SCIP data structure */
3418  const char* name /**< name of presolver */
3419  );
3420 
3421 /** returns the array of currently available presolvers */
3422 extern
3424  SCIP* scip /**< SCIP data structure */
3425  );
3426 
3427 /** returns the number of currently available presolvers */
3428 extern
3429 int SCIPgetNPresols(
3430  SCIP* scip /**< SCIP data structure */
3431  );
3432 
3433 /** sets the priority of a presolver */
3434 extern
3436  SCIP* scip, /**< SCIP data structure */
3437  SCIP_PRESOL* presol, /**< presolver */
3438  int priority /**< new priority of the presolver */
3439  );
3440 
3441 /* @} */
3442 
3443 /**@addtogroup PublicRelaxatorMethods
3444  *
3445  * @{
3446  */
3447 
3448 /** creates a relaxation handler and includes it in SCIP
3449  *
3450  * @note method has all relaxation handler callbacks as arguments and is thus changed every time a new
3451  * callback is added
3452  * in future releases; consider using SCIPincludeRelaxBasic() and setter functions
3453  * if you seek for a method which is less likely to change in future releases
3454  */
3455 extern
3457  SCIP* scip, /**< SCIP data structure */
3458  const char* name, /**< name of relaxation handler */
3459  const char* desc, /**< description of relaxation handler */
3460  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3461  int freq, /**< frequency for calling relaxation handler */
3462  SCIP_Bool includeslp, /**< Does the relaxator contain all cuts in the LP? */
3463  SCIP_DECL_RELAXCOPY ((*relaxcopy)), /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3464  SCIP_DECL_RELAXFREE ((*relaxfree)), /**< destructor of relaxation handler */
3465  SCIP_DECL_RELAXINIT ((*relaxinit)), /**< initialize relaxation handler */
3466  SCIP_DECL_RELAXEXIT ((*relaxexit)), /**< deinitialize relaxation handler */
3467  SCIP_DECL_RELAXINITSOL((*relaxinitsol)), /**< solving process initialization method of relaxation handler */
3468  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), /**< solving process deinitialization method of relaxation handler */
3469  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3470  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3471  );
3472 
3473 /** creates a relaxation handler and includes it in SCIP. All non fundamental
3474  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3475  * Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(),
3476  * SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()
3477  *
3478  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeRelax() instead
3479  */
3480 extern
3482  SCIP* scip, /**< SCIP data structure */
3483  SCIP_RELAX** relaxptr, /**< reference to relaxation pointer, or NULL */
3484  const char* name, /**< name of relaxation handler */
3485  const char* desc, /**< description of relaxation handler */
3486  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3487  int freq, /**< frequency for calling relaxation handler */
3488  SCIP_Bool includeslp, /**< Does the relaxator contain all cuts in the LP? */
3489  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3490  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3491  );
3492 
3493 /** sets copy method of relaxation handler */
3494 extern
3496  SCIP* scip, /**< SCIP data structure */
3497  SCIP_RELAX* relax, /**< relaxation handler */
3498  SCIP_DECL_RELAXCOPY ((*relaxcopy)) /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3499  );
3500 
3501 /** sets destructor method of relaxation handler */
3502 extern
3504  SCIP* scip, /**< SCIP data structure */
3505  SCIP_RELAX* relax, /**< relaxation handler */
3506  SCIP_DECL_RELAXFREE ((*relaxfree)) /**< destructor of relaxation handler */
3507  );
3508 
3509 /** sets initialization method of relaxation handler */
3510 extern
3512  SCIP* scip, /**< SCIP data structure */
3513  SCIP_RELAX* relax, /**< relaxation handler */
3514  SCIP_DECL_RELAXINIT ((*relaxinit)) /**< initialize relaxation handler */
3515  );
3516 
3517 /** sets deinitialization method of relaxation handler */
3518 extern
3520  SCIP* scip, /**< SCIP data structure */
3521  SCIP_RELAX* relax, /**< relaxation handler */
3522  SCIP_DECL_RELAXEXIT ((*relaxexit)) /**< deinitialize relaxation handler */
3523  );
3524 
3525 /** sets solving process initialization method of relaxation handler */
3526 extern
3528  SCIP* scip, /**< SCIP data structure */
3529  SCIP_RELAX* relax, /**< relaxation handler */
3530  SCIP_DECL_RELAXINITSOL((*relaxinitsol)) /**< solving process initialization method of relaxation handler */
3531  );
3532 
3533 /** sets solving process deinitialization method of relaxation handler */
3534 extern
3536  SCIP* scip, /**< SCIP data structure */
3537  SCIP_RELAX* relax, /**< relaxation handler */
3538  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)) /**< solving process deinitialization method of relaxation handler */
3539  );
3540 
3541 /** returns the relaxation handler of the given name, or NULL if not existing */
3542 extern
3544  SCIP* scip, /**< SCIP data structure */
3545  const char* name /**< name of relaxation handler */
3546  );
3547 
3548 /** returns the array of currently available relaxation handlers */
3549 extern
3551  SCIP* scip /**< SCIP data structure */
3552  );
3553 
3554 /** returns the number of currently available relaxation handlers */
3555 extern
3556 int SCIPgetNRelaxs(
3557  SCIP* scip /**< SCIP data structure */
3558  );
3559 
3560 /** sets the priority of a relaxation handler*/
3561 extern
3563  SCIP* scip, /**< SCIP data structure */
3564  SCIP_RELAX* relax, /**< relaxation handler */
3565  int priority /**< new priority of the relaxation handler */
3566  );
3567 
3568 /* @} */
3569 
3570 /**@addtogroup PublicSeparatorMethods
3571  *
3572  * @{
3573  */
3574 
3575 /** creates a separator and includes it in SCIP.
3576  *
3577  * @note method has all separator callbacks as arguments and is thus changed every time a new
3578  * callback is added
3579  * in future releases; consider using SCIPincludeSepaBasic() and setter functions
3580  * if you seek for a method which is less likely to change in future releases
3581  */
3582 extern
3584  SCIP* scip, /**< SCIP data structure */
3585  const char* name, /**< name of separator */
3586  const char* desc, /**< description of separator */
3587  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3588  int freq, /**< frequency for calling separator */
3589  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3590  * to best node's dual bound for applying separation */
3591  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3592  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3593  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3594  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
3595  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
3596  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
3597  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
3598  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
3599  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3600  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3601  SCIP_SEPADATA* sepadata /**< separator data */
3602  );
3603 
3604 /** creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3605  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3606  * Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(),
3607  * SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().
3608  *
3609  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeSepa() instead
3610  */
3611 extern
3613  SCIP* scip, /**< SCIP data structure */
3614  SCIP_SEPA** sepa, /**< reference to a separator, or NULL */
3615  const char* name, /**< name of separator */
3616  const char* desc, /**< description of separator */
3617  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3618  int freq, /**< frequency for calling separator */
3619  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3620  * to best node's dual bound for applying separation */
3621  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3622  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3623  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3624  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3625  SCIP_SEPADATA* sepadata /**< separator data */
3626  );
3627 
3628 /** sets copy method of separator */
3629 extern
3631  SCIP* scip, /**< SCIP data structure */
3632  SCIP_SEPA* sepa, /**< separator */
3633  SCIP_DECL_SEPACOPY ((*sepacopy)) /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3634  );
3635 
3636 /** sets destructor method of separator */
3637 extern
3639  SCIP* scip, /**< SCIP data structure */
3640  SCIP_SEPA* sepa, /**< separator */
3641  SCIP_DECL_SEPAFREE ((*sepafree)) /**< destructor of separator */
3642  );
3643 
3644 /** sets initialization method of separator */
3645 extern
3647  SCIP* scip, /**< SCIP data structure */
3648  SCIP_SEPA* sepa, /**< separator */
3649  SCIP_DECL_SEPAINIT ((*sepainit)) /**< initialize separator */
3650  );
3651 
3652 /** sets deinitialization method of separator */
3653 extern
3655  SCIP* scip, /**< SCIP data structure */
3656  SCIP_SEPA* sepa, /**< separator */
3657  SCIP_DECL_SEPAEXIT ((*sepaexit)) /**< deinitialize separator */
3658  );
3659 
3660 /** sets solving process initialization method of separator */
3661 extern
3663  SCIP* scip, /**< SCIP data structure */
3664  SCIP_SEPA* sepa, /**< separator */
3665  SCIP_DECL_SEPAINITSOL ((*sepainitsol)) /**< solving process initialization method of separator */
3666  );
3667 
3668 /** sets solving process deinitialization method of separator */
3669 extern
3671  SCIP* scip, /**< SCIP data structure */
3672  SCIP_SEPA* sepa, /**< separator */
3673  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)) /**< solving process deinitialization method of separator */
3674  );
3675 
3676 /** returns the separator of the given name, or NULL if not existing */
3677 extern
3679  SCIP* scip, /**< SCIP data structure */
3680  const char* name /**< name of separator */
3681  );
3682 
3683 /** returns the array of currently available separators */
3684 extern
3686  SCIP* scip /**< SCIP data structure */
3687  );
3688 
3689 /** returns the number of currently available separators */
3690 extern
3691 int SCIPgetNSepas(
3692  SCIP* scip /**< SCIP data structure */
3693  );
3694 
3695 /** sets the priority of a separator */
3696 extern
3698  SCIP* scip, /**< SCIP data structure */
3699  SCIP_SEPA* sepa, /**< separator */
3700  int priority /**< new priority of the separator */
3701  );
3702 
3703 /* @} */
3704 
3705 /**@addtogroup PublicPropagatorMethods
3706  *
3707  * @{
3708  */
3709 
3710 /** creates a propagator and includes it in SCIP.
3711  *
3712 
3713  * @note method has all propagator callbacks as arguments and is thus changed every time a new
3714  * callback is added in future releases; consider using SCIPincludePropBasic() and setter functions
3715  * if you seek for a method which is less likely to change in future releases
3716  */
3717 extern
3719  SCIP* scip, /**< SCIP data structure */
3720  const char* name, /**< name of propagator */
3721  const char* desc, /**< description of propagator */
3722  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3723  int freq, /**< frequency for calling propagator */
3724  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3725  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagator should be executed */
3726  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3727  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3728  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the propagator's presolving method */
3729  SCIP_DECL_PROPCOPY ((*propcopy)), /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3730  SCIP_DECL_PROPFREE ((*propfree)), /**< destructor of propagator */
3731  SCIP_DECL_PROPINIT ((*propinit)), /**< initialize propagator */
3732  SCIP_DECL_PROPEXIT ((*propexit)), /**< deinitialize propagator */
3733  SCIP_DECL_PROPINITPRE ((*propinitpre)), /**< presolving initialization method of propagator */
3734  SCIP_DECL_PROPEXITPRE ((*propexitpre)), /**< presolving deinitialization method of propagator */
3735  SCIP_DECL_PROPINITSOL ((*propinitsol)), /**< solving process initialization method of propagator */
3736  SCIP_DECL_PROPEXITSOL ((*propexitsol)), /**< solving process deinitialization method of propagator */
3737  SCIP_DECL_PROPPRESOL ((*proppresol)), /**< presolving method */
3738  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3739  SCIP_DECL_PROPRESPROP ((*propresprop)), /**< propagation conflict resolving method */
3740  SCIP_PROPDATA* propdata /**< propagator data */
3741  );
3742 
3743 /** creates a propagator and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
3744  * Optional callbacks can be set via specific setter functions, see SCIPsetPropInit(), SCIPsetPropExit(),
3745  * SCIPsetPropCopy(), SCIPsetPropFree(), SCIPsetPropInitsol(), SCIPsetPropExitsol(),
3746  * SCIPsetPropInitpre(), SCIPsetPropExitpre(), SCIPsetPropPresol(), and SCIPsetPropResprop().
3747  *
3748  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeProp() instead
3749  */
3750 extern
3752  SCIP* scip, /**< SCIP data structure */
3753  SCIP_PROP** propptr, /**< reference to a propagator pointer, or NULL */
3754  const char* name, /**< name of propagator */
3755  const char* desc, /**< description of propagator */
3756  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3757  int freq, /**< frequency for calling propagator */
3758  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3759  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagators should be executed */
3760  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3761  SCIP_PROPDATA* propdata /**< propagator data */
3762  );
3763 
3764 /** sets copy method of propagator */
3765 extern
3767  SCIP* scip, /**< SCIP data structure */
3768  SCIP_PROP* prop, /**< propagator */
3769  SCIP_DECL_PROPCOPY ((*propcopy)) /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3770  );
3771 
3772 /** sets destructor method of propagator */
3773 extern
3775  SCIP* scip, /**< SCIP data structure */
3776  SCIP_PROP* prop, /**< propagator */
3777  SCIP_DECL_PROPFREE ((*propfree)) /**< destructor of propagator */
3778  );
3779 
3780 /** sets initialization method of propagator */
3781 extern
3783  SCIP* scip, /**< SCIP data structure */
3784  SCIP_PROP* prop, /**< propagator */
3785  SCIP_DECL_PROPINIT ((*propinit)) /**< initialize propagator */
3786  );
3787 
3788 /** sets deinitialization method of propagator */
3789 extern
3791  SCIP* scip, /**< SCIP data structure */
3792  SCIP_PROP* prop, /**< propagator */
3793  SCIP_DECL_PROPEXIT ((*propexit)) /**< deinitialize propagator */
3794  );
3795 
3796 /** sets solving process initialization method of propagator */
3797 extern
3799  SCIP* scip, /**< SCIP data structure */
3800  SCIP_PROP* prop, /**< propagator */
3801  SCIP_DECL_PROPINITSOL((*propinitsol)) /**< solving process initialization method of propagator */
3802  );
3803 
3804 /** sets solving process deinitialization method of propagator */
3805 extern
3807  SCIP* scip, /**< SCIP data structure */
3808  SCIP_PROP* prop, /**< propagator */
3809  SCIP_DECL_PROPEXITSOL ((*propexitsol)) /**< solving process deinitialization method of propagator */
3810  );
3811 
3812 /** sets preprocessing initialization method of propagator */
3813 extern
3815  SCIP* scip, /**< SCIP data structure */
3816  SCIP_PROP* prop, /**< propagator */
3817  SCIP_DECL_PROPINITPRE((*propinitpre)) /**< preprocessing initialization method of propagator */
3818  );
3819 
3820 /** sets preprocessing deinitialization method of propagator */
3821 extern
3823  SCIP* scip, /**< SCIP data structure */
3824  SCIP_PROP* prop, /**< propagator */
3825  SCIP_DECL_PROPEXITPRE((*propexitpre)) /**< preprocessing deinitialization method of propagator */
3826  );
3827 
3828 /** sets presolving method of propagator */
3829 extern
3831  SCIP* scip, /**< SCIP data structure */
3832  SCIP_PROP* prop, /**< propagator */
3833  SCIP_DECL_PROPPRESOL((*proppresol)), /**< presolving method of propagator */
3834  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3835  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3836  SCIP_PRESOLTIMING presoltiming /**< timing mask of the propagator's presolving method */
3837  );
3838 
3839 /** sets propagation conflict resolving callback of propagator */
3840 extern
3842  SCIP* scip, /**< SCIP data structure */
3843  SCIP_PROP* prop, /**< propagator */
3844  SCIP_DECL_PROPRESPROP ((*propresprop)) /**< propagation conflict resolving callback */
3845  );
3846 
3847 /** returns the propagator of the given name, or NULL if not existing */
3848 extern
3850  SCIP* scip, /**< SCIP data structure */
3851  const char* name /**< name of propagator */
3852  );
3853 
3854 /** returns the array of currently available propagators */
3855 extern
3857  SCIP* scip /**< SCIP data structure */
3858  );
3859 
3860 /** returns the number of currently available propagators */
3861 extern
3862 int SCIPgetNProps(
3863  SCIP* scip /**< SCIP data structure */
3864  );
3865 
3866 /** sets the priority of a propagator */
3867 extern
3869  SCIP* scip, /**< SCIP data structure */
3870  SCIP_PROP* prop, /**< propagator */
3871  int priority /**< new priority of the propagator */
3872  );
3873 
3874 /** sets the presolving priority of a propagator */
3875 extern
3877  SCIP* scip, /**< SCIP data structure */
3878  SCIP_PROP* prop, /**< propagator */
3879  int presolpriority /**< new presol priority of the propagator */
3880  );
3881 
3882 /* @} */
3883 
3884 /**@addtogroup PublicConcsolverTypeMethods
3885  *
3886  * @{
3887  */
3888 
3889 /** creates a concurrent solver type and includes it in SCIP.
3890  *
3891  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3892  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3893  *
3894  * @pre This method can be called if @p scip is in one of the following stages:
3895  * - \ref SCIP_STAGE_INIT
3896  * - \ref SCIP_STAGE_PROBLEM
3897  */
3898 extern
3900  SCIP* scip, /**< SCIP data structure */
3901  const char* name, /**< name of concurrent_solver */
3902  SCIP_Real prefpriodefault, /**< the default preferred priority of this concurrent solver type */
3903  SCIP_DECL_CONCSOLVERCREATEINST ((*concsolvercreateinst)), /**< data copy method of concurrent solver */
3904  SCIP_DECL_CONCSOLVERDESTROYINST ((*concsolverdestroyinst)), /**< data copy method of concurrent solver */
3905  SCIP_DECL_CONCSOLVERINITSEEDS ((*concsolverinitseeds)), /**< initialize random seeds of concurrent solver */
3906  SCIP_DECL_CONCSOLVEREXEC ((*concsolverexec)), /**< execution method of concurrent solver */
3907  SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA ((*concsolvercopysolvdata)),/**< method to copy solving data */
3908  SCIP_DECL_CONCSOLVERSTOP ((*concsolverstop)), /**< terminate solving in concurrent solver */
3909  SCIP_DECL_CONCSOLVERSYNCWRITE ((*concsolversyncwrite)), /**< synchronization method of concurrent solver */
3910  SCIP_DECL_CONCSOLVERSYNCREAD ((*concsolversyncread)), /**< synchronization method of concurrent solver */
3911  SCIP_DECL_CONCSOLVERTYPEFREEDATA ((*concsolvertypefreedata)),/**< method to free data of concurrent solver type */
3912  SCIP_CONCSOLVERTYPEDATA* data /**< the concurent solver type's data */
3913  );
3914 
3915 /** returns the concurrent solver type with the given name, or NULL if not existing */
3916 extern
3918  SCIP* scip, /**< SCIP data structure */
3919  const char* name /**< name of concurrent_solver */
3920  );
3921 
3922 /** returns the array of included concurrent solver types */
3923 extern
3925  SCIP* scip /**< SCIP data structure */
3926  );
3927 
3928 /** returns the number of included concurrent solver types */
3929 extern
3931  SCIP* scip /**< SCIP data structure */
3932  );
3933 
3934 /* @} */
3935 
3936 /**@addtogroup PublicHeuristicMethods
3937  *
3938  * @{
3939  */
3940 
3941 /** creates a primal heuristic and includes it in SCIP.
3942  *
3943  * @note method has all heuristic callbacks as arguments and is thus changed every time a new
3944  * callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions
3945  * if you seek for a method which is less likely to change in future releases
3946  *
3947  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3948  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3949  *
3950  * @pre This method can be called if @p scip is in one of the following stages:
3951  * - \ref SCIP_STAGE_INIT
3952  * - \ref SCIP_STAGE_PROBLEM
3953  */
3954 extern
3956  SCIP* scip, /**< SCIP data structure */
3957  const char* name, /**< name of primal heuristic */
3958  const char* desc, /**< description of primal heuristic */
3959  char dispchar, /**< display character of primal heuristic */
3960  int priority, /**< priority of the primal heuristic */
3961  int freq, /**< frequency for calling primal heuristic */
3962  int freqofs, /**< frequency offset for calling primal heuristic */
3963  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3964  SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
3965  * see definition of SCIP_HEURTIMING for possible values */
3966  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3967  SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
3968  SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
3969  SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
3970  SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
3971  SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
3972  SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
3973  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
3974  SCIP_HEURDATA* heurdata /**< primal heuristic data */
3975  );
3976 
3977 /** creates a primal heuristic and includes it in SCIP with its most fundamental callbacks.
3978  * All non-fundamental (or optional) callbacks
3979  * as, e. g., init and exit callbacks, will be set to NULL.
3980  * Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(),
3981  * SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
3982  *
3983 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead
3984  */
3985 extern
3987  SCIP* scip, /**< SCIP data structure */
3988  SCIP_HEUR** heur, /**< pointer to the heuristic */
3989  const char* name, /**< name of primal heuristic */
3990  const char* desc, /**< description of primal heuristic */
3991  char dispchar, /**< display character of primal heuristic */
3992  int priority, /**< priority of the primal heuristic */
3993  int freq, /**< frequency for calling primal heuristic */
3994  int freqofs, /**< frequency offset for calling primal heuristic */
3995  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3996  SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
3997  * see definition of SCIP_HEURTIMING for possible values */
3998  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3999  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
4000  SCIP_HEURDATA* heurdata /**< primal heuristic data */
4001  );
4002 
4003 /** sets copy method of primal heuristic */
4004 extern
4006  SCIP* scip, /**< SCIP data structure */
4007  SCIP_HEUR* heur, /**< primal heuristic */
4008  SCIP_DECL_HEURCOPY ((*heurcopy)) /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
4009  );
4010 
4011 /** sets destructor method of primal heuristic */
4012 extern
4014  SCIP* scip, /**< SCIP data structure */
4015  SCIP_HEUR* heur, /**< primal heuristic */
4016  SCIP_DECL_HEURFREE ((*heurfree)) /**< destructor of primal heuristic */
4017  );
4018 
4019 /** sets initialization method of primal heuristic */
4020 extern
4022  SCIP* scip, /**< SCIP data structure */
4023  SCIP_HEUR* heur, /**< primal heuristic */
4024  SCIP_DECL_HEURINIT ((*heurinit)) /**< initialize primal heuristic */
4025  );
4026 
4027 /** sets deinitialization method of primal heuristic */
4028 extern
4030  SCIP* scip, /**< SCIP data structure */
4031  SCIP_HEUR* heur, /**< primal heuristic */
4032  SCIP_DECL_HEUREXIT ((*heurexit)) /**< deinitialize primal heuristic */
4033  );
4034 
4035 /** sets solving process initialization method of primal heuristic */
4036 extern
4038  SCIP* scip, /**< SCIP data structure */
4039  SCIP_HEUR* heur, /**< primal heuristic */
4040  SCIP_DECL_HEURINITSOL ((*heurinitsol)) /**< solving process initialization method of primal heuristic */
4041  );
4042 
4043 /** sets solving process deinitialization method of primal heuristic */
4044 extern
4046  SCIP* scip, /**< SCIP data structure */
4047  SCIP_HEUR* heur, /**< primal heuristic */
4048  SCIP_DECL_HEUREXITSOL ((*heurexitsol)) /**< solving process deinitialization method of primal heuristic */
4049  );
4050 
4051 /** returns the primal heuristic of the given name, or NULL if not existing */
4052 extern
4054  SCIP* scip, /**< SCIP data structure */
4055  const char* name /**< name of primal heuristic */
4056  );
4057 
4058 /** returns the array of currently available primal heuristics */
4059 extern
4061  SCIP* scip /**< SCIP data structure */
4062  );
4063 
4064 /** returns the number of currently available primal heuristics */
4065 extern
4066 int SCIPgetNHeurs(
4067  SCIP* scip /**< SCIP data structure */
4068  );
4069 
4070 /** sets the priority of a primal heuristic */
4071 extern
4073  SCIP* scip, /**< SCIP data structure */
4074  SCIP_HEUR* heur, /**< primal heuristic */
4075  int priority /**< new priority of the primal heuristic */
4076  );
4077 
4078 /* @} */
4079 
4080 /**@addtogroup PublicCompressionMethods
4081  *
4082  * @{
4083  */
4084 /** creates a tree compression and includes it in SCIP.
4085  *
4086  * @note method has all compression callbacks as arguments and is thus changed every time a new
4087  * callback is added in future releases; consider using SCIPincludeComprBasic() and setter functions
4088  * if you seek for a method which is less likely to change in future releases
4089  */
4090 extern
4092  SCIP* scip, /**< SCIP data structure */
4093  const char* name, /**< name of tree compression */
4094  const char* desc, /**< description of tree compression */
4095  int priority, /**< priority of the tree compression */
4096  int minnnodes, /**< minimal number of nodes to call compression */
4097  SCIP_DECL_COMPRCOPY ((*comprcopy)), /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
4098  SCIP_DECL_COMPRFREE ((*comprfree)), /**< destructor of tree compression */
4099  SCIP_DECL_COMPRINIT ((*comprinit)), /**< initialize tree compression */
4100  SCIP_DECL_COMPREXIT ((*comprexit)), /**< deinitialize tree compression */
4101  SCIP_DECL_COMPRINITSOL ((*comprinitsol)), /**< solving process initialization method of tree compression */
4102  SCIP_DECL_COMPREXITSOL ((*comprexitsol)), /**< solving process deinitialization method of tree compression */
4103  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
4104  SCIP_COMPRDATA* comprdata /**< tree compression data */
4105  );
4106 
4107 /** creates a tree compression and includes it in SCIP with its most fundamental callbacks.
4108  * All non-fundamental (or optional) callbacks
4109  * as, e. g., init and exit callbacks, will be set to NULL.
4110  * Optional callbacks can be set via specific setter functions, see SCIPsetComprCopy(), SCIPsetComprFree(),
4111  * SCIPsetComprInit(), SCIPsetComprExit(), SCIPsetComprInitsol(), and SCIPsetComprExitsol()
4112  *
4113  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeCompr() instead
4114  */
4115 extern
4117  SCIP* scip, /**< SCIP data structure */
4118  SCIP_COMPR** compr, /**< pointer to tree compression */
4119  const char* name, /**< name of tree compression */
4120  const char* desc, /**< description of tree compression */
4121  int priority, /**< priority of the tree compression */
4122  int minnnodes, /**< minimal number of nodes to call the compression */
4123  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
4124  SCIP_COMPRDATA* comprdata /**< tree compression data */
4125  );
4126 
4127 /** sets copy method of tree compression */
4128 extern
4130  SCIP* scip, /**< SCIP data structure */
4131  SCIP_COMPR* compr, /**< tree compression */
4132  SCIP_DECL_COMPRCOPY ((*comprcopy)) /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
4133  );
4134 
4135 /** sets destructor method of tree compression */
4136 extern
4138  SCIP* scip, /**< SCIP data structure */
4139  SCIP_COMPR* compr, /**< tree compression */
4140  SCIP_DECL_COMPRFREE ((*comprfree)) /**< destructor of tree compression */
4141  );
4142 
4143 /** sets initialization method of tree compression */
4144 extern
4146  SCIP* scip, /**< SCIP data structure */
4147  SCIP_COMPR* compr, /**< tree compression */
4148  SCIP_DECL_COMPRINIT ((*comprinit)) /**< initialize tree compression */
4149  );
4150 
4151 /** sets deinitialization method of tree compression */
4152 extern
4154  SCIP* scip, /**< SCIP data structure */
4155  SCIP_COMPR* compr, /**< tree compression */
4156  SCIP_DECL_COMPREXIT ((*comprexit)) /**< deinitialize tree compression */
4157  );
4158 
4159 /** sets solving process initialization method of tree compression */
4160 extern
4162  SCIP* scip, /**< SCIP data structure */
4163  SCIP_COMPR* compr, /**< tree compression */
4164  SCIP_DECL_COMPRINITSOL ((*comprinitsol)) /**< solving process initialization method of tree compression */
4165  );
4166 
4167 /** sets solving process deinitialization method of tree compression */
4168 extern
4170  SCIP* scip, /**< SCIP data structure */
4171  SCIP_COMPR* compr, /**< tree compression */
4172  SCIP_DECL_COMPREXITSOL ((*comprexitsol)) /**< solving process deinitialization method of tree compression */
4173  );
4174 
4175 /** returns the tree compression of the given name, or NULL if not existing */
4176 extern
4178  SCIP* scip, /**< SCIP data structure */
4179  const char* name /**< name of tree compression */
4180  );
4181 
4182 /** returns the array of currently available tree compression */
4183 extern
4185  SCIP* scip /**< SCIP data structure */
4186  );
4187 
4188 /** returns the number of currently available tree compression */
4189 extern
4190 int SCIPgetNCompr(
4191  SCIP* scip /**< SCIP data structure */
4192  );
4193 
4194 /** set the priority of a tree compression method */
4196  SCIP* scip, /**< SCIP data structure */
4197  SCIP_COMPR* compr, /**< compression */
4198  int priority /**< new priority of the tree compression */
4199  );
4200 
4201 /* @} */
4202 
4203 /**@addtogroup PublicDivesetMethods
4204  *
4205  * @{
4206  */
4207 
4208 /** create a diving set associated with a primal heuristic. The primal heuristic needs to be included
4209  * before this method can be called. The diveset is installed in the array of divesets of the heuristic
4210  * and can be retrieved later by accessing SCIPheurGetDivesets()
4211  *
4212  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4213  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4214  *
4215  * @pre This method can be called if @p scip is in one of the following stages:
4216  * - \ref SCIP_STAGE_INIT
4217  * - \ref SCIP_STAGE_PROBLEM
4218  */
4219 extern
4221  SCIP* scip, /**< SCIP data structure */
4222  SCIP_DIVESET** diveset, /**< pointer to created diving heuristic settings, or NULL if not needed */
4223  SCIP_HEUR* heur, /**< primal heuristic to which the diveset belongs */
4224  const char* name, /**< name for the diveset, or NULL if the name of the heuristic should be used */
4225  SCIP_Real minreldepth, /**< minimal relative depth to start diving */
4226  SCIP_Real maxreldepth, /**< maximal relative depth to start diving */
4227  SCIP_Real maxlpiterquot, /**< maximal fraction of diving LP iterations compared to node LP iterations */
4228  SCIP_Real maxdiveubquot, /**< maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound)
4229  * where diving is performed (0.0: no limit) */
4230  SCIP_Real maxdiveavgquot, /**< maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound)
4231  * where diving is performed (0.0: no limit) */
4232  SCIP_Real maxdiveubquotnosol, /**< maximal UBQUOT when no solution was found yet (0.0: no limit) */
4233  SCIP_Real maxdiveavgquotnosol,/**< maximal AVGQUOT when no solution was found yet (0.0: no limit) */
4234  SCIP_Real lpresolvedomchgquot,/**< percentage of immediate domain changes during probing to trigger LP resolve */
4235  int lpsolvefreq, /**< LP solve frequency for (0: only if enough domain reductions are found by propagation)*/
4236  int maxlpiterofs, /**< additional number of allowed LP iterations */
4237  unsigned int initialseed, /**< initial seed for random number generation */
4238  SCIP_Bool backtrack, /**< use one level of backtracking if infeasibility is encountered? */
4239  SCIP_Bool onlylpbranchcands, /**< should only LP branching candidates be considered instead of the slower but
4240  * more general constraint handler diving variable selection? */
4241  SCIP_Bool specificsos1score, /**< should SOS1 variables be scored by the diving heuristics specific score function;
4242  * otherwise use the score function of the SOS1 constraint handler */
4243  SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)) /**< method for candidate score and rounding direction */
4244 
4245  );
4246 
4247 /* @} */
4248 
4249 /**@addtogroup PublicEventHandlerMethods
4250  *
4251  * @{
4252  */
4253 
4254 /** creates an event handler and includes it in SCIP
4255  *
4256  * @note method has all event handler callbacks as arguments and is thus changed every time a new
4257  * callback is added in future releases; consider using SCIPincludeEventhdlrBasic() and setter functions
4258  * if you seek for a method which is less likely to change in future releases
4259  */
4260 extern
4262  SCIP* scip, /**< SCIP data structure */
4263  const char* name, /**< name of event handler */
4264  const char* desc, /**< description of event handler */
4265  SCIP_DECL_EVENTCOPY ((*eventcopy)), /**< copy method of event handler or NULL if you don't want to copy your plugin into sub-SCIPs */
4266  SCIP_DECL_EVENTFREE ((*eventfree)), /**< destructor of event handler */
4267  SCIP_DECL_EVENTINIT ((*eventinit)), /**< initialize event handler */
4268  SCIP_DECL_EVENTEXIT ((*eventexit)), /**< deinitialize event handler */
4269  SCIP_DECL_EVENTINITSOL((*eventinitsol)), /**< solving process initialization method of event handler */
4270  SCIP_DECL_EVENTEXITSOL((*eventexitsol)), /**< solving process deinitialization method of event handler */
4271  SCIP_DECL_EVENTDELETE ((*eventdelete)), /**< free specific event data */
4272  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
4273  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
4274  );
4275 
4276 /** creates an event handler and includes it in SCIP with all its non-fundamental callbacks set
4277  * to NULL; if needed, non-fundamental callbacks can be set afterwards via setter functions
4278  * SCIPsetEventhdlrCopy(), SCIPsetEventhdlrFree(), SCIPsetEventhdlrInit(), SCIPsetEventhdlrExit(),
4279  * SCIPsetEventhdlrInitsol(), SCIPsetEventhdlrExitsol(), and SCIPsetEventhdlrDelete()
4280  *
4281  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeEventhdlr() instead
4282  */
4283 extern
4285  SCIP* scip, /**< SCIP data structure */
4286  SCIP_EVENTHDLR** eventhdlrptr, /**< reference to an event handler, or NULL */
4287  const char* name, /**< name of event handler */
4288  const char* desc, /**< description of event handler */
4289  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
4290  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
4291  );
4292 
4293 /** sets copy callback of the event handler */
4294 extern
4296  SCIP* scip, /**< scip instance */
4297  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4298  SCIP_DECL_EVENTCOPY ((*eventcopy)) /**< copy callback of the event handler */
4299  );
4300 
4301 /** sets deinitialization callback of the event handler */
4302 extern
4304  SCIP* scip, /**< scip instance */
4305  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4306  SCIP_DECL_EVENTFREE ((*eventfree)) /**< deinitialization callback of the event handler */
4307  );
4308 
4309 /** sets initialization callback of the event handler */
4310 extern
4312  SCIP* scip, /**< scip instance */
4313  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4314  SCIP_DECL_EVENTINIT ((*eventinit)) /**< initialize event handler */
4315  );
4316 
4317 /** sets deinitialization callback of the event handler */
4318 extern
4320  SCIP* scip, /**< scip instance */
4321  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4322  SCIP_DECL_EVENTEXIT ((*eventexit)) /**< deinitialize event handler */
4323  );
4324 
4325 /** sets solving process initialization callback of the event handler */
4326 extern
4328  SCIP* scip, /**< scip instance */
4329  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4330  SCIP_DECL_EVENTINITSOL((*eventinitsol)) /**< solving process initialization callback of event handler */
4331  );
4332 
4333 /** sets solving process deinitialization callback of the event handler */
4334 extern
4336  SCIP* scip, /**< scip instance */
4337  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4338  SCIP_DECL_EVENTEXITSOL((*eventexitsol)) /**< solving process deinitialization callback of event handler */
4339  );
4340 
4341 /** sets callback of the event handler to free specific event data */
4342 extern
4344  SCIP* scip, /**< scip instance */
4345  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4346  SCIP_DECL_EVENTDELETE ((*eventdelete)) /**< free specific event data */
4347  );
4348 
4349 /** returns the event handler of the given name, or NULL if not existing */
4350 extern
4352  SCIP* scip, /**< SCIP data structure */
4353  const char* name /**< name of event handler */
4354  );
4355 
4356 /** returns the array of currently available event handlers */
4357 extern
4359  SCIP* scip /**< SCIP data structure */
4360  );
4361 
4362 /** returns the number of currently available event handlers */
4363 extern
4364 int SCIPgetNEventhdlrs(
4365  SCIP* scip /**< SCIP data structure */
4366  );
4367 
4368 /* @} */
4369 
4370 /**@addtogroup PublicNodeSelectorMethods
4371  *
4372  * @{
4373  */
4374 
4375 /** creates a node selector and includes it in SCIP.
4376  *
4377  * @note method has all node selector callbacks as arguments and is thus changed every time a new
4378  * callback is added in future releases; consider using SCIPincludeNodeselBasic() and setter functions
4379  * if you seek for a method which is less likely to change in future releases
4380  */
4381 extern
4383  SCIP* scip, /**< SCIP data structure */
4384  const char* name, /**< name of node selector */
4385  const char* desc, /**< description of node selector */
4386  int stdpriority, /**< priority of the node selector in standard mode */
4387  int memsavepriority, /**< priority of the node selector in memory saving mode */
4388  SCIP_DECL_NODESELCOPY ((*nodeselcopy)), /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
4389  SCIP_DECL_NODESELFREE ((*nodeselfree)), /**< destructor of node selector */
4390  SCIP_DECL_NODESELINIT ((*nodeselinit)), /**< initialize node selector */
4391  SCIP_DECL_NODESELEXIT ((*nodeselexit)), /**< deinitialize node selector */
4392  SCIP_DECL_NODESELINITSOL((*nodeselinitsol)),/**< solving process initialization method of node selector */
4393  SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)),/**< solving process deinitialization method of node selector */
4394  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
4395  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
4396  SCIP_NODESELDATA* nodeseldata /**< node selector data */
4397  );
4398 
4399 /** Creates a node selector and includes it in SCIP with its most fundamental callbacks. All non-fundamental
4400  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
4401  * Optional callbacks can be set via specific setter functions, see SCIPsetNodeselCopy(), SCIPsetNodeselFree(),
4402  * SCIPsetNodeselInit(), SCIPsetNodeselExit(), SCIPsetNodeselInitsol(), and SCIPsetNodeselExitsol()
4403  *
4404  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeNodesel() instead
4405  */
4406 extern
4408  SCIP* scip, /**< SCIP data structure */
4409  SCIP_NODESEL** nodesel, /**< reference to a node selector, or NULL */
4410  const char* name, /**< name of node selector */
4411  const char* desc, /**< description of node selector */
4412  int stdpriority, /**< priority of the node selector in standard mode */
4413  int memsavepriority, /**< priority of the node selector in memory saving mode */
4414  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
4415  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
4416  SCIP_NODESELDATA* nodeseldata /**< node selector data */
4417  );
4418 
4419 /** sets copy method of node selector */
4420 extern
4422  SCIP* scip, /**< SCIP data structure */
4423  SCIP_NODESEL* nodesel, /**< node selector */
4424  SCIP_DECL_NODESELCOPY ((*nodeselcopy)) /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
4425  );
4426 
4427 /** sets destructor method of node selector */
4428 extern
4430  SCIP* scip, /**< SCIP data structure */
4431  SCIP_NODESEL* nodesel, /**< node selector */
4432  SCIP_DECL_NODESELFREE ((*nodeselfree)) /**< destructor of node selector */
4433  );
4434 
4435 /** sets initialization method of node selector */
4436 extern
4438  SCIP* scip, /**< SCIP data structure */
4439  SCIP_NODESEL* nodesel, /**< node selector */
4440  SCIP_DECL_NODESELINIT ((*nodeselinit)) /**< initialize node selector */
4441  );
4442 
4443 /** sets deinitialization method of node selector */
4444 extern
4446  SCIP* scip, /**< SCIP data structure */
4447  SCIP_NODESEL* nodesel, /**< node selector */
4448  SCIP_DECL_NODESELEXIT ((*nodeselexit)) /**< deinitialize node selector */
4449  );
4450 
4451 /** sets solving process initialization method of node selector */
4452 extern
4454  SCIP* scip, /**< SCIP data structure */
4455  SCIP_NODESEL* nodesel, /**< node selector */
4456  SCIP_DECL_NODESELINITSOL ((*nodeselinitsol))/**< solving process initialization method of node selector */
4457  );
4458 
4459 /** sets solving process deinitialization method of node selector */
4460 extern
4462  SCIP* scip, /**< SCIP data structure */
4463  SCIP_NODESEL* nodesel, /**< node selector */
4464  SCIP_DECL_NODESELEXITSOL ((*nodeselexitsol))/**< solving process deinitialization method of node selector */
4465  );
4466 
4467 /** returns the node selector of the given name, or NULL if not existing */
4468 extern
4470  SCIP* scip, /**< SCIP data structure */
4471  const char* name /**< name of node selector */
4472  );
4473 
4474 /** returns the array of currently available node selectors */
4475 extern
4477  SCIP* scip /**< SCIP data structure */
4478  );
4479 
4480 /** returns the number of currently available node selectors */
4481 extern
4482 int SCIPgetNNodesels(
4483  SCIP* scip /**< SCIP data structure */
4484  );
4485 
4486 /** sets the priority of a node selector in standard mode */
4487 extern
4489  SCIP* scip, /**< SCIP data structure */
4490  SCIP_NODESEL* nodesel, /**< node selector */
4491  int priority /**< new standard priority of the node selector */
4492  );
4493 
4494 /** sets the priority of a node selector in memory saving mode */
4495 extern
4497  SCIP* scip, /**< SCIP data structure */
4498  SCIP_NODESEL* nodesel, /**< node selector */
4499  int priority /**< new memory saving priority of the node selector */
4500  );
4501 
4502 /** returns the currently used node selector */
4503 extern
4505  SCIP* scip /**< SCIP data structure */
4506  );
4507 
4508 /* @} */
4509 
4510 /**@addtogroup PublicBranchRuleMethods
4511  *
4512  * @{
4513  */
4514 
4515 /** creates a branching rule and includes it in SCIP
4516  *
4517  * @note method has all branching rule callbacks as arguments and is thus changed every time a new
4518  * callback is added in future releases; consider using SCIPincludeBranchruleBasic() and setter functions
4519  * if you seek for a method which is less likely to change in future releases
4520  */
4521 extern
4523  SCIP* scip, /**< SCIP data structure */
4524  const char* name, /**< name of branching rule */
4525  const char* desc, /**< description of branching rule */
4526  int priority, /**< priority of the branching rule */
4527  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
4528  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
4529  * compared to best node's dual bound for applying branching rule
4530  * (0.0: only on current best node, 1.0: on all nodes) */
4531  SCIP_DECL_BRANCHCOPY ((*branchcopy)), /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
4532  SCIP_DECL_BRANCHFREE ((*branchfree)), /**< destructor of branching rule */
4533  SCIP_DECL_BRANCHINIT ((*branchinit)), /**< initialize branching rule */
4534  SCIP_DECL_BRANCHEXIT ((*branchexit)), /**< deinitialize branching rule */
4535  SCIP_DECL_BRANCHINITSOL((*branchinitsol)),/**< solving process initialization method of branching rule */
4536  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)),/**< solving process deinitialization method of branching rule */
4537  SCIP_DECL_BRANCHEXECLP((*branchexeclp)), /**< branching execution method for fractional LP solutions */
4538  SCIP_DECL_BRANCHEXECEXT((*branchexecext)),/**< branching execution method for external candidates */
4539  SCIP_DECL_BRANCHEXECPS((*branchexecps)), /**< branching execution method for not completely fixed pseudo solutions */
4540  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
4541  );
4542 
4543 /** creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
4544  * Optional callbacks can be set via specific setter functions, see SCIPsetBranchruleInit(), SCIPsetBranchruleExit(),
4545  * SCIPsetBranchruleCopy(), SCIPsetBranchruleFree(), SCIPsetBranchruleInitsol(), SCIPsetBranchruleExitsol(),
4546  * SCIPsetBranchruleExecLp(), SCIPsetBranchruleExecExt(), and SCIPsetBranchruleExecPs().
4547  *
4548  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeBranchrule() instead
4549  */
4550 extern
4552  SCIP* scip, /**< SCIP data structure */
4553  SCIP_BRANCHRULE** branchruleptr, /**< pointer to branching rule, or NULL */
4554  const char* name, /**< name of branching rule */
4555  const char* desc, /**< description of branching rule */
4556  int priority, /**< priority of the branching rule */
4557  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
4558  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
4559  * compared to best node's dual bound for applying branching rule
4560  * (0.0: only on current best node, 1.0: on all nodes) */
4561  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
4562  );
4563 
4564 /** sets copy method of branching rule */
4565 extern
4567  SCIP* scip, /**< SCIP data structure */
4568  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4569  SCIP_DECL_BRANCHCOPY ((*branchcopy)) /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
4570  );
4571 
4572 /** sets destructor method of branching rule */
4573 extern
4575  SCIP* scip, /**< SCIP data structure */
4576  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4577  SCIP_DECL_BRANCHFREE ((*branchfree)) /**< destructor of branching rule */
4578  );
4579 
4580 /** sets initialization method of branching rule */
4581 extern
4583  SCIP* scip, /**< SCIP data structure */
4584  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4585  SCIP_DECL_BRANCHINIT ((*branchinit)) /**< initialize branching rule */
4586  );
4587 
4588 /** sets deinitialization method of branching rule */
4589 extern
4591  SCIP* scip, /**< SCIP data structure */
4592  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4593  SCIP_DECL_BRANCHEXIT ((*branchexit)) /**< deinitialize branching rule */
4594  );
4595 
4596 /** sets solving process initialization method of branching rule */
4597 extern
4599  SCIP* scip, /**< SCIP data structure */
4600  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4601  SCIP_DECL_BRANCHINITSOL((*branchinitsol)) /**< solving process initialization method of branching rule */
4602  );
4603 
4604 /** sets solving process deinitialization method of branching rule */
4605 extern
4607  SCIP* scip, /**< SCIP data structure */
4608  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4609  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)) /**< solving process deinitialization method of branching rule */
4610  );
4611 
4612 /** sets branching execution method for fractional LP solutions */
4613 extern
4615  SCIP* scip, /**< SCIP data structure */
4616  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4617  SCIP_DECL_BRANCHEXECLP((*branchexeclp)) /**< branching execution method for fractional LP solutions */
4618  );
4619 
4620 /** sets branching execution method for external candidates */
4621 extern
4623  SCIP* scip, /**< SCIP data structure */
4624  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4625  SCIP_DECL_BRANCHEXECEXT((*branchexecext)) /**< branching execution method for external candidates */
4626  );
4627 
4628 /** sets branching execution method for not completely fixed pseudo solutions */
4629 extern
4631  SCIP* scip, /**< SCIP data structure */
4632  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4633  SCIP_DECL_BRANCHEXECPS((*branchexecps)) /**< branching execution method for not completely fixed pseudo solutions */
4634  );
4635 
4636 /** returns the branching rule of the given name, or NULL if not existing */
4637 extern
4639  SCIP* scip, /**< SCIP data structure */
4640  const char* name /**< name of branching rule */
4641  );
4642 
4643 /** returns the array of currently available branching rules */
4644 extern
4646  SCIP* scip /**< SCIP data structure */
4647  );
4648 
4649 /** returns the number of currently available branching rules */
4650 extern
4652  SCIP* scip /**< SCIP data structure */
4653  );
4654 
4655 /** sets the priority of a branching rule */
4656 extern
4658  SCIP* scip, /**< SCIP data structure */
4659  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4660  int priority /**< new priority of the branching rule */
4661  );
4662 
4663 /** sets maximal depth level, up to which this branching rule should be used (-1 for no limit) */
4664 extern
4666  SCIP* scip, /**< SCIP data structure */
4667  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4668  int maxdepth /**< new maxdepth of the branching rule */
4669  );
4670 
4671 /** sets maximal relative distance from current node's dual bound to primal bound for applying branching rule */
4672 extern
4674  SCIP* scip, /**< SCIP data structure */
4675  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4676  SCIP_Real maxbounddist /**< new maxbounddist of the branching rule */
4677  );
4678 
4679 /* @} */
4680 
4681 /**@addtogroup PublicDisplayMethods
4682  *
4683  * @{
4684  */
4685 
4686 /** creates a display column and includes it in SCIP */
4687 extern
4689  SCIP* scip, /**< SCIP data structure */
4690  const char* name, /**< name of display column */
4691  const char* desc, /**< description of display column */
4692  const char* header, /**< head line of display column */
4693  SCIP_DISPSTATUS dispstatus, /**< display activation status of display column */
4694  SCIP_DECL_DISPCOPY ((*dispcopy)), /**< copy method of display column or NULL if you don't want to copy your plugin into sub-SCIPs */
4695  SCIP_DECL_DISPFREE ((*dispfree)), /**< destructor of display column */
4696  SCIP_DECL_DISPINIT ((*dispinit)), /**< initialize display column */
4697  SCIP_DECL_DISPEXIT ((*dispexit)), /**< deinitialize display column */
4698  SCIP_DECL_DISPINITSOL ((*dispinitsol)), /**< solving process initialization method of display column */
4699  SCIP_DECL_DISPEXITSOL ((*dispexitsol)), /**< solving process deinitialization method of display column */
4700  SCIP_DECL_DISPOUTPUT ((*dispoutput)), /**< output method */
4701  SCIP_DISPDATA* dispdata, /**< display column data */
4702  int width, /**< width of display column (no. of chars used) */
4703  int priority, /**< priority of display column */
4704  int position, /**< relative position of display column */
4705  SCIP_Bool stripline /**< should the column be separated with a line from its right neighbor? */
4706  );
4707 
4708 /** returns the display column of the given name, or NULL if not existing */
4709 extern
4711  SCIP* scip, /**< SCIP data structure */
4712  const char* name /**< name of display column */
4713  );
4714 
4715 /** returns the array of currently available display columns */
4716 extern
4718  SCIP* scip /**< SCIP data structure */
4719  );
4720 
4721 /** returns the number of currently available display columns */
4722 extern
4723 int SCIPgetNDisps(
4724  SCIP* scip /**< SCIP data structure */
4725  );
4726 
4727 /** automatically selects display columns for being shown w.r.t. the display width parameter */
4728 extern
4730  SCIP* scip /**< SCIP data structure */
4731  );
4732 
4733 /** changes the display column mode */
4734 extern
4735 void SCIPchgDispMode(
4736  SCIP_DISP* disp, /**< display column */
4737  SCIP_DISPMODE mode /**< the display column mode */
4738  );
4739 
4740 /* @} */
4741 
4742 /**@addtogroup PublicNLPInterfaceMethods
4743  *
4744  * @{
4745  */
4746 
4747 /** includes an NLPI in SCIP */
4748 extern
4750  SCIP* scip, /**< SCIP data structure */
4751  SCIP_NLPI* nlpi /**< NLPI data structure */
4752  );
4753 
4754 /** returns the NLPI of the given name, or NULL if not existing */
4755 extern
4757  SCIP* scip, /**< SCIP data structure */
4758  const char* name /**< name of NLPI */
4759  );
4760 
4761 /** returns the array of currently available NLPIs (sorted by priority) */
4762 extern
4764  SCIP* scip /**< SCIP data structure */
4765  );
4766 
4767 /** returns the number of currently available NLPIs */
4768 extern
4769 int SCIPgetNNlpis(
4770  SCIP* scip /**< SCIP data structure */
4771  );
4772 
4773 /** sets the priority of an NLPI */
4774 extern
4776  SCIP* scip, /**< SCIP data structure */
4777  SCIP_NLPI* nlpi, /**< NLPI */
4778  int priority /**< new priority of the NLPI */
4779  );
4780 
4781 /* @} */
4782 
4783 /**@addtogroup PublicExternalCodeMethods
4784  *
4785  * @{
4786  */
4787 
4788 
4789 
4790 /** includes information about an external code linked into the SCIP library */
4791 extern
4793  SCIP* scip, /**< SCIP data structure */
4794  const char* name, /**< name of external code */
4795  const char* description /**< description of external code, or NULL */
4796  );
4797 
4798 /** returns an array of names of currently included external codes */
4799 extern
4801  SCIP* scip /**< SCIP data structure */
4802  );
4803 
4804 /** returns an array of the descriptions of currently included external codes
4805  *
4806  * @note some descriptions may be NULL
4807  */
4808 extern
4810  SCIP* scip /**< SCIP data structure */
4811  );
4812 
4813 /** returns the number of currently included information on external codes */
4814 extern
4816  SCIP* scip /**< SCIP data structure */
4817  );
4818 
4819 /** prints information on external codes to a file stream via the message handler system
4820  *
4821  * @note If the message handler is set to a NULL pointer nothing will be printed
4822  */
4823 extern
4825  SCIP* scip, /**< SCIP data structure */
4826  FILE* file /**< output file (or NULL for standard output) */
4827  );
4828 
4829 /* @} */
4830 
4831 /*
4832  * user interactive dialog methods
4833  */
4834 
4835 /**@addtogroup PublicDialogMethods
4836  *
4837  * @{
4838  */
4839 
4840 /** creates and includes dialog
4841  *
4842  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4843  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4844  */
4845 extern
4847  SCIP* scip, /**< SCIP data structure */
4848  SCIP_DIALOG** dialog, /**< pointer to store the dialog */
4849  SCIP_DECL_DIALOGCOPY ((*dialogcopy)), /**< copy method of dialog or NULL if you don't want to copy your plugin into sub-SCIPs */
4850  SCIP_DECL_DIALOGEXEC ((*dialogexec)), /**< execution method of dialog */
4851  SCIP_DECL_DIALOGDESC ((*dialogdesc)), /**< description output method of dialog, or NULL */
4852  SCIP_DECL_DIALOGFREE ((*dialogfree)), /**< destructor of dialog to free user data, or NULL */
4853  const char* name, /**< name of dialog: command name appearing in parent's dialog menu */
4854  const char* desc, /**< description of dialog used if description output method is NULL */
4855  SCIP_Bool issubmenu, /**< is the dialog a submenu? */
4856  SCIP_DIALOGDATA* dialogdata /**< user defined dialog data */
4857  );
4858 
4859 /** returns if the dialog already exists
4860  *
4861  * @return TRUE is returned if the dialog exists, otherwise FALSE.
4862  */
4863 extern
4865  SCIP* scip, /**< SCIP data structure */
4866  SCIP_DIALOG* dialog /**< dialog */
4867  );
4868 
4869 /** captures a dialog
4870  *
4871  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4872  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4873  */
4874 extern
4876  SCIP* scip, /**< SCIP data structure */
4877  SCIP_DIALOG* dialog /**< dialog */
4878  );
4879 
4880 /** releases a dialog
4881  *
4882  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4883  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4884  */
4885 extern
4887  SCIP* scip, /**< SCIP data structure */
4888  SCIP_DIALOG** dialog /**< pointer to the dialog */
4889  );
4890 
4891 /** makes given dialog the root dialog of SCIP's interactive user shell; captures dialog and releases former root dialog
4892  *
4893  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4894  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4895  */
4896 extern
4898  SCIP* scip, /**< SCIP data structure */
4899  SCIP_DIALOG* dialog /**< dialog to be the root */
4900  );
4901 
4902 /** returns the root dialog of SCIP's interactive user shell
4903  *
4904  * @return the root dialog of SCIP's interactive user shell is returned.
4905  */
4906 extern
4908  SCIP* scip /**< SCIP data structure */
4909  );
4910 
4911 /** adds a sub dialog to the given dialog as menu entry and captures it
4912  *
4913  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4914  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4915  */
4916 extern
4918  SCIP* scip, /**< SCIP data structure */
4919  SCIP_DIALOG* dialog, /**< dialog to extend, or NULL for root dialog */
4920  SCIP_DIALOG* subdialog /**< subdialog to add as menu entry in dialog */
4921  );
4922 
4923 /** adds a single line of input which is treated as if the user entered the command line
4924  *
4925  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4926  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4927  */
4928 extern
4930  SCIP* scip, /**< SCIP data structure */
4931  const char* inputline /**< input line to add */
4932  );
4933 
4934 /** adds a single line of input to the command history which can be accessed with the cursor keys
4935  *
4936  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4937  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4938  */
4939 extern
4941  SCIP* scip, /**< SCIP data structure */
4942  const char* inputline /**< input line to add */
4943  );
4944 
4945 /** starts interactive mode of SCIP by executing the root dialog
4946  *
4947  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4948  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4949  *
4950  * @pre This method can be called if @p scip is in one of the following stages:
4951  * - \ref SCIP_STAGE_INIT
4952  * - \ref SCIP_STAGE_FREE
4953  *
4954  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the
4955  * interactive shell was closed:
4956  * - \ref SCIP_STAGE_PROBLEM if the interactive shell was closed after the problem was created
4957  * - \ref SCIP_STAGE_TRANSFORMED if the interactive shell was closed after the problem was transformed
4958  * - \ref SCIP_STAGE_PRESOLVING if the interactive shell was closed during presolving
4959  * - \ref SCIP_STAGE_PRESOLVED if the interactive shell was closed after presolve
4960  * - \ref SCIP_STAGE_SOLVING if the interactive shell was closed during the tree search
4961  * - \ref SCIP_STAGE_SOLVED if the interactive shell was closed after the problem was solved
4962  * - \ref SCIP_STAGE_FREE if the interactive shell was closed after the problem was freed
4963  *
4964  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
4965  */
4966 extern
4968  SCIP* scip /**< SCIP data structure */
4969  );
4970 
4971 /**@} */
4972 
4973 /*
4974  * global problem methods
4975  */
4976 
4977 /**@addtogroup GlobalProblemMethods
4978  *
4979  * @{
4980  */
4981 
4982 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
4983  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
4984  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
4985  *
4986  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4987  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4988  *
4989  * @pre This method can be called if @p scip is in one of the following stages:
4990  * - \ref SCIP_STAGE_INIT
4991  * - \ref SCIP_STAGE_PROBLEM
4992  * - \ref SCIP_STAGE_TRANSFORMED
4993  * - \ref SCIP_STAGE_PRESOLVING
4994  * - \ref SCIP_STAGE_PRESOLVED
4995  * - \ref SCIP_STAGE_SOLVING
4996  * - \ref SCIP_STAGE_SOLVED
4997  * - \ref SCIP_STAGE_FREE
4998  *
4999  * @post After calling this method, \SCIP reaches the following stage:
5000  * - \ref SCIP_STAGE_PROBLEM
5001  */
5002 extern
5004  SCIP* scip, /**< SCIP data structure */
5005  const char* name, /**< problem name */
5006  SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
5007  SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
5008  SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
5009  SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
5010  SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
5011  SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
5012  SCIP_PROBDATA* probdata /**< user problem data set by the reader */
5013  );
5014 
5015 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
5016  * all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(),
5017  * SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and
5018  * SCIPsetProbCopy()
5019  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
5020  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
5021  *
5022  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5023  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5024  *
5025  * @pre This method can be called if @p scip is in one of the following stages:
5026  * - \ref SCIP_STAGE_INIT
5027  * - \ref SCIP_STAGE_PROBLEM
5028  * - \ref SCIP_STAGE_TRANSFORMED
5029  * - \ref SCIP_STAGE_PRESOLVING
5030  * - \ref SCIP_STAGE_PRESOLVED
5031  * - \ref SCIP_STAGE_SOLVING
5032  * - \ref SCIP_STAGE_SOLVED
5033  * - \ref SCIP_STAGE_FREE
5034  *
5035  * @post After calling this method, \SCIP reaches the following stage:
5036  * - \ref SCIP_STAGE_PROBLEM
5037  */
5038 extern
5040  SCIP* scip, /**< SCIP data structure */
5041  const char* name /**< problem name */
5042  );
5043 
5044 /** sets callback to free user data of original problem
5045  *
5046  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5047  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5048  *
5049  * @pre This method can be called if @p scip is in one of the following stages:
5050  * - \ref SCIP_STAGE_PROBLEM
5051  */
5053  SCIP* scip, /**< SCIP data structure */
5054  SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
5055  );
5056 
5057 /** sets callback to create user data of transformed problem by transforming original user data
5058  *
5059  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5060  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5061  *
5062  * @pre This method can be called if @p scip is in one of the following stages:
5063  * - \ref SCIP_STAGE_PROBLEM
5064  */
5065 extern
5067  SCIP* scip, /**< SCIP data structure */
5068  SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
5069  );
5070 
5071 /** sets callback to free user data of transformed problem
5072  *
5073  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5074  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5075  *
5076  * @pre This method can be called if @p scip is in one of the following stages:
5077  * - \ref SCIP_STAGE_PROBLEM
5078  */
5079 extern
5081  SCIP* scip, /**< SCIP data structure */
5082  SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
5083  );
5084 
5085 /** sets solving process initialization callback of transformed data
5086  *
5087  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5088  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5089  *
5090  * @pre This method can be called if @p scip is in one of the following stages:
5091  * - \ref SCIP_STAGE_PROBLEM
5092  */
5093 extern
5095  SCIP* scip, /**< SCIP data structure */
5096  SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization method of transformed data */
5097  );
5098 
5099 /** sets solving process deinitialization callback of transformed data
5100  *
5101  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5102  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5103  *
5104  * @pre This method can be called if @p scip is in one of the following stages:
5105  * - \ref SCIP_STAGE_PROBLEM
5106  */
5107 extern
5109  SCIP* scip, /**< SCIP data structure */
5110  SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization method of transformed data */
5111  );
5112 
5113 /** sets callback to copy user data to a subscip
5114  *
5115  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5116  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5117  *
5118  * @pre This method can be called if @p scip is in one of the following stages:
5119  * - \ref SCIP_STAGE_PROBLEM
5120  */
5121 extern
5123  SCIP* scip, /**< SCIP data structure */
5124  SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
5125  );
5126 
5127 /** reads problem from file and initializes all solving data structures
5128  *
5129  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5130  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5131  *
5132  * @pre This method can be called if @p scip is in one of the following stages:
5133  * - \ref SCIP_STAGE_INIT
5134  * - \ref SCIP_STAGE_PROBLEM
5135  * - \ref SCIP_STAGE_TRANSFORMED
5136  * - \ref SCIP_STAGE_INITPRESOLVE
5137  * - \ref SCIP_STAGE_PRESOLVING
5138  * - \ref SCIP_STAGE_EXITPRESOLVE
5139  * - \ref SCIP_STAGE_PRESOLVED
5140  * - \ref SCIP_STAGE_SOLVING
5141  * - \ref SCIP_STAGE_EXITSOLVE
5142  *
5143  * @post After the method was called, \SCIP is in one of the following stages:
5144  * - \ref SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
5145  * - \ref SCIP_STAGE_PROBLEM if the problem file was successfully read
5146  */
5147 extern
5149  SCIP* scip, /**< SCIP data structure */
5150  const char* filename, /**< problem file name */
5151  const char* extension /**< extension of the desired file reader,
5152  * or NULL if file extension should be used */
5153  );
5154 
5155 /** writes original problem to file
5156  *
5157  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5158  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5159  *
5160  * @pre This method can be called if @p scip is in one of the following stages:
5161  * - \ref SCIP_STAGE_PROBLEM
5162  * - \ref SCIP_STAGE_TRANSFORMING
5163  * - \ref SCIP_STAGE_TRANSFORMED
5164  * - \ref SCIP_STAGE_INITPRESOLVE
5165  * - \ref SCIP_STAGE_PRESOLVING
5166  * - \ref SCIP_STAGE_EXITPRESOLVE
5167  * - \ref SCIP_STAGE_PRESOLVED
5168  * - \ref SCIP_STAGE_INITSOLVE
5169  * - \ref SCIP_STAGE_SOLVING
5170  * - \ref SCIP_STAGE_SOLVED
5171  * - \ref SCIP_STAGE_EXITSOLVE
5172  * - \ref SCIP_STAGE_FREETRANS
5173  */
5174 extern
5176  SCIP* scip, /**< SCIP data structure */
5177  const char* filename, /**< output file (or NULL for standard output) */
5178  const char* extension, /**< extension of the desired file reader,
5179  * or NULL if file extension should be used */
5180  SCIP_Bool genericnames /**< use generic variable and constraint names? */
5181  );
5182 
5183 /** writes transformed problem which are valid in the current node to file
5184  *
5185  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5186  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5187  *
5188  * @pre This method can be called if @p scip is in one of the following stages:
5189  * - \ref SCIP_STAGE_TRANSFORMED
5190  * - \ref SCIP_STAGE_INITPRESOLVE
5191  * - \ref SCIP_STAGE_PRESOLVING
5192  * - \ref SCIP_STAGE_EXITPRESOLVE
5193  * - \ref SCIP_STAGE_PRESOLVED
5194  * - \ref SCIP_STAGE_INITSOLVE
5195  * - \ref SCIP_STAGE_SOLVING
5196  * - \ref SCIP_STAGE_SOLVED
5197  * - \ref SCIP_STAGE_EXITSOLVE
5198  *
5199  * @note If you want the write all constraints (including the once which are redundant for example), you need to set
5200  * the parameter <write/allconss> to TRUE
5201  */
5202 extern
5204  SCIP* scip, /**< SCIP data structure */
5205  const char* filename, /**< output file (or NULL for standard output) */
5206  const char* extension, /**< extension of the desired file reader,
5207  * or NULL if file extension should be used */
5208  SCIP_Bool genericnames /**< using generic variable and constraint names? */
5209  );
5210 
5211 /** frees problem and solution process data
5212  *
5213  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5214  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5215  *
5216  * @pre This method can be called if @p scip is in one of the following stages:
5217  * - \ref SCIP_STAGE_INIT
5218  * - \ref SCIP_STAGE_PROBLEM
5219  * - \ref SCIP_STAGE_TRANSFORMED
5220  * - \ref SCIP_STAGE_PRESOLVING
5221  * - \ref SCIP_STAGE_PRESOLVED
5222  * - \ref SCIP_STAGE_SOLVING
5223  * - \ref SCIP_STAGE_SOLVED
5224  * - \ref SCIP_STAGE_FREE
5225  *
5226  * @post After this method was called, SCIP is in the following stage:
5227  * - \ref SCIP_STAGE_INIT
5228  */
5229 extern
5231  SCIP* scip /**< SCIP data structure */
5232  );
5233 
5234 /** permutes parts of the problem data structure
5235  *
5236  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5237  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5238  *
5239  * @pre This method can be called if @p scip is in one of the following stages:
5240  * - \ref SCIP_STAGE_PROBLEM
5241  * - \ref SCIP_STAGE_TRANSFORMED
5242  */
5243 extern
5245  SCIP* scip, /**< SCIP data structure */
5246  unsigned int randseed, /**< seed value for random generator */
5247  SCIP_Bool permuteconss, /**< should the list of constraints in each constraint handler be permuted? */
5248  SCIP_Bool permutebinvars, /**< should the list of binary variables be permuted? */
5249  SCIP_Bool permuteintvars, /**< should the list of integer variables be permuted? */
5250  SCIP_Bool permuteimplvars, /**< should the list of implicit integer variables be permuted? */
5251  SCIP_Bool permutecontvars /**< should the list of continuous integer variables be permuted? */
5252  );
5253 
5254 /** gets user problem data
5255  *
5256  * @return a SCIP_PROBDATA pointer, or NULL if no problem data was allocated
5257  *
5258  * @pre This method can be called if @p scip is in one of the following stages:
5259  * - \ref SCIP_STAGE_PROBLEM
5260  * - \ref SCIP_STAGE_TRANSFORMING
5261  * - \ref SCIP_STAGE_TRANSFORMED
5262  * - \ref SCIP_STAGE_INITPRESOLVE
5263  * - \ref SCIP_STAGE_PRESOLVING
5264  * - \ref SCIP_STAGE_EXITPRESOLVE
5265  * - \ref SCIP_STAGE_PRESOLVED
5266  * - \ref SCIP_STAGE_INITSOLVE
5267  * - \ref SCIP_STAGE_SOLVING
5268  * - \ref SCIP_STAGE_SOLVED
5269  * - \ref SCIP_STAGE_EXITSOLVE
5270  * - \ref SCIP_STAGE_FREETRANS
5271  */
5272 extern
5274  SCIP* scip /**< SCIP data structure */
5275  );
5276 
5277 /** sets user problem data
5278  *
5279  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5280  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5281  *
5282  * @pre This method can be called if @p scip is in one of the following stages:
5283  * - \ref SCIP_STAGE_PROBLEM
5284  * - \ref SCIP_STAGE_TRANSFORMING
5285  * - \ref SCIP_STAGE_TRANSFORMED
5286  * - \ref SCIP_STAGE_INITPRESOLVE
5287  * - \ref SCIP_STAGE_PRESOLVING
5288  * - \ref SCIP_STAGE_EXITPRESOLVE
5289  * - \ref SCIP_STAGE_PRESOLVED
5290  * - \ref SCIP_STAGE_INITSOLVE
5291  * - \ref SCIP_STAGE_SOLVING
5292  * - \ref SCIP_STAGE_SOLVED
5293  * - \ref SCIP_STAGE_EXITSOLVE
5294  * - \ref SCIP_STAGE_FREETRANS
5295  */
5296 extern
5298  SCIP* scip, /**< SCIP data structure */
5299  SCIP_PROBDATA* probdata /**< user problem data to use */
5300  );
5301 
5302 /** returns name of the current problem instance
5303  *
5304  * @return name of the current problem instance
5305  *
5306  * @pre This method can be called if @p scip is in one of the following stages:
5307  * - \ref SCIP_STAGE_PROBLEM
5308  * - \ref SCIP_STAGE_TRANSFORMING
5309  * - \ref SCIP_STAGE_TRANSFORMED
5310  * - \ref SCIP_STAGE_INITPRESOLVE
5311  * - \ref SCIP_STAGE_PRESOLVING
5312  * - \ref SCIP_STAGE_EXITPRESOLVE
5313  * - \ref SCIP_STAGE_PRESOLVED
5314  * - \ref SCIP_STAGE_INITSOLVE
5315  * - \ref SCIP_STAGE_SOLVING
5316  * - \ref SCIP_STAGE_SOLVED
5317  * - \ref SCIP_STAGE_EXITSOLVE
5318  * - \ref SCIP_STAGE_FREETRANS
5319  */
5320 extern
5321 const char* SCIPgetProbName(
5322  SCIP* scip /**< SCIP data structure */
5323  );
5324 
5325 /** sets name of the current problem instance
5326  *
5327  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5328  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5329  *
5330  * @pre This method can be called if @p scip is in one of the following stages:
5331  * - \ref SCIP_STAGE_PROBLEM
5332  * - \ref SCIP_STAGE_TRANSFORMING
5333  * - \ref SCIP_STAGE_TRANSFORMED
5334  * - \ref SCIP_STAGE_INITPRESOLVE
5335  * - \ref SCIP_STAGE_PRESOLVING
5336  * - \ref SCIP_STAGE_EXITPRESOLVE
5337  * - \ref SCIP_STAGE_PRESOLVED
5338  * - \ref SCIP_STAGE_INITSOLVE
5339  * - \ref SCIP_STAGE_SOLVING
5340  * - \ref SCIP_STAGE_SOLVED
5341  * - \ref SCIP_STAGE_EXITSOLVE
5342  * - \ref SCIP_STAGE_FREETRANS
5343  */
5344 extern
5346  SCIP* scip, /**< SCIP data structure */
5347  const char* name /**< name to be set */
5348  );
5349 
5350 /** changes the objective function
5351  *
5352  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5353  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5354  *
5355  * @pre This method can be called if @p scip is in one of the following stages:
5356  * - \ref SCIP_STAGE_PROBLEM
5357  * - \ref SCIP_STAGE_PRESOLVED
5358  *
5359  * @note This method should be only used to change the objective function during two reoptimization runs and is only
5360  * recommended to an experienced user.
5361  *
5362  * @note All variables not given in \p vars array are assumed to have an objective coefficient of zero.
5363  */
5364 extern
5366  SCIP* scip, /**< SCIP data structure */
5367  SCIP_OBJSENSE objsense, /**< new objective function */
5368  SCIP_VAR** vars, /**< problem variables */
5369  SCIP_Real* coefs, /**< objective coefficients */
5370  int nvars /**< variables in vars array */
5371  );
5372 
5373 /** returns objective sense of original problem
5374  *
5375  * @return objective sense of original problem
5376  *
5377  * @pre This method can be called if @p scip is in one of the following stages:
5378  * - \ref SCIP_STAGE_PROBLEM
5379  * - \ref SCIP_STAGE_TRANSFORMING
5380  * - \ref SCIP_STAGE_TRANSFORMED
5381  * - \ref SCIP_STAGE_INITPRESOLVE
5382  * - \ref SCIP_STAGE_PRESOLVING
5383  * - \ref SCIP_STAGE_EXITPRESOLVE
5384  * - \ref SCIP_STAGE_PRESOLVED
5385  * - \ref SCIP_STAGE_INITSOLVE
5386  * - \ref SCIP_STAGE_SOLVING
5387  * - \ref SCIP_STAGE_SOLVED
5388  * - \ref SCIP_STAGE_EXITSOLVE
5389  * - \ref SCIP_STAGE_FREETRANS
5390  */
5391 extern
5393  SCIP* scip /**< SCIP data structure */
5394  );
5395 
5396 /** sets objective sense of problem
5397  *
5398  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5399  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5400  *
5401  * @pre This method can be called if @p scip is in one of the following stages:
5402  * - \ref SCIP_STAGE_PROBLEM
5403  */
5404 extern
5406  SCIP* scip, /**< SCIP data structure */
5407  SCIP_OBJSENSE objsense /**< new objective sense */
5408  );
5409 
5410 /** adds offset of objective function
5411  *
5412  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5413  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5414  *
5415  * @pre This method can be called if @p scip is in one of the following stages:
5416  * - \ref SCIP_STAGE_PRESOLVING
5417  */
5418 extern
5420  SCIP* scip, /**< SCIP data structure */
5421  SCIP_Real addval /**< value to add to objective offset */
5422  );
5423 
5424 /** adds offset of objective function to original problem and to all existing solution in original space
5425  *
5426  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5427  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5428  *
5429  * @pre This method can be called if @p scip is in one of the following stages:
5430  * - \ref SCIP_STAGE_PROBLEM
5431  */
5432 extern
5434  SCIP* scip, /**< SCIP data structure */
5435  SCIP_Real addval /**< value to add to objective offset */
5436  );
5437 
5438 /** returns the objective offset of the original problem
5439  *
5440  * @return the objective offset of the original problem
5441  *
5442  * @pre This method can be called if @p scip is in one of the following stages:
5443  * - \ref SCIP_STAGE_PROBLEM
5444  * - \ref SCIP_STAGE_TRANSFORMING
5445  * - \ref SCIP_STAGE_TRANSFORMED
5446  * - \ref SCIP_STAGE_INITPRESOLVE
5447  * - \ref SCIP_STAGE_PRESOLVING
5448  * - \ref SCIP_STAGE_EXITPRESOLVE
5449  * - \ref SCIP_STAGE_PRESOLVED
5450  * - \ref SCIP_STAGE_INITSOLVE
5451  * - \ref SCIP_STAGE_SOLVING
5452  * - \ref SCIP_STAGE_SOLVED
5453  */
5454 extern
5456  SCIP* scip /**< SCIP data structure */
5457  );
5458 
5459 /** returns the objective scale of the original problem
5460  *
5461  * @return the objective scale of the original problem
5462  *
5463  * @pre This method can be called if @p scip is in one of the following stages:
5464  * - \ref SCIP_STAGE_PROBLEM
5465  * - \ref SCIP_STAGE_TRANSFORMING
5466  * - \ref SCIP_STAGE_TRANSFORMED
5467  * - \ref SCIP_STAGE_INITPRESOLVE
5468  * - \ref SCIP_STAGE_PRESOLVING
5469  * - \ref SCIP_STAGE_EXITPRESOLVE
5470  * - \ref SCIP_STAGE_PRESOLVED
5471  * - \ref SCIP_STAGE_INITSOLVE
5472  * - \ref SCIP_STAGE_SOLVING
5473  * - \ref SCIP_STAGE_SOLVED
5474  */
5475 extern
5477  SCIP* scip /**< SCIP data structure */
5478  );
5479 
5480 /** returns the objective offset of the transformed problem
5481  *
5482  * @return the objective offset of the transformed problem
5483  *
5484  * @pre This method can be called if @p scip is in one of the following stages:
5485  * - \ref SCIP_STAGE_TRANSFORMED
5486  * - \ref SCIP_STAGE_INITPRESOLVE
5487  * - \ref SCIP_STAGE_PRESOLVING
5488  * - \ref SCIP_STAGE_EXITPRESOLVE
5489  * - \ref SCIP_STAGE_PRESOLVED
5490  * - \ref SCIP_STAGE_INITSOLVE
5491  * - \ref SCIP_STAGE_SOLVING
5492  * - \ref SCIP_STAGE_SOLVED
5493  */
5494 extern
5496  SCIP* scip /**< SCIP data structure */
5497  );
5498 
5499 /** returns the objective scale of the transformed problem
5500  *
5501  * @return the objective scale of the transformed problem
5502  *
5503  * @pre This method can be called if @p scip is in one of the following stages:
5504  * - \ref SCIP_STAGE_TRANSFORMED
5505  * - \ref SCIP_STAGE_INITPRESOLVE
5506  * - \ref SCIP_STAGE_PRESOLVING
5507  * - \ref SCIP_STAGE_EXITPRESOLVE
5508  * - \ref SCIP_STAGE_PRESOLVED
5509  * - \ref SCIP_STAGE_INITSOLVE
5510  * - \ref SCIP_STAGE_SOLVING
5511  * - \ref SCIP_STAGE_SOLVED
5512  */
5513 extern
5515  SCIP* scip /**< SCIP data structure */
5516  );
5517 
5518 /** sets limit on objective function, such that only solutions better than this limit are accepted
5519  *
5520  * @note SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune
5521  * all branch-and-bound nodes with dual bound equal or worse to the objective limit.
5522  * However, SCIP will also collect solutions with objective value worse than the objective limit and
5523  * use them to run improvement heuristics on them.
5524  * @note If SCIP can prove that there exists no solution with a strictly better objective value, the solving status
5525  * will normally be infeasible (the objective limit is interpreted as part of the problem).
5526  * The only exception is that by chance, SCIP found a solution with the same objective value and thus
5527  * proved the optimality of this solution, resulting in solution status optimal.
5528  *
5529  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5530  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5531  *
5532  * @pre This method can be called if @p scip is in one of the following stages:
5533  * - \ref SCIP_STAGE_PROBLEM
5534  * - \ref SCIP_STAGE_TRANSFORMED
5535  * - \ref SCIP_STAGE_INITPRESOLVE
5536  * - \ref SCIP_STAGE_PRESOLVING
5537  * - \ref SCIP_STAGE_EXITPRESOLVE
5538  * - \ref SCIP_STAGE_PRESOLVED
5539  * - \ref SCIP_STAGE_SOLVING
5540  */
5541 extern
5543  SCIP* scip, /**< SCIP data structure */
5544  SCIP_Real objlimit /**< new primal objective limit */
5545  );
5546 
5547 /** returns current limit on objective function
5548  *
5549  * @return the current objective limit of the original problem
5550  *
5551  * @pre This method can be called if @p scip is in one of the following stages:
5552  * - \ref SCIP_STAGE_PROBLEM
5553  * - \ref SCIP_STAGE_TRANSFORMING
5554  * - \ref SCIP_STAGE_TRANSFORMED
5555  * - \ref SCIP_STAGE_INITPRESOLVE
5556  * - \ref SCIP_STAGE_PRESOLVING
5557  * - \ref SCIP_STAGE_EXITPRESOLVE
5558  * - \ref SCIP_STAGE_PRESOLVED
5559  * - \ref SCIP_STAGE_INITSOLVE
5560  * - \ref SCIP_STAGE_SOLVING
5561  * - \ref SCIP_STAGE_SOLVED
5562  */
5563 extern
5565  SCIP* scip /**< SCIP data structure */
5566  );
5567 
5568 /** informs SCIP, that the objective value is always integral in every feasible solution
5569  *
5570  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5571  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5572  *
5573  * @pre This method can be called if @p scip is in one of the following stages:
5574  * - \ref SCIP_STAGE_PROBLEM
5575  * - \ref SCIP_STAGE_TRANSFORMING
5576  * - \ref SCIP_STAGE_INITPRESOLVE
5577  * - \ref SCIP_STAGE_EXITPRESOLVE
5578  * - \ref SCIP_STAGE_SOLVING
5579  *
5580  * @note This function should be used to inform SCIP that the objective function is integral, helping to improve the
5581  * performance. This is useful when using column generation. If no column generation (pricing) is used, SCIP
5582  * automatically detects whether the objective function is integral or can be scaled to be integral. However, in
5583  * any case, the user has to make sure that no variable is added during the solving process that destroys this
5584  * property.
5585  */
5586 extern
5588  SCIP* scip /**< SCIP data structure */
5589  );
5590 
5591 /** returns whether the objective value is known to be integral in every feasible solution
5592  *
5593  * @return TRUE, if objective value is known to be always integral, otherwise FALSE
5594  *
5595  * @pre This method can be called if @p scip is in one of the following stages:
5596  * - \ref SCIP_STAGE_PROBLEM
5597  * - \ref SCIP_STAGE_TRANSFORMING
5598  * - \ref SCIP_STAGE_INITPRESOLVE
5599  * - \ref SCIP_STAGE_PRESOLVING
5600  * - \ref SCIP_STAGE_EXITPRESOLVE
5601  * - \ref SCIP_STAGE_PRESOLVED
5602  * - \ref SCIP_STAGE_SOLVING
5603  *
5604  * @note If no pricing is performed, SCIP automatically detects whether the objective function is integral or can be
5605  * scaled to be integral, helping to improve performance. This function returns the result. Otherwise
5606  * SCIPsetObjIntegral() can be used to inform SCIP. However, in any case, the user has to make sure that no
5607  * variable is added during the solving process that destroys this property.
5608  */
5609 extern
5611  SCIP* scip /**< SCIP data structure */
5612  );
5613 
5614 /** returns the Euclidean norm of the objective function vector (available only for transformed problem)
5615  *
5616  * @return the Euclidean norm of the transformed objective function vector
5617  *
5618  * @pre This method can be called if @p scip is in one of the following stages:
5619  * - \ref SCIP_STAGE_TRANSFORMED
5620  * - \ref SCIP_STAGE_INITPRESOLVE
5621  * - \ref SCIP_STAGE_PRESOLVING
5622  * - \ref SCIP_STAGE_EXITPRESOLVE
5623  * - \ref SCIP_STAGE_PRESOLVED
5624  * - \ref SCIP_STAGE_INITSOLVE
5625  * - \ref SCIP_STAGE_SOLVING
5626  * - \ref SCIP_STAGE_SOLVED
5627  * - \ref SCIP_STAGE_EXITSOLVE
5628  */
5629 extern
5631  SCIP* scip /**< SCIP data structure */
5632  );
5633 
5634 /** adds variable to the problem
5635  *
5636  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5637  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5638  *
5639  * @pre This method can be called if @p scip is in one of the following stages:
5640  * - \ref SCIP_STAGE_PROBLEM
5641  * - \ref SCIP_STAGE_TRANSFORMING
5642  * - \ref SCIP_STAGE_INITPRESOLVE
5643  * - \ref SCIP_STAGE_PRESOLVING
5644  * - \ref SCIP_STAGE_EXITPRESOLVE
5645  * - \ref SCIP_STAGE_PRESOLVED
5646  * - \ref SCIP_STAGE_SOLVING
5647  */
5648 extern
5650  SCIP* scip, /**< SCIP data structure */
5651  SCIP_VAR* var /**< variable to add */
5652  );
5653 
5654 /** adds variable to the problem and uses it as pricing candidate to enter the LP
5655  *
5656  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5657  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5658  *
5659  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
5660  */
5661 extern
5663  SCIP* scip, /**< SCIP data structure */
5664  SCIP_VAR* var, /**< variable to add */
5665  SCIP_Real score /**< pricing score of variable (the larger, the better the variable) */
5666  );
5667 
5668 /** removes variable from the problem
5669  *
5670  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5671  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5672  *
5673  * @pre This method can be called if @p scip is in one of the following stages:
5674  * - \ref SCIP_STAGE_PROBLEM
5675  * - \ref SCIP_STAGE_TRANSFORMING
5676  * - \ref SCIP_STAGE_TRANSFORMED
5677  * - \ref SCIP_STAGE_PRESOLVING
5678  * - \ref SCIP_STAGE_FREETRANS
5679  */
5680 extern
5682  SCIP* scip, /**< SCIP data structure */
5683  SCIP_VAR* var, /**< variable to delete */
5684  SCIP_Bool* deleted /**< pointer to store whether variable was successfully marked to be deleted */
5685  );
5686 
5687 /** gets variables of the problem along with the numbers of different variable types; data may become invalid after
5688  * calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5689  *
5690  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5691  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5692  *
5693  * @pre This method can be called if @p scip is in one of the following stages:
5694  * - \ref SCIP_STAGE_PROBLEM
5695  * - \ref SCIP_STAGE_TRANSFORMED
5696  * - \ref SCIP_STAGE_INITPRESOLVE
5697  * - \ref SCIP_STAGE_PRESOLVING
5698  * - \ref SCIP_STAGE_EXITPRESOLVE
5699  * - \ref SCIP_STAGE_PRESOLVED
5700  * - \ref SCIP_STAGE_INITSOLVE
5701  * - \ref SCIP_STAGE_SOLVING
5702  * - \ref SCIP_STAGE_SOLVED
5703  * - \ref SCIP_STAGE_EXITSOLVE
5704  *
5705  * @note Variables in the vars array are ordered: binaries first, then integers, implicit integers and continuous last.
5706  */
5707 extern
5709  SCIP* scip, /**< SCIP data structure */
5710  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5711  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5712  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5713  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5714  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5715  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5716  );
5717 
5718 /** gets array with active problem variables
5719  *
5720  * @return array with active problem variables
5721  *
5722  * @pre This method can be called if @p scip is in one of the following stages:
5723  * - \ref SCIP_STAGE_PROBLEM
5724  * - \ref SCIP_STAGE_TRANSFORMED
5725  * - \ref SCIP_STAGE_INITPRESOLVE
5726  * - \ref SCIP_STAGE_PRESOLVING
5727  * - \ref SCIP_STAGE_EXITPRESOLVE
5728  * - \ref SCIP_STAGE_PRESOLVED
5729  * - \ref SCIP_STAGE_INITSOLVE
5730  * - \ref SCIP_STAGE_SOLVING
5731  * - \ref SCIP_STAGE_SOLVED
5732  * - \ref SCIP_STAGE_EXITSOLVE
5733  *
5734  * @warning If your are using the methods which add or change bound of variables (e.g., SCIPchgVarType(), SCIPfixVar(),
5735  * SCIPaggregateVars(), and SCIPmultiaggregateVar()), it can happen that the internal variable array (which is
5736  * accessed via this method) gets resized and/or resorted. This can invalid the data pointer which is returned
5737  * by this method.
5738  *
5739  * @note Variables in the array are ordered: binaries first, then integers, implicit integers and continuous last.
5740  */
5741 extern
5743  SCIP* scip /**< SCIP data structure */
5744  );
5745 
5746 /** gets number of active problem variables
5747  *
5748  * @return the number of active problem variables
5749  *
5750  * @pre This method can be called if @p scip is in one of the following stages:
5751  * - \ref SCIP_STAGE_PROBLEM
5752  * - \ref SCIP_STAGE_TRANSFORMED
5753  * - \ref SCIP_STAGE_INITPRESOLVE
5754  * - \ref SCIP_STAGE_PRESOLVING
5755  * - \ref SCIP_STAGE_EXITPRESOLVE
5756  * - \ref SCIP_STAGE_PRESOLVED
5757  * - \ref SCIP_STAGE_INITSOLVE
5758  * - \ref SCIP_STAGE_SOLVING
5759  * - \ref SCIP_STAGE_SOLVED
5760  * - \ref SCIP_STAGE_EXITSOLVE
5761  */
5762 extern
5763 int SCIPgetNVars(
5764  SCIP* scip /**< SCIP data structure */
5765  );
5766 
5767 /** gets number of binary active problem variables
5768  *
5769  * @return the number of binary active problem variables
5770  *
5771  * @pre This method can be called if @p scip is in one of the following stages:
5772  * - \ref SCIP_STAGE_PROBLEM
5773  * - \ref SCIP_STAGE_TRANSFORMED
5774  * - \ref SCIP_STAGE_INITPRESOLVE
5775  * - \ref SCIP_STAGE_PRESOLVING
5776  * - \ref SCIP_STAGE_EXITPRESOLVE
5777  * - \ref SCIP_STAGE_PRESOLVED
5778  * - \ref SCIP_STAGE_INITSOLVE
5779  * - \ref SCIP_STAGE_SOLVING
5780  * - \ref SCIP_STAGE_SOLVED
5781  * - \ref SCIP_STAGE_EXITSOLVE
5782  */
5783 extern
5784 int SCIPgetNBinVars(
5785  SCIP* scip /**< SCIP data structure */
5786  );
5787 
5788 /** gets number of integer active problem variables
5789  *
5790  * @return the number of integer active problem variables
5791  *
5792  * @pre This method can be called if @p scip is in one of the following stages:
5793  * - \ref SCIP_STAGE_PROBLEM
5794  * - \ref SCIP_STAGE_TRANSFORMED
5795  * - \ref SCIP_STAGE_INITPRESOLVE
5796  * - \ref SCIP_STAGE_PRESOLVING
5797  * - \ref SCIP_STAGE_EXITPRESOLVE
5798  * - \ref SCIP_STAGE_PRESOLVED
5799  * - \ref SCIP_STAGE_INITSOLVE
5800  * - \ref SCIP_STAGE_SOLVING
5801  * - \ref SCIP_STAGE_SOLVED
5802  * - \ref SCIP_STAGE_EXITSOLVE
5803  */
5804 extern
5805 int SCIPgetNIntVars(
5806  SCIP* scip /**< SCIP data structure */
5807  );
5808 
5809 /** gets number of implicit integer active problem variables
5810  *
5811  * @return the number of implicit integer active problem variables
5812  *
5813  * @pre This method can be called if @p scip is in one of the following stages:
5814  * - \ref SCIP_STAGE_PROBLEM
5815  * - \ref SCIP_STAGE_TRANSFORMED
5816  * - \ref SCIP_STAGE_INITPRESOLVE
5817  * - \ref SCIP_STAGE_PRESOLVING
5818  * - \ref SCIP_STAGE_EXITPRESOLVE
5819  * - \ref SCIP_STAGE_PRESOLVED
5820  * - \ref SCIP_STAGE_INITSOLVE
5821  * - \ref SCIP_STAGE_SOLVING
5822  * - \ref SCIP_STAGE_SOLVED
5823  * - \ref SCIP_STAGE_EXITSOLVE
5824  */
5825 extern
5826 int SCIPgetNImplVars(
5827  SCIP* scip /**< SCIP data structure */
5828  );
5829 
5830 /** gets number of continuous active problem variables
5831  *
5832  * @return the number of continuous active problem variables
5833  *
5834  * @pre This method can be called if @p scip is in one of the following stages:
5835  * - \ref SCIP_STAGE_PROBLEM
5836  * - \ref SCIP_STAGE_TRANSFORMED
5837  * - \ref SCIP_STAGE_INITPRESOLVE
5838  * - \ref SCIP_STAGE_PRESOLVING
5839  * - \ref SCIP_STAGE_EXITPRESOLVE
5840  * - \ref SCIP_STAGE_PRESOLVED
5841  * - \ref SCIP_STAGE_INITSOLVE
5842  * - \ref SCIP_STAGE_SOLVING
5843  * - \ref SCIP_STAGE_SOLVED
5844  * - \ref SCIP_STAGE_EXITSOLVE
5845  */
5846 extern
5847 int SCIPgetNContVars(
5848  SCIP* scip /**< SCIP data structure */
5849  );
5850 
5851 /** gets number of active problem variables with a non-zero objective coefficient
5852  *
5853  * @note In case of the original problem the number of variables is counted. In case of the transformed problem the
5854  * number of variables is just returned since it is stored internally
5855  *
5856  * @return the number of active problem variables with a non-zero objective coefficient
5857  *
5858  * @pre This method can be called if @p scip is in one of the following stages:
5859  * - \ref SCIP_STAGE_PROBLEM
5860  * - \ref SCIP_STAGE_TRANSFORMED
5861  * - \ref SCIP_STAGE_INITPRESOLVE
5862  * - \ref SCIP_STAGE_PRESOLVING
5863  * - \ref SCIP_STAGE_EXITPRESOLVE
5864  * - \ref SCIP_STAGE_PRESOLVED
5865  * - \ref SCIP_STAGE_INITSOLVE
5866  * - \ref SCIP_STAGE_SOLVING
5867  * - \ref SCIP_STAGE_SOLVED
5868  */
5869 extern
5870 int SCIPgetNObjVars(
5871  SCIP* scip /**< SCIP data structure */
5872  );
5873 
5874 /** gets array with fixed and aggregated problem variables; data may become invalid after
5875  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5876  *
5877  * @return an array with fixed and aggregated problem variables; data may become invalid after
5878  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
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  */
5891 extern
5893  SCIP* scip /**< SCIP data structure */
5894  );
5895 
5896 /** gets number of fixed or aggregated problem variables
5897  *
5898  * @return the number of fixed or aggregated problem variables
5899  *
5900  * @pre This method can be called if @p scip is in one of the following stages:
5901  * - \ref SCIP_STAGE_PROBLEM
5902  * - \ref SCIP_STAGE_TRANSFORMED
5903  * - \ref SCIP_STAGE_INITPRESOLVE
5904  * - \ref SCIP_STAGE_PRESOLVING
5905  * - \ref SCIP_STAGE_EXITPRESOLVE
5906  * - \ref SCIP_STAGE_PRESOLVED
5907  * - \ref SCIP_STAGE_INITSOLVE
5908  * - \ref SCIP_STAGE_SOLVING
5909  * - \ref SCIP_STAGE_SOLVED
5910  */
5911 extern
5912 int SCIPgetNFixedVars(
5913  SCIP* scip /**< SCIP data structure */
5914  );
5915 
5916 /** gets variables of the original problem along with the numbers of different variable types; data may become invalid
5917  * after a call to SCIPchgVarType()
5918  *
5919  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5920  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
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_TRANSFORMING
5925  * - \ref SCIP_STAGE_TRANSFORMED
5926  * - \ref SCIP_STAGE_INITPRESOLVE
5927  * - \ref SCIP_STAGE_PRESOLVING
5928  * - \ref SCIP_STAGE_EXITPRESOLVE
5929  * - \ref SCIP_STAGE_PRESOLVED
5930  * - \ref SCIP_STAGE_INITSOLVE
5931  * - \ref SCIP_STAGE_SOLVING
5932  * - \ref SCIP_STAGE_SOLVED
5933  * - \ref SCIP_STAGE_EXITSOLVE
5934  * - \ref SCIP_STAGE_FREETRANS
5935  */
5936 extern
5938  SCIP* scip, /**< SCIP data structure */
5939  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5940  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5941  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5942  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5943  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5944  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5945  );
5946 
5947 /** gets array with original problem variables; data may become invalid after
5948  * a call to SCIPchgVarType()
5949  *
5950  * @return an array with original problem variables; data may become invalid after
5951  * a call to SCIPchgVarType()
5952  *
5953  * @pre This method can be called if @p scip is in one of the following stages:
5954  * - \ref SCIP_STAGE_PROBLEM
5955  * - \ref SCIP_STAGE_TRANSFORMING
5956  * - \ref SCIP_STAGE_TRANSFORMED
5957  * - \ref SCIP_STAGE_INITPRESOLVE
5958  * - \ref SCIP_STAGE_PRESOLVING
5959  * - \ref SCIP_STAGE_EXITPRESOLVE
5960  * - \ref SCIP_STAGE_PRESOLVED
5961  * - \ref SCIP_STAGE_INITSOLVE
5962  * - \ref SCIP_STAGE_SOLVING
5963  * - \ref SCIP_STAGE_SOLVED
5964  * - \ref SCIP_STAGE_EXITSOLVE
5965  * - \ref SCIP_STAGE_FREETRANS
5966  */
5967 extern
5969  SCIP* scip /**< SCIP data structure */
5970  );
5971 
5972 /** gets number of original problem variables
5973  *
5974  * @return the number of original problem variables
5975  *
5976  * @pre This method can be called if @p scip is in one of the following stages:
5977  * - \ref SCIP_STAGE_PROBLEM
5978  * - \ref SCIP_STAGE_TRANSFORMING
5979  * - \ref SCIP_STAGE_TRANSFORMED
5980  * - \ref SCIP_STAGE_INITPRESOLVE
5981  * - \ref SCIP_STAGE_PRESOLVING
5982  * - \ref SCIP_STAGE_EXITPRESOLVE
5983  * - \ref SCIP_STAGE_PRESOLVED
5984  * - \ref SCIP_STAGE_INITSOLVE
5985  * - \ref SCIP_STAGE_SOLVING
5986  * - \ref SCIP_STAGE_SOLVED
5987  * - \ref SCIP_STAGE_EXITSOLVE
5988  * - \ref SCIP_STAGE_FREETRANS
5989  */
5990 extern
5991 int SCIPgetNOrigVars(
5992  SCIP* scip /**< SCIP data structure */
5993  );
5994 
5995 /** gets number of binary variables in the original problem
5996  *
5997  * @return the number of binary variables in the original problem
5998  *
5999  * @pre This method can be called if @p scip is in one of the following stages:
6000  * - \ref SCIP_STAGE_PROBLEM
6001  * - \ref SCIP_STAGE_TRANSFORMING
6002  * - \ref SCIP_STAGE_TRANSFORMED
6003  * - \ref SCIP_STAGE_INITPRESOLVE
6004  * - \ref SCIP_STAGE_PRESOLVING
6005  * - \ref SCIP_STAGE_EXITPRESOLVE
6006  * - \ref SCIP_STAGE_PRESOLVED
6007  * - \ref SCIP_STAGE_INITSOLVE
6008  * - \ref SCIP_STAGE_SOLVING
6009  * - \ref SCIP_STAGE_SOLVED
6010  * - \ref SCIP_STAGE_EXITSOLVE
6011  * - \ref SCIP_STAGE_FREETRANS
6012  */
6013 extern
6015  SCIP* scip /**< SCIP data structure */
6016  );
6017 
6018 /** gets the number of integer variables in the original problem
6019  *
6020  * @return the number of integer variables in the original problem
6021  *
6022  * @pre This method can be called if @p scip is in one of the following stages:
6023  * - \ref SCIP_STAGE_PROBLEM
6024  * - \ref SCIP_STAGE_TRANSFORMING
6025  * - \ref SCIP_STAGE_TRANSFORMED
6026  * - \ref SCIP_STAGE_INITPRESOLVE
6027  * - \ref SCIP_STAGE_PRESOLVING
6028  * - \ref SCIP_STAGE_EXITPRESOLVE
6029  * - \ref SCIP_STAGE_PRESOLVED
6030  * - \ref SCIP_STAGE_INITSOLVE
6031  * - \ref SCIP_STAGE_SOLVING
6032  * - \ref SCIP_STAGE_SOLVED
6033  * - \ref SCIP_STAGE_EXITSOLVE
6034  * - \ref SCIP_STAGE_FREETRANS
6035  */
6036 extern
6038  SCIP* scip /**< SCIP data structure */
6039  );
6040 
6041 /** gets number of implicit integer variables in the original problem
6042  *
6043  * @return the number of implicit integer variables in the original problem
6044  *
6045  * @pre This method can be called if @p scip is in one of the following stages:
6046  * - \ref SCIP_STAGE_PROBLEM
6047  * - \ref SCIP_STAGE_TRANSFORMING
6048  * - \ref SCIP_STAGE_TRANSFORMED
6049  * - \ref SCIP_STAGE_INITPRESOLVE
6050  * - \ref SCIP_STAGE_PRESOLVING
6051  * - \ref SCIP_STAGE_EXITPRESOLVE
6052  * - \ref SCIP_STAGE_PRESOLVED
6053  * - \ref SCIP_STAGE_INITSOLVE
6054  * - \ref SCIP_STAGE_SOLVING
6055  * - \ref SCIP_STAGE_SOLVED
6056  * - \ref SCIP_STAGE_EXITSOLVE
6057  * - \ref SCIP_STAGE_FREETRANS
6058  */
6059 extern
6061  SCIP* scip /**< SCIP data structure */
6062  );
6063 
6064 /** gets number of continuous variables in the original problem
6065  *
6066  * @return the number of continuous variables in the original problem
6067  *
6068  * @pre This method can be called if @p scip is in one of the following stages:
6069  * - \ref SCIP_STAGE_PROBLEM
6070  * - \ref SCIP_STAGE_TRANSFORMING
6071  * - \ref SCIP_STAGE_TRANSFORMED
6072  * - \ref SCIP_STAGE_INITPRESOLVE
6073  * - \ref SCIP_STAGE_PRESOLVING
6074  * - \ref SCIP_STAGE_EXITPRESOLVE
6075  * - \ref SCIP_STAGE_PRESOLVED
6076  * - \ref SCIP_STAGE_INITSOLVE
6077  * - \ref SCIP_STAGE_SOLVING
6078  * - \ref SCIP_STAGE_SOLVED
6079  * - \ref SCIP_STAGE_EXITSOLVE
6080  * - \ref SCIP_STAGE_FREETRANS
6081  */
6082 extern
6084  SCIP* scip /**< SCIP data structure */
6085  );
6086 
6087 /** gets number of all problem variables created during creation and solving of problem;
6088  * this includes also variables that were deleted in the meantime
6089  *
6090  * @return the number of all problem variables created during creation and solving of problem;
6091  * this includes also variables that were deleted in the meantime
6092  *
6093  * @pre This method can be called if @p scip is in one of the following stages:
6094  * - \ref SCIP_STAGE_PROBLEM
6095  * - \ref SCIP_STAGE_TRANSFORMING
6096  * - \ref SCIP_STAGE_TRANSFORMED
6097  * - \ref SCIP_STAGE_INITPRESOLVE
6098  * - \ref SCIP_STAGE_PRESOLVING
6099  * - \ref SCIP_STAGE_EXITPRESOLVE
6100  * - \ref SCIP_STAGE_PRESOLVED
6101  * - \ref SCIP_STAGE_INITSOLVE
6102  * - \ref SCIP_STAGE_SOLVING
6103  * - \ref SCIP_STAGE_SOLVED
6104  * - \ref SCIP_STAGE_EXITSOLVE
6105  * - \ref SCIP_STAGE_FREETRANS
6106  */
6107 extern
6108 int SCIPgetNTotalVars(
6109  SCIP* scip /**< SCIP data structure */
6110  );
6111 
6112 /** gets variables of the original or transformed problem along with the numbers of different variable types;
6113  * the returned problem space (original or transformed) corresponds to the given solution;
6114  * data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and
6115  * SCIPmultiaggregateVar()
6116  *
6117  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6118  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6119  *
6120  * @pre This method can be called if @p scip is in one of the following stages:
6121  * - \ref SCIP_STAGE_PROBLEM
6122  * - \ref SCIP_STAGE_TRANSFORMED
6123  * - \ref SCIP_STAGE_INITPRESOLVE
6124  * - \ref SCIP_STAGE_PRESOLVING
6125  * - \ref SCIP_STAGE_EXITPRESOLVE
6126  * - \ref SCIP_STAGE_PRESOLVED
6127  * - \ref SCIP_STAGE_INITSOLVE
6128  * - \ref SCIP_STAGE_SOLVING
6129  * - \ref SCIP_STAGE_SOLVED
6130  */
6131 extern
6133  SCIP* scip, /**< SCIP data structure */
6134  SCIP_SOL* sol, /**< primal solution that selects the problem space, NULL for current solution */
6135  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
6136  int* nvars, /**< pointer to store number of variables or NULL if not needed */
6137  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
6138  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
6139  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
6140  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
6141  );
6142 
6143 /** returns variable of given name in the problem, or NULL if not existing
6144  *
6145  * @return variable of given name in the problem, or NULL if not existing
6146  *
6147  * @pre This method can be called if @p scip is in one of the following stages:
6148  * - \ref SCIP_STAGE_PROBLEM
6149  * - \ref SCIP_STAGE_TRANSFORMING
6150  * - \ref SCIP_STAGE_TRANSFORMED
6151  * - \ref SCIP_STAGE_INITPRESOLVE
6152  * - \ref SCIP_STAGE_PRESOLVING
6153  * - \ref SCIP_STAGE_EXITPRESOLVE
6154  * - \ref SCIP_STAGE_PRESOLVED
6155  * - \ref SCIP_STAGE_INITSOLVE
6156  * - \ref SCIP_STAGE_SOLVING
6157  * - \ref SCIP_STAGE_SOLVED
6158  * - \ref SCIP_STAGE_EXITSOLVE
6159  * - \ref SCIP_STAGE_FREETRANS
6160  */
6161 extern
6163  SCIP* scip, /**< SCIP data structure */
6164  const char* name /**< name of variable to find */
6165  );
6166 
6167 /** returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables,
6168  * that will be added in pricing and improve the objective value
6169  *
6170  * @return TRUE, if all potential variables exist in the problem; FALSE, otherwise
6171  *
6172  * @pre This method can be called if @p scip is in one of the following stages:
6173  * - \ref SCIP_STAGE_TRANSFORMING
6174  * - \ref SCIP_STAGE_TRANSFORMED
6175  * - \ref SCIP_STAGE_INITPRESOLVE
6176  * - \ref SCIP_STAGE_PRESOLVING
6177  * - \ref SCIP_STAGE_EXITPRESOLVE
6178  * - \ref SCIP_STAGE_PRESOLVED
6179  * - \ref SCIP_STAGE_INITSOLVE
6180  * - \ref SCIP_STAGE_SOLVING
6181  * - \ref SCIP_STAGE_SOLVED
6182  * - \ref SCIP_STAGE_EXITSOLVE
6183  * - \ref SCIP_STAGE_FREETRANS
6184  */
6185 extern
6187  SCIP* scip /**< SCIP data structure */
6188  );
6189 
6190 /** adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the
6191  * current node (and all of its subnodes); otherwise it is added to the global problem;
6192  * if a local constraint is added at the root node, it is automatically upgraded into a global constraint
6193  *
6194  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6195  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6196  *
6197  * @pre This method can be called if @p scip is in one of the following stages:
6198  * - \ref SCIP_STAGE_PROBLEM
6199  * - \ref SCIP_STAGE_INITPRESOLVE
6200  * - \ref SCIP_STAGE_PRESOLVING
6201  * - \ref SCIP_STAGE_EXITPRESOLVE
6202  * - \ref SCIP_STAGE_PRESOLVED
6203  * - \ref SCIP_STAGE_INITSOLVE
6204  * - \ref SCIP_STAGE_SOLVING
6205  * - \ref SCIP_STAGE_EXITSOLVE
6206  */
6207 extern
6209  SCIP* scip, /**< SCIP data structure */
6210  SCIP_CONS* cons /**< constraint to add */
6211  );
6212 
6213 /** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
6214  * node, where it was added, or from the problem, if it was a problem constraint
6215  *
6216  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6217  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6218  *
6219  * @pre This method can be called if @p scip is in one of the following stages:
6220  * - \ref SCIP_STAGE_PROBLEM
6221  * - \ref SCIP_STAGE_INITPRESOLVE
6222  * - \ref SCIP_STAGE_PRESOLVING
6223  * - \ref SCIP_STAGE_EXITPRESOLVE
6224  * - \ref SCIP_STAGE_INITSOLVE
6225  * - \ref SCIP_STAGE_SOLVING
6226  * - \ref SCIP_STAGE_EXITSOLVE
6227  */
6228 extern
6230  SCIP* scip, /**< SCIP data structure */
6231  SCIP_CONS* cons /**< constraint to delete */
6232  );
6233 
6234 /** returns original constraint of given name in the problem, or NULL if not existing
6235  *
6236  * @return original constraint of given name in the problem, or NULL if not existing
6237  *
6238  * @pre This method can be called if @p scip is in one of the following stages:
6239  * - \ref SCIP_STAGE_PROBLEM
6240  * - \ref SCIP_STAGE_TRANSFORMING
6241  * - \ref SCIP_STAGE_TRANSFORMED
6242  * - \ref SCIP_STAGE_INITPRESOLVE
6243  * - \ref SCIP_STAGE_PRESOLVING
6244  * - \ref SCIP_STAGE_EXITPRESOLVE
6245  * - \ref SCIP_STAGE_INITSOLVE
6246  * - \ref SCIP_STAGE_SOLVING
6247  * - \ref SCIP_STAGE_SOLVED
6248  * - \ref SCIP_STAGE_EXITSOLVE
6249  * - \ref SCIP_STAGE_FREETRANS */
6250 extern
6252  SCIP* scip, /**< SCIP data structure */
6253  const char* name /**< name of constraint to find */
6254  );
6255 
6256 /** returns constraint of given name in the problem, or NULL if not existing
6257  *
6258  * @return constraint of given name in the problem, or NULL if not existing
6259  *
6260  * @pre This method can be called if @p scip is in one of the following stages:
6261  * - \ref SCIP_STAGE_PROBLEM
6262  * - \ref SCIP_STAGE_TRANSFORMING
6263  * - \ref SCIP_STAGE_TRANSFORMED
6264  * - \ref SCIP_STAGE_INITPRESOLVE
6265  * - \ref SCIP_STAGE_PRESOLVING
6266  * - \ref SCIP_STAGE_EXITPRESOLVE
6267  * - \ref SCIP_STAGE_PRESOLVED
6268  * - \ref SCIP_STAGE_INITSOLVE
6269  * - \ref SCIP_STAGE_SOLVING
6270  * - \ref SCIP_STAGE_SOLVED
6271  * - \ref SCIP_STAGE_EXITSOLVE
6272  * - \ref SCIP_STAGE_FREETRANS
6273  */
6274 extern
6276  SCIP* scip, /**< SCIP data structure */
6277  const char* name /**< name of constraint to find */
6278  );
6279 
6280 /** gets number of upgraded constraints
6281  *
6282  * @return number of upgraded constraints
6283  *
6284  * @pre This method can be called if @p scip is in one of the following stages:
6285  * - \ref SCIP_STAGE_PROBLEM
6286  * - \ref SCIP_STAGE_TRANSFORMED
6287  * - \ref SCIP_STAGE_INITPRESOLVE
6288  * - \ref SCIP_STAGE_PRESOLVING
6289  * - \ref SCIP_STAGE_PRESOLVED
6290  * - \ref SCIP_STAGE_EXITPRESOLVE
6291  * - \ref SCIP_STAGE_SOLVING
6292  * - \ref SCIP_STAGE_SOLVED
6293  */
6294 extern
6295 int SCIPgetNUpgrConss(
6296  SCIP* scip /**< SCIP data structure */
6297  );
6298 
6299 /** gets total number of globally valid constraints currently in the problem
6300  *
6301  * @return total number of globally valid constraints currently in the problem
6302  *
6303  * @pre This method can be called if @p scip is in one of the following stages:
6304  * - \ref SCIP_STAGE_PROBLEM
6305  * - \ref SCIP_STAGE_TRANSFORMED
6306  * - \ref SCIP_STAGE_INITPRESOLVE
6307  * - \ref SCIP_STAGE_PRESOLVING
6308  * - \ref SCIP_STAGE_EXITPRESOLVE
6309  * - \ref SCIP_STAGE_PRESOLVED
6310  * - \ref SCIP_STAGE_INITSOLVE
6311  * - \ref SCIP_STAGE_SOLVING
6312  * - \ref SCIP_STAGE_SOLVED
6313  */
6314 extern
6315 int SCIPgetNConss(
6316  SCIP* scip /**< SCIP data structure */
6317  );
6318 
6319 /** gets array of globally valid constraints currently in the problem
6320  *
6321  * @return array of globally valid constraints currently in the problem
6322  *
6323  * @pre This method can be called if @p scip is in one of the following stages:
6324  * - \ref SCIP_STAGE_PROBLEM
6325  * - \ref SCIP_STAGE_TRANSFORMED
6326  * - \ref SCIP_STAGE_INITPRESOLVE
6327  * - \ref SCIP_STAGE_PRESOLVING
6328  * - \ref SCIP_STAGE_EXITPRESOLVE
6329  * - \ref SCIP_STAGE_PRESOLVED
6330  * - \ref SCIP_STAGE_SOLVING
6331  * - \ref SCIP_STAGE_SOLVED
6332  *
6333  * @warning If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is
6334  * accessed via this method) gets resized. This can invalid the pointer which is returned by this method.
6335  */
6336 extern
6338  SCIP* scip /**< SCIP data structure */
6339  );
6340 
6341 /** gets total number of constraints in the original problem
6342  *
6343  * @return total number of constraints in the original problem
6344  *
6345  * @pre This method can be called if @p scip is in one of the following stages:
6346  * - \ref SCIP_STAGE_PROBLEM
6347  * - \ref SCIP_STAGE_TRANSFORMING
6348  * - \ref SCIP_STAGE_TRANSFORMED
6349  * - \ref SCIP_STAGE_INITPRESOLVE
6350  * - \ref SCIP_STAGE_PRESOLVING
6351  * - \ref SCIP_STAGE_EXITPRESOLVE
6352  * - \ref SCIP_STAGE_PRESOLVED
6353  * - \ref SCIP_STAGE_INITSOLVE
6354  * - \ref SCIP_STAGE_SOLVING
6355  * - \ref SCIP_STAGE_SOLVED
6356  * - \ref SCIP_STAGE_EXITSOLVE
6357  * - \ref SCIP_STAGE_FREETRANS
6358  */
6359 extern
6360 int SCIPgetNOrigConss(
6361  SCIP* scip /**< SCIP data structure */
6362  );
6363 
6364 /** gets array of constraints in the original problem
6365  *
6366  * @return array of constraints in the original problem
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_PRESOLVED
6376  * - \ref SCIP_STAGE_INITSOLVE
6377  * - \ref SCIP_STAGE_SOLVING
6378  * - \ref SCIP_STAGE_SOLVED
6379  * - \ref SCIP_STAGE_EXITSOLVE
6380  * - \ref SCIP_STAGE_FREETRANS
6381  */
6382 extern
6384  SCIP* scip /**< SCIP data structure */
6385  );
6386 
6387 /** computes the number of check constraint in the current node (loop over all constraint handler and cumulates the
6388  * number of check constraints)
6389  *
6390  * @return returns the number of check constraints
6391  *
6392  * @pre This method can be called if @p scip is in one of the following stages:
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  */
6401 extern
6402 int SCIPgetNCheckConss(
6403  SCIP* scip /**< SCIP data structure */
6404  );
6405 
6406 /**@} */
6407 
6408 
6409 
6410 
6411 /*
6412  * local subproblem methods
6413  */
6414 
6415 /**@addtogroup LocalSubproblemMethods
6416  *
6417  * @{
6418  */
6419 
6420 /** adds a conflict to a given node or globally to the problem if @p node == NULL.
6421  *
6422  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6423  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6424  *
6425  * @pre this method can be called in one of the following stages of the SCIP solving process:
6426  * - \ref SCIP_STAGE_INITPRESOLVE
6427  * - \ref SCIP_STAGE_PRESOLVING
6428  * - \ref SCIP_STAGE_EXITPRESOLVE
6429  * - \ref SCIP_STAGE_SOLVING
6430  *
6431  * @note this method will release the constraint
6432  */
6433 extern
6435  SCIP* scip, /**< SCIP data structure */
6436  SCIP_NODE* node, /**< node to add conflict (or NULL if global) */
6437  SCIP_CONS* cons, /**< constraint representing the conflict */
6438  SCIP_NODE* validnode, /**< node at which the constraint is valid (or NULL) */
6439  SCIP_CONFTYPE conftype, /**< type of the conflict */
6440  SCIP_Bool iscutoffinvolved /**< is a cutoff bound involved in this conflict */
6441  );
6442 
6443 /** removes all conflicts depending on an old cutoff bound if the improvement of the incumbent is good enough
6444  *
6445  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6446  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6447  *
6448  * @pre this method can be called in one of the following stages of the SCIP solving process:
6449  * - \ref SCIP_STAGE_PRESOLVING
6450  * - \ref SCIP_STAGE_SOLVING
6451  */
6452 extern
6454  SCIP* scip, /**< SCIP data structure */
6455  SCIP_EVENT* event /**< event data */
6456  );
6457 
6458 /** adds constraint to the given node (and all of its subnodes), even if it is a global constraint;
6459  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
6460  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
6461  * only active in a small part of the tree although it is valid in a larger part.
6462  * In this case, one should pass the more global node where the constraint is valid as "validnode".
6463  * Note that the same constraint cannot be added twice to the branching tree with different "validnode" parameters.
6464  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
6465  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
6466  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
6467  *
6468  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6469  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6470  *
6471  * @pre this method can be called in one of the following stages of the SCIP solving process:
6472  * - \ref SCIP_STAGE_INITPRESOLVE
6473  * - \ref SCIP_STAGE_PRESOLVING
6474  * - \ref SCIP_STAGE_EXITPRESOLVE
6475  * - \ref SCIP_STAGE_SOLVING
6476  */
6477 extern
6479  SCIP* scip, /**< SCIP data structure */
6480  SCIP_NODE* node, /**< node to add constraint to */
6481  SCIP_CONS* cons, /**< constraint to add */
6482  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
6483  );
6484 
6485 /** adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint;
6486  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
6487  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
6488  * only active in a small part of the tree although it is valid in a larger part.
6489  *
6490  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
6491  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
6492  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
6493  *
6494  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6495  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6496  *
6497  * @pre this method can be called in one of the following stages of the SCIP solving process:
6498  * - \ref SCIP_STAGE_INITPRESOLVE
6499  * - \ref SCIP_STAGE_PRESOLVING
6500  * - \ref SCIP_STAGE_EXITPRESOLVE
6501  * - \ref SCIP_STAGE_SOLVING
6502  *
6503  * @note The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is
6504  * the case due internal data structures and performance issues. In such a case you should try to realize your
6505  * issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.
6506  */
6507 extern
6509  SCIP* scip, /**< SCIP data structure */
6510  SCIP_CONS* cons, /**< constraint to add */
6511  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
6512  );
6513 
6514 /** disables constraint's separation, enforcing, and propagation capabilities at the given node (and all subnodes);
6515  * if the method is called at the root node, the constraint is globally deleted from the problem;
6516  * the constraint deletion is being remembered at the given node, s.t. after leaving the node's subtree, the constraint
6517  * is automatically enabled again, and after entering the node's subtree, it is automatically disabled;
6518  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
6519  * alternatively, use SCIPdisableCons()
6520  *
6521  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6522  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6523  *
6524  * @pre this method can be called in one of the following stages of the SCIP solving process:
6525  * - \ref SCIP_STAGE_INITPRESOLVE
6526  * - \ref SCIP_STAGE_PRESOLVING
6527  * - \ref SCIP_STAGE_EXITPRESOLVE
6528  * - \ref SCIP_STAGE_SOLVING
6529  */
6530 extern
6532  SCIP* scip, /**< SCIP data structure */
6533  SCIP_NODE* node, /**< node to disable constraint in */
6534  SCIP_CONS* cons /**< constraint to locally delete */
6535  );
6536 
6537 /** disables constraint's separation, enforcing, and propagation capabilities at the current node (and all subnodes);
6538  * if the method is called during problem modification or at the root node, the constraint is globally deleted from
6539  * the problem;
6540  * the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the
6541  * constraint is automatically enabled again, and after reentering the current node's subtree, it is automatically
6542  * disabled again;
6543  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
6544  * alternatively, use SCIPdisableCons()
6545  *
6546  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6547  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6548  *
6549  * @pre this method can be called in one of the following stages of the SCIP solving process:
6550  * - \ref SCIP_STAGE_PROBLEM
6551  * - \ref SCIP_STAGE_INITPRESOLVE
6552  * - \ref SCIP_STAGE_PRESOLVING
6553  * - \ref SCIP_STAGE_EXITPRESOLVE
6554  * - \ref SCIP_STAGE_SOLVING
6555  */
6556 extern
6558  SCIP* scip, /**< SCIP data structure */
6559  SCIP_CONS* cons /**< constraint to locally delete */
6560  );
6561 
6562 /** gets estimate of best primal solution w.r.t. original problem contained in current subtree
6563  *
6564  * @return estimate of best primal solution w.r.t. original problem contained in current subtree
6565  *
6566  * @pre this method can be called in one of the following stages of the SCIP solving process:
6567  * - \ref SCIP_STAGE_SOLVING
6568  */
6569 extern
6571  SCIP* scip /**< SCIP data structure */
6572  );
6573 
6574 /** gets estimate of best primal solution w.r.t. transformed problem contained in current subtree
6575  *
6576  * @return estimate of best primal solution w.r.t. transformed problem contained in current subtree
6577  *
6578  * @pre this method can be called in one of the following stages of the SCIP solving process:
6579  * - \ref SCIP_STAGE_SOLVING
6580  */
6581 extern
6583  SCIP* scip /**< SCIP data structure */
6584  );
6585 
6586 /** gets dual bound of current node
6587  *
6588  * @return dual bound of current node
6589  *
6590  * @pre this method can be called in one of the following stages of the SCIP solving process:
6591  * - \ref SCIP_STAGE_SOLVING
6592  */
6593 extern
6595  SCIP* scip /**< SCIP data structure */
6596  );
6597 
6598 /** gets lower bound of current node in transformed problem
6599  *
6600  * @return lower bound of current node in transformed problem
6601  *
6602  * @pre this method can be called in one of the following stages of the SCIP solving process:
6603  * - \ref SCIP_STAGE_SOLVING
6604  */
6605 extern
6607  SCIP* scip /**< SCIP data structure */
6608  );
6609 
6610 /** gets dual bound of given node
6611  *
6612  * @return dual bound of a given node
6613  *
6614  * @pre this method can be called in one of the following stages of the SCIP solving process:
6615  * - \ref SCIP_STAGE_SOLVING
6616  */
6617 extern
6619  SCIP* scip, /**< SCIP data structure */
6620  SCIP_NODE* node /**< node to get dual bound for */
6621  );
6622 
6623 /** gets lower bound of given node in transformed problem
6624  *
6625  * @return lower bound of given node in transformed problem
6626  *
6627  * @pre this method can be called in one of the following stages of the SCIP solving process:
6628  * - \ref SCIP_STAGE_SOLVING
6629  */
6630 extern
6632  SCIP* scip, /**< SCIP data structure */
6633  SCIP_NODE* node /**< node to get dual bound for */
6634  );
6635 
6636 /** if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in
6637  * original problem space), sets the current node's dual bound to the new value
6638  *
6639  * @note the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.
6640  *
6641  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6642  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6643  *
6644  * @pre this method can be called in one of the following stages of the SCIP solving process:
6645  * - \ref SCIP_STAGE_PROBLEM
6646  * - \ref SCIP_STAGE_PRESOLVING
6647  * - \ref SCIP_STAGE_PRESOLVED
6648  * - \ref SCIP_STAGE_SOLVING
6649  */
6650 extern
6652  SCIP* scip, /**< SCIP data structure */
6653  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
6654  );
6655 
6656 /** if given value is larger than the current node's lower bound (in transformed problem), sets the current node's
6657  * lower bound to the new value
6658  *
6659  * @note the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.
6660  *
6661  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6662  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6663  *
6664  * @pre this method can be called in one of the following stages of the SCIP solving process:
6665  * - \ref SCIP_STAGE_PRESOLVING
6666  * - \ref SCIP_STAGE_PRESOLVED
6667  * - \ref SCIP_STAGE_SOLVING
6668  */
6669 extern
6671  SCIP* scip, /**< SCIP data structure */
6672  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
6673  );
6674 
6675 /** if given value is tighter (larger for minimization, smaller for maximization) than the node's dual bound,
6676  * sets the node's dual bound to the new value
6677  *
6678  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6679  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6680  *
6681  * @pre this method can be called in one of the following stages of the SCIP solving process:
6682  * - \ref SCIP_STAGE_SOLVING
6683  */
6684 extern
6686  SCIP* scip, /**< SCIP data structure */
6687  SCIP_NODE* node, /**< node to update dual bound for */
6688  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
6689  );
6690 
6691 /** if given value is larger than the node's lower bound (in transformed problem), sets the node's lower bound
6692  * to the new value
6693  *
6694  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6695  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
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  SCIP_NODE* node, /**< node to update lower bound for */
6704  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
6705  );
6706 
6707 /** change the node selection priority of the given child
6708  *
6709  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6710  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6711  *
6712  * @pre this method can be called in one of the following stages of the SCIP solving process:
6713  * - \ref SCIP_STAGE_SOLVING
6714  */
6715 extern
6717  SCIP* scip, /**< SCIP data structure */
6718  SCIP_NODE* child, /**< child to update the node selection priority */
6719  SCIP_Real priority /**< node selection priority value */
6720  );
6721 
6722 /**@} */
6723 
6724 
6725 
6726 
6727 /*
6728  * solve methods
6729  */
6730 
6731 /**@addtogroup PublicSolveMethods
6732  *
6733  * @{
6734  */
6735 
6736 /** initializes solving data structures and transforms problem
6737  *
6738  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6739  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6740  *
6741  * @pre This method can be called if @p scip is in one of the following stages:
6742  * - \ref SCIP_STAGE_PROBLEM
6743  * - \ref SCIP_STAGE_TRANSFORMED
6744  * - \ref SCIP_STAGE_INITPRESOLVE
6745  * - \ref SCIP_STAGE_PRESOLVING
6746  * - \ref SCIP_STAGE_EXITPRESOLVE
6747  * - \ref SCIP_STAGE_PRESOLVED
6748  * - \ref SCIP_STAGE_INITSOLVE
6749  * - \ref SCIP_STAGE_SOLVING
6750  * - \ref SCIP_STAGE_SOLVED
6751  * - \ref SCIP_STAGE_EXITSOLVE
6752  * - \ref SCIP_STAGE_FREETRANS
6753  * - \ref SCIP_STAGE_FREE
6754  *
6755  * @post When calling this method in the \ref SCIP_STAGE_PROBLEM stage, the \SCIP stage is changed to \ref
6756  * SCIP_STAGE_TRANSFORMED; otherwise, the stage is not changed
6757  *
6758  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6759  */
6760 extern
6762  SCIP* scip /**< SCIP data structure */
6763  );
6764 
6765 /** transforms and presolves problem
6766  *
6767  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6768  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6769  *
6770  * @pre This method can be called if @p scip is in one of the following stages:
6771  * - \ref SCIP_STAGE_PROBLEM
6772  * - \ref SCIP_STAGE_TRANSFORMED
6773  * - \ref SCIP_STAGE_PRESOLVING
6774  * - \ref SCIP_STAGE_PRESOLVED
6775  *
6776  * @post After calling this method \SCIP reaches one of the following stages:
6777  * - \ref SCIP_STAGE_PRESOLVING if the presolving process was interrupted
6778  * - \ref SCIP_STAGE_PRESOLVED if the presolving process was finished and did not solve the problem
6779  * - \ref SCIP_STAGE_SOLVED if the problem was solved during presolving
6780  *
6781  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6782  */
6783 extern
6785  SCIP* scip /**< SCIP data structure */
6786  );
6787 
6788 /** transforms, presolves, and solves problem
6789  *
6790  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6791  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6792  *
6793  * @pre This method can be called if @p scip is in one of the following stages:
6794  * - \ref SCIP_STAGE_PROBLEM
6795  * - \ref SCIP_STAGE_TRANSFORMED
6796  * - \ref SCIP_STAGE_PRESOLVING
6797  * - \ref SCIP_STAGE_PRESOLVED
6798  * - \ref SCIP_STAGE_SOLVING
6799  * - \ref SCIP_STAGE_SOLVED
6800  *
6801  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
6802  * process was interrupted:
6803 
6804  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
6805  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
6806  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
6807  *
6808  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6809  */
6810 extern
6812  SCIP* scip /**< SCIP data structure */
6813  );
6814 
6815 /** transforms, presolves, and solves problem using additional solvers which emphasize on
6816  * finding solutions.
6817  *
6818  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6819  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6820  *
6821  * @pre This method can be called if @p scip is in one of the following stages:
6822  * - \ref SCIP_STAGE_PROBLEM
6823  * - \ref SCIP_STAGE_TRANSFORMED
6824  * - \ref SCIP_STAGE_PRESOLVING
6825  * - \ref SCIP_STAGE_PRESOLVED
6826  * - \ref SCIP_STAGE_SOLVING
6827  * - \ref SCIP_STAGE_SOLVED
6828  *
6829  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
6830  * process was interrupted:
6831  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
6832  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
6833  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
6834  *
6835  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6836  */
6837 extern
6839  SCIP* scip /**< SCIP data structure */
6840  );
6841 
6842 /** frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is
6843  * preserved
6844  *
6845  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6846  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6847  *
6848  * @pre This method can be called if @p scip is in one of the following stages:
6849  * - \ref SCIP_STAGE_INIT
6850  * - \ref SCIP_STAGE_PROBLEM
6851  * - \ref SCIP_STAGE_TRANSFORMED
6852  * - \ref SCIP_STAGE_PRESOLVING
6853  * - \ref SCIP_STAGE_PRESOLVED
6854  * - \ref SCIP_STAGE_SOLVING
6855  * - \ref SCIP_STAGE_SOLVED
6856  *
6857  * @post If this method is called in \SCIP stage \ref SCIP_STAGE_INIT or \ref SCIP_STAGE_PROBLEM, the stage of
6858  * \SCIP is not changed; otherwise, the \SCIP stage is changed to \ref SCIP_STAGE_TRANSFORMED
6859  *
6860  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6861  */
6862 extern
6864  SCIP* scip, /**< SCIP data structure */
6865  SCIP_Bool restart /**< should certain data be preserved for improved restarting? */
6866  );
6867 
6868 /** frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is
6869  * preserved
6870  *
6871  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6872  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6873  *
6874  * @pre This method can be called if @p scip is in one of the following stages:
6875  * - \ref SCIP_STAGE_INIT
6876  * - \ref SCIP_STAGE_PROBLEM
6877  * - \ref SCIP_STAGE_TRANSFORMED
6878  * - \ref SCIP_STAGE_PRESOLVING
6879  * - \ref SCIP_STAGE_PRESOLVED
6880  * - \ref SCIP_STAGE_SOLVING
6881  * - \ref SCIP_STAGE_SOLVED
6882  *
6883  * @post If this method is called in \SCIP stage \ref SCIP_STAGE_INIT or \ref SCIP_STAGE_PROBLEM, the stage of
6884  * \SCIP is not changed; otherwise, the \SCIP stage is changed to \ref SCIP_STAGE_PRESOLVED.
6885  *
6886  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6887  */
6888 extern
6890  SCIP* scip /**< SCIP data structure */
6891  );
6892 
6893 /** frees all solution process data including presolving and transformed problem, only original problem is kept
6894  *
6895  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6896  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6897  *
6898  * @pre This method can be called if @p scip is in one of the following stages:
6899  * - \ref SCIP_STAGE_INIT
6900  * - \ref SCIP_STAGE_PROBLEM
6901  * - \ref SCIP_STAGE_TRANSFORMED
6902  * - \ref SCIP_STAGE_PRESOLVING
6903  * - \ref SCIP_STAGE_PRESOLVED
6904  * - \ref SCIP_STAGE_SOLVING
6905  * - \ref SCIP_STAGE_SOLVED
6906  *
6907  * @post After calling this method \SCIP reaches one of the following stages:
6908  * - \ref SCIP_STAGE_INIT if the method was called from \SCIP stage \ref SCIP_STAGE_INIT
6909  * - \ref SCIP_STAGE_PROBLEM if the method was called from any other of the allowed stages
6910  *
6911  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6912  */
6913 extern
6915  SCIP* scip /**< SCIP data structure */
6916  );
6917 
6918 /** informs \SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has
6919  * been solved)
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_TRANSFORMING
6927  * - \ref SCIP_STAGE_TRANSFORMED
6928  * - \ref SCIP_STAGE_INITPRESOLVE
6929  * - \ref SCIP_STAGE_PRESOLVING
6930  * - \ref SCIP_STAGE_EXITPRESOLVE
6931  * - \ref SCIP_STAGE_PRESOLVED
6932  * - \ref SCIP_STAGE_SOLVING
6933  * - \ref SCIP_STAGE_SOLVED
6934  * - \ref SCIP_STAGE_EXITSOLVE
6935  * - \ref SCIP_STAGE_FREETRANS
6936  *
6937  * @note the \SCIP stage does not get changed
6938  */
6939 extern
6941  SCIP* scip /**< SCIP data structure */
6942  );
6943 
6944 /** informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has
6945  * been solved)
6946  *
6947  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6948  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6949  *
6950  * @pre This method can be called if @p scip is in one of the following stages:
6951  * - \ref SCIP_STAGE_INITPRESOLVE
6952  * - \ref SCIP_STAGE_PRESOLVING
6953  * - \ref SCIP_STAGE_EXITPRESOLVE
6954  * - \ref SCIP_STAGE_SOLVING
6955  *
6956  * @note the \SCIP stage does not get changed
6957  */
6958 extern
6960  SCIP* scip /**< SCIP data structure */
6961  );
6962 
6963 /** include specific heuristics and branching rules for reoptimization
6964  *
6965  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6966  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6967  *
6968  * @pre This method can be called if @p scip is in one of the following stages:
6969  * - \ref SCIP_STAGE_PROBLEM
6970  */
6971 extern
6973  SCIP* scip, /**< SCIP data structure */
6974  SCIP_Bool enable /**< enable reoptimization (TRUE) or disable it (FALSE) */
6975  );
6976 
6977 /** returns whether reoptimization is enabled or not */
6978 extern
6980  SCIP* scip /**< SCIP data structure */
6981  );
6982 
6983 /** returns the stored solutions corresponding to a given run */
6984 extern
6986  SCIP* scip, /**< SCIP data structue */
6987  int run, /**< number of the run */
6988  SCIP_SOL** sols, /**< array to store solutions */
6989  int allocmem, /**< allocated size of the array */
6990  int* nsols /**< number of solutions */
6991  );
6992 
6993 /** mark all stored solutions as not updated */
6994 extern
6996  SCIP* scip /**< SCIP data structure */
6997  );
6998 
6999 /** check if the reoptimization process should be restarted
7000  *
7001  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7002  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7003  *
7004  * @pre This method can be called if @p scip is in one of the following stages:
7005  * - \ref SCIP_STAGE_TRANSFORMED
7006  * - \ref SCIP_STAGE_SOLVING
7007  */
7008 extern
7010  SCIP* scip, /**< SCIP data structure */
7011  SCIP_NODE* node, /**< current node of the branch and bound tree (or NULL) */
7012  SCIP_Bool* restart /**< pointer to store of the reoptimitation process should be restarted */
7013  );
7014 
7015 /** save bound change based on dual information in the reoptimization tree
7016  *
7017  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7018  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7019  *
7020  * @pre This method can be called if @p scip is in one of the following stages:
7021  * - \ref SCIP_STAGE_SOLVING
7022  * - \ref SCIP_STAGE_SOLVED
7023  */
7024 extern
7026  SCIP* scip, /**< SCIP data structure */
7027  SCIP_NODE* node, /**< node of the search tree */
7028  SCIP_VAR* var, /**< variable whose bound changed */
7029  SCIP_Real newbound, /**< new bound of the variable */
7030  SCIP_Real oldbound /**< old bound of the variable */
7031  );
7032 
7033 /** returns the optimal solution of the last iteration or NULL of none exists */
7034 extern
7036  SCIP* scip /**< SCIP data structure */
7037  );
7038 
7039 /** returns the objective coefficent of a given variable in a previous iteration
7040  *
7041  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7042  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7043  *
7044  * @pre This method can be called if @p scip is in one of the following stages:
7045  * - \ref SCIP_STAGE_PRESOLVING
7046  * - \ref SCIP_STAGE_SOLVING
7047  */
7048 extern
7050  SCIP* scip, /**< SCIP data structure */
7051  SCIP_VAR* var, /**< variable */
7052  int run, /**< number of the run */
7053  SCIP_Real* objcoef /**< pointer to store the objective coefficient */
7054  );
7055 
7056 /** returns whether we are in the restarting phase
7057  *
7058  * @return TRUE, if we are in the restarting phase; FALSE, otherwise
7059  *
7060  * @pre This method can be called if @p scip is in one of the following stages:
7061  * - \ref SCIP_STAGE_INITPRESOLVE
7062  * - \ref SCIP_STAGE_PRESOLVING
7063  * - \ref SCIP_STAGE_EXITPRESOLVE
7064  * - \ref SCIP_STAGE_PRESOLVED
7065  * - \ref SCIP_STAGE_INITSOLVE
7066  * - \ref SCIP_STAGE_SOLVING
7067  * - \ref SCIP_STAGE_SOLVED
7068  * - \ref SCIP_STAGE_EXITSOLVE
7069  * - \ref SCIP_STAGE_FREETRANS
7070  */
7071 extern
7073  SCIP* scip /**< SCIP data structure */
7074  );
7075 
7076 /**@} */
7077 
7078 
7079 
7080 
7081 /*
7082  * variable methods
7083  */
7084 
7085 /**@addtogroup PublicVariableMethods
7086  *
7087  *@{
7088  */
7089 
7090 /** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded;
7091  * an integer variable with bounds zero and one is automatically converted into a binary variable;
7092  *
7093  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
7094  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
7095  * original objective function value of variables created during the solving process has to be multiplied by
7096  * -1, too.
7097  *
7098  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7099  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7100  *
7101  * @pre This method can be called if @p scip is in one of the following stages:
7102  * - \ref SCIP_STAGE_PROBLEM
7103  * - \ref SCIP_STAGE_TRANSFORMING
7104  * - \ref SCIP_STAGE_INITPRESOLVE
7105  * - \ref SCIP_STAGE_PRESOLVING
7106  * - \ref SCIP_STAGE_EXITPRESOLVE
7107  * - \ref SCIP_STAGE_PRESOLVED
7108  * - \ref SCIP_STAGE_SOLVING
7109  *
7110  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
7111  */
7112 extern
7114  SCIP* scip, /**< SCIP data structure */
7115  SCIP_VAR** var, /**< pointer to variable object */
7116  const char* name, /**< name of variable, or NULL for automatic name creation */
7117  SCIP_Real lb, /**< lower bound of variable */
7118  SCIP_Real ub, /**< upper bound of variable */
7119  SCIP_Real obj, /**< objective function value */
7120  SCIP_VARTYPE vartype, /**< type of variable */
7121  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
7122  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
7123  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
7124  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
7125  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
7126  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
7127  SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */
7128  );
7129 
7130 /** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set
7131  * afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(),
7132  * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE
7133  * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.;
7134  * if variable is of integral type, fractional bounds are automatically rounded;
7135  * an integer variable with bounds zero and one is automatically converted into a binary variable;
7136  *
7137  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
7138  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
7139  * original objective function value of variables created during the solving process has to be multiplied by
7140  * -1, too.
7141  *
7142  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7143  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7144  *
7145  * @pre This method can be called if @p scip is in one of the following stages:
7146  * - \ref SCIP_STAGE_PROBLEM
7147  * - \ref SCIP_STAGE_TRANSFORMING
7148  * - \ref SCIP_STAGE_INITPRESOLVE
7149  * - \ref SCIP_STAGE_PRESOLVING
7150  * - \ref SCIP_STAGE_EXITPRESOLVE
7151  * - \ref SCIP_STAGE_PRESOLVED
7152  * - \ref SCIP_STAGE_SOLVING
7153  *
7154  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
7155  */
7156 extern
7158  SCIP* scip, /**< SCIP data structure */
7159  SCIP_VAR** var, /**< pointer to variable object */
7160  const char* name, /**< name of variable, or NULL for automatic name creation */
7161  SCIP_Real lb, /**< lower bound of variable */
7162  SCIP_Real ub, /**< upper bound of variable */
7163  SCIP_Real obj, /**< objective function value */
7164  SCIP_VARTYPE vartype /**< type of variable */
7165  );
7166 
7167 /** outputs the variable name to the file stream
7168  *
7169  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7170  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7171  *
7172  * @pre This method can be called if @p scip is in one of the following stages:
7173  * - \ref SCIP_STAGE_PROBLEM
7174  * - \ref SCIP_STAGE_TRANSFORMING
7175  * - \ref SCIP_STAGE_TRANSFORMED
7176  * - \ref SCIP_STAGE_INITPRESOLVE
7177  * - \ref SCIP_STAGE_PRESOLVING
7178  * - \ref SCIP_STAGE_EXITPRESOLVE
7179  * - \ref SCIP_STAGE_PRESOLVED
7180  * - \ref SCIP_STAGE_INITSOLVE
7181  * - \ref SCIP_STAGE_SOLVING
7182  * - \ref SCIP_STAGE_SOLVED
7183  * - \ref SCIP_STAGE_EXITSOLVE
7184  * - \ref SCIP_STAGE_FREETRANS
7185  */
7186 extern
7188  SCIP* scip, /**< SCIP data structure */
7189  FILE* file, /**< output file, or NULL for stdout */
7190  SCIP_VAR* var, /**< variable to output */
7191  SCIP_Bool type /**< should the variable type be also posted */
7192  );
7193 
7194 /** print the given list of variables to output stream separated by the given delimiter character;
7195  *
7196  * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
7197  *
7198  * the method SCIPparseVarsList() can parse such a string
7199  *
7200  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7201  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7202  *
7203  * @pre This method can be called if @p scip is in one of the following stages:
7204  * - \ref SCIP_STAGE_PROBLEM
7205  * - \ref SCIP_STAGE_TRANSFORMING
7206  * - \ref SCIP_STAGE_TRANSFORMED
7207  * - \ref SCIP_STAGE_INITPRESOLVE
7208  * - \ref SCIP_STAGE_PRESOLVING
7209  * - \ref SCIP_STAGE_EXITPRESOLVE
7210  * - \ref SCIP_STAGE_PRESOLVED
7211  * - \ref SCIP_STAGE_INITSOLVE
7212  * - \ref SCIP_STAGE_SOLVING
7213  * - \ref SCIP_STAGE_SOLVED
7214  * - \ref SCIP_STAGE_EXITSOLVE
7215  * - \ref SCIP_STAGE_FREETRANS
7216  *
7217  * @note The printing process is done via the message handler system.
7218  */
7219 extern
7221  SCIP* scip, /**< SCIP data structure */
7222  FILE* file, /**< output file, or NULL for stdout */
7223  SCIP_VAR** vars, /**< variable array to output */
7224  int nvars, /**< number of variables */
7225  SCIP_Bool type, /**< should the variable type be also posted */
7226  char delimiter /**< character which is used for delimitation */
7227  );
7228 
7229 /** print the given variables and coefficients as linear sum in the following form
7230  * c1 <x1> + c2 <x2> ... + cn <xn>
7231  *
7232  * This string can be parsed by the method SCIPparseVarsLinearsum().
7233  *
7234  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7235  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7236  *
7237  * @pre This method can be called if @p scip is in one of the following stages:
7238  * - \ref SCIP_STAGE_PROBLEM
7239  * - \ref SCIP_STAGE_TRANSFORMING
7240  * - \ref SCIP_STAGE_TRANSFORMED
7241  * - \ref SCIP_STAGE_INITPRESOLVE
7242  * - \ref SCIP_STAGE_PRESOLVING
7243  * - \ref SCIP_STAGE_EXITPRESOLVE
7244  * - \ref SCIP_STAGE_PRESOLVED
7245  * - \ref SCIP_STAGE_INITSOLVE
7246  * - \ref SCIP_STAGE_SOLVING
7247  * - \ref SCIP_STAGE_SOLVED
7248  * - \ref SCIP_STAGE_EXITSOLVE
7249  * - \ref SCIP_STAGE_FREETRANS
7250  *
7251  * @note The printing process is done via the message handler system.
7252  */
7253 extern
7255  SCIP* scip, /**< SCIP data structure */
7256  FILE* file, /**< output file, or NULL for stdout */
7257  SCIP_VAR** vars, /**< variable array to output */
7258  SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
7259  int nvars, /**< number of variables */
7260  SCIP_Bool type /**< should the variable type be also posted */
7261  );
7262 
7263 /** print the given monomials as polynomial in the following form
7264  * c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...
7265  *
7266  * This string can be parsed by the method SCIPparseVarsPolynomial().
7267  *
7268  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7269  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7270  *
7271  * @pre This method can be called if @p scip is in one of the following stages:
7272  * - \ref SCIP_STAGE_PROBLEM
7273  * - \ref SCIP_STAGE_TRANSFORMING
7274  * - \ref SCIP_STAGE_TRANSFORMED
7275  * - \ref SCIP_STAGE_INITPRESOLVE
7276  * - \ref SCIP_STAGE_PRESOLVING
7277  * - \ref SCIP_STAGE_EXITPRESOLVE
7278  * - \ref SCIP_STAGE_PRESOLVED
7279  * - \ref SCIP_STAGE_INITSOLVE
7280  * - \ref SCIP_STAGE_SOLVING
7281  * - \ref SCIP_STAGE_SOLVED
7282  * - \ref SCIP_STAGE_EXITSOLVE
7283  * - \ref SCIP_STAGE_FREETRANS
7284  *
7285  * @note The printing process is done via the message handler system.
7286  */
7287 extern
7289  SCIP* scip, /**< SCIP data structure */
7290  FILE* file, /**< output file, or NULL for stdout */
7291  SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */
7292  SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */
7293  SCIP_Real* monomialcoefs, /**< array with monomial coefficients */
7294  int* monomialnvars, /**< array with number of variables for each monomial */
7295  int nmonomials, /**< number of monomials */
7296  SCIP_Bool type /**< should the variable type be also posted */
7297  );
7298 
7299 /** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
7300  * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
7301  * variable with bounds zero and one is automatically converted into a binary variable
7302  *
7303  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7304  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7305  *
7306  * @pre This method can be called if @p scip is in one of the following stages:
7307  * - \ref SCIP_STAGE_PROBLEM
7308  * - \ref SCIP_STAGE_TRANSFORMING
7309  * - \ref SCIP_STAGE_INITPRESOLVE
7310  * - \ref SCIP_STAGE_PRESOLVING
7311  * - \ref SCIP_STAGE_EXITPRESOLVE
7312  * - \ref SCIP_STAGE_PRESOLVED
7313  * - \ref SCIP_STAGE_SOLVING
7314  */
7315 extern
7317  SCIP* scip, /**< SCIP data structure */
7318  SCIP_VAR** var, /**< pointer to store the problem variable */
7319  const char* str, /**< string to parse */
7320  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
7321  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
7322  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
7323  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
7324  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
7325  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
7326  SCIP_VARDATA* vardata, /**< user data for this specific variable */
7327  char** endptr, /**< pointer to store the final string position if successful */
7328  SCIP_Bool* success /**< pointer store if the paring process was successful */
7329  );
7330 
7331 /** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
7332  * exits and returns the position where the parsing stopped
7333  *
7334  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7335  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7336  *
7337  * @pre This method can be called if @p scip is in one of the following stages:
7338  * - \ref SCIP_STAGE_PROBLEM
7339  * - \ref SCIP_STAGE_TRANSFORMING
7340  * - \ref SCIP_STAGE_INITPRESOLVE
7341  * - \ref SCIP_STAGE_PRESOLVING
7342  * - \ref SCIP_STAGE_EXITPRESOLVE
7343  * - \ref SCIP_STAGE_PRESOLVED
7344  * - \ref SCIP_STAGE_SOLVING
7345  */
7346 extern
7348  SCIP* scip, /**< SCIP data structure */
7349  const char* str, /**< string to parse */
7350  SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */
7351  char** endptr /**< pointer to store the final string position if successful */
7352  );
7353 
7354 /** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
7355  * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
7356  *
7357  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7358  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7359  *
7360  * @pre This method can be called if @p scip is in one of the following stages:
7361  * - \ref SCIP_STAGE_PROBLEM
7362  * - \ref SCIP_STAGE_TRANSFORMING
7363  * - \ref SCIP_STAGE_INITPRESOLVE
7364  * - \ref SCIP_STAGE_PRESOLVING
7365  * - \ref SCIP_STAGE_EXITPRESOLVE
7366  * - \ref SCIP_STAGE_PRESOLVED
7367  * - \ref SCIP_STAGE_SOLVING
7368  *
7369  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
7370  *
7371  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
7372  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
7373  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
7374  * memory functions).
7375  */
7376 extern
7378  SCIP* scip, /**< SCIP data structure */
7379  const char* str, /**< string to parse */
7380  SCIP_VAR** vars, /**< array to store the parsed variable */
7381  int* nvars, /**< pointer to store number of parsed variables */
7382  int varssize, /**< size of the variable array */
7383  int* requiredsize, /**< pointer to store the required array size for the active variables */
7384  char** endptr, /**< pointer to store the final string position if successful */
7385  char delimiter, /**< character which is used for delimitation */
7386  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7387  );
7388 
7389 /** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
7390  * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
7391  *
7392  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7393  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7394  *
7395  * @pre This method can be called if @p scip is in one of the following stages:
7396  * - \ref SCIP_STAGE_PROBLEM
7397  * - \ref SCIP_STAGE_TRANSFORMING
7398  * - \ref SCIP_STAGE_INITPRESOLVE
7399  * - \ref SCIP_STAGE_PRESOLVING
7400  * - \ref SCIP_STAGE_EXITPRESOLVE
7401  * - \ref SCIP_STAGE_PRESOLVED
7402  * - \ref SCIP_STAGE_SOLVING
7403  *
7404  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
7405  *
7406  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
7407  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
7408  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
7409  * memory functions).
7410  */
7411 extern
7413  SCIP* scip, /**< SCIP data structure */
7414  const char* str, /**< string to parse */
7415  SCIP_VAR** vars, /**< array to store the parsed variables */
7416  SCIP_Real* vals, /**< array to store the parsed coefficients */
7417  int* nvars, /**< pointer to store number of parsed variables */
7418  int varssize, /**< size of the variable array */
7419  int* requiredsize, /**< pointer to store the required array size for the active variables */
7420  char** endptr, /**< pointer to store the final string position if successful */
7421  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7422  );
7423 
7424 /** parse the given string as polynomial of variables and coefficients
7425  * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
7426  * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
7427  *
7428  * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
7429  * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
7430  * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
7431  * they use buffer memory that is intended for short term use only.
7432  *
7433  * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
7434  * are recognized.
7435  *
7436  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7437  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7438  *
7439  * @pre This method can be called if @p scip is in one of the following stages:
7440  * - \ref SCIP_STAGE_PROBLEM
7441  * - \ref SCIP_STAGE_TRANSFORMING
7442  * - \ref SCIP_STAGE_INITPRESOLVE
7443  * - \ref SCIP_STAGE_PRESOLVING
7444  * - \ref SCIP_STAGE_EXITPRESOLVE
7445  * - \ref SCIP_STAGE_PRESOLVED
7446  * - \ref SCIP_STAGE_SOLVING
7447  */
7448 extern
7450  SCIP* scip, /**< SCIP data structure */
7451  const char* str, /**< string to parse */
7452  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
7453  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
7454  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
7455  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
7456  int* nmonomials, /**< pointer to store number of parsed monomials */
7457  char** endptr, /**< pointer to store the final string position if successful */
7458  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7459  );
7460 
7461 /** frees memory allocated when parsing a polynomial from a string
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**** monomialvars, /**< pointer to store arrays with variables for each monomial */
7479  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
7480  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
7481  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
7482  int nmonomials /**< pointer to store number of parsed monomials */
7483  );
7484 
7485 /** increases usage counter of variable
7486  *
7487  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7488  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7489  *
7490  * @pre This method can be called if @p scip is in one of the following stages:
7491  * - \ref SCIP_STAGE_PROBLEM
7492  * - \ref SCIP_STAGE_TRANSFORMING
7493  * - \ref SCIP_STAGE_TRANSFORMED
7494  * - \ref SCIP_STAGE_INITPRESOLVE
7495  * - \ref SCIP_STAGE_PRESOLVING
7496  * - \ref SCIP_STAGE_EXITPRESOLVE
7497  * - \ref SCIP_STAGE_PRESOLVED
7498  * - \ref SCIP_STAGE_INITSOLVE
7499  * - \ref SCIP_STAGE_SOLVING
7500  * - \ref SCIP_STAGE_SOLVED
7501  * - \ref SCIP_STAGE_EXITSOLVE
7502  */
7503 extern
7505  SCIP* scip, /**< SCIP data structure */
7506  SCIP_VAR* var /**< variable to capture */
7507  );
7508 
7509 /** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
7510  *
7511  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7512  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7513  *
7514  * @pre This method can be called if @p scip is in one of the following stages:
7515  * - \ref SCIP_STAGE_PROBLEM
7516  * - \ref SCIP_STAGE_TRANSFORMING
7517  * - \ref SCIP_STAGE_TRANSFORMED
7518  * - \ref SCIP_STAGE_INITPRESOLVE
7519  * - \ref SCIP_STAGE_PRESOLVING
7520  * - \ref SCIP_STAGE_EXITPRESOLVE
7521  * - \ref SCIP_STAGE_PRESOLVED
7522  * - \ref SCIP_STAGE_INITSOLVE
7523  * - \ref SCIP_STAGE_SOLVING
7524  * - \ref SCIP_STAGE_SOLVED
7525  * - \ref SCIP_STAGE_EXITSOLVE
7526  * - \ref SCIP_STAGE_FREETRANS
7527  *
7528  * @note the pointer of the variable will be NULLed
7529  */
7530 extern
7532  SCIP* scip, /**< SCIP data structure */
7533  SCIP_VAR** var /**< pointer to variable */
7534  );
7535 
7536 /** changes the name of a variable
7537  *
7538  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7539  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7540  *
7541  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM
7542  *
7543  * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h
7544  */
7545 extern
7547  SCIP* scip, /**< SCIP data structure */
7548  SCIP_VAR* var, /**< variable */
7549  const char* name /**< new name of constraint */
7550  );
7551 
7552 /** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
7553  * a new transformed variable for this variable is created
7554  *
7555  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7556  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7557  *
7558  * @pre This method can be called if @p scip is in one of the following stages:
7559  * - \ref SCIP_STAGE_TRANSFORMING
7560  * - \ref SCIP_STAGE_TRANSFORMED
7561  * - \ref SCIP_STAGE_INITPRESOLVE
7562  * - \ref SCIP_STAGE_PRESOLVING
7563  * - \ref SCIP_STAGE_EXITPRESOLVE
7564  * - \ref SCIP_STAGE_PRESOLVED
7565  * - \ref SCIP_STAGE_INITSOLVE
7566  * - \ref SCIP_STAGE_SOLVING
7567  */
7568 extern
7570  SCIP* scip, /**< SCIP data structure */
7571  SCIP_VAR* var, /**< variable to get/create transformed variable for */
7572  SCIP_VAR** transvar /**< pointer to store the transformed variable */
7573  );
7574 
7575 /** gets and captures transformed variables for an array of variables;
7576  * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
7577  * it is possible to call this method with vars == transvars
7578  *
7579  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7580  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7581  *
7582  * @pre This method can be called if @p scip is in one of the following stages:
7583  * - \ref SCIP_STAGE_TRANSFORMING
7584  * - \ref SCIP_STAGE_TRANSFORMED
7585  * - \ref SCIP_STAGE_INITPRESOLVE
7586  * - \ref SCIP_STAGE_PRESOLVING
7587  * - \ref SCIP_STAGE_EXITPRESOLVE
7588  * - \ref SCIP_STAGE_PRESOLVED
7589  * - \ref SCIP_STAGE_INITSOLVE
7590  * - \ref SCIP_STAGE_SOLVING
7591  */
7592 extern
7594  SCIP* scip, /**< SCIP data structure */
7595  int nvars, /**< number of variables to get/create transformed variables for */
7596  SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */
7597  SCIP_VAR** transvars /**< array to store the transformed variables */
7598  );
7599 
7600 /** gets corresponding transformed variable of a given variable;
7601  * returns NULL as transvar, if transformed variable is not yet existing
7602  *
7603  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7604  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7605  *
7606  * @pre This method can be called if @p scip is in one of the following stages:
7607  * - \ref SCIP_STAGE_TRANSFORMING
7608  * - \ref SCIP_STAGE_TRANSFORMED
7609  * - \ref SCIP_STAGE_INITPRESOLVE
7610  * - \ref SCIP_STAGE_PRESOLVING
7611  * - \ref SCIP_STAGE_EXITPRESOLVE
7612  * - \ref SCIP_STAGE_PRESOLVED
7613  * - \ref SCIP_STAGE_INITSOLVE
7614  * - \ref SCIP_STAGE_SOLVING
7615  * - \ref SCIP_STAGE_SOLVED
7616  * - \ref SCIP_STAGE_EXITSOLVE
7617  * - \ref SCIP_STAGE_FREETRANS
7618  */
7619 extern
7621  SCIP* scip, /**< SCIP data structure */
7622  SCIP_VAR* var, /**< variable to get transformed variable for */
7623  SCIP_VAR** transvar /**< pointer to store the transformed variable */
7624  );
7625 
7626 /** gets corresponding transformed variables for an array of variables;
7627  * stores NULL in a transvars slot, if the transformed variable is not yet existing;
7628  * it is possible to call this method with vars == transvars, but remember that variables that are not
7629  * yet transformed will be replaced with NULL
7630  *
7631  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7632  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7633  *
7634  * @pre This method can be called if @p scip is in one of the following stages:
7635  * - \ref SCIP_STAGE_TRANSFORMING
7636  * - \ref SCIP_STAGE_TRANSFORMED
7637  * - \ref SCIP_STAGE_INITPRESOLVE
7638  * - \ref SCIP_STAGE_PRESOLVING
7639  * - \ref SCIP_STAGE_EXITPRESOLVE
7640  * - \ref SCIP_STAGE_PRESOLVED
7641  * - \ref SCIP_STAGE_INITSOLVE
7642  * - \ref SCIP_STAGE_SOLVING
7643  * - \ref SCIP_STAGE_SOLVED
7644  * - \ref SCIP_STAGE_EXITSOLVE
7645  * - \ref SCIP_STAGE_FREETRANS
7646  */
7647 extern
7649  SCIP* scip, /**< SCIP data structure */
7650  int nvars, /**< number of variables to get transformed variables for */
7651  SCIP_VAR** vars, /**< array with variables to get transformed variables for */
7652  SCIP_VAR** transvars /**< array to store the transformed variables */
7653  );
7654 
7655 /** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing
7656  *
7657  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7658  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7659  *
7660  * @pre This method can be called if @p scip is in one of the following stages:
7661  * - \ref SCIP_STAGE_PROBLEM
7662  * - \ref SCIP_STAGE_TRANSFORMING
7663  * - \ref SCIP_STAGE_TRANSFORMED
7664  * - \ref SCIP_STAGE_INITPRESOLVE
7665  * - \ref SCIP_STAGE_PRESOLVING
7666  * - \ref SCIP_STAGE_EXITPRESOLVE
7667  * - \ref SCIP_STAGE_PRESOLVED
7668  * - \ref SCIP_STAGE_INITSOLVE
7669  * - \ref SCIP_STAGE_SOLVING
7670  * - \ref SCIP_STAGE_SOLVED
7671  * - \ref SCIP_STAGE_EXITSOLVE
7672  * - \ref SCIP_STAGE_FREETRANS
7673  */
7674 extern
7676  SCIP* scip, /**< SCIP data structure */
7677  SCIP_VAR* var, /**< variable to get negated variable for */
7678  SCIP_VAR** negvar /**< pointer to store the negated variable */
7679  );
7680 
7681 /** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing;
7682  * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
7683  *
7684  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7685  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7686  *
7687  * @pre This method can be called if @p scip is in one of the following stages:
7688  * - \ref SCIP_STAGE_PROBLEM
7689  * - \ref SCIP_STAGE_TRANSFORMING
7690  * - \ref SCIP_STAGE_TRANSFORMED
7691  * - \ref SCIP_STAGE_INITPRESOLVE
7692  * - \ref SCIP_STAGE_PRESOLVING
7693  * - \ref SCIP_STAGE_EXITPRESOLVE
7694  * - \ref SCIP_STAGE_PRESOLVED
7695  * - \ref SCIP_STAGE_INITSOLVE
7696  * - \ref SCIP_STAGE_SOLVING
7697  * - \ref SCIP_STAGE_SOLVED
7698  * - \ref SCIP_STAGE_EXITSOLVE
7699  * - \ref SCIP_STAGE_FREETRANS
7700  */
7701 extern
7703  SCIP* scip, /**< SCIP data structure */
7704  int nvars, /**< number of variables to get negated variables for */
7705  SCIP_VAR** vars, /**< array of variables to get negated variables for */
7706  SCIP_VAR** negvars /**< array to store the negated variables */
7707  );
7708 
7709 /** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
7710  * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
7711  *
7712  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7713  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7714  *
7715  * @pre This method can be called if @p scip is in one of the following stages:
7716  * - \ref SCIP_STAGE_PROBLEM
7717  * - \ref SCIP_STAGE_TRANSFORMED
7718  * - \ref SCIP_STAGE_INITPRESOLVE
7719  * - \ref SCIP_STAGE_PRESOLVING
7720  * - \ref SCIP_STAGE_EXITPRESOLVE
7721  * - \ref SCIP_STAGE_PRESOLVED
7722  * - \ref SCIP_STAGE_INITSOLVE
7723  * - \ref SCIP_STAGE_SOLVING
7724  * - \ref SCIP_STAGE_SOLVED
7725  * - \ref SCIP_STAGE_EXITSOLVE
7726  */
7727 extern
7729  SCIP* scip, /**< SCIP data structure */
7730  SCIP_VAR* var, /**< binary variable to get binary representative for */
7731  SCIP_VAR** repvar, /**< pointer to store the binary representative */
7732  SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
7733  );
7734 
7735 /** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
7736  * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
7737  *
7738  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7739  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7740  *
7741  * @pre This method can be called if @p scip is in one of the following stages:
7742  * - \ref SCIP_STAGE_PROBLEM
7743  * - \ref SCIP_STAGE_TRANSFORMED
7744  * - \ref SCIP_STAGE_INITPRESOLVE
7745  * - \ref SCIP_STAGE_PRESOLVING
7746  * - \ref SCIP_STAGE_EXITPRESOLVE
7747  * - \ref SCIP_STAGE_PRESOLVED
7748  * - \ref SCIP_STAGE_INITSOLVE
7749  * - \ref SCIP_STAGE_SOLVING
7750  * - \ref SCIP_STAGE_SOLVED
7751  * - \ref SCIP_STAGE_EXITSOLVE
7752  */
7753 extern
7755  SCIP* scip, /**< SCIP data structure */
7756  int nvars, /**< number of binary variables to get representatives for */
7757  SCIP_VAR** vars, /**< binary variables to get binary representatives for */
7758  SCIP_VAR** repvars, /**< array to store the binary representatives */
7759  SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
7760  );
7761 
7762 /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
7763  *
7764  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7765  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7766  *
7767  * @pre This method can be called if @p scip is in one of the following stages:
7768  * - \ref SCIP_STAGE_INITPRESOLVE
7769  * - \ref SCIP_STAGE_PRESOLVING
7770  * - \ref SCIP_STAGE_EXITPRESOLVE
7771  * - \ref SCIP_STAGE_PRESOLVED
7772  * - \ref SCIP_STAGE_INITSOLVE
7773  * - \ref SCIP_STAGE_SOLVING
7774  * - \ref SCIP_STAGE_SOLVED
7775  */
7776 extern
7778  SCIP* scip, /**< SCIP data structure */
7779  SCIP_VAR* var /**< problem variable */
7780  );
7781 
7782 /** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
7783  * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
7784  *
7785  * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
7786  * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
7787  * representation is stored in the variable array, scalar array and constant.
7788  *
7789  * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
7790  * allocated (e.g., by a C++ 'new' or SCIP functions).
7791  *
7792  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7793  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7794  *
7795  * @pre This method can be called if @p scip is in one of the following stages:
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  * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
7808  * given entries are overwritten.
7809  *
7810  * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
7811  * the method with the linear sum 1.0*x + 0.0.
7812  */
7813 extern
7815  SCIP* scip, /**< SCIP data structure */
7816  SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
7817  * overwritten by the variable array y_1, ..., y_m in the linear sum
7818  * w.r.t. active variables */
7819  SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
7820  * scalars b_1, ..., b_m in the linear sum of the active variables */
7821  int* nvars, /**< pointer to number of variables in the linear sum which will be
7822  * overwritten by the number of variables in the linear sum corresponding
7823  * to the active variables */
7824  int varssize, /**< available slots in vars and scalars array which is needed to check if
7825  * the array are large enough for the linear sum w.r.t. active
7826  * variables */
7827  SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
7828  * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
7829  * d w.r.t. the active variables */
7830  int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
7831  * active variables */
7832  SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
7833  );
7834 
7835 /** transforms given variable, scalar and constant to the corresponding active, fixed, or
7836  * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
7837  * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
7838  * with only one active variable (this can happen due to fixings after the multi-aggregation),
7839  * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
7840  *
7841  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7842  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7843  *
7844  * @pre This method can be called if @p scip is in one of the following stages:
7845  * - \ref SCIP_STAGE_TRANSFORMED
7846  * - \ref SCIP_STAGE_INITPRESOLVE
7847  * - \ref SCIP_STAGE_PRESOLVING
7848  * - \ref SCIP_STAGE_EXITPRESOLVE
7849  * - \ref SCIP_STAGE_PRESOLVED
7850  * - \ref SCIP_STAGE_INITSOLVE
7851  * - \ref SCIP_STAGE_SOLVING
7852  * - \ref SCIP_STAGE_SOLVED
7853  * - \ref SCIP_STAGE_EXITSOLVE
7854  * - \ref SCIP_STAGE_FREETRANS
7855  */
7856 extern
7858  SCIP* scip, /**< SCIP data structure */
7859  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
7860  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
7861  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
7862  );
7863 
7864 /** return for given variables all their active counterparts; all active variables will be pairwise different
7865  * @note It does not hold that the first output variable is the active variable for the first input variable.
7866  *
7867  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7868  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7869  *
7870  * @pre This method can be called if @p scip is in one of the following stages:
7871  * - \ref SCIP_STAGE_TRANSFORMED
7872  * - \ref SCIP_STAGE_INITPRESOLVE
7873  * - \ref SCIP_STAGE_PRESOLVING
7874  * - \ref SCIP_STAGE_EXITPRESOLVE
7875  * - \ref SCIP_STAGE_PRESOLVED
7876  * - \ref SCIP_STAGE_INITSOLVE
7877  * - \ref SCIP_STAGE_SOLVING
7878  * - \ref SCIP_STAGE_SOLVED
7879  * - \ref SCIP_STAGE_EXITSOLVE
7880  * - \ref SCIP_STAGE_FREETRANS
7881  */
7882 extern
7884  SCIP* scip, /**< SCIP data structure */
7885  SCIP_VAR** vars, /**< variable array with given variables and as output all active
7886  * variables, if enough slots exist */
7887  int* nvars, /**< number of given variables, and as output number of active variables,
7888  * if enough slots exist */
7889  int varssize, /**< available slots in vars array */
7890  int* requiredsize /**< pointer to store the required array size for the active variables */
7891  );
7892 
7893 /** returns the reduced costs of the variable in the current node's LP relaxation;
7894  * the current node has to have a feasible LP.
7895  *
7896  * returns SCIP_INVALID if the variable is active but not in the current LP;
7897  * returns 0 if the variable has been aggregated out or fixed in presolving.
7898  *
7899  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7900  */
7901 extern
7903  SCIP* scip, /**< SCIP data structure */
7904  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
7905  );
7906 
7907 /** returns the implied reduced costs of the variable in the current node's LP relaxation;
7908  * the current node has to have a feasible LP.
7909  *
7910  * returns SCIP_INVALID if the variable is active but not in the current LP;
7911  * returns 0 if the variable has been aggregated out or fixed in presolving.
7912  *
7913  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7914  */
7915 extern
7917  SCIP* scip, /**< SCIP data structure */
7918  SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */
7919  SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */
7920  );
7921 
7922 /** returns the Farkas coefficient of the variable in the current node's LP relaxation;
7923  * the current node has to have an infeasible LP.
7924  *
7925  * returns SCIP_INVALID if the variable is active but not in the current LP;
7926  * returns 0 if the variable has been aggregated out or fixed in presolving.
7927  *
7928  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7929  */
7930 extern
7932  SCIP* scip, /**< SCIP data structure */
7933  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
7934  );
7935 
7936 /** returns lower bound of variable directly before or after the bound change given by the bound change index
7937  * was applied
7938  */
7939 extern
7941  SCIP* scip, /**< SCIP data structure */
7942  SCIP_VAR* var, /**< problem variable */
7943  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
7944  SCIP_Bool after /**< should the bound change with given index be included? */
7945  );
7946 
7947 /** returns upper bound of variable directly before or after the bound change given by the bound change index
7948  * was applied
7949  */
7950 extern
7952  SCIP* scip, /**< SCIP data structure */
7953  SCIP_VAR* var, /**< problem variable */
7954  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
7955  SCIP_Bool after /**< should the bound change with given index be included? */
7956  );
7957 
7958 /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
7959  * was applied
7960  */
7961 extern
7963  SCIP* scip, /**< SCIP data structure */
7964  SCIP_VAR* var, /**< problem variable */
7965  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
7966  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
7967  SCIP_Bool after /**< should the bound change with given index be included? */
7968  );
7969 
7970 /** returns whether the binary variable was fixed at the time given by the bound change index */
7971 extern
7973  SCIP* scip, /**< SCIP data structure */
7974  SCIP_VAR* var, /**< problem variable */
7975  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
7976  SCIP_Bool after /**< should the bound change with given index be included? */
7977  );
7978 
7979 /** gets solution value for variable in current node
7980  *
7981  * @return solution value for variable in current node
7982  *
7983  * @pre This method can be called if @p scip is in one of the following stages:
7984  * - \ref SCIP_STAGE_PRESOLVED
7985  * - \ref SCIP_STAGE_SOLVING
7986  */
7987 extern
7989  SCIP* scip, /**< SCIP data structure */
7990  SCIP_VAR* var /**< variable to get solution value for */
7991  );
7992 
7993 /** gets solution values of multiple variables in current node
7994  *
7995  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7996  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7997  *
7998  * @pre This method can be called if @p scip is in one of the following stages:
7999  * - \ref SCIP_STAGE_PRESOLVED
8000  * - \ref SCIP_STAGE_SOLVING
8001  */
8002 extern
8004  SCIP* scip, /**< SCIP data structure */
8005  int nvars, /**< number of variables to get solution value for */
8006  SCIP_VAR** vars, /**< array with variables to get value for */
8007  SCIP_Real* vals /**< array to store solution values of variables */
8008  );
8009 
8010 /** sets the solution value of all variables in the global relaxation solution to zero
8011  *
8012  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8013  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8014  *
8015  * @pre This method can be called if @p scip is in one of the following stages:
8016  * - \ref SCIP_STAGE_PRESOLVED
8017  * - \ref SCIP_STAGE_SOLVING
8018  */
8019 extern
8021  SCIP* scip /**< SCIP data structure */
8022  );
8023 
8024 /** sets the value of the given variable in the global relaxation solution;
8025  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
8026  * You can use SCIPclearRelaxSolVals() to set all values to zero, initially;
8027  * after setting all solution values, you have to call SCIPmarkRelaxSolValid()
8028  * to inform SCIP that the stored solution is valid
8029  *
8030  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8031  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8032  *
8033  * @pre This method can be called if @p scip is in one of the following stages:
8034  * - \ref SCIP_STAGE_PRESOLVED
8035  * - \ref SCIP_STAGE_SOLVING
8036  */
8037 extern
8039  SCIP* scip, /**< SCIP data structure */
8040  SCIP_VAR* var, /**< variable to set value for */
8041  SCIP_Real val /**< solution value of variable */
8042  );
8043 
8044 /** sets the values of the given variables in the global relaxation solution;
8045  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
8046  * the solution is automatically cleared, s.t. all other variables get value 0.0
8047  *
8048  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8049  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8050  *
8051  * @pre This method can be called if @p scip is in one of the following stages:
8052  * - \ref SCIP_STAGE_PRESOLVED
8053  * - \ref SCIP_STAGE_SOLVING
8054  */
8055 extern
8057  SCIP* scip, /**< SCIP data structure */
8058  int nvars, /**< number of variables to set relaxation solution value for */
8059  SCIP_VAR** vars, /**< array with variables to set value for */
8060  SCIP_Real* vals /**< array with solution values of variables */
8061  );
8062 
8063 /** sets the values of the variables in the global relaxation solution to the values
8064  * in the given primal solution; the relaxation solution can be filled by the relaxation hanlders
8065  * and might be used by heuristics and for separation
8066  *
8067  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8068  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8069  *
8070  * @pre This method can be called if @p scip is in one of the following stages:
8071  * - \ref SCIP_STAGE_PRESOLVED
8072  * - \ref SCIP_STAGE_SOLVING
8073  */
8074 extern
8076  SCIP* scip, /**< SCIP data structure */
8077  SCIP_SOL* sol /**< primal relaxation solution */
8078  );
8079 
8080 /** returns whether the relaxation solution is valid
8081  *
8082  * @return TRUE, if the relaxation solution is valid; FALSE, otherwise
8083  *
8084  * @pre This method can be called if @p scip is in one of the following stages:
8085  * - \ref SCIP_STAGE_PRESOLVED
8086  * - \ref SCIP_STAGE_SOLVING
8087  */
8088 extern
8090  SCIP* scip /**< SCIP data structure */
8091  );
8092 
8093 /** informs SCIP, that the relaxation solution is valid
8094  *
8095  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8096  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8097  *
8098  * @pre This method can be called if @p scip is in one of the following stages:
8099  * - \ref SCIP_STAGE_PRESOLVED
8100  * - \ref SCIP_STAGE_SOLVING
8101  */
8102 extern
8104  SCIP* scip /**< SCIP data structure */
8105  );
8106 
8107 /** informs SCIP, that the relaxation solution is invalid
8108  *
8109  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8110  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8111  *
8112  * @pre This method can be called if @p scip is in one of the following stages:
8113  * - \ref SCIP_STAGE_PRESOLVED
8114  * - \ref SCIP_STAGE_SOLVING
8115  */
8116 extern
8118  SCIP* scip /**< SCIP data structure */
8119  );
8120 
8121 /** gets the relaxation solution value of the given variable
8122  *
8123  * @return the relaxation solution value of the given variable
8124  *
8125  * @pre This method can be called if @p scip is in one of the following stages:
8126  * - \ref SCIP_STAGE_PRESOLVED
8127  * - \ref SCIP_STAGE_SOLVING
8128  */
8129 extern
8131  SCIP* scip, /**< SCIP data structure */
8132  SCIP_VAR* var /**< variable to get value for */
8133  );
8134 
8135 /** gets the relaxation solution objective value
8136  *
8137  * @return the objective value of the relaxation solution
8138  *
8139  * @pre This method can be called if @p scip is in one of the following stages:
8140  * - \ref SCIP_STAGE_PRESOLVED
8141  * - \ref SCIP_STAGE_SOLVING
8142  */
8143 extern
8145  SCIP* scip /**< SCIP data structure */
8146  );
8147 
8148 /** start strong branching - call before any strong branching
8149  *
8150  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8151  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8152  *
8153  * @pre This method can be called if @p scip is in one of the following stages:
8154  * - \ref SCIP_STAGE_PRESOLVED
8155  * - \ref SCIP_STAGE_SOLVING
8156  *
8157  * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
8158  * which allow to perform propagation but also creates some overhead
8159  */
8160 extern
8162  SCIP* scip, /**< SCIP data structure */
8163  SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
8164  );
8165 
8166 /** end strong branching - call after any strong branching
8167  *
8168  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8169  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8170  *
8171  * @pre This method can be called if @p scip is in one of the following stages:
8172  * - \ref SCIP_STAGE_PRESOLVED
8173  * - \ref SCIP_STAGE_SOLVING
8174  */
8175 extern
8177  SCIP* scip /**< SCIP data structure */
8178  );
8179 
8180 /** gets strong branching information on column variable with fractional value
8181  *
8182  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8183  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8184  *
8185  * @pre This method can be called if @p scip is in one of the following stages:
8186  * - \ref SCIP_STAGE_PRESOLVED
8187  * - \ref SCIP_STAGE_SOLVING
8188  */
8189 extern
8191  SCIP* scip, /**< SCIP data structure */
8192  SCIP_VAR* var, /**< variable to get strong branching values for */
8193  int itlim, /**< iteration limit for strong branchings */
8194  SCIP_Real* down, /**< stores dual bound after branching column down */
8195  SCIP_Real* up, /**< stores dual bound after branching column up */
8196  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8197  * otherwise, it can only be used as an estimate value */
8198  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8199  * otherwise, it can only be used as an estimate value */
8200  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8201  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8202  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8203  * infeasible downwards branch, or NULL */
8204  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8205  * infeasible upwards branch, or NULL */
8206  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8207  * solving process should be stopped (e.g., due to a time limit) */
8208  );
8209 
8210 /** gets strong branching information with previous domain propagation on column variable
8211  *
8212  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
8213  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
8214  * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
8215  * enabled in the SCIPstartStrongbranch() call.
8216  *
8217  * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
8218  * can be specified by the parameter @p maxproprounds.
8219  *
8220  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8221  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8222  *
8223  * @pre This method can be called if @p scip is in one of the following stages:
8224  * - \ref SCIP_STAGE_PRESOLVED
8225  * - \ref SCIP_STAGE_SOLVING
8226  *
8227  * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
8228  * they are updated w.r.t. the strong branching LP solution.
8229  */
8230 extern
8232  SCIP* scip, /**< SCIP data structure */
8233  SCIP_VAR* var, /**< variable to get strong branching values for */
8234  SCIP_Real solval, /**< value of the variable in the current LP solution */
8235  SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
8236  int itlim, /**< iteration limit for strong branchings */
8237  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
8238  * settings) */
8239  SCIP_Real* down, /**< stores dual bound after branching column down */
8240  SCIP_Real* up, /**< stores dual bound after branching column up */
8241  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8242  * otherwise, it can only be used as an estimate value */
8243  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8244  * otherwise, it can only be used as an estimate value */
8245  SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
8246  SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */
8247  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8248  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8249  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8250  * infeasible downwards branch, or NULL */
8251  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8252  * infeasible upwards branch, or NULL */
8253  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
8254  * solving process should be stopped (e.g., due to a time limit) */
8255  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
8256  SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
8257  );
8258 
8259 /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
8260  * is (val -1.0) and the up brach ins (val +1.0)
8261  *
8262  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8263  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8264  *
8265  * @pre This method can be called if @p scip is in one of the following stages:
8266  * - \ref SCIP_STAGE_PRESOLVED
8267  * - \ref SCIP_STAGE_SOLVING
8268  *
8269  * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
8270  * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
8271  */
8272 extern
8274  SCIP* scip, /**< SCIP data structure */
8275  SCIP_VAR* var, /**< variable to get strong branching values for */
8276  int itlim, /**< iteration limit for strong branchings */
8277  SCIP_Real* down, /**< stores dual bound after branching column down */
8278  SCIP_Real* up, /**< stores dual bound after branching column up */
8279  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8280  * otherwise, it can only be used as an estimate value */
8281  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8282  * otherwise, it can only be used as an estimate value */
8283  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8284  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8285  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8286  * infeasible downwards branch, or NULL */
8287  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8288  * infeasible upwards branch, or NULL */
8289  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8290  * solving process should be stopped (e.g., due to a time limit) */
8291  );
8292 
8293 /** gets strong branching information on column variables with fractional values
8294  *
8295  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8296  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8297  *
8298  * @pre This method can be called if @p scip is in one of the following stages:
8299  * - \ref SCIP_STAGE_PRESOLVED
8300  * - \ref SCIP_STAGE_SOLVING
8301  */
8302 extern
8304  SCIP* scip, /**< SCIP data structure */
8305  SCIP_VAR** vars, /**< variables to get strong branching values for */
8306  int nvars, /**< number of variables */
8307  int itlim, /**< iteration limit for strong branchings */
8308  SCIP_Real* down, /**< stores dual bounds after branching variables down */
8309  SCIP_Real* up, /**< stores dual bounds after branching variables up */
8310  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
8311  * otherwise, they can only be used as an estimate value */
8312  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
8313  * otherwise, they can only be used as an estimate value */
8314  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
8315  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
8316  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
8317  * infeasible downward branches, or NULL */
8318  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
8319  * infeasible upward branches, or NULL */
8320  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8321  * solving process should be stopped (e.g., due to a time limit) */
8322  );
8323 
8324 /** gets strong branching information on column variables with integral values
8325  *
8326  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8327  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8328  *
8329  * @pre This method can be called if @p scip is in one of the following stages:
8330  * - \ref SCIP_STAGE_PRESOLVED
8331  * - \ref SCIP_STAGE_SOLVING
8332  */
8333 extern
8335  SCIP* scip, /**< SCIP data structure */
8336  SCIP_VAR** vars, /**< variables to get strong branching values for */
8337  int nvars, /**< number of variables */
8338  int itlim, /**< iteration limit for strong branchings */
8339  SCIP_Real* down, /**< stores dual bounds after branching variables down */
8340  SCIP_Real* up, /**< stores dual bounds after branching variables up */
8341  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
8342  * otherwise, they can only be used as an estimate value */
8343  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
8344  * otherwise, they can only be used as an estimate value */
8345  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
8346  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
8347  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
8348  * infeasible downward branches, or NULL */
8349  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
8350  * infeasible upward branches, or NULL */
8351  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8352  * solving process should be stopped (e.g., due to a time limit) */
8353  );
8354 
8355 /** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */
8356 extern
8358  SCIP* scip, /**< SCIP data structure */
8359  SCIP_BRANCHDIR branchdir /**< branching direction for which LP solution status is requested */
8360  );
8361 
8362 /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
8363  * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
8364  * keep in mind, that the returned old values may have nothing to do with the current LP solution
8365  *
8366  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8367  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8368  *
8369  * @pre This method can be called if @p scip is in one of the following stages:
8370  * - \ref SCIP_STAGE_SOLVING
8371  * - \ref SCIP_STAGE_SOLVED
8372  */
8373 extern
8375  SCIP* scip, /**< SCIP data structure */
8376  SCIP_VAR* var, /**< variable to get last strong branching values for */
8377  SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
8378  SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
8379  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8380  * otherwise, it can only be used as an estimate value */
8381  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8382  * otherwise, it can only be used as an estimate value */
8383  SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */
8384  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
8385  );
8386 
8387 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
8388  * given variable, or -1 if strong branching was never applied to the variable in current run
8389  *
8390  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8391  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8392  *
8393  * @pre This method can be called if @p scip is in one of the following stages:
8394  * - \ref SCIP_STAGE_TRANSFORMING
8395  * - \ref SCIP_STAGE_TRANSFORMED
8396  * - \ref SCIP_STAGE_INITPRESOLVE
8397  * - \ref SCIP_STAGE_PRESOLVING
8398  * - \ref SCIP_STAGE_EXITPRESOLVE
8399  * - \ref SCIP_STAGE_PRESOLVED
8400  * - \ref SCIP_STAGE_INITSOLVE
8401  * - \ref SCIP_STAGE_SOLVING
8402  * - \ref SCIP_STAGE_SOLVED
8403  * - \ref SCIP_STAGE_EXITSOLVE
8404  */
8405 extern
8407  SCIP* scip, /**< SCIP data structure */
8408  SCIP_VAR* var /**< variable to get last strong branching node for */
8409  );
8410 
8411 /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
8412  * the LP where the strong branching on this variable was applied;
8413  * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
8414  *
8415  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8416  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8417  *
8418  * @pre This method can be called if @p scip is in one of the following stages:
8419  * - \ref SCIP_STAGE_TRANSFORMING
8420  * - \ref SCIP_STAGE_TRANSFORMED
8421  * - \ref SCIP_STAGE_INITPRESOLVE
8422  * - \ref SCIP_STAGE_PRESOLVING
8423  * - \ref SCIP_STAGE_EXITPRESOLVE
8424  * - \ref SCIP_STAGE_PRESOLVED
8425  * - \ref SCIP_STAGE_INITSOLVE
8426  * - \ref SCIP_STAGE_SOLVING
8427  * - \ref SCIP_STAGE_SOLVED
8428  * - \ref SCIP_STAGE_EXITSOLVE
8429  */
8430 extern
8432  SCIP* scip, /**< SCIP data structure */
8433  SCIP_VAR* var /**< variable to get strong branching LP age for */
8434  );
8435 
8436 /** gets number of times, strong branching was applied in current run on the given variable
8437  *
8438  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8439  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8440  *
8441  * @pre This method can be called if @p scip is in one of the following stages:
8442  * - \ref SCIP_STAGE_TRANSFORMING
8443  * - \ref SCIP_STAGE_TRANSFORMED
8444  * - \ref SCIP_STAGE_INITPRESOLVE
8445  * - \ref SCIP_STAGE_PRESOLVING
8446  * - \ref SCIP_STAGE_EXITPRESOLVE
8447  * - \ref SCIP_STAGE_PRESOLVED
8448  * - \ref SCIP_STAGE_INITSOLVE
8449  * - \ref SCIP_STAGE_SOLVING
8450  * - \ref SCIP_STAGE_SOLVED
8451  * - \ref SCIP_STAGE_EXITSOLVE
8452  */
8453 extern
8455  SCIP* scip, /**< SCIP data structure */
8456  SCIP_VAR* var /**< variable to get last strong branching node for */
8457  );
8458 
8459 /** adds given values to lock numbers of variable for rounding
8460  *
8461  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8462  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8463  *
8464  * @pre This method can be called if @p scip is in one of the following stages:
8465  * - \ref SCIP_STAGE_PROBLEM
8466  * - \ref SCIP_STAGE_TRANSFORMING
8467  * - \ref SCIP_STAGE_TRANSFORMED
8468  * - \ref SCIP_STAGE_INITPRESOLVE
8469  * - \ref SCIP_STAGE_PRESOLVING
8470  * - \ref SCIP_STAGE_EXITPRESOLVE
8471  * - \ref SCIP_STAGE_PRESOLVED
8472  * - \ref SCIP_STAGE_INITSOLVE
8473  * - \ref SCIP_STAGE_SOLVING
8474  * - \ref SCIP_STAGE_EXITSOLVE
8475  * - \ref SCIP_STAGE_FREETRANS
8476  */
8477 extern
8479  SCIP* scip, /**< SCIP data structure */
8480  SCIP_VAR* var, /**< problem variable */
8481  int nlocksdown, /**< modification in number of rounding down locks */
8482  int nlocksup /**< modification in number of rounding up locks */
8483  );
8484 
8485 /** locks rounding of variable with respect to the lock status of the constraint and its negation;
8486  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
8487  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
8488  * added or removed
8489  *
8490  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8491  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8492  *
8493  * @pre This method can be called if @p scip is in one of the following stages:
8494  * - \ref SCIP_STAGE_PROBLEM
8495  * - \ref SCIP_STAGE_TRANSFORMING
8496  * - \ref SCIP_STAGE_INITPRESOLVE
8497  * - \ref SCIP_STAGE_PRESOLVING
8498  * - \ref SCIP_STAGE_EXITPRESOLVE
8499  * - \ref SCIP_STAGE_INITSOLVE
8500  * - \ref SCIP_STAGE_SOLVING
8501  * - \ref SCIP_STAGE_EXITSOLVE
8502  * - \ref SCIP_STAGE_FREETRANS
8503  */
8504 extern
8506  SCIP* scip, /**< SCIP data structure */
8507  SCIP_VAR* var, /**< problem variable */
8508  SCIP_CONS* cons, /**< constraint */
8509  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
8510  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
8511  );
8512 
8513 /** unlocks rounding of variable with respect to the lock status of the constraint and its negation;
8514  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
8515  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
8516  * added or removed
8517  *
8518  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8519  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8520  *
8521  * @pre This method can be called if @p scip is in one of the following stages:
8522  * - \ref SCIP_STAGE_PROBLEM
8523  * - \ref SCIP_STAGE_TRANSFORMING
8524  * - \ref SCIP_STAGE_INITPRESOLVE
8525  * - \ref SCIP_STAGE_PRESOLVING
8526  * - \ref SCIP_STAGE_EXITPRESOLVE
8527  * - \ref SCIP_STAGE_INITSOLVE
8528  * - \ref SCIP_STAGE_SOLVING
8529  * - \ref SCIP_STAGE_EXITSOLVE
8530  * - \ref SCIP_STAGE_FREETRANS
8531  */
8532 extern
8534  SCIP* scip, /**< SCIP data structure */
8535  SCIP_VAR* var, /**< problem variable */
8536  SCIP_CONS* cons, /**< constraint */
8537  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
8538  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
8539  );
8540 
8541 /** changes variable's objective value
8542  *
8543  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8544  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8545  *
8546  * @pre This method can be called if @p scip is in one of the following stages:
8547  * - \ref SCIP_STAGE_PROBLEM
8548  * - \ref SCIP_STAGE_TRANSFORMING
8549  * - \ref SCIP_STAGE_PRESOLVING
8550  */
8551 extern
8553  SCIP* scip, /**< SCIP data structure */
8554  SCIP_VAR* var, /**< variable to change the objective value for */
8555  SCIP_Real newobj /**< new objective value */
8556  );
8557 
8558 /** adds value to variable's objective value
8559  *
8560  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8561  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8562  *
8563  * @pre This method can be called if @p scip is in one of the following stages:
8564  * - \ref SCIP_STAGE_PROBLEM
8565  * - \ref SCIP_STAGE_TRANSFORMING
8566  * - \ref SCIP_STAGE_PRESOLVING
8567  * - \ref SCIP_STAGE_EXITPRESOLVE
8568  * - \ref SCIP_STAGE_PRESOLVED
8569  */
8570 extern
8572  SCIP* scip, /**< SCIP data structure */
8573  SCIP_VAR* var, /**< variable to change the objective value for */
8574  SCIP_Real addobj /**< additional objective value */
8575  );
8576 
8577 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
8578  * does not change the bounds of the variable
8579  *
8580  * @return adjusted lower bound for the given variable; the bound of the variable is not changed
8581  *
8582  * @pre This method can be called if @p scip is in one of the following stages:
8583  * - \ref SCIP_STAGE_PROBLEM
8584  * - \ref SCIP_STAGE_TRANSFORMING
8585  * - \ref SCIP_STAGE_TRANSFORMED
8586  * - \ref SCIP_STAGE_INITPRESOLVE
8587  * - \ref SCIP_STAGE_PRESOLVING
8588  * - \ref SCIP_STAGE_EXITPRESOLVE
8589  * - \ref SCIP_STAGE_PRESOLVED
8590  * - \ref SCIP_STAGE_INITSOLVE
8591  * - \ref SCIP_STAGE_SOLVING
8592  * - \ref SCIP_STAGE_SOLVED
8593  * - \ref SCIP_STAGE_EXITSOLVE
8594  * - \ref SCIP_STAGE_FREETRANS
8595  */
8596 extern
8598  SCIP* scip, /**< SCIP data structure */
8599  SCIP_VAR* var, /**< variable to adjust the bound for */
8600  SCIP_Real lb /**< lower bound value to adjust */
8601  );
8602 
8603 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
8604  * does not change the bounds of the variable
8605  *
8606  * @return adjusted upper bound for the given variable; the bound of the variable is not changed
8607  *
8608  * @pre This method can be called if @p scip is in one of the following stages:
8609  * - \ref SCIP_STAGE_PROBLEM
8610  * - \ref SCIP_STAGE_TRANSFORMING
8611  * - \ref SCIP_STAGE_TRANSFORMED
8612  * - \ref SCIP_STAGE_INITPRESOLVE
8613  * - \ref SCIP_STAGE_PRESOLVING
8614  * - \ref SCIP_STAGE_EXITPRESOLVE
8615  * - \ref SCIP_STAGE_PRESOLVED
8616  * - \ref SCIP_STAGE_INITSOLVE
8617  * - \ref SCIP_STAGE_SOLVING
8618  * - \ref SCIP_STAGE_SOLVED
8619  * - \ref SCIP_STAGE_EXITSOLVE
8620  * - \ref SCIP_STAGE_FREETRANS
8621  */
8622 extern
8624  SCIP* scip, /**< SCIP data structure */
8625  SCIP_VAR* var, /**< variable to adjust the bound for */
8626  SCIP_Real ub /**< upper bound value to adjust */
8627  );
8628 
8629 /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
8630  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
8631  * that in conflict analysis, this change is treated like a branching decision
8632  *
8633  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8634  * SCIPgetVars()) gets resorted.
8635  *
8636  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8637  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8638  *
8639  * @pre This method can be called if @p scip is in one of the following stages:
8640  * - \ref SCIP_STAGE_PROBLEM
8641  * - \ref SCIP_STAGE_TRANSFORMING
8642  * - \ref SCIP_STAGE_PRESOLVING
8643  * - \ref SCIP_STAGE_SOLVING
8644  *
8645  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8646  */
8647 extern
8649  SCIP* scip, /**< SCIP data structure */
8650  SCIP_VAR* var, /**< variable to change the bound for */
8651  SCIP_Real newbound /**< new value for bound */
8652  );
8653 
8654 /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
8655  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
8656  * that in conflict analysis, this change is treated like a branching decision
8657  *
8658  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8659  * SCIPgetVars()) gets resorted.
8660  *
8661  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8662  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8663  *
8664  * @pre This method can be called if @p scip is in one of the following stages:
8665  * - \ref SCIP_STAGE_PROBLEM
8666  * - \ref SCIP_STAGE_TRANSFORMING
8667  * - \ref SCIP_STAGE_PRESOLVING
8668  * - \ref SCIP_STAGE_SOLVING
8669  *
8670  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8671  */
8672 extern
8674  SCIP* scip, /**< SCIP data structure */
8675  SCIP_VAR* var, /**< variable to change the bound for */
8676  SCIP_Real newbound /**< new value for bound */
8677  );
8678 
8679 /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
8680  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
8681  * decision
8682  *
8683  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8684  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8685  *
8686  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8687  */
8688 extern
8690  SCIP* scip, /**< SCIP data structure */
8691  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
8692  SCIP_VAR* var, /**< variable to change the bound for */
8693  SCIP_Real newbound /**< new value for bound */
8694  );
8695 
8696 /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
8697  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
8698  * decision
8699  *
8700  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8701  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8702  *
8703  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8704  */
8705 extern
8707  SCIP* scip, /**< SCIP data structure */
8708  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
8709  SCIP_VAR* var, /**< variable to change the bound for */
8710  SCIP_Real newbound /**< new value for bound */
8711  );
8712 
8713 /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
8714  * if the global bound is better than the local bound
8715  *
8716  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8717  * SCIPgetVars()) gets resorted.
8718  *
8719  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8720  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8721  *
8722  * @pre This method can be called if @p scip is in one of the following stages:
8723  * - \ref SCIP_STAGE_PROBLEM
8724  * - \ref SCIP_STAGE_TRANSFORMING
8725  * - \ref SCIP_STAGE_PRESOLVING
8726  * - \ref SCIP_STAGE_SOLVING
8727  *
8728  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8729  */
8730 extern
8732  SCIP* scip, /**< SCIP data structure */
8733  SCIP_VAR* var, /**< variable to change the bound for */
8734  SCIP_Real newbound /**< new value for bound */
8735  );
8736 
8737 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
8738  * if the global bound is better than the local bound
8739  *
8740  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8741  * SCIPgetVars()) gets resorted.
8742  *
8743  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8744  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8745  *
8746  * @pre This method can be called if @p scip is in one of the following stages:
8747  * - \ref SCIP_STAGE_PROBLEM
8748  * - \ref SCIP_STAGE_TRANSFORMING
8749  * - \ref SCIP_STAGE_PRESOLVING
8750  * - \ref SCIP_STAGE_SOLVING
8751  *
8752  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8753  */
8754 extern
8756  SCIP* scip, /**< SCIP data structure */
8757  SCIP_VAR* var, /**< variable to change the bound for */
8758  SCIP_Real newbound /**< new value for bound */
8759  );
8760 
8761 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
8762  *
8763  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
8764  * to be put into the LP explicitly.
8765  *
8766  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8767  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8768  *
8769  * @pre This method can be called if @p scip is in one of the following stages:
8770  * - \ref SCIP_STAGE_PROBLEM
8771  * - \ref SCIP_STAGE_TRANSFORMING
8772  * - \ref SCIP_STAGE_TRANSFORMED
8773  * - \ref SCIP_STAGE_PRESOLVING
8774  * - \ref SCIP_STAGE_SOLVING
8775  *
8776  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
8777  */
8778 extern
8780  SCIP* scip, /**< SCIP data structure */
8781  SCIP_VAR* var, /**< problem variable */
8782  SCIP_Real lazylb /**< the lazy lower bound to be set */
8783  );
8784 
8785 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
8786  *
8787  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
8788  * to be put into the LP explicitly.
8789  *
8790  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8791  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8792  *
8793  * @pre This method can be called if @p scip is in one of the following stages:
8794  * - \ref SCIP_STAGE_PROBLEM
8795  * - \ref SCIP_STAGE_TRANSFORMING
8796  * - \ref SCIP_STAGE_TRANSFORMED
8797  * - \ref SCIP_STAGE_PRESOLVING
8798  * - \ref SCIP_STAGE_SOLVING
8799  *
8800  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
8801  */
8802 extern
8804  SCIP* scip, /**< SCIP data structure */
8805  SCIP_VAR* var, /**< problem variable */
8806  SCIP_Real lazyub /**< the lazy lower bound to be set */
8807  );
8808 
8809 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8810  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8811  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
8812  * is treated like a branching decision
8813  *
8814  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8815  * SCIPgetVars()) gets resorted.
8816  *
8817  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8818  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8819  *
8820  * @pre This method can be called if @p scip is in one of the following stages:
8821  * - \ref SCIP_STAGE_PROBLEM
8822  * - \ref SCIP_STAGE_PRESOLVING
8823  * - \ref SCIP_STAGE_SOLVING
8824  *
8825  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8826  */
8827 extern
8829  SCIP* scip, /**< SCIP data structure */
8830  SCIP_VAR* var, /**< variable to change the bound for */
8831  SCIP_Real newbound, /**< new value for bound */
8832  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8833  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
8834  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8835  );
8836 
8837 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
8838  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8839  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
8840  * is treated like a branching decision
8841  *
8842  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8843  * SCIPgetVars()) gets resorted.
8844  *
8845  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8846  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8847  *
8848  * @pre This method can be called if @p scip is in one of the following stages:
8849  * - \ref SCIP_STAGE_PROBLEM
8850  * - \ref SCIP_STAGE_PRESOLVING
8851  * - \ref SCIP_STAGE_SOLVING
8852  *
8853  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8854  */
8855 extern
8857  SCIP* scip, /**< SCIP data structure */
8858  SCIP_VAR* var, /**< variable to change the bound for */
8859  SCIP_Real newbound, /**< new value for bound */
8860  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8861  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
8862  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8863  );
8864 
8865 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
8866  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
8867  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
8868  *
8869  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
8870  * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
8871  * SCIPinferVarUbCons
8872  *
8873  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
8874  * SCIPgetVars()) gets resorted.
8875  *
8876  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
8877  */
8878 extern
8880  SCIP* scip, /**< SCIP data structure */
8881  SCIP_VAR* var, /**< variable to change the bound for */
8882  SCIP_Real fixedval, /**< new value for fixation */
8883  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
8884  int inferinfo, /**< user information for inference to help resolving the conflict */
8885  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8886  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8887  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8888  );
8889 
8890 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8891  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8892  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
8893  * for the deduction of the bound change
8894  *
8895  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8896  * SCIPgetVars()) gets resorted.
8897  *
8898  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8899  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8900  *
8901  * @pre This method can be called if @p scip is in one of the following stages:
8902  * - \ref SCIP_STAGE_PROBLEM
8903  * - \ref SCIP_STAGE_PRESOLVING
8904  * - \ref SCIP_STAGE_SOLVING
8905  *
8906  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8907  */
8908 extern
8910  SCIP* scip, /**< SCIP data structure */
8911  SCIP_VAR* var, /**< variable to change the bound for */
8912  SCIP_Real newbound, /**< new value for bound */
8913  SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
8914  int inferinfo, /**< user information for inference to help resolving the conflict */
8915  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8916  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8917  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8918  );
8919 
8920 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
8921  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8922  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
8923  * for the deduction of the bound change
8924  *
8925  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8926  * SCIPgetVars()) gets resorted.
8927  *
8928  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8929  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8930  *
8931  * @pre This method can be called if @p scip is in one of the following stages:
8932  * - \ref SCIP_STAGE_PROBLEM
8933  * - \ref SCIP_STAGE_PRESOLVING
8934  * - \ref SCIP_STAGE_SOLVING
8935  *
8936  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8937  */
8938 extern
8940  SCIP* scip, /**< SCIP data structure */
8941  SCIP_VAR* var, /**< variable to change the bound for */
8942  SCIP_Real newbound, /**< new value for bound */
8943  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
8944  int inferinfo, /**< user information for inference to help resolving the conflict */
8945  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8946  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8947  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8948  );
8949 
8950 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
8951  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
8952  * deduction of the fixing
8953  *
8954  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8955  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8956  *
8957  * @pre This method can be called if @p scip is in one of the following stages:
8958  * - \ref SCIP_STAGE_PROBLEM
8959  * - \ref SCIP_STAGE_PRESOLVING
8960  * - \ref SCIP_STAGE_SOLVING
8961  */
8962 extern
8964  SCIP* scip, /**< SCIP data structure */
8965  SCIP_VAR* var, /**< binary variable to fix */
8966  SCIP_Bool fixedval, /**< value to fix binary variable to */
8967  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
8968  int inferinfo, /**< user information for inference to help resolving the conflict */
8969  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
8970  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
8971  );
8972 
8973 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
8974  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
8975  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
8976  *
8977  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
8978  * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
8979  * SCIPinferVarUbProp
8980  *
8981  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
8982  * SCIPgetVars()) gets resorted.
8983  *
8984  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
8985  */
8986 extern
8988  SCIP* scip, /**< SCIP data structure */
8989  SCIP_VAR* var, /**< variable to change the bound for */
8990  SCIP_Real fixedval, /**< new value for fixation */
8991  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
8992  int inferinfo, /**< user information for inference to help resolving the conflict */
8993  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8994  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8995  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8996  );
8997 
8998 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8999  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9000  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
9001  * for the deduction of the bound change
9002  *
9003  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9004  * SCIPgetVars()) gets resorted.
9005  *
9006  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9007  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9008  *
9009  * @pre This method can be called if @p scip is in one of the following stages:
9010  * - \ref SCIP_STAGE_PROBLEM
9011  * - \ref SCIP_STAGE_PRESOLVING
9012  * - \ref SCIP_STAGE_SOLVING
9013  *
9014  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9015  */
9016 extern
9018  SCIP* scip, /**< SCIP data structure */
9019  SCIP_VAR* var, /**< variable to change the bound for */
9020  SCIP_Real newbound, /**< new value for bound */
9021  SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
9022  int inferinfo, /**< user information for inference to help resolving the conflict */
9023  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9024  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9025  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9026  );
9027 
9028 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
9029  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9030  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
9031  * for the deduction of the bound change
9032  *
9033  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9034  * SCIPgetVars()) gets resorted.
9035  *
9036  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9037  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9038  *
9039  * @pre This method can be called if @p scip is in one of the following stages:
9040  * - \ref SCIP_STAGE_PROBLEM
9041  * - \ref SCIP_STAGE_PRESOLVING
9042  * - \ref SCIP_STAGE_SOLVING
9043  *
9044  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9045  */
9046 extern
9048  SCIP* scip, /**< SCIP data structure */
9049  SCIP_VAR* var, /**< variable to change the bound for */
9050  SCIP_Real newbound, /**< new value for bound */
9051  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
9052  int inferinfo, /**< user information for inference to help resolving the conflict */
9053  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9054  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9055  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9056  );
9057 
9058 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
9059  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
9060  * deduction of the fixing
9061  *
9062  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9063  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9064  *
9065  * @pre This method can be called if @p scip is in one of the following stages:
9066  * - \ref SCIP_STAGE_PROBLEM
9067  * - \ref SCIP_STAGE_PRESOLVING
9068  * - \ref SCIP_STAGE_PRESOLVED
9069  * - \ref SCIP_STAGE_SOLVING
9070  */
9071 extern
9073  SCIP* scip, /**< SCIP data structure */
9074  SCIP_VAR* var, /**< binary variable to fix */
9075  SCIP_Bool fixedval, /**< value to fix binary variable to */
9076  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
9077  int inferinfo, /**< user information for inference to help resolving the conflict */
9078  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
9079  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
9080  );
9081 
9082 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
9083  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
9084  * also tightens the local bound, if the global bound is better than the local bound
9085  *
9086  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9087  * SCIPgetVars()) gets resorted.
9088  *
9089  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9090  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9091  *
9092  * @pre This method can be called if @p scip is in one of the following stages:
9093  * - \ref SCIP_STAGE_PROBLEM
9094  * - \ref SCIP_STAGE_TRANSFORMING
9095  * - \ref SCIP_STAGE_PRESOLVING
9096  * - \ref SCIP_STAGE_SOLVING
9097  *
9098  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9099  */
9100 extern
9102  SCIP* scip, /**< SCIP data structure */
9103  SCIP_VAR* var, /**< variable to change the bound for */
9104  SCIP_Real newbound, /**< new value for bound */
9105  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9106  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
9107  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9108  );
9109 
9110 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
9111  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
9112  * also tightens the local bound, if the global bound is better than the local bound
9113  *
9114  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9115  * SCIPgetVars()) gets resorted.
9116  *
9117  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9118  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9119  *
9120  * @pre This method can be called if @p scip is in one of the following stages:
9121  * - \ref SCIP_STAGE_PROBLEM
9122  * - \ref SCIP_STAGE_TRANSFORMING
9123  * - \ref SCIP_STAGE_PRESOLVING
9124  * - \ref SCIP_STAGE_SOLVING
9125  *
9126  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9127  */
9128 extern
9130  SCIP* scip, /**< SCIP data structure */
9131  SCIP_VAR* var, /**< variable to change the bound for */
9132  SCIP_Real newbound, /**< new value for bound */
9133  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9134  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
9135  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9136  );
9137 
9138 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
9139  *
9140  * 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
9141  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
9142  *
9143  * @return the global lower bound computed by adding the global bounds from all aggregation variables
9144  */
9145 extern
9147  SCIP* scip, /**< SCIP data structure */
9148  SCIP_VAR* var /**< variable to compute the bound for */
9149  );
9150 
9151 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
9152  *
9153  * 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
9154  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
9155  *
9156  * @return the global upper bound computed by adding the global bounds from all aggregation variables
9157  */
9158 extern
9160  SCIP* scip, /**< SCIP data structure */
9161  SCIP_VAR* var /**< variable to compute the bound for */
9162  );
9163 
9164 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
9165  *
9166  * 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
9167  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
9168  *
9169  * @return the local lower bound computed by adding the global bounds from all aggregation variables
9170  */
9171 extern
9173  SCIP* scip, /**< SCIP data structure */
9174  SCIP_VAR* var /**< variable to compute the bound for */
9175  );
9176 
9177 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
9178  *
9179  * 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
9180  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
9181  *
9182  * @return the local upper bound computed by adding the global bounds from all aggregation variables
9183  */
9184 extern
9186  SCIP* scip, /**< SCIP data structure */
9187  SCIP_VAR* var /**< variable to compute the bound for */
9188  );
9189 
9190 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
9191  * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
9192  * not updated if bounds of aggregation variables are changing
9193  *
9194  * calling this function for a non-multi-aggregated variable is not allowed
9195  */
9196 extern
9198  SCIP* scip, /**< SCIP data structure */
9199  SCIP_VAR* var /**< variable to compute the bound for */
9200  );
9201 
9202 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
9203  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
9204  * not updated if bounds of aggregation variables are changing
9205  *
9206  * calling this function for a non-multi-aggregated variable is not allowed
9207  */
9208 extern
9210  SCIP* scip, /**< SCIP data structure */
9211  SCIP_VAR* var /**< variable to compute the bound for */
9212  );
9213 
9214 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
9215  * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
9216  * not updated if bounds of aggregation variables are changing
9217  *
9218  * calling this function for a non-multi-aggregated variable is not allowed
9219  */
9220 extern
9222  SCIP* scip, /**< SCIP data structure */
9223  SCIP_VAR* var /**< variable to compute the bound for */
9224  );
9225 
9226 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
9227  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
9228  * not updated if bounds of aggregation variables are changing
9229  *
9230  * calling this function for a non-multi-aggregated variable is not allowed
9231  */
9232 extern
9234  SCIP* scip, /**< SCIP data structure */
9235  SCIP_VAR* var /**< variable to compute the bound for */
9236  );
9237 
9238 #ifdef NDEBUG
9239 
9240 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
9241  * speed up the algorithms.
9242  */
9243 
9244 #define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
9245 #define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
9246 #define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
9247 #define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
9248 
9249 #endif
9250 
9251 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
9252  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
9253  * available
9254  *
9255  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9256  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9257  *
9258  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
9259  */
9260 extern
9262  SCIP* scip, /**< SCIP data structure */
9263  SCIP_VAR* var, /**< active problem variable */
9264  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
9265  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
9266  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
9267  );
9268 
9269 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
9270  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
9271  *
9272  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9273  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9274  *
9275  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
9276  */
9277 extern
9279  SCIP* scip, /**< SCIP data structure */
9280  SCIP_VAR* var, /**< active problem variable */
9281  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
9282  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
9283  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
9284  );
9285 
9286 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
9287  * if z is binary, the corresponding valid implication for z is also added;
9288  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
9289  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
9290  * improves the global bounds of the variable and the vlb variable if possible
9291  *
9292  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9293  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9294  *
9295  * @pre This method can be called if @p scip is in one of the following stages:
9296  * - \ref SCIP_STAGE_PRESOLVING
9297  * - \ref SCIP_STAGE_PRESOLVED
9298  * - \ref SCIP_STAGE_SOLVING
9299  */
9300 extern
9302  SCIP* scip, /**< SCIP data structure */
9303  SCIP_VAR* var, /**< problem variable */
9304  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
9305  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
9306  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
9307  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9308  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9309  );
9310 
9311 
9312 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
9313  * if z is binary, the corresponding valid implication for z is also added;
9314  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
9315  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
9316  * improves the global bounds of the variable and the vlb variable if possible
9317  *
9318  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9319  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9320  *
9321  * @pre This method can be called if @p scip is in one of the following stages:
9322  * - \ref SCIP_STAGE_PRESOLVING
9323  * - \ref SCIP_STAGE_PRESOLVED
9324  * - \ref SCIP_STAGE_SOLVING
9325  */
9326 extern
9328  SCIP* scip, /**< SCIP data structure */
9329  SCIP_VAR* var, /**< problem variable */
9330  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
9331  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
9332  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
9333  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9334  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9335  );
9336 
9337 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
9338  * also adds the corresponding implication or variable bound to the implied variable;
9339  * if the implication is conflicting, the variable is fixed to the opposite value;
9340  * if the variable is already fixed to the given value, the implication is performed immediately;
9341  * if the implication is redundant with respect to the variables' global bounds, it is ignored
9342  *
9343  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9344  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9345  *
9346  * @pre This method can be called if @p scip is in one of the following stages:
9347  * - \ref SCIP_STAGE_TRANSFORMED
9348  * - \ref SCIP_STAGE_PRESOLVING
9349  * - \ref SCIP_STAGE_PRESOLVED
9350  * - \ref SCIP_STAGE_SOLVING
9351  */
9352 extern
9354  SCIP* scip, /**< SCIP data structure */
9355  SCIP_VAR* var, /**< problem variable */
9356  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
9357  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
9358  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
9359  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
9360  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
9361  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9362  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9363  );
9364 
9365 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
9366  * if a variable appears twice in the same clique, the corresponding implications are performed
9367  *
9368  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9369  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9370  *
9371  * @pre This method can be called if @p scip is in one of the following stages:
9372  * - \ref SCIP_STAGE_TRANSFORMED
9373  * - \ref SCIP_STAGE_PRESOLVING
9374  * - \ref SCIP_STAGE_PRESOLVED
9375  * - \ref SCIP_STAGE_SOLVING
9376  */
9377 extern
9379  SCIP* scip, /**< SCIP data structure */
9380  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
9381  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
9382  int nvars, /**< number of variables in the clique */
9383  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
9384  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9385  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9386  );
9387 
9388 /** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
9389  *
9390  * The algorithm performs the following steps:
9391  * - recomputes connected components of the clique table, if necessary
9392  * - computes a clique partition for every connected component greedily.
9393  * - relabels the resulting clique partition such that it satisfies the description below
9394  *
9395  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
9396  * were assigned to the same clique;
9397  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
9398  * the preceding variables was assigned to clique i-1;
9399  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
9400  *
9401  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9402  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9403  *
9404  * @pre This method can be called if @p scip is in one of the following stages:
9405  * - \ref SCIP_STAGE_INITPRESOLVE
9406  * - \ref SCIP_STAGE_PRESOLVING
9407  * - \ref SCIP_STAGE_EXITPRESOLVE
9408  * - \ref SCIP_STAGE_PRESOLVED
9409  * - \ref SCIP_STAGE_SOLVING
9410  */
9411 extern
9413  SCIP*const scip, /**< SCIP data structure */
9414  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
9415  int const nvars, /**< number of variables in the clique */
9416  int*const cliquepartition, /**< array of length nvars to store the clique partition */
9417  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
9418  );
9419 
9420 /** calculates a partition of the given set of binary variables into negated cliques;
9421  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
9422  * were assigned to the same negated clique;
9423  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
9424  * the preceding variables was assigned to clique i-1;
9425  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
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 be called if @p scip is in one of the following stages:
9431  * - \ref SCIP_STAGE_INITPRESOLVE
9432  * - \ref SCIP_STAGE_PRESOLVING
9433  * - \ref SCIP_STAGE_EXITPRESOLVE
9434  * - \ref SCIP_STAGE_PRESOLVED
9435  * - \ref SCIP_STAGE_SOLVING
9436  */
9437 extern
9439  SCIP*const scip, /**< SCIP data structure */
9440  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
9441  int const nvars, /**< number of variables in the clique */
9442  int*const cliquepartition, /**< array of length nvars to store the clique partition */
9443  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
9444  );
9445 
9446 /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
9447  * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
9448  *
9449  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
9450  *
9451  * @pre This method can be called if @p scip is in one of the following stages:
9452  * - \ref SCIP_STAGE_TRANSFORMED
9453  * - \ref SCIP_STAGE_INITPRESOLVE
9454  * - \ref SCIP_STAGE_PRESOLVING
9455  * - \ref SCIP_STAGE_EXITPRESOLVE
9456  * - \ref SCIP_STAGE_PRESOLVED
9457  * - \ref SCIP_STAGE_INITSOLVE
9458  * - \ref SCIP_STAGE_SOLVING
9459  * - \ref SCIP_STAGE_SOLVED
9460  * - \ref SCIP_STAGE_EXITSOLVE
9461  */
9462 extern
9464  SCIP* scip, /**< SCIP data structure */
9465  SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
9466  );
9467 
9468 /** gets the number of cliques in the clique table
9469  *
9470  * @return number of cliques in the clique table
9471  *
9472  * @pre This method can be called if @p scip is in one of the following stages:
9473  * - \ref SCIP_STAGE_TRANSFORMED
9474  * - \ref SCIP_STAGE_INITPRESOLVE
9475  * - \ref SCIP_STAGE_PRESOLVING
9476  * - \ref SCIP_STAGE_EXITPRESOLVE
9477  * - \ref SCIP_STAGE_PRESOLVED
9478  * - \ref SCIP_STAGE_INITSOLVE
9479  * - \ref SCIP_STAGE_SOLVING
9480  * - \ref SCIP_STAGE_SOLVED
9481  * - \ref SCIP_STAGE_EXITSOLVE
9482  */
9483 extern
9484 int SCIPgetNCliques(
9485  SCIP* scip /**< SCIP data structure */
9486  );
9487 
9488 /** gets the array of cliques in the clique table
9489  *
9490  * @return array of cliques in the clique table
9491  *
9492  * @pre This method can be called if @p scip is in one of the following stages:
9493  * - \ref SCIP_STAGE_TRANSFORMED
9494  * - \ref SCIP_STAGE_INITPRESOLVE
9495  * - \ref SCIP_STAGE_PRESOLVING
9496  * - \ref SCIP_STAGE_EXITPRESOLVE
9497  * - \ref SCIP_STAGE_PRESOLVED
9498  * - \ref SCIP_STAGE_INITSOLVE
9499  * - \ref SCIP_STAGE_SOLVING
9500  * - \ref SCIP_STAGE_SOLVED
9501  * - \ref SCIP_STAGE_EXITSOLVE
9502  */
9503 extern
9505  SCIP* scip /**< SCIP data structure */
9506  );
9507 
9508 /** returns whether there is a clique that contains both given variable/value pairs;
9509  * the variables must be active binary variables;
9510  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
9511  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
9512  *
9513  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
9514  *
9515  * @pre This method can be called if @p scip is in one of the following stages:
9516  * - \ref SCIP_STAGE_TRANSFORMED
9517  * - \ref SCIP_STAGE_INITPRESOLVE
9518  * - \ref SCIP_STAGE_PRESOLVING
9519  * - \ref SCIP_STAGE_EXITPRESOLVE
9520  * - \ref SCIP_STAGE_PRESOLVED
9521  * - \ref SCIP_STAGE_INITSOLVE
9522  * - \ref SCIP_STAGE_SOLVING
9523  * - \ref SCIP_STAGE_SOLVED
9524  * - \ref SCIP_STAGE_EXITSOLVE
9525  *
9526  * @note a variable with it's negated variable are NOT! in a clique
9527  * @note a variable with itself are in a clique
9528  */
9529 extern
9531  SCIP* scip, /**< SCIP data structure */
9532  SCIP_VAR* var1, /**< first variable */
9533  SCIP_Bool value1, /**< value of first variable */
9534  SCIP_VAR* var2, /**< second variable */
9535  SCIP_Bool value2, /**< value of second variable */
9536  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
9537  );
9538 
9539 /** writes the clique graph to a gml file
9540  *
9541  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9542  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9543  *
9544  * @pre This method can be called if @p scip is in one of the following stages:
9545  * - \ref SCIP_STAGE_TRANSFORMED
9546  * - \ref SCIP_STAGE_INITPRESOLVE
9547  * - \ref SCIP_STAGE_PRESOLVING
9548  * - \ref SCIP_STAGE_EXITPRESOLVE
9549  * - \ref SCIP_STAGE_PRESOLVED
9550  * - \ref SCIP_STAGE_INITSOLVE
9551  * - \ref SCIP_STAGE_SOLVING
9552  * - \ref SCIP_STAGE_SOLVED
9553  * - \ref SCIP_STAGE_EXITSOLVE
9554  *
9555  * @note there can be duplicated arcs in the output file
9556  *
9557  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
9558  * between such nodes are written.
9559  */
9560 extern
9562  SCIP* scip, /**< SCIP data structure */
9563  const char* fname, /**< name of file */
9564  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
9565  );
9566 
9567 /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
9568  * This is an advanced method which should be used with care.
9569  *
9570  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
9571  *
9572  * @pre This method can be called if @p scip is in one of the following stages:
9573  * - \ref SCIP_STAGE_TRANSFORMED
9574  * - \ref SCIP_STAGE_INITPRESOLVE
9575  * - \ref SCIP_STAGE_PRESOLVING
9576  * - \ref SCIP_STAGE_EXITPRESOLVE
9577  * - \ref SCIP_STAGE_PRESOLVED
9578  * - \ref SCIP_STAGE_INITSOLVE
9579  * - \ref SCIP_STAGE_SOLVING
9580  * - \ref SCIP_STAGE_SOLVED
9581  * - \ref SCIP_STAGE_EXITSOLVE
9582  */
9583 extern
9585  SCIP* scip, /**< SCIP data structure */
9586  SCIP_VAR* var /**< variable to remove from global structures */
9587  );
9588 
9589 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
9590  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
9591  *
9592  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9593  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9594  *
9595  * @pre This method can be called if @p scip is in one of the following stages:
9596  * - \ref SCIP_STAGE_PROBLEM
9597  * - \ref SCIP_STAGE_TRANSFORMING
9598  * - \ref SCIP_STAGE_TRANSFORMED
9599  * - \ref SCIP_STAGE_INITPRESOLVE
9600  * - \ref SCIP_STAGE_PRESOLVING
9601  * - \ref SCIP_STAGE_EXITPRESOLVE
9602  * - \ref SCIP_STAGE_PRESOLVED
9603  * - \ref SCIP_STAGE_SOLVING
9604  */
9605 extern
9607  SCIP* scip, /**< SCIP data structure */
9608  SCIP_VAR* var, /**< problem variable */
9609  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
9610  );
9611 
9612 /** scales the branch factor of the variable with the given value
9613  *
9614  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9615  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9616  *
9617  * @pre This method can be called if @p scip is in one of the following stages:
9618  * - \ref SCIP_STAGE_PROBLEM
9619  * - \ref SCIP_STAGE_TRANSFORMING
9620  * - \ref SCIP_STAGE_TRANSFORMED
9621  * - \ref SCIP_STAGE_INITPRESOLVE
9622  * - \ref SCIP_STAGE_PRESOLVING
9623  * - \ref SCIP_STAGE_EXITPRESOLVE
9624  * - \ref SCIP_STAGE_PRESOLVED
9625  * - \ref SCIP_STAGE_SOLVING
9626  */
9627 extern
9629  SCIP* scip, /**< SCIP data structure */
9630  SCIP_VAR* var, /**< problem variable */
9631  SCIP_Real scale /**< factor to scale variable's branching factor with */
9632  );
9633 
9634 /** adds the given value to the branch factor of the variable
9635  *
9636  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9637  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9638  *
9639  * @pre This method can be called if @p scip is in one of the following stages:
9640  * - \ref SCIP_STAGE_PROBLEM
9641  * - \ref SCIP_STAGE_TRANSFORMING
9642  * - \ref SCIP_STAGE_TRANSFORMED
9643  * - \ref SCIP_STAGE_INITPRESOLVE
9644  * - \ref SCIP_STAGE_PRESOLVING
9645  * - \ref SCIP_STAGE_EXITPRESOLVE
9646  * - \ref SCIP_STAGE_PRESOLVED
9647  * - \ref SCIP_STAGE_SOLVING
9648  */
9649 extern
9651  SCIP* scip, /**< SCIP data structure */
9652  SCIP_VAR* var, /**< problem variable */
9653  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
9654  );
9655 
9656 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
9657  * with lower priority in selection of branching variable
9658  *
9659  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9660  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9661  *
9662  * @pre This method can be called if @p scip is in one of the following stages:
9663  * - \ref SCIP_STAGE_PROBLEM
9664  * - \ref SCIP_STAGE_TRANSFORMING
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_SOLVING
9671  *
9672  * @note the default branching priority is 0
9673  */
9674 extern
9676  SCIP* scip, /**< SCIP data structure */
9677  SCIP_VAR* var, /**< problem variable */
9678  int branchpriority /**< branch priority of the variable */
9679  );
9680 
9681 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
9682  *
9683  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9684  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9685  *
9686  * @pre This method can be called if @p scip is in one of the following stages:
9687  * - \ref SCIP_STAGE_PROBLEM
9688  * - \ref SCIP_STAGE_TRANSFORMING
9689  * - \ref SCIP_STAGE_TRANSFORMED
9690  * - \ref SCIP_STAGE_INITPRESOLVE
9691  * - \ref SCIP_STAGE_PRESOLVING
9692  * - \ref SCIP_STAGE_EXITPRESOLVE
9693  * - \ref SCIP_STAGE_PRESOLVED
9694  * - \ref SCIP_STAGE_SOLVING
9695  */
9696 extern
9698  SCIP* scip, /**< SCIP data structure */
9699  SCIP_VAR* var, /**< problem variable */
9700  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
9701  );
9702 
9703 /** adds the given value to the branch priority of the variable
9704  *
9705  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9706  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9707  *
9708  * @pre This method can be called if @p scip is in one of the following stages:
9709  * - \ref SCIP_STAGE_PROBLEM
9710  * - \ref SCIP_STAGE_TRANSFORMING
9711  * - \ref SCIP_STAGE_TRANSFORMED
9712  * - \ref SCIP_STAGE_INITPRESOLVE
9713  * - \ref SCIP_STAGE_PRESOLVING
9714  * - \ref SCIP_STAGE_EXITPRESOLVE
9715  * - \ref SCIP_STAGE_PRESOLVED
9716  * - \ref SCIP_STAGE_SOLVING
9717  */
9718 extern
9720  SCIP* scip, /**< SCIP data structure */
9721  SCIP_VAR* var, /**< problem variable */
9722  int addpriority /**< value to add to the branch priority of the variable */
9723  );
9724 
9725 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
9726  * branch)
9727  *
9728  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9729  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9730  *
9731  * @pre This method can be called if @p scip is in one of the following stages:
9732  * - \ref SCIP_STAGE_PROBLEM
9733  * - \ref SCIP_STAGE_TRANSFORMING
9734  * - \ref SCIP_STAGE_TRANSFORMED
9735  * - \ref SCIP_STAGE_INITPRESOLVE
9736  * - \ref SCIP_STAGE_PRESOLVING
9737  * - \ref SCIP_STAGE_EXITPRESOLVE
9738  * - \ref SCIP_STAGE_PRESOLVED
9739  * - \ref SCIP_STAGE_SOLVING
9740  */
9741 extern
9743  SCIP* scip, /**< SCIP data structure */
9744  SCIP_VAR* var, /**< problem variable */
9745  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
9746  );
9747 
9748 /** changes type of variable in the problem;
9749  *
9750  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
9751  *
9752  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9753  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9754  *
9755  * @pre This method can be called if @p scip is in one of the following stages:
9756  * - \ref SCIP_STAGE_PROBLEM
9757  * - \ref SCIP_STAGE_TRANSFORMING
9758  * - \ref SCIP_STAGE_PRESOLVING
9759  *
9760  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
9761  * corresponding transformed variable is changed; the type of the original variable does not change
9762  *
9763  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
9764  * adjusted w.r.t. to integrality information
9765  */
9766 extern
9768  SCIP* scip, /**< SCIP data structure */
9769  SCIP_VAR* var, /**< variable to change the bound for */
9770  SCIP_VARTYPE vartype, /**< new type of variable */
9771  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
9772  * integrality condition of the new variable type) */
9773  );
9774 
9775 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
9776  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
9777  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
9778  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
9779  *
9780  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9781  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9782  *
9783  * @pre This method can be called if @p scip is in one of the following stages:
9784  * - \ref SCIP_STAGE_PROBLEM
9785  * - \ref SCIP_STAGE_PRESOLVING
9786  * - \ref SCIP_STAGE_SOLVING
9787  */
9788 extern
9790  SCIP* scip, /**< SCIP data structure */
9791  SCIP_VAR* var, /**< variable to fix */
9792  SCIP_Real fixedval, /**< value to fix variable to */
9793  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
9794  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
9795  );
9796 
9797 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
9798  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
9799  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
9800  * In the first step, the equality is transformed into an equality with active problem variables
9801  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
9802  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
9803  * infeasibility) otherwise.
9804  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
9805  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
9806  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
9807  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
9808  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
9809  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
9810  *
9811  * The output flags have the following meaning:
9812  * - infeasible: the problem is infeasible
9813  * - redundant: the equality can be deleted from the constraint set
9814  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
9815  *
9816  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9817  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9818  *
9819  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
9820  */
9821 extern
9823  SCIP* scip, /**< SCIP data structure */
9824  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
9825  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
9826  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
9827  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
9828  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
9829  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
9830  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
9831  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
9832  );
9833 
9834 /** converts variable into multi-aggregated variable; this changes the variable array returned from
9835  * SCIPgetVars() and SCIPgetVarsData();
9836  *
9837  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
9838  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
9839  * implies integrality on the aggregated variable.
9840  *
9841  * The output flags have the following meaning:
9842  * - infeasible: the problem is infeasible
9843  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
9844  *
9845  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9846  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9847  *
9848  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
9849  */
9850 extern
9852  SCIP* scip, /**< SCIP data structure */
9853  SCIP_VAR* var, /**< variable x to aggregate */
9854  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9855  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9856  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9857  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9858  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
9859  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
9860  );
9861 
9862 /** returns whether aggregation of variables is not allowed */
9863 extern
9865  SCIP* scip /**< SCIP data structure */
9866  );
9867 
9868 /** returns whether multi-aggregation is disabled */
9869 extern
9871  SCIP* scip /**< SCIP data structure */
9872  );
9873 
9874 /** returns whether variable is not allowed to be multi-aggregated */
9875 extern
9877  SCIP* scip, /**< SCIP data structure */
9878  SCIP_VAR* var /**< variable x to aggregate */
9879  );
9880 
9881 /** returns whether dual reductions propagation methods and presolvers is allowed */
9882 extern
9884  SCIP* scip /**< SCIP data structure */
9885  );
9886 
9887 /** returns whether propagation w.r.t. current objective is allowed */
9888 extern
9890  SCIP* scip /**< SCIP data structure */
9891  );
9892 
9893 /** modifies an initial seed value with the global shift of random seeds */
9894 extern
9895 unsigned int SCIPinitializeRandomSeed(
9896  SCIP* scip, /**< SCIP data structure */
9897  int initialseedvalue /**< initial seed value to be modified */
9898  );
9899 
9900 /** marks the variable that it must not be multi-aggregated
9901  *
9902  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9903  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9904  *
9905  * @pre This method can be called if @p scip is in one of the following stages:
9906  * - \ref SCIP_STAGE_INIT
9907  * - \ref SCIP_STAGE_PROBLEM
9908  * - \ref SCIP_STAGE_TRANSFORMING
9909  * - \ref SCIP_STAGE_TRANSFORMED
9910  * - \ref SCIP_STAGE_INITPRESOLVE
9911  * - \ref SCIP_STAGE_PRESOLVING
9912  * - \ref SCIP_STAGE_EXITPRESOLVE
9913  *
9914  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
9915  * multi-aggregated that this is will be the case.
9916  */
9917 extern
9919  SCIP* scip, /**< SCIP data structure */
9920  SCIP_VAR* var /**< variable to delete */
9921  );
9922 
9923 /** enables the collection of statistics for a variable
9924  *
9925  * @pre This method can be called if @p scip is in one of the following stages:
9926  * - \ref SCIP_STAGE_PROBLEM
9927  * - \ref SCIP_STAGE_INITPRESOLVE
9928  * - \ref SCIP_STAGE_PRESOLVING
9929  * - \ref SCIP_STAGE_EXITPRESOLVE
9930  * - \ref SCIP_STAGE_SOLVING
9931  * - \ref SCIP_STAGE_SOLVED
9932  */
9933 extern
9935  SCIP* scip /**< SCIP data structure */
9936  );
9937 
9938 /** disables the collection of any statistic for a variable
9939  *
9940  * @pre This method can be called if @p scip is in one of the following stages:
9941  * - \ref SCIP_STAGE_PROBLEM
9942  * - \ref SCIP_STAGE_INITPRESOLVE
9943  * - \ref SCIP_STAGE_PRESOLVING
9944  * - \ref SCIP_STAGE_EXITPRESOLVE
9945  * - \ref SCIP_STAGE_SOLVING
9946  * - \ref SCIP_STAGE_SOLVED
9947  */
9948 extern
9950  SCIP* scip /**< SCIP data structure */
9951  );
9952 
9953 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
9954  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
9955  * the update is ignored, if the objective value difference is infinite
9956  *
9957  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9958  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9959  *
9960  * @pre This method can be called if @p scip is in one of the following stages:
9961  * - \ref SCIP_STAGE_SOLVING
9962  * - \ref SCIP_STAGE_SOLVED
9963  */
9964 extern
9966  SCIP* scip, /**< SCIP data structure */
9967  SCIP_VAR* var, /**< problem variable */
9968  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
9969  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
9970  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
9971  );
9972 
9973 /** gets the variable's pseudo cost value for the given change of the variable's LP value
9974  *
9975  * @return the variable's pseudo cost value for the given change of the variable's LP value
9976  *
9977  * @pre This method can be called if @p scip is in one of the following stages:
9978  * - \ref SCIP_STAGE_INITPRESOLVE
9979  * - \ref SCIP_STAGE_PRESOLVING
9980  * - \ref SCIP_STAGE_EXITPRESOLVE
9981  * - \ref SCIP_STAGE_PRESOLVED
9982  * - \ref SCIP_STAGE_INITSOLVE
9983  * - \ref SCIP_STAGE_SOLVING
9984  * - \ref SCIP_STAGE_SOLVED
9985  */
9986 extern
9988  SCIP* scip, /**< SCIP data structure */
9989  SCIP_VAR* var, /**< problem variable */
9990  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
9991  );
9992 
9993 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
9994  * only using the pseudo cost information of the current run
9995  *
9996  * @return the variable's pseudo cost value for the given change of the variable's LP value,
9997  * only using the pseudo cost information of the current run
9998  *
9999  * @pre This method can be called if @p scip is in one of the following stages:
10000  * - \ref SCIP_STAGE_INITPRESOLVE
10001  * - \ref SCIP_STAGE_PRESOLVING
10002  * - \ref SCIP_STAGE_EXITPRESOLVE
10003  * - \ref SCIP_STAGE_PRESOLVED
10004  * - \ref SCIP_STAGE_INITSOLVE
10005  * - \ref SCIP_STAGE_SOLVING
10006  * - \ref SCIP_STAGE_SOLVED
10007  */
10008 extern
10010  SCIP* scip, /**< SCIP data structure */
10011  SCIP_VAR* var, /**< problem variable */
10012  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
10013  );
10014 
10015 /** gets the variable's pseudo cost value for the given direction
10016  *
10017  * @return the variable's pseudo cost value for the given direction
10018  *
10019  * @pre This method can be called if @p scip is in one of the following stages:
10020  * - \ref SCIP_STAGE_INITPRESOLVE
10021  * - \ref SCIP_STAGE_PRESOLVING
10022  * - \ref SCIP_STAGE_EXITPRESOLVE
10023  * - \ref SCIP_STAGE_PRESOLVED
10024  * - \ref SCIP_STAGE_INITSOLVE
10025  * - \ref SCIP_STAGE_SOLVING
10026  * - \ref SCIP_STAGE_SOLVED
10027  */
10028 extern
10030  SCIP* scip, /**< SCIP data structure */
10031  SCIP_VAR* var, /**< problem variable */
10032  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10033  );
10034 
10035 /** gets the variable's pseudo cost value for the given direction,
10036  * only using the pseudo cost information of the current run
10037  *
10038  * @return the variable's pseudo cost value for the given direction,
10039  * only using the pseudo cost information of the current run
10040  *
10041  * @pre This method can be called if @p scip is in one of the following stages:
10042  * - \ref SCIP_STAGE_INITPRESOLVE
10043  * - \ref SCIP_STAGE_PRESOLVING
10044  * - \ref SCIP_STAGE_EXITPRESOLVE
10045  * - \ref SCIP_STAGE_PRESOLVED
10046  * - \ref SCIP_STAGE_INITSOLVE
10047  * - \ref SCIP_STAGE_SOLVING
10048  * - \ref SCIP_STAGE_SOLVED
10049  */
10050 extern
10052  SCIP* scip, /**< SCIP data structure */
10053  SCIP_VAR* var, /**< problem variable */
10054  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10055  );
10056 
10057 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
10058  *
10059  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
10060  *
10061  * @pre This method can be called if @p scip is in one of the following stages:
10062  * - \ref SCIP_STAGE_INITPRESOLVE
10063  * - \ref SCIP_STAGE_PRESOLVING
10064  * - \ref SCIP_STAGE_EXITPRESOLVE
10065  * - \ref SCIP_STAGE_PRESOLVED
10066  * - \ref SCIP_STAGE_INITSOLVE
10067  * - \ref SCIP_STAGE_SOLVING
10068  * - \ref SCIP_STAGE_SOLVED
10069  */
10070 extern
10072  SCIP* scip, /**< SCIP data structure */
10073  SCIP_VAR* var, /**< problem variable */
10074  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10075  );
10076 
10077 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
10078  * only using the pseudo cost information of the current run
10079  *
10080  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
10081  * only using the pseudo cost information of the current run
10082  *
10083  * @pre This method can be called if @p scip is in one of the following stages:
10084  * - \ref SCIP_STAGE_INITPRESOLVE
10085  * - \ref SCIP_STAGE_PRESOLVING
10086  * - \ref SCIP_STAGE_EXITPRESOLVE
10087  * - \ref SCIP_STAGE_PRESOLVED
10088  * - \ref SCIP_STAGE_INITSOLVE
10089  * - \ref SCIP_STAGE_SOLVING
10090  * - \ref SCIP_STAGE_SOLVED
10091  */
10092 extern
10094  SCIP* scip, /**< SCIP data structure */
10095  SCIP_VAR* var, /**< problem variable */
10096  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10097  );
10098 
10099 /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
10100  *
10101  * @return returns the (corrected) variance of pseudo code information collected so far.
10102  *
10103  * @pre This method can be called if @p scip is in one of the following stages:
10104  * - \ref SCIP_STAGE_INITPRESOLVE
10105  * - \ref SCIP_STAGE_PRESOLVING
10106  * - \ref SCIP_STAGE_EXITPRESOLVE
10107  * - \ref SCIP_STAGE_PRESOLVED
10108  * - \ref SCIP_STAGE_INITSOLVE
10109  * - \ref SCIP_STAGE_SOLVING
10110  * - \ref SCIP_STAGE_SOLVED
10111  */
10112 extern
10114  SCIP* scip, /**< SCIP data structure */
10115  SCIP_VAR* var, /**< problem variable */
10116  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
10117  SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
10118  );
10119 
10120 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
10121  *
10122  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
10123  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
10124  * of 2 * clevel - 1.
10125  *
10126  * @return value of confidence bound for this variable
10127  */
10128 extern
10130  SCIP* scip, /**< SCIP data structure */
10131  SCIP_VAR* var, /**< variable in question */
10132  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
10133  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
10134  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
10135  );
10136 
10137 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
10138  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
10139  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
10140  * unknown location means of the underlying pseudo-cost distributions of x and y.
10141  *
10142  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
10143  * better than x (despite the current information), meaning that y can be expected to yield branching
10144  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
10145  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
10146  * than y.
10147  *
10148  * @note The order of x and y matters for the one-sided hypothesis
10149  *
10150  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
10151  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
10152  *
10153  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
10154  */
10155 extern
10157  SCIP* scip, /**< SCIP data structure */
10158  SCIP_VAR* varx, /**< variable x */
10159  SCIP_Real fracx, /**< the fractionality of variable x */
10160  SCIP_VAR* vary, /**< variable y */
10161  SCIP_Real fracy, /**< the fractionality of variable y */
10162  SCIP_BRANCHDIR dir, /**< branching direction */
10163  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
10164  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
10165  );
10166 
10167 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
10168  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
10169  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
10170  * of at least \p threshold.
10171  *
10172  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
10173  * the estimated probability to exceed \p threshold is less than 25 %.
10174  *
10175  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
10176  * of confidence.
10177  *
10178  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
10179  * at the given confidence level \p clevel.
10180  */
10181 extern
10183  SCIP* scip, /**< SCIP data structure */
10184  SCIP_VAR* var, /**< variable x */
10185  SCIP_Real frac, /**< the fractionality of variable x */
10186  SCIP_Real threshold, /**< the threshold to test against */
10187  SCIP_BRANCHDIR dir, /**< branching direction */
10188  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
10189  );
10190 
10191 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
10192  * Error is calculated at a specific confidence level
10193  *
10194  * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
10195  */
10196 extern
10198  SCIP* scip, /**< SCIP data structure */
10199  SCIP_VAR* var, /**< variable in question */
10200  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
10201  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
10202  );
10203 
10204 /** gets the variable's pseudo cost score value for the given LP solution value
10205  *
10206  * @return the variable's pseudo cost score value for the given LP solution value
10207  *
10208  * @pre This method can be called if @p scip is in one of the following stages:
10209  * - \ref SCIP_STAGE_INITPRESOLVE
10210  * - \ref SCIP_STAGE_PRESOLVING
10211  * - \ref SCIP_STAGE_EXITPRESOLVE
10212  * - \ref SCIP_STAGE_PRESOLVED
10213  * - \ref SCIP_STAGE_INITSOLVE
10214  * - \ref SCIP_STAGE_SOLVING
10215  * - \ref SCIP_STAGE_SOLVED
10216  */
10217 extern
10219  SCIP* scip, /**< SCIP data structure */
10220  SCIP_VAR* var, /**< problem variable */
10221  SCIP_Real solval /**< variable's LP solution value */
10222  );
10223 
10224 /** gets the variable's pseudo cost score value for the given LP solution value,
10225  * only using the pseudo cost information of the current run
10226  *
10227  * @return the variable's pseudo cost score value for the given LP solution value,
10228  * only using the pseudo cost information of the current run
10229  *
10230  * @pre This method can be called if @p scip is in one of the following stages:
10231  * - \ref SCIP_STAGE_INITPRESOLVE
10232  * - \ref SCIP_STAGE_PRESOLVING
10233  * - \ref SCIP_STAGE_EXITPRESOLVE
10234  * - \ref SCIP_STAGE_PRESOLVED
10235  * - \ref SCIP_STAGE_INITSOLVE
10236  * - \ref SCIP_STAGE_SOLVING
10237  * - \ref SCIP_STAGE_SOLVED
10238  */
10239 extern
10241  SCIP* scip, /**< SCIP data structure */
10242  SCIP_VAR* var, /**< problem variable */
10243  SCIP_Real solval /**< variable's LP solution value */
10244  );
10245 
10246 /** returns the variable's VSIDS value
10247  *
10248  * @return the variable's VSIDS value
10249  *
10250  * @pre This method can be called if @p scip is in one of the following stages:
10251  * - \ref SCIP_STAGE_INITPRESOLVE
10252  * - \ref SCIP_STAGE_PRESOLVING
10253  * - \ref SCIP_STAGE_EXITPRESOLVE
10254  * - \ref SCIP_STAGE_PRESOLVED
10255  * - \ref SCIP_STAGE_INITSOLVE
10256  * - \ref SCIP_STAGE_SOLVING
10257  * - \ref SCIP_STAGE_SOLVED
10258  */
10259 extern
10261  SCIP* scip, /**< SCIP data structure */
10262  SCIP_VAR* var, /**< problem variable */
10263  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10264  );
10265 
10266 /** returns the variable's VSIDS value only using conflicts of the current run
10267  *
10268  * @return the variable's VSIDS value only using conflicts of the current run
10269  *
10270  * @pre This method can be called if @p scip is in one of the following stages:
10271  * - \ref SCIP_STAGE_INITPRESOLVE
10272  * - \ref SCIP_STAGE_PRESOLVING
10273  * - \ref SCIP_STAGE_EXITPRESOLVE
10274  * - \ref SCIP_STAGE_PRESOLVED
10275  * - \ref SCIP_STAGE_INITSOLVE
10276  * - \ref SCIP_STAGE_SOLVING
10277  * - \ref SCIP_STAGE_SOLVED
10278  */
10279 extern
10281  SCIP* scip, /**< SCIP data structure */
10282  SCIP_VAR* var, /**< problem variable */
10283  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10284  );
10285 
10286 /** returns the variable's conflict score value
10287  *
10288  * @return the variable's conflict score value
10289  *
10290  * @pre This method can be called if @p scip is in one of the following stages:
10291  * - \ref SCIP_STAGE_INITPRESOLVE
10292  * - \ref SCIP_STAGE_PRESOLVING
10293  * - \ref SCIP_STAGE_EXITPRESOLVE
10294  * - \ref SCIP_STAGE_PRESOLVED
10295  * - \ref SCIP_STAGE_INITSOLVE
10296  * - \ref SCIP_STAGE_SOLVING
10297  * - \ref SCIP_STAGE_SOLVED
10298  */
10299 extern
10301  SCIP* scip, /**< SCIP data structure */
10302  SCIP_VAR* var /**< problem variable */
10303  );
10304 
10305 /** returns the variable's conflict score value only using conflicts of the current run
10306  *
10307  * @return the variable's conflict score value only using conflicts of the current run
10308  *
10309  * @pre This method can be called if @p scip is in one of the following stages:
10310  * - \ref SCIP_STAGE_INITPRESOLVE
10311  * - \ref SCIP_STAGE_PRESOLVING
10312  * - \ref SCIP_STAGE_EXITPRESOLVE
10313  * - \ref SCIP_STAGE_PRESOLVED
10314  * - \ref SCIP_STAGE_INITSOLVE
10315  * - \ref SCIP_STAGE_SOLVING
10316  * - \ref SCIP_STAGE_SOLVED
10317  */
10318 extern
10320  SCIP* scip, /**< SCIP data structure */
10321  SCIP_VAR* var /**< problem variable */
10322  );
10323 
10324 /** returns the variable's conflict length score
10325  *
10326  * @return the variable's conflict length score
10327  *
10328  * @pre This method can be called if @p scip is in one of the following stages:
10329  * - \ref SCIP_STAGE_INITPRESOLVE
10330  * - \ref SCIP_STAGE_PRESOLVING
10331  * - \ref SCIP_STAGE_EXITPRESOLVE
10332  * - \ref SCIP_STAGE_PRESOLVED
10333  * - \ref SCIP_STAGE_INITSOLVE
10334  * - \ref SCIP_STAGE_SOLVING
10335  * - \ref SCIP_STAGE_SOLVED
10336  */
10337 extern
10339  SCIP* scip, /**< SCIP data structure */
10340  SCIP_VAR* var /**< problem variable */
10341  );
10342 
10343 /** returns the variable's conflict length score only using conflicts of the current run
10344  *
10345  * @return the variable's conflict length score only using conflicts of the current run
10346  *
10347  * @pre This method can be called if @p scip is in one of the following stages:
10348  * - \ref SCIP_STAGE_INITPRESOLVE
10349  * - \ref SCIP_STAGE_PRESOLVING
10350  * - \ref SCIP_STAGE_EXITPRESOLVE
10351  * - \ref SCIP_STAGE_PRESOLVED
10352  * - \ref SCIP_STAGE_INITSOLVE
10353  * - \ref SCIP_STAGE_SOLVING
10354  * - \ref SCIP_STAGE_SOLVED
10355  */
10356 extern
10358  SCIP* scip, /**< SCIP data structure */
10359  SCIP_VAR* var /**< problem variable */
10360  );
10361 
10362 /** returns the variable's average conflict length
10363  *
10364  * @return the variable's average conflict length
10365  *
10366  * @pre This method can be called if @p scip is in one of the following stages:
10367  * - \ref SCIP_STAGE_INITPRESOLVE
10368  * - \ref SCIP_STAGE_PRESOLVING
10369  * - \ref SCIP_STAGE_EXITPRESOLVE
10370  * - \ref SCIP_STAGE_PRESOLVED
10371  * - \ref SCIP_STAGE_INITSOLVE
10372  * - \ref SCIP_STAGE_SOLVING
10373  * - \ref SCIP_STAGE_SOLVED
10374  */
10375 extern
10377  SCIP* scip, /**< SCIP data structure */
10378  SCIP_VAR* var, /**< problem variable */
10379  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10380  );
10381 
10382 /** returns the variable's average conflict length only using conflicts of the current run
10383  *
10384  * @return the variable's average conflict length only using conflicts of the current run
10385  *
10386  * @pre This method can be called if @p scip is in one of the following stages:
10387  * - \ref SCIP_STAGE_INITPRESOLVE
10388  * - \ref SCIP_STAGE_PRESOLVING
10389  * - \ref SCIP_STAGE_EXITPRESOLVE
10390  * - \ref SCIP_STAGE_PRESOLVED
10391  * - \ref SCIP_STAGE_INITSOLVE
10392  * - \ref SCIP_STAGE_SOLVING
10393  * - \ref SCIP_STAGE_SOLVED
10394  */
10395 extern
10397  SCIP* scip, /**< SCIP data structure */
10398  SCIP_VAR* var, /**< problem variable */
10399  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10400  );
10401 
10402 /** returns the average number of inferences found after branching on the variable in given direction;
10403  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
10404  * over all variables for branching in the given direction is returned
10405  *
10406  * @return the average number of inferences found after branching on the variable in given direction
10407  *
10408  * @pre This method can be called if @p scip is in one of the following stages:
10409  * - \ref SCIP_STAGE_INITPRESOLVE
10410  * - \ref SCIP_STAGE_PRESOLVING
10411  * - \ref SCIP_STAGE_EXITPRESOLVE
10412  * - \ref SCIP_STAGE_PRESOLVED
10413  * - \ref SCIP_STAGE_INITSOLVE
10414  * - \ref SCIP_STAGE_SOLVING
10415  * - \ref SCIP_STAGE_SOLVED
10416  */
10417 extern
10419  SCIP* scip, /**< SCIP data structure */
10420  SCIP_VAR* var, /**< problem variable */
10421  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10422  );
10423 
10424 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
10425  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
10426  * over all variables for branching in the given direction is returned
10427  *
10428  * @return the average number of inferences found after branching on the variable in given direction in the current run
10429  *
10430  * @pre This method can be called if @p scip is in one of the following stages:
10431  * - \ref SCIP_STAGE_INITPRESOLVE
10432  * - \ref SCIP_STAGE_PRESOLVING
10433  * - \ref SCIP_STAGE_EXITPRESOLVE
10434  * - \ref SCIP_STAGE_PRESOLVED
10435  * - \ref SCIP_STAGE_INITSOLVE
10436  * - \ref SCIP_STAGE_SOLVING
10437  * - \ref SCIP_STAGE_SOLVED
10438  */
10439 extern
10441  SCIP* scip, /**< SCIP data structure */
10442  SCIP_VAR* var, /**< problem variable */
10443  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10444  );
10445 
10446 /** returns the variable's average inference score value
10447  *
10448  * @return the variable's average inference score value
10449  *
10450  * @pre This method can be called if @p scip is in one of the following stages:
10451  * - \ref SCIP_STAGE_INITPRESOLVE
10452  * - \ref SCIP_STAGE_PRESOLVING
10453  * - \ref SCIP_STAGE_EXITPRESOLVE
10454  * - \ref SCIP_STAGE_PRESOLVED
10455  * - \ref SCIP_STAGE_INITSOLVE
10456  * - \ref SCIP_STAGE_SOLVING
10457  * - \ref SCIP_STAGE_SOLVED
10458  */
10459 extern
10461  SCIP* scip, /**< SCIP data structure */
10462  SCIP_VAR* var /**< problem variable */
10463  );
10464 
10465 /** returns the variable's average inference score value only using inferences of the current run
10466  *
10467  * @return the variable's average inference score value only using inferences of the current run
10468  *
10469  * @pre This method can be called if @p scip is in one of the following stages:
10470  * - \ref SCIP_STAGE_INITPRESOLVE
10471  * - \ref SCIP_STAGE_PRESOLVING
10472  * - \ref SCIP_STAGE_EXITPRESOLVE
10473  * - \ref SCIP_STAGE_PRESOLVED
10474  * - \ref SCIP_STAGE_INITSOLVE
10475  * - \ref SCIP_STAGE_SOLVING
10476  * - \ref SCIP_STAGE_SOLVED
10477  */
10478 extern
10480  SCIP* scip, /**< SCIP data structure */
10481  SCIP_VAR* var /**< problem variable */
10482  );
10483 
10484 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
10485  * of a variable to the given values
10486  *
10487  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10488  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10489  *
10490  * @pre This method can be called if @p scip is in one of the following stages:
10491  * - \ref SCIP_STAGE_TRANSFORMED
10492  * - \ref SCIP_STAGE_INITPRESOLVE
10493  * - \ref SCIP_STAGE_PRESOLVING
10494  * - \ref SCIP_STAGE_EXITPRESOLVE
10495  * - \ref SCIP_STAGE_PRESOLVED
10496  * - \ref SCIP_STAGE_INITSOLVE
10497  * - \ref SCIP_STAGE_SOLVING
10498  */
10499 extern
10501  SCIP* scip, /**< SCIP data structure */
10502  SCIP_VAR* var, /**< variable which should be initialized */
10503  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
10504  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
10505  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
10506  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
10507  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
10508  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
10509  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
10510  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
10511  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
10512  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
10513  );
10514 
10515 /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
10516  * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
10517  *
10518  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10519  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10520  *
10521  * @pre This method can be called if @p scip is in one of the following stages:
10522  * - \ref SCIP_STAGE_TRANSFORMED
10523  * - \ref SCIP_STAGE_INITPRESOLVE
10524  * - \ref SCIP_STAGE_PRESOLVING
10525  * - \ref SCIP_STAGE_EXITPRESOLVE
10526  * - \ref SCIP_STAGE_PRESOLVED
10527  * - \ref SCIP_STAGE_INITSOLVE
10528  * - \ref SCIP_STAGE_SOLVING
10529  */
10530 extern
10532  SCIP* scip, /**< SCIP data structure */
10533  SCIP_VAR* var, /**< variable which should be initialized */
10534  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
10535  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
10536  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
10537  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
10538  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
10539  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
10540  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
10541  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
10542  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
10543  );
10544 
10545 /** returns the average number of cutoffs found after branching on the variable in given direction;
10546  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
10547  * over all variables for branching in the given direction is returned
10548  *
10549  * @return the average number of cutoffs found after branching on the variable in given direction
10550  *
10551  * @pre This method can be called if @p scip is in one of the following stages:
10552  * - \ref SCIP_STAGE_INITPRESOLVE
10553  * - \ref SCIP_STAGE_PRESOLVING
10554  * - \ref SCIP_STAGE_EXITPRESOLVE
10555  * - \ref SCIP_STAGE_PRESOLVED
10556  * - \ref SCIP_STAGE_INITSOLVE
10557  * - \ref SCIP_STAGE_SOLVING
10558  * - \ref SCIP_STAGE_SOLVED
10559  */
10560 extern
10562  SCIP* scip, /**< SCIP data structure */
10563  SCIP_VAR* var, /**< problem variable */
10564  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10565  );
10566 
10567 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
10568  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
10569  * over all variables for branching in the given direction is returned
10570  *
10571  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
10572  *
10573  * @pre This method can be called if @p scip is in one of the following stages:
10574  * - \ref SCIP_STAGE_INITPRESOLVE
10575  * - \ref SCIP_STAGE_PRESOLVING
10576  * - \ref SCIP_STAGE_EXITPRESOLVE
10577  * - \ref SCIP_STAGE_PRESOLVED
10578  * - \ref SCIP_STAGE_INITSOLVE
10579  * - \ref SCIP_STAGE_SOLVING
10580  * - \ref SCIP_STAGE_SOLVED
10581  */
10582 extern
10584  SCIP* scip, /**< SCIP data structure */
10585  SCIP_VAR* var, /**< problem variable */
10586  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10587  );
10588 
10589 /** returns the variable's average cutoff score value
10590  *
10591  * @return the variable's average cutoff score value
10592  *
10593  * @pre This method can be called if @p scip is in one of the following stages:
10594  * - \ref SCIP_STAGE_INITPRESOLVE
10595  * - \ref SCIP_STAGE_PRESOLVING
10596  * - \ref SCIP_STAGE_EXITPRESOLVE
10597  * - \ref SCIP_STAGE_PRESOLVED
10598  * - \ref SCIP_STAGE_INITSOLVE
10599  * - \ref SCIP_STAGE_SOLVING
10600  * - \ref SCIP_STAGE_SOLVED
10601  */
10602 extern
10604  SCIP* scip, /**< SCIP data structure */
10605  SCIP_VAR* var /**< problem variable */
10606  );
10607 
10608 /** returns the variable's average cutoff score value, only using cutoffs of the current run
10609  *
10610  * @return the variable's average cutoff score value, only using cutoffs of the current run
10611  *
10612  * @pre This method can be called if @p scip is in one of the following stages:
10613  * - \ref SCIP_STAGE_INITPRESOLVE
10614  * - \ref SCIP_STAGE_PRESOLVING
10615  * - \ref SCIP_STAGE_EXITPRESOLVE
10616  * - \ref SCIP_STAGE_PRESOLVED
10617  * - \ref SCIP_STAGE_INITSOLVE
10618  * - \ref SCIP_STAGE_SOLVING
10619  * - \ref SCIP_STAGE_SOLVED
10620  */
10621 extern
10623  SCIP* scip, /**< SCIP data structure */
10624  SCIP_VAR* var /**< problem variable */
10625  );
10626 
10627 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
10628  * factor
10629  *
10630  * @return the variable's average inference/cutoff score value
10631  *
10632  * @pre This method can be called if @p scip is in one of the following stages:
10633  * - \ref SCIP_STAGE_INITPRESOLVE
10634  * - \ref SCIP_STAGE_PRESOLVING
10635  * - \ref SCIP_STAGE_EXITPRESOLVE
10636  * - \ref SCIP_STAGE_PRESOLVED
10637  * - \ref SCIP_STAGE_INITSOLVE
10638  * - \ref SCIP_STAGE_SOLVING
10639  * - \ref SCIP_STAGE_SOLVED
10640  */
10641 extern
10643  SCIP* scip, /**< SCIP data structure */
10644  SCIP_VAR* var, /**< problem variable */
10645  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
10646  );
10647 
10648 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
10649  * factor, only using inferences and cutoffs of the current run
10650  *
10651  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
10652  *
10653  * @pre This method can be called if @p scip is in one of the following stages:
10654  * - \ref SCIP_STAGE_INITPRESOLVE
10655  * - \ref SCIP_STAGE_PRESOLVING
10656  * - \ref SCIP_STAGE_EXITPRESOLVE
10657  * - \ref SCIP_STAGE_PRESOLVED
10658  * - \ref SCIP_STAGE_INITSOLVE
10659  * - \ref SCIP_STAGE_SOLVING
10660  * - \ref SCIP_STAGE_SOLVED
10661  */
10662 extern
10664  SCIP* scip, /**< SCIP data structure */
10665  SCIP_VAR* var, /**< problem variable */
10666  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
10667  );
10668 
10669 /** outputs variable information to file stream via the message system
10670  *
10671  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10672  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10673  *
10674  * @pre This method can be called if @p scip is in one of the following stages:
10675  * - \ref SCIP_STAGE_PROBLEM
10676  * - \ref SCIP_STAGE_TRANSFORMING
10677  * - \ref SCIP_STAGE_TRANSFORMED
10678  * - \ref SCIP_STAGE_INITPRESOLVE
10679  * - \ref SCIP_STAGE_PRESOLVING
10680  * - \ref SCIP_STAGE_EXITPRESOLVE
10681  * - \ref SCIP_STAGE_PRESOLVED
10682  * - \ref SCIP_STAGE_INITSOLVE
10683  * - \ref SCIP_STAGE_SOLVING
10684  * - \ref SCIP_STAGE_SOLVED
10685  * - \ref SCIP_STAGE_EXITSOLVE
10686  * - \ref SCIP_STAGE_FREETRANS
10687  *
10688  * @note If the message handler is set to a NULL pointer nothing will be printed
10689  */
10690 extern
10692  SCIP* scip, /**< SCIP data structure */
10693  SCIP_VAR* var, /**< problem variable */
10694  FILE* file /**< output file (or NULL for standard output) */
10695  );
10696 
10697 /**@} */
10698 
10699 
10700 
10701 
10702 /*
10703  * conflict analysis methods
10704  */
10705 
10706 /**@addtogroup PublicConflictMethods
10707  *
10708  * @{
10709  */
10710 
10711 /** return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
10712  * conflict analysis since it will not be applied
10713  *
10714  * @return return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
10715  * conflict analysis since it will not be applied
10716  *
10717  * @pre This method can be called if SCIP is in one of the following stages:
10718  * - \ref SCIP_STAGE_INITPRESOLVE
10719  * - \ref SCIP_STAGE_PRESOLVING
10720  * - \ref SCIP_STAGE_EXITPRESOLVE
10721  * - \ref SCIP_STAGE_SOLVING
10722  *
10723  * @note SCIP stage does not get changed
10724  */
10725 extern
10727  SCIP* scip /**< SCIP data structure */
10728  );
10729 
10730 /** initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you
10731  * enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
10732  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
10733  *
10734  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10735  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10736  *
10737  * @pre This method can be called if SCIP is in one of the following stages:
10738  * - \ref SCIP_STAGE_PRESOLVING
10739  * - \ref SCIP_STAGE_SOLVING
10740  *
10741  * @note SCIP stage does not get changed
10742  */
10743 extern
10745  SCIP* scip, /**< SCIP data structure */
10746  SCIP_CONFTYPE conftype, /**< type of conflict */
10747  SCIP_Bool iscutoffinvolved /**< is the current cutoff bound involved? */
10748  );
10749 
10750 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
10751  * this method should be called in one of the following two cases:
10752  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound
10753  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10754  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called
10755  * for each lower bound, whose current assignment led to the deduction of the given conflict bound.
10756  *
10757  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10758  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10759  *
10760  * @pre This method can be called if SCIP is in one of the following stages:
10761  * - \ref SCIP_STAGE_PRESOLVING
10762  * - \ref SCIP_STAGE_SOLVING
10763  *
10764  * @note SCIP stage does not get changed
10765  */
10766 extern
10768  SCIP* scip, /**< SCIP data structure */
10769  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
10770  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10771  * conflicting bound was valid, NULL for current local bound */
10772  );
10773 
10774 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
10775  * with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough
10776  * to explain a certain bound change;
10777  * this method should be called in one of the following two cases:
10778  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound
10779  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10780  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called
10781  * for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.
10782  *
10783  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10784  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10785  *
10786  * @pre This method can be called if SCIP is in one of the following stages:
10787  * - \ref SCIP_STAGE_PRESOLVING
10788  * - \ref SCIP_STAGE_SOLVING
10789  *
10790  * @note SCIP stage does not get changed
10791  */
10792 extern
10794  SCIP* scip, /**< SCIP data structure */
10795  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
10796  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10797  * conflicting bound was valid, NULL for current local bound */
10798  SCIP_Real relaxedlb /**< the relaxed lower bound */
10799  );
10800 
10801 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
10802  * this method should be called in one of the following two cases:
10803  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that
10804  * led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10805  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for
10806  * each upper bound, whose current assignment led to the deduction of the given conflict bound.
10807  *
10808  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10809  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10810  *
10811  * @pre This method can be called if SCIP is in one of the following stages:
10812  * - \ref SCIP_STAGE_PRESOLVING
10813  * - \ref SCIP_STAGE_SOLVING
10814  *
10815  * @note SCIP stage does not get changed
10816  */
10817 extern
10819  SCIP* scip, /**< SCIP data structure */
10820  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10821  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10822  * conflicting bound was valid, NULL for current local bound */
10823  );
10824 
10825 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
10826  * with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough
10827  * to explain a certain bound change;
10828  * this method should be called in one of the following two cases:
10829  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper
10830  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10831  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be
10832  * called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict
10833  * bound.
10834  *
10835  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10836  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10837  *
10838  * @pre This method can be called if SCIP is in one of the following stages:
10839  * - \ref SCIP_STAGE_PRESOLVING
10840  * - \ref SCIP_STAGE_SOLVING
10841  *
10842  * @note SCIP stage does not get changed
10843  */
10844 extern
10846  SCIP* scip, /**< SCIP data structure */
10847  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10848  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10849  * conflicting bound was valid, NULL for current local bound */
10850  SCIP_Real relaxedub /**< the relaxed upper bound */
10851  );
10852 
10853 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate
10854  * storage; this method should be called in one of the following two cases:
10855  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound
10856  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10857  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called
10858  * for each bound, whose current assignment led to the deduction of the given conflict bound.
10859  *
10860  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10861  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10862  *
10863  * @pre This method can be called if SCIP is in one of the following stages:
10864  * - \ref SCIP_STAGE_PRESOLVING
10865  * - \ref SCIP_STAGE_SOLVING
10866  *
10867  * @note SCIP stage does not get changed
10868  */
10869 extern
10871  SCIP* scip, /**< SCIP data structure */
10872  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10873  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10874  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10875  * conflicting bound was valid, NULL for current local bound */
10876  );
10877 
10878 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis'
10879  * candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one
10880  * which would be enough to explain a certain bound change;
10881  * this method should be called in one of the following two cases:
10882  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed)
10883  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10884  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be
10885  * called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.
10886  *
10887  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10888  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10889  *
10890  * @pre This method can be called if SCIP is in one of the following stages:
10891  * - \ref SCIP_STAGE_PRESOLVING
10892  * - \ref SCIP_STAGE_SOLVING
10893  *
10894  * @note SCIP stage does not get changed
10895  */
10896 extern
10898  SCIP* scip, /**< SCIP data structure */
10899  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10900  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10901  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10902  * conflicting bound was valid, NULL for current local bound */
10903  SCIP_Real relaxedbd /**< the relaxed bound */
10904  );
10905 
10906 /** adds changed bound of fixed binary variable to the conflict analysis' candidate storage;
10907  * this method should be called in one of the following two cases:
10908  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary
10909  * variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10910  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called
10911  * for each binary variable, whose current fixing led to the deduction of the given conflict bound.
10912  *
10913  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10914  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10915  *
10916  * @pre This method can be called if SCIP is in one of the following stages:
10917  * - \ref SCIP_STAGE_PRESOLVING
10918  * - \ref SCIP_STAGE_SOLVING
10919  *
10920  * @note SCIP stage does not get changed
10921  */
10922 extern
10924  SCIP* scip, /**< SCIP data structure */
10925  SCIP_VAR* var /**< binary variable whose changed bound should be added to conflict queue */
10926  );
10927 
10928 /** checks if the given variable is already part of the current conflict set or queued for resolving with the same or
10929  * even stronger bound
10930  *
10931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10933  *
10934  * @pre This method can be called if SCIP is in one of the following stages:
10935  * - \ref SCIP_STAGE_PRESOLVING
10936  * - \ref SCIP_STAGE_SOLVING
10937  *
10938  * @note SCIP stage does not get changed
10939  */
10940 extern
10942  SCIP* scip, /**< SCIP data structure */
10943  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10944  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10945  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10946  * conflicting bound was valid, NULL for current local bound */
10947  SCIP_Bool* used /**< pointer to store if the variable is already used */
10948  );
10949 
10950 /** returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
10951  * bound
10952  *
10953  * @return returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
10954  * bound
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 /**< problem variable */
10966  );
10967 
10968 /** returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
10969  * upper bound
10970  *
10971  * @return returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
10972  * upper bound
10973  *
10974  * @pre This method can be called if SCIP is in one of the following stages:
10975  * - \ref SCIP_STAGE_PRESOLVING
10976  * - \ref SCIP_STAGE_SOLVING
10977  *
10978  * @note SCIP stage does not get changed
10979  */
10980 extern
10982  SCIP* scip, /**< SCIP data structure */
10983  SCIP_VAR* var /**< problem variable */
10984  );
10985 
10986 /** analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to
10987  * SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
10988  * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict
10989  * handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth
10990  * level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
10991  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is
10992  * valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons()
10993  * instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used
10994  *
10995  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10996  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10997  *
10998  * @pre This method can be called if SCIP is in one of the following stages:
10999  * - \ref SCIP_STAGE_PRESOLVING
11000  * - \ref SCIP_STAGE_SOLVING
11001  *
11002  * @note SCIP stage does not get changed
11003  */
11004 extern
11006  SCIP* scip, /**< SCIP data structure */
11007  int validdepth, /**< minimal depth level at which the initial conflict set is valid */
11008  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
11009  );
11010 
11011 /** analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(),
11012  * SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or
11013  * SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the
11014  * resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint
11015  * that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(),
11016  * SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(),
11017  * SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())
11018  *
11019  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11020  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11021  *
11022  * @pre This method can be called if SCIP is in one of the following stages:
11023  * - \ref SCIP_STAGE_PRESOLVING
11024  * - \ref SCIP_STAGE_SOLVING
11025  *
11026  * @note SCIP stage does not get changed
11027  */
11028 extern
11030  SCIP* scip, /**< SCIP data structure */
11031  SCIP_CONS* cons, /**< constraint that detected the conflict */
11032  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
11033  );
11034 
11035 /**@} */
11036 
11037 
11038 
11039 
11040 /*
11041  * constraint methods
11042  */
11043 
11044 /**@addtogroup PublicConstraintMethods
11045  *
11046  * @{
11047  */
11048 
11049 /** creates and captures a constraint of the given constraint handler
11050  *
11051  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
11052  * be declared feasible even if it violates this particular constraint. This constellation should only be
11053  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
11054  * to the variable's local bounds.
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 @p scip is in one of the following stages:
11060  * - \ref SCIP_STAGE_PROBLEM
11061  * - \ref SCIP_STAGE_TRANSFORMING
11062  * - \ref SCIP_STAGE_INITPRESOLVE
11063  * - \ref SCIP_STAGE_PRESOLVING
11064  * - \ref SCIP_STAGE_EXITPRESOLVE
11065  * - \ref SCIP_STAGE_PRESOLVED
11066  * - \ref SCIP_STAGE_INITSOLVE
11067  * - \ref SCIP_STAGE_SOLVING
11068  * - \ref SCIP_STAGE_EXITSOLVE
11069  *
11070  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
11071  */
11072 extern
11074  SCIP* scip, /**< SCIP data structure */
11075  SCIP_CONS** cons, /**< pointer to constraint */
11076  const char* name, /**< name of constraint */
11077  SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
11078  SCIP_CONSDATA* consdata, /**< data for this specific constraint */
11079  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
11080  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
11081  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
11082  * Usually set to TRUE. */
11083  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
11084  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11085  SCIP_Bool check, /**< should the constraint be checked for feasibility?
11086  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11087  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
11088  * Usually set to TRUE. */
11089  SCIP_Bool local, /**< is constraint only valid locally?
11090  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
11091  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
11092  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
11093  * adds coefficients to this constraint. */
11094  SCIP_Bool dynamic, /**< is constraint subject to aging?
11095  * Usually set to FALSE. Set to TRUE for own cuts which
11096  * are separated as constraints. */
11097  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
11098  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
11099  SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
11100  * if it may be moved to a more global node?
11101  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
11102  );
11103 
11104 /** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
11105  * creates and captures;
11106  *
11107  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11108  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11109  *
11110  * @pre This method can be called if @p scip is in one of the following stages:
11111  * - \ref SCIP_STAGE_PROBLEM
11112  * - \ref SCIP_STAGE_TRANSFORMING
11113  * - \ref SCIP_STAGE_INITPRESOLVE
11114  * - \ref SCIP_STAGE_PRESOLVING
11115  * - \ref SCIP_STAGE_EXITPRESOLVE
11116  * - \ref SCIP_STAGE_PRESOLVED
11117  * - \ref SCIP_STAGE_SOLVING
11118  * - \ref SCIP_STAGE_EXITSOLVE
11119  *
11120  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
11121  * be declared feasible even if it violates this particular constraint. This constellation should only be
11122  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
11123  * to the variable's local bounds.
11124  */
11125 extern
11127  SCIP* scip, /**< SCIP data structure */
11128  SCIP_CONS** cons, /**< pointer to store constraint */
11129  const char* str, /**< string to parse for constraint */
11130  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
11131  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
11132  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
11133  * Usually set to TRUE. */
11134  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
11135  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11136  SCIP_Bool check, /**< should the constraint be checked for feasibility?
11137  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11138  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
11139  * Usually set to TRUE. */
11140  SCIP_Bool local, /**< is constraint only valid locally?
11141  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
11142  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
11143  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
11144  * adds coefficients to this constraint. */
11145  SCIP_Bool dynamic, /**< is constraint subject to aging?
11146  * Usually set to FALSE. Set to TRUE for own cuts which
11147  * are separated as constraints. */
11148  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
11149  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
11150  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
11151  * if it may be moved to a more global node?
11152  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
11153  SCIP_Bool* success /**< pointer to store if the paring process was successful */
11154  );
11155 
11156 /** increases usage counter of constraint
11157  *
11158  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11159  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11160  *
11161  * @pre This method can be called if @p scip is in one of the following stages:
11162  * - \ref SCIP_STAGE_PROBLEM
11163  * - \ref SCIP_STAGE_TRANSFORMING
11164  * - \ref SCIP_STAGE_TRANSFORMED
11165  * - \ref SCIP_STAGE_INITPRESOLVE
11166  * - \ref SCIP_STAGE_PRESOLVING
11167  * - \ref SCIP_STAGE_EXITPRESOLVE
11168  * - \ref SCIP_STAGE_PRESOLVED
11169  * - \ref SCIP_STAGE_INITSOLVE
11170  * - \ref SCIP_STAGE_SOLVING
11171  * - \ref SCIP_STAGE_SOLVED
11172  */
11173 extern
11175  SCIP* scip, /**< SCIP data structure */
11176  SCIP_CONS* cons /**< constraint to capture */
11177  );
11178 
11179 /** decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
11180  *
11181  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11182  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11183  *
11184  * @pre This method can be called if @p scip is in one of the following stages:
11185  * - \ref SCIP_STAGE_PROBLEM
11186  * - \ref SCIP_STAGE_TRANSFORMING
11187  * - \ref SCIP_STAGE_TRANSFORMED
11188  * - \ref SCIP_STAGE_INITPRESOLVE
11189  * - \ref SCIP_STAGE_PRESOLVING
11190  * - \ref SCIP_STAGE_EXITPRESOLVE
11191  * - \ref SCIP_STAGE_PRESOLVED
11192  * - \ref SCIP_STAGE_INITSOLVE
11193  * - \ref SCIP_STAGE_SOLVING
11194  * - \ref SCIP_STAGE_SOLVED
11195  * - \ref SCIP_STAGE_EXITSOLVE
11196  * - \ref SCIP_STAGE_FREETRANS
11197  *
11198  * @note the pointer of the constraint will be NULLed
11199  */
11200 extern
11202  SCIP* scip, /**< SCIP data structure */
11203  SCIP_CONS** cons /**< pointer to constraint */
11204  );
11205 
11206 /** change constraint name
11207  *
11208  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11209  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11210  *
11211  * @pre This method can be called if @p scip is in one of the following stages:
11212  * - \ref SCIP_STAGE_PROBLEM
11213  *
11214  * @note to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h
11215  */
11216 extern
11218  SCIP* scip, /**< SCIP data structure */
11219  SCIP_CONS* cons, /**< constraint */
11220  const char* name /**< new name of constraint */
11221  );
11222 
11223 /** sets the initial flag of the given constraint
11224  *
11225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11227  *
11228  * @pre This method can be called if @p scip is in one of the following stages:
11229  * - \ref SCIP_STAGE_PROBLEM
11230  * - \ref SCIP_STAGE_TRANSFORMING
11231  * - \ref SCIP_STAGE_PRESOLVING
11232  * - \ref SCIP_STAGE_PRESOLVED
11233  * - \ref SCIP_STAGE_SOLVING
11234  */
11235 extern
11237  SCIP* scip, /**< SCIP data structure */
11238  SCIP_CONS* cons, /**< constraint */
11239  SCIP_Bool initial /**< new value */
11240  );
11241 
11242 /** sets the separate flag of the given constraint
11243  *
11244  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11245  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11246  *
11247  * @pre This method can be called if @p scip is in one of the following stages:
11248  * - \ref SCIP_STAGE_PROBLEM
11249  * - \ref SCIP_STAGE_TRANSFORMING
11250  * - \ref SCIP_STAGE_PRESOLVING
11251  * - \ref SCIP_STAGE_PRESOLVED
11252  * - \ref SCIP_STAGE_SOLVING
11253  */
11254 extern
11256  SCIP* scip, /**< SCIP data structure */
11257  SCIP_CONS* cons, /**< constraint */
11258  SCIP_Bool separate /**< new value */
11259  );
11260 
11261 /** sets the enforce flag of the given constraint
11262  *
11263  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11264  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11265  *
11266  * @pre This method can be called if @p scip is in one of the following stages:
11267  * - \ref SCIP_STAGE_PROBLEM
11268  * - \ref SCIP_STAGE_TRANSFORMING
11269  * - \ref SCIP_STAGE_PRESOLVING
11270  * - \ref SCIP_STAGE_PRESOLVED
11271  * - \ref SCIP_STAGE_SOLVING
11272  */
11273 extern
11275  SCIP* scip, /**< SCIP data structure */
11276  SCIP_CONS* cons, /**< constraint */
11277  SCIP_Bool enforce /**< new value */
11278  );
11279 
11280 /** sets the check flag of the given constraint
11281  *
11282  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11283  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11284  *
11285  * @pre This method can be called if @p scip is in one of the following stages:
11286  * - \ref SCIP_STAGE_PROBLEM
11287  * - \ref SCIP_STAGE_TRANSFORMING
11288  * - \ref SCIP_STAGE_PRESOLVING
11289  * - \ref SCIP_STAGE_PRESOLVED
11290  * - \ref SCIP_STAGE_SOLVING
11291  */
11292 extern
11294  SCIP* scip, /**< SCIP data structure */
11295  SCIP_CONS* cons, /**< constraint */
11296  SCIP_Bool check /**< new value */
11297  );
11298 
11299 /** sets the propagate flag of the given constraint
11300  *
11301  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11302  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11303  *
11304  * @pre This method can be called if @p scip is in one of the following stages:
11305  * - \ref SCIP_STAGE_PROBLEM
11306  * - \ref SCIP_STAGE_TRANSFORMING
11307  * - \ref SCIP_STAGE_PRESOLVING
11308  * - \ref SCIP_STAGE_PRESOLVED
11309  * - \ref SCIP_STAGE_SOLVING
11310  */
11311 extern
11313  SCIP* scip, /**< SCIP data structure */
11314  SCIP_CONS* cons, /**< constraint */
11315  SCIP_Bool propagate /**< new value */
11316  );
11317 
11318 /** sets the local flag of the given constraint
11319  *
11320  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11321  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11322  *
11323  * @pre This method can be called if @p scip is in one of the following stages:
11324  * - \ref SCIP_STAGE_PROBLEM
11325  * - \ref SCIP_STAGE_TRANSFORMING
11326  * - \ref SCIP_STAGE_INITPRESOLVE
11327  * - \ref SCIP_STAGE_PRESOLVING
11328  * - \ref SCIP_STAGE_PRESOLVED
11329  * - \ref SCIP_STAGE_INITSOLVE
11330  * - \ref SCIP_STAGE_SOLVING
11331  */
11332 extern
11334  SCIP* scip, /**< SCIP data structure */
11335  SCIP_CONS* cons, /**< constraint */
11336  SCIP_Bool local /**< new value */
11337  );
11338 
11339 /** sets the modifiable flag of the given constraint
11340  *
11341  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11342  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11343  *
11344  * @pre This method can be called if @p scip is in one of the following stages:
11345  * - \ref SCIP_STAGE_PROBLEM
11346  * - \ref SCIP_STAGE_TRANSFORMING
11347  * - \ref SCIP_STAGE_PRESOLVING
11348  * - \ref SCIP_STAGE_PRESOLVED
11349  * - \ref SCIP_STAGE_SOLVING
11350  * - \ref SCIP_STAGE_EXITSOLVE
11351  */
11352 extern
11354  SCIP* scip, /**< SCIP data structure */
11355  SCIP_CONS* cons, /**< constraint */
11356  SCIP_Bool modifiable /**< new value */
11357  );
11358 
11359 /** sets the dynamic flag of the given constraint
11360  *
11361  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11362  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11363  *
11364  * @pre This method can be called if @p scip is in one of the following stages:
11365  * - \ref SCIP_STAGE_PROBLEM
11366  * - \ref SCIP_STAGE_TRANSFORMING
11367  * - \ref SCIP_STAGE_PRESOLVING
11368  * - \ref SCIP_STAGE_PRESOLVED
11369  * - \ref SCIP_STAGE_SOLVING
11370  */
11371 extern
11373  SCIP* scip, /**< SCIP data structure */
11374  SCIP_CONS* cons, /**< constraint */
11375  SCIP_Bool dynamic /**< new value */
11376  );
11377 
11378 /** sets the removable flag of the given constraint
11379  *
11380  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11381  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11382  *
11383  * @pre This method can be called if @p scip is in one of the following stages:
11384  * - \ref SCIP_STAGE_PROBLEM
11385  * - \ref SCIP_STAGE_TRANSFORMING
11386  * - \ref SCIP_STAGE_PRESOLVING
11387  * - \ref SCIP_STAGE_PRESOLVED
11388  * - \ref SCIP_STAGE_SOLVING
11389  */
11390 extern
11392  SCIP* scip, /**< SCIP data structure */
11393  SCIP_CONS* cons, /**< constraint */
11394  SCIP_Bool removable /**< new value */
11395  );
11396 
11397 /** sets the stickingatnode flag of the given constraint
11398  *
11399  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11400  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11401  *
11402  * @pre This method can be called if @p scip is in one of the following stages:
11403  * - \ref SCIP_STAGE_PROBLEM
11404  * - \ref SCIP_STAGE_TRANSFORMING
11405  * - \ref SCIP_STAGE_PRESOLVING
11406  * - \ref SCIP_STAGE_PRESOLVED
11407  * - \ref SCIP_STAGE_SOLVING
11408  */
11409 extern
11411  SCIP* scip, /**< SCIP data structure */
11412  SCIP_CONS* cons, /**< constraint */
11413  SCIP_Bool stickingatnode /**< new value */
11414  );
11415 
11416 /** updates the flags of the first constraint according to the ones of the second constraint
11417  *
11418  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11419  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11420  *
11421  * @pre This method can be called if @p scip is in one of the following stages:
11422  * - \ref SCIP_STAGE_PROBLEM
11423  * - \ref SCIP_STAGE_TRANSFORMING
11424  * - \ref SCIP_STAGE_PRESOLVING
11425  * - \ref SCIP_STAGE_PRESOLVED
11426  * - \ref SCIP_STAGE_SOLVING
11427  */
11428 extern
11430  SCIP* scip, /**< SCIP data structure */
11431  SCIP_CONS* cons0, /**< constraint that should stay */
11432  SCIP_CONS* cons1 /**< constraint that should be deleted */
11433  );
11434 
11435 /** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
11436  * a new transformed constraint for this constraint is created
11437  *
11438  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11439  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11440  *
11441  * @pre This method can be called if @p scip is in one of the following stages:
11442  * - \ref SCIP_STAGE_TRANSFORMING
11443  * - \ref SCIP_STAGE_TRANSFORMED
11444  * - \ref SCIP_STAGE_INITPRESOLVE
11445  * - \ref SCIP_STAGE_PRESOLVING
11446  * - \ref SCIP_STAGE_EXITPRESOLVE
11447  * - \ref SCIP_STAGE_PRESOLVED
11448  * - \ref SCIP_STAGE_INITSOLVE
11449  * - \ref SCIP_STAGE_SOLVING
11450  */
11451 extern
11453  SCIP* scip, /**< SCIP data structure */
11454  SCIP_CONS* cons, /**< constraint to get/create transformed constraint for */
11455  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
11456  );
11457 
11458 /** gets and captures transformed constraints for an array of constraints;
11459  * if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created;
11460  * it is possible to call this method with conss == transconss
11461  *
11462  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11463  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11464  *
11465  * @pre This method can be called if @p scip is in one of the following stages:
11466  * - \ref SCIP_STAGE_TRANSFORMING
11467  * - \ref SCIP_STAGE_TRANSFORMED
11468  * - \ref SCIP_STAGE_INITPRESOLVE
11469  * - \ref SCIP_STAGE_PRESOLVING
11470  * - \ref SCIP_STAGE_EXITPRESOLVE
11471  * - \ref SCIP_STAGE_PRESOLVED
11472  * - \ref SCIP_STAGE_INITSOLVE
11473  * - \ref SCIP_STAGE_SOLVING
11474  */
11475 extern
11477  SCIP* scip, /**< SCIP data structure */
11478  int nconss, /**< number of constraints to get/create transformed constraints for */
11479  SCIP_CONS** conss, /**< array with constraints to get/create transformed constraints for */
11480  SCIP_CONS** transconss /**< array to store the transformed constraints */
11481  );
11482 
11483 /** gets corresponding transformed constraint of a given constraint;
11484  * returns NULL as transcons, if transformed constraint is not yet existing
11485  *
11486  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11487  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11488  *
11489  * @pre This method can be called if @p scip is in one of the following stages:
11490  * - \ref SCIP_STAGE_TRANSFORMING
11491  * - \ref SCIP_STAGE_TRANSFORMED
11492  * - \ref SCIP_STAGE_INITPRESOLVE
11493  * - \ref SCIP_STAGE_PRESOLVING
11494  * - \ref SCIP_STAGE_EXITPRESOLVE
11495  * - \ref SCIP_STAGE_PRESOLVED
11496  * - \ref SCIP_STAGE_INITSOLVE
11497  * - \ref SCIP_STAGE_SOLVING
11498  * - \ref SCIP_STAGE_SOLVED
11499  * - \ref SCIP_STAGE_EXITSOLVE
11500  * - \ref SCIP_STAGE_FREETRANS
11501  */
11502 extern
11504  SCIP* scip, /**< SCIP data structure */
11505  SCIP_CONS* cons, /**< constraint to get the transformed constraint for */
11506  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
11507  );
11508 
11509 /** gets corresponding transformed constraints for an array of constraints;
11510  * stores NULL in a transconss slot, if the transformed constraint is not yet existing;
11511  * it is possible to call this method with conss == transconss, but remember that constraints that are not
11512  * yet transformed will be replaced with NULL
11513  *
11514  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11515  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11516  *
11517  * @pre This method can be called if @p scip is in one of the following stages:
11518  * - \ref SCIP_STAGE_TRANSFORMING
11519  * - \ref SCIP_STAGE_TRANSFORMED
11520  * - \ref SCIP_STAGE_INITPRESOLVE
11521  * - \ref SCIP_STAGE_PRESOLVING
11522  * - \ref SCIP_STAGE_EXITPRESOLVE
11523  * - \ref SCIP_STAGE_PRESOLVED
11524  * - \ref SCIP_STAGE_INITSOLVE
11525  * - \ref SCIP_STAGE_SOLVING
11526  * - \ref SCIP_STAGE_SOLVED
11527  * - \ref SCIP_STAGE_EXITSOLVE
11528  * - \ref SCIP_STAGE_FREETRANS
11529  */
11530 extern
11532  SCIP* scip, /**< SCIP data structure */
11533  int nconss, /**< number of constraints to get the transformed constraints for */
11534  SCIP_CONS** conss, /**< constraints to get the transformed constraints for */
11535  SCIP_CONS** transconss /**< array to store the transformed constraints */
11536  );
11537 
11538 /** adds given value to age of constraint, but age can never become negative;
11539  * should be called
11540  * - in constraint separation, if no cut was found for this constraint,
11541  * - in constraint enforcing, if constraint was feasible, and
11542  * - in constraint propagation, if no domain reduction was deduced;
11543  *
11544  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11545  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11546  *
11547  * @pre This method can be called if @p scip is in one of the following stages:
11548  * - \ref SCIP_STAGE_TRANSFORMED
11549  * - \ref SCIP_STAGE_PRESOLVING
11550  * - \ref SCIP_STAGE_PRESOLVED
11551  * - \ref SCIP_STAGE_SOLVING
11552  * - \ref SCIP_STAGE_SOLVED
11553  */
11554 extern
11556  SCIP* scip, /**< SCIP data structure */
11557  SCIP_CONS* cons, /**< constraint */
11558  SCIP_Real deltaage /**< value to add to the constraint's age */
11559  );
11560 
11561 /** increases age of constraint by 1.0;
11562  * should be called
11563  * - in constraint separation, if no cut was found for this constraint,
11564  * - in constraint enforcing, if constraint was feasible, and
11565  * - in constraint propagation, if no domain reduction was deduced;
11566  *
11567  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11568  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11569  *
11570  * @pre This method can be called if @p scip is in one of the following stages:
11571  * - \ref SCIP_STAGE_TRANSFORMED
11572  * - \ref SCIP_STAGE_PRESOLVING
11573  * - \ref SCIP_STAGE_PRESOLVED
11574  * - \ref SCIP_STAGE_SOLVING
11575  * - \ref SCIP_STAGE_SOLVED
11576  */
11577 extern
11579  SCIP* scip, /**< SCIP data structure */
11580  SCIP_CONS* cons /**< constraint */
11581  );
11582 
11583 /** resets age of constraint to zero;
11584  * should be called
11585  * - in constraint separation, if a cut was found for this constraint,
11586  * - in constraint enforcing, if the constraint was violated, and
11587  * - in constraint propagation, if a domain reduction was deduced;
11588  *
11589  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11590  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11591  *
11592  * @pre This method can be called if @p scip is in one of the following stages:
11593  * - \ref SCIP_STAGE_TRANSFORMED
11594  * - \ref SCIP_STAGE_PRESOLVING
11595  * - \ref SCIP_STAGE_PRESOLVED
11596  * - \ref SCIP_STAGE_SOLVING
11597  * - \ref SCIP_STAGE_SOLVED
11598  */
11599 extern
11601  SCIP* scip, /**< SCIP data structure */
11602  SCIP_CONS* cons /**< constraint */
11603  );
11604 
11605 /** enables constraint's separation, propagation, and enforcing capabilities
11606  *
11607  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11608  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11609  *
11610  * @pre This method can be called if @p scip is in one of the following stages:
11611  * - \ref SCIP_STAGE_TRANSFORMED
11612  * - \ref SCIP_STAGE_PRESOLVING
11613  * - \ref SCIP_STAGE_PRESOLVED
11614  * - \ref SCIP_STAGE_INITSOLVE
11615  * - \ref SCIP_STAGE_SOLVING
11616  * - \ref SCIP_STAGE_SOLVED
11617  */
11618 extern
11620  SCIP* scip, /**< SCIP data structure */
11621  SCIP_CONS* cons /**< constraint */
11622  );
11623 
11624 /** disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated,
11625  * separated, and enforced anymore until it is enabled again with a call to SCIPenableCons();
11626  * in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and
11627  * does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor
11628  * automatically disabled again on entering the node again;
11629  * note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint
11630  * is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree,
11631  * and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using
11632  * an appropriate event handler that watches the corresponding variables' domain changes)
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_TRANSFORMED
11639  * - \ref SCIP_STAGE_INITPRESOLVE
11640  * - \ref SCIP_STAGE_PRESOLVING
11641  * - \ref SCIP_STAGE_PRESOLVED
11642  * - \ref SCIP_STAGE_INITSOLVE
11643  * - \ref SCIP_STAGE_SOLVING
11644  * - \ref SCIP_STAGE_SOLVED
11645  */
11646 extern
11648  SCIP* scip, /**< SCIP data structure */
11649  SCIP_CONS* cons /**< constraint */
11650  );
11651 
11652 /** enables constraint's separation capabilities
11653  *
11654  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11655  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11656  *
11657  * @pre This method can be called if @p scip is in one of the following stages:
11658  * - \ref SCIP_STAGE_TRANSFORMED
11659  * - \ref SCIP_STAGE_PRESOLVING
11660  * - \ref SCIP_STAGE_PRESOLVED
11661  * - \ref SCIP_STAGE_INITSOLVE
11662  * - \ref SCIP_STAGE_SOLVING
11663  * - \ref SCIP_STAGE_SOLVED
11664  */
11665 extern
11667  SCIP* scip, /**< SCIP data structure */
11668  SCIP_CONS* cons /**< constraint */
11669  );
11670 
11671 /** disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation
11672  * is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
11673  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
11674  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
11675  *
11676  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11677  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11678  *
11679  * @pre This method can be called if @p scip is in one of the following stages:
11680  * - \ref SCIP_STAGE_TRANSFORMED
11681  * - \ref SCIP_STAGE_PRESOLVING
11682  * - \ref SCIP_STAGE_PRESOLVED
11683  * - \ref SCIP_STAGE_INITSOLVE
11684  * - \ref SCIP_STAGE_SOLVING
11685  * - \ref SCIP_STAGE_SOLVED
11686  */
11687 extern
11689  SCIP* scip, /**< SCIP data structure */
11690  SCIP_CONS* cons /**< constraint */
11691  );
11692 
11693 /** enables constraint's propagation capabilities
11694  *
11695  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11696  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11697  *
11698  * @pre This method can be called if @p scip is in one of the following stages:
11699  * - \ref SCIP_STAGE_TRANSFORMED
11700  * - \ref SCIP_STAGE_INITPRESOLVE
11701  * - \ref SCIP_STAGE_PRESOLVING
11702  * - \ref SCIP_STAGE_EXITPRESOLVE
11703  * - \ref SCIP_STAGE_PRESOLVED
11704  * - \ref SCIP_STAGE_INITSOLVE
11705  * - \ref SCIP_STAGE_SOLVING
11706  * - \ref SCIP_STAGE_SOLVED
11707  */
11708 extern
11710  SCIP* scip, /**< SCIP data structure */
11711  SCIP_CONS* cons /**< constraint */
11712  );
11713 
11714 /** disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation
11715  * is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
11716  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
11717  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
11718  *
11719  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11720  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11721  *
11722  * @pre This method can be called if @p scip is in one of the following stages:
11723  * - \ref SCIP_STAGE_TRANSFORMED
11724  * - \ref SCIP_STAGE_INITPRESOLVE
11725  * - \ref SCIP_STAGE_PRESOLVING
11726  * - \ref SCIP_STAGE_EXITPRESOLVE
11727  * - \ref SCIP_STAGE_PRESOLVED
11728  * - \ref SCIP_STAGE_INITSOLVE
11729  * - \ref SCIP_STAGE_SOLVING
11730  * - \ref SCIP_STAGE_SOLVED
11731  */
11732 extern
11734  SCIP* scip, /**< SCIP data structure */
11735  SCIP_CONS* cons /**< constraint */
11736  );
11737 
11738 
11739 /** marks constraint to be propagated
11740  *
11741  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11742  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11743  *
11744  * @pre This method can be called if @p scip is in one of the following stages:
11745  * - \ref SCIP_STAGE_TRANSFORMING
11746  * - \ref SCIP_STAGE_TRANSFORMED
11747  * - \ref SCIP_STAGE_PRESOLVING
11748  * - \ref SCIP_STAGE_EXITPRESOLVE
11749  * - \ref SCIP_STAGE_PRESOLVED
11750  * - \ref SCIP_STAGE_INITSOLVE
11751  * - \ref SCIP_STAGE_SOLVING
11752  * - \ref SCIP_STAGE_SOLVED
11753  *
11754  * @note if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation
11755  */
11756 extern
11758  SCIP* scip, /**< SCIP data structure */
11759  SCIP_CONS* cons /**< constraint */
11760  );
11761 
11762 /** unmarks the constraint to be propagated
11763  *
11764  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11765  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11766  *
11767  * @pre This method can be called if @p scip is in one of the following stages:
11768  * - \ref SCIP_STAGE_TRANSFORMED
11769  * - \ref SCIP_STAGE_PRESOLVING
11770  * - \ref SCIP_STAGE_EXITPRESOLVE
11771  * - \ref SCIP_STAGE_PRESOLVED
11772  * - \ref SCIP_STAGE_INITSOLVE
11773  * - \ref SCIP_STAGE_SOLVING
11774  * - \ref SCIP_STAGE_SOLVED
11775  */
11776 extern
11778  SCIP* scip, /**< SCIP data structure */
11779  SCIP_CONS* cons /**< constraint */
11780  );
11781 
11782 /** adds given values to lock status of the constraint and updates the rounding locks of the involved variables
11783  *
11784  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11785  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11786  *
11787  * @pre This method can be called if @p scip is in one of the following stages:
11788  * - \ref SCIP_STAGE_PROBLEM
11789  * - \ref SCIP_STAGE_TRANSFORMING
11790  * - \ref SCIP_STAGE_INITPRESOLVE
11791  * - \ref SCIP_STAGE_PRESOLVING
11792  * - \ref SCIP_STAGE_EXITPRESOLVE
11793  * - \ref SCIP_STAGE_INITSOLVE
11794  * - \ref SCIP_STAGE_SOLVING
11795  * - \ref SCIP_STAGE_EXITSOLVE
11796  * - \ref SCIP_STAGE_FREETRANS
11797  */
11798 extern
11800  SCIP* scip, /**< SCIP data structure */
11801  SCIP_CONS* cons, /**< constraint */
11802  int nlockspos, /**< increase in number of rounding locks for constraint */
11803  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
11804  );
11805 
11806 /** checks single constraint for feasibility of the given solution
11807  *
11808  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11809  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11810  *
11811  * @pre This method can be called if @p scip is in one of the following stages:
11812  * - \ref SCIP_STAGE_TRANSFORMED
11813  * - \ref SCIP_STAGE_INITPRESOLVE
11814  * - \ref SCIP_STAGE_PRESOLVING
11815  * - \ref SCIP_STAGE_EXITPRESOLVE
11816  * - \ref SCIP_STAGE_PRESOLVED
11817  * - \ref SCIP_STAGE_INITSOLVE
11818  * - \ref SCIP_STAGE_SOLVING
11819  * - \ref SCIP_STAGE_SOLVED
11820  */
11821 extern
11823  SCIP* scip, /**< SCIP data structure */
11824  SCIP_CONS* cons, /**< constraint to check */
11825  SCIP_SOL* sol, /**< primal CIP solution */
11826  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
11827  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
11828  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
11829  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11830  );
11831 
11832 /** enforces single constraint for a given pseudo solution
11833  *
11834  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11835  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11836  *
11837  * @pre This method can be called if @p scip is in one of the following stages:
11838  * - \ref SCIP_STAGE_SOLVING
11839  *
11840  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11841  * added to SCIP beforehand.
11842  */
11843 extern
11845  SCIP* scip, /**< SCIP data structure */
11846  SCIP_CONS* cons, /**< constraint to enforce */
11847  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
11848  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
11849  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11850  );
11851 
11852 /** enforces single constraint for a given LP solution
11853  *
11854  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11855  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11856  *
11857  * @pre This method can be called if @p scip is in one of the following stages:
11858  * - \ref SCIP_STAGE_SOLVING
11859  *
11860  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11861  * added to SCIP beforehand.
11862  */
11863 extern
11865  SCIP* scip, /**< SCIP data structure */
11866  SCIP_CONS* cons, /**< constraint to enforce */
11867  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
11868  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11869  );
11870 
11871 /** enforces single constraint for a given relaxation solution
11872  *
11873  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11874  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11875  *
11876  * @pre This method can be called if @p scip is in one of the following stages:
11877  * - \ref SCIP_STAGE_SOLVING
11878  *
11879  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11880  * added to SCIP beforehand.
11881  */
11883  SCIP* scip, /**< SCIP data structure */
11884  SCIP_CONS* cons, /**< constraint to enforce */
11885  SCIP_SOL* sol, /**< solution to enforce */
11886  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
11887  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11888  );
11889 
11890 /** calls LP initialization method for single constraint
11891  *
11892  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11893  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11894  *
11895  * @pre This method can be called if @p scip is in one of the following stages:
11896  * - \ref SCIP_STAGE_SOLVING
11897  *
11898  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11899  * added to SCIP beforehand.
11900  */
11901 extern
11903  SCIP* scip, /**< SCIP data structure */
11904  SCIP_CONS* cons, /**< constraint to initialize */
11905  SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
11906 
11907  );
11908 
11909 /** calls separation method of single constraint for LP solution
11910  *
11911  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11912  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11913  *
11914  * @pre This method can be called if @p scip is in one of the following stages:
11915  * - \ref SCIP_STAGE_SOLVING
11916  *
11917  * @note This is an advanced method and should be used with caution.
11918  */
11919 extern
11921  SCIP* scip, /**< SCIP data structure */
11922  SCIP_CONS* cons, /**< constraint to separate */
11923  SCIP_RESULT* result /**< pointer to store the result of the separation call */
11924  );
11925 
11926 /** calls separation method of single constraint for given primal solution
11927  *
11928  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11929  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11930  *
11931  * @pre This method can be called if @p scip is in one of the following stages:
11932  * - \ref SCIP_STAGE_SOLVING
11933  *
11934  * @note This is an advanced method and should be used with caution.
11935  */
11936 extern
11938  SCIP* scip, /**< SCIP data structure */
11939  SCIP_CONS* cons, /**< constraint to separate */
11940  SCIP_SOL* sol, /**< primal solution that should be separated*/
11941  SCIP_RESULT* result /**< pointer to store the result of the separation call */
11942  );
11943 
11944 /** calls domain propagation method of single constraint
11945  *
11946  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11947  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11948  *
11949  * @pre This method can be called if @p scip is in one of the following stages:
11950  * - \ref SCIP_STAGE_PRESOLVING
11951  * - \ref SCIP_STAGE_SOLVING
11952  *
11953  * @note This is an advanced method and should be used with caution.
11954  */
11955 extern
11957  SCIP* scip, /**< SCIP data structure */
11958  SCIP_CONS* cons, /**< constraint to propagate */
11959  SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
11960  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11961  );
11962 
11963 /** resolves propagation conflict of single constraint
11964  *
11965  *
11966  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11967  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11968  *
11969  * @pre This method can be called if @p scip is in one of the following stages:
11970  * - \ref SCIP_STAGE_PRESOLVING
11971  * - \ref SCIP_STAGE_SOLVING
11972  *
11973  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11974  * added to SCIP beforehand.
11975  */
11976 extern
11978  SCIP* scip, /**< SCIP data structure */
11979  SCIP_CONS* cons, /**< constraint to resolve conflict for */
11980  SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
11981  int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
11982  SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
11983  SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
11984  SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
11985  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11986  );
11987 
11988 /** presolves of single constraint
11989  *
11990  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11991  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11992  *
11993  * @pre This method can be called if @p scip is in one of the following stages:
11994  * - \ref SCIP_STAGE_PRESOLVING
11995  *
11996  * @note This is an advanced method and should be used with caution.
11997  */
11998 extern
12000  SCIP* scip, /**< SCIP data structure */
12001  SCIP_CONS* cons, /**< constraint to presolve */
12002  int nrounds, /**< number of presolving rounds already done */
12003  SCIP_PRESOLTIMING presoltiming, /**< presolving timing(s) to be performed */
12004  int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
12005  int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
12006  int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
12007  int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
12008  int nnewholes, /**< number of domain holes added since the last call to the presolving method */
12009  int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
12010  int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
12011  int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
12012  int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
12013  int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
12014  int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
12015  int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
12016  int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
12017  int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
12018  int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
12019  int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
12020  int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
12021  int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
12022  int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
12023  int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
12024  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12025  );
12026 
12027 /** calls constraint activation notification method of single constraint
12028  *
12029  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12030  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12031  *
12032  * @pre This method can be called if @p scip is in one of the following stages:
12033  * - \ref SCIP_STAGE_TRANSFORMING
12034  *
12035  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12036  * added to SCIP beforehand.
12037  */
12038 extern
12040  SCIP* scip, /**< SCIP data structure */
12041  SCIP_CONS* cons /**< constraint to notify */
12042  );
12043 
12044 /** calls constraint deactivation notification method of single constraint
12045  *
12046  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12047  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12048  *
12049  * @pre This method can be called if @p scip is in one of the following stages:
12050  * - \ref SCIP_STAGE_PRESOLVING
12051  * - \ref SCIP_STAGE_SOLVING
12052  *
12053  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12054  * added to SCIP beforehand.
12055  */
12056 extern
12058  SCIP* scip, /**< SCIP data structure */
12059  SCIP_CONS* cons /**< constraint to notify */
12060  );
12061 
12062 /** outputs constraint information to file stream via the message handler system
12063  *
12064  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12065  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12066  *
12067  * @pre This method can be called if @p scip is in one of the following stages:
12068  * - \ref SCIP_STAGE_PROBLEM
12069  * - \ref SCIP_STAGE_TRANSFORMING
12070  * - \ref SCIP_STAGE_TRANSFORMED
12071  * - \ref SCIP_STAGE_INITPRESOLVE
12072  * - \ref SCIP_STAGE_PRESOLVING
12073  * - \ref SCIP_STAGE_EXITPRESOLVE
12074  * - \ref SCIP_STAGE_PRESOLVED
12075  * - \ref SCIP_STAGE_INITSOLVE
12076  * - \ref SCIP_STAGE_SOLVING
12077  * - \ref SCIP_STAGE_SOLVED
12078  * - \ref SCIP_STAGE_EXITSOLVE
12079  * - \ref SCIP_STAGE_FREETRANS
12080  *
12081  * @note If the message handler is set to a NULL pointer nothing will be printed.
12082  * @note The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a
12083  * newline character.
12084  */
12085 extern
12087  SCIP* scip, /**< SCIP data structure */
12088  SCIP_CONS* cons, /**< constraint */
12089  FILE* file /**< output file (or NULL for standard output) */
12090  );
12091 
12092 /** method to collect the variables of a constraint
12093  *
12094  * If the number of variables is greater than the available slots in the variable array, nothing happens except that
12095  * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
12096  * a constraint has in its scope.
12097  *
12098  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12099  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12100  *
12101  * @pre This method can be called if @p scip is in one of the following stages:
12102  * - \ref SCIP_STAGE_PROBLEM
12103  * - \ref SCIP_STAGE_TRANSFORMING
12104  * - \ref SCIP_STAGE_TRANSFORMED
12105  * - \ref SCIP_STAGE_INITPRESOLVE
12106  * - \ref SCIP_STAGE_PRESOLVING
12107  * - \ref SCIP_STAGE_EXITPRESOLVE
12108  * - \ref SCIP_STAGE_PRESOLVED
12109  * - \ref SCIP_STAGE_INITSOLVE
12110  * - \ref SCIP_STAGE_SOLVING
12111  * - \ref SCIP_STAGE_SOLVED
12112  * - \ref SCIP_STAGE_EXITSOLVE
12113  * - \ref SCIP_STAGE_FREETRANS
12114  *
12115  * @note The success pointer indicates if all variables were copied into the vars arrray.
12116  *
12117  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
12118  * set to FALSE.
12119  */
12120 extern
12122  SCIP* scip, /**< SCIP data structure */
12123  SCIP_CONS* cons, /**< constraint for which the variables are wanted */
12124  SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
12125  int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
12126  SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
12127  );
12128 
12129 /** method to collect the number of variables of a constraint
12130  *
12131  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12132  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12133  *
12134  * @pre This method can be called if @p scip is in one of the following stages:
12135  * - \ref SCIP_STAGE_PROBLEM
12136  * - \ref SCIP_STAGE_TRANSFORMING
12137  * - \ref SCIP_STAGE_TRANSFORMED
12138  * - \ref SCIP_STAGE_INITPRESOLVE
12139  * - \ref SCIP_STAGE_PRESOLVING
12140  * - \ref SCIP_STAGE_EXITPRESOLVE
12141  * - \ref SCIP_STAGE_PRESOLVED
12142  * - \ref SCIP_STAGE_INITSOLVE
12143  * - \ref SCIP_STAGE_SOLVING
12144  * - \ref SCIP_STAGE_SOLVED
12145  * - \ref SCIP_STAGE_EXITSOLVE
12146  * - \ref SCIP_STAGE_FREETRANS
12147  *
12148  * @note The success pointer indicates if the contraint handler was able to return the number of variables
12149  *
12150  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
12151  * set to FALSE
12152  */
12153 extern
12155  SCIP* scip, /**< SCIP data structure */
12156  SCIP_CONS* cons, /**< constraint for which the number of variables is wanted */
12157  int* nvars, /**< pointer to store the number of variables */
12158  SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
12159  );
12160 
12161 /**@} */
12162 
12163 
12164 
12165 
12166 /*
12167  * LP methods
12168  */
12169 
12170 /**@addtogroup PublicLPMethods
12171  *
12172  * @{
12173  */
12174 
12175 /** returns, whether the LP was or is to be solved in the current node
12176  *
12177  * @return whether the LP was or is to be solved in the current node.
12178  *
12179  * @pre This method can be called if @p scip is in one of the following stages:
12180  * - \ref SCIP_STAGE_SOLVING
12181  *
12182  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12183  */
12184 extern
12186  SCIP* scip /**< SCIP data structure */
12187  );
12188 
12189 /** returns, whether the LP of the current node is already constructed
12190  *
12191  * @return whether the LP of the current node is already constructed.
12192  *
12193  * @pre This method can be called if @p scip is in one of the following stages:
12194  * - \ref SCIP_STAGE_SOLVING
12195  *
12196  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12197  */
12198 extern
12200  SCIP* scip /**< SCIP data structure */
12201  );
12202 
12203 /** makes sure that the LP of the current node is loaded and may be accessed through the LP information methods
12204  *
12205  * @warning Contructing the LP might change the amount of variables known in the transformed problem and therefore also
12206  * the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to
12207  * call one of the later method after this one
12208  *
12209  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12210  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12211  *
12212  * @pre This method can be called if @p scip is in one of the following stages:
12213  * - \ref SCIP_STAGE_SOLVING
12214  *
12215  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12216  */
12217 extern
12219  SCIP* scip, /**< SCIP data structure */
12220  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
12221  );
12222 
12223 /** makes sure that the LP of the current node is flushed
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_SOLVING
12230  *
12231  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12232  */
12233 extern
12235  SCIP* scip /**< SCIP data structure */
12236  );
12237 
12238 /** gets solution status of current LP
12239  *
12240  * @return the solution status of current LP.
12241  *
12242  * @pre This method can be called if @p scip is in one of the following stages:
12243  * - \ref SCIP_STAGE_SOLVING
12244  *
12245  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12246  */
12247 extern
12249  SCIP* scip /**< SCIP data structure */
12250  );
12251 
12252 /** returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
12253  *
12254  * @return whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.
12255  *
12256  * @pre This method can be called if @p scip is in one of the following stages:
12257  * - \ref SCIP_STAGE_SOLVING
12258  *
12259  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12260  */
12261 extern
12263  SCIP* scip /**< SCIP data structure */
12264  );
12265 
12266 /** gets objective value of current LP (which is the sum of column and loose objective value)
12267  *
12268  * @return the objective value of current LP (which is the sum of column and loose objective value).
12269  *
12270  * @pre This method can be called if @p scip is in one of the following stages:
12271  * - \ref SCIP_STAGE_SOLVING
12272  *
12273  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
12274  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by
12275  * SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
12276  *
12277  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12278  */
12279 extern
12281  SCIP* scip /**< SCIP data structure */
12282  );
12283 
12284 /** gets part of objective value of current LP that results from COLUMN variables only
12285  *
12286  * @return the part of objective value of current LP that results from COLUMN variables only.
12287  *
12288  * @pre This method can be called if @p scip is in one of the following stages:
12289  * - \ref SCIP_STAGE_SOLVING
12290  *
12291  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12292  */
12293 extern
12295  SCIP* scip /**< SCIP data structure */
12296  );
12297 
12298 /** gets part of objective value of current LP that results from LOOSE variables only
12299  *
12300  * @return part of objective value of current LP that results from LOOSE variables only.
12301  *
12302  * @pre This method can be called if @p scip is in one of the following stages:
12303  * - \ref SCIP_STAGE_SOLVING
12304  *
12305  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12306  */
12307 extern
12309  SCIP* scip /**< SCIP data structure */
12310  );
12311 
12312 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
12313  * function) global bound
12314  *
12315  * @return the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
12316  * function) global bound.
12317  *
12318  * @pre This method can be called if @p scip is in one of the following stages:
12319  * - \ref SCIP_STAGE_INITPRESOLVE
12320  * - \ref SCIP_STAGE_PRESOLVING
12321  * - \ref SCIP_STAGE_EXITPRESOLVE
12322  * - \ref SCIP_STAGE_PRESOLVED
12323  * - \ref SCIP_STAGE_INITSOLVE
12324  * - \ref SCIP_STAGE_SOLVING
12325  *
12326  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12327  */
12328 extern
12330  SCIP* scip /**< SCIP data structure */
12331  );
12332 
12333 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
12334  * objective function) local bound
12335  *
12336  * @return the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
12337  * objective function) local bound.
12338  *
12339  * @pre This method can be called if @p scip is in one of the following stages:
12340  * - \ref SCIP_STAGE_INITPRESOLVE
12341  * - \ref SCIP_STAGE_PRESOLVING
12342  * - \ref SCIP_STAGE_EXITPRESOLVE
12343  * - \ref SCIP_STAGE_PRESOLVED
12344  * - \ref SCIP_STAGE_INITSOLVE
12345  * - \ref SCIP_STAGE_SOLVING
12346  *
12347  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12348  */
12349 extern
12351  SCIP* scip /**< SCIP data structure */
12352  );
12353 
12354 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
12355  *
12356  * @return whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.
12357  *
12358  * @pre This method can be called if @p scip is in one of the following stages:
12359  * - \ref SCIP_STAGE_SOLVING
12360  *
12361  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12362  */
12363 extern
12365  SCIP* scip /**< SCIP data structure */
12366  );
12367 
12368 /** gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved
12369  *
12370  * @return the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved.
12371  *
12372  * @pre This method can be called if @p scip is in one of the following stages:
12373  * - \ref SCIP_STAGE_INITPRESOLVE
12374  * - \ref SCIP_STAGE_PRESOLVING
12375  * - \ref SCIP_STAGE_EXITPRESOLVE
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 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
12386  * returns SCIP_INVALID if the root node LP was not (yet) solved
12387  *
12388  * @return the part of the objective value of the root node LP that results from COLUMN variables only;
12389  * or SCIP_INVALID if the root node LP was not (yet) solved.
12390  *
12391  * @pre This method can be called if @p scip is in one of the following stages:
12392  * - \ref SCIP_STAGE_INITPRESOLVE
12393  * - \ref SCIP_STAGE_PRESOLVING
12394  * - \ref SCIP_STAGE_EXITPRESOLVE
12395  * - \ref SCIP_STAGE_SOLVING
12396  *
12397  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12398  */
12399 extern
12401  SCIP* scip /**< SCIP data structure */
12402  );
12403 
12404 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
12405  * returns SCIP_INVALID if the root node LP was not (yet) solved
12406  *
12407  * @return the part of the objective value of the root node LP that results from LOOSE variables only;
12408  * or SCIP_INVALID if the root node LP was not (yet) solved.
12409  *
12410  * @pre This method can be called if @p scip is in one of the following stages:
12411  * - \ref SCIP_STAGE_INITPRESOLVE
12412  * - \ref SCIP_STAGE_PRESOLVING
12413  * - \ref SCIP_STAGE_EXITPRESOLVE
12414  * - \ref SCIP_STAGE_SOLVING
12415  *
12416  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12417  */
12418 extern
12420  SCIP* scip /**< SCIP data structure */
12421  );
12422 
12423 /** gets current LP columns along with the current number of LP columns
12424  *
12425  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12426  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12427  *
12428  * @pre This method can be called if @p scip is in one of the following stages:
12429  * - \ref SCIP_STAGE_SOLVING
12430  *
12431  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12432  */
12433 extern
12435  SCIP* scip, /**< SCIP data structure */
12436  SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */
12437  int* ncols /**< pointer to store the number of LP columns, or NULL */
12438  );
12439 
12440 /** gets current LP columns
12441  *
12442  * @return the current LP columns.
12443  *
12444  * @pre This method can be called if @p scip is in one of the following stages:
12445  * - \ref SCIP_STAGE_SOLVING
12446  *
12447  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12448  */
12449 extern
12451  SCIP* scip /**< SCIP data structure */
12452  );
12453 
12454 /** gets current number of LP columns
12455  *
12456  * @return the current number of LP columns.
12457  *
12458  * @pre This method can be called if @p scip is in one of the following stages:
12459  * - \ref SCIP_STAGE_SOLVING
12460  *
12461  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12462  */
12463 extern
12464 int SCIPgetNLPCols(
12465  SCIP* scip /**< SCIP data structure */
12466  );
12467 
12468 /** gets current LP rows along with the current number of LP rows
12469  *
12470  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12471  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12472  *
12473  * @pre This method can be called if @p scip is in one of the following stages:
12474  * - \ref SCIP_STAGE_SOLVING
12475  *
12476  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12477  */
12478 extern
12480  SCIP* scip, /**< SCIP data structure */
12481  SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */
12482  int* nrows /**< pointer to store the number of LP rows, or NULL */
12483  );
12484 
12485 /** gets current LP rows
12486  *
12487  * @return the current LP rows.
12488  *
12489  * @pre This method can be called if @p scip is in one of the following stages:
12490  * - \ref SCIP_STAGE_SOLVING
12491  *
12492  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12493  */
12494 extern
12496  SCIP* scip /**< SCIP data structure */
12497  );
12498 
12499 /** gets current number of LP rows
12500  *
12501  * @return the current number of LP rows.
12502  *
12503  * @pre This method can be called if @p scip is in one of the following stages:
12504  * - \ref SCIP_STAGE_SOLVING
12505  *
12506  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12507  */
12508 extern
12509 int SCIPgetNLPRows(
12510  SCIP* scip /**< SCIP data structure */
12511  );
12512 
12513 /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
12514  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
12515  *
12516  * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
12517  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.
12518  *
12519  * @pre This method can be called if @p scip is in one of the following stages:
12520  * - \ref SCIP_STAGE_SOLVING
12521  *
12522  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12523  */
12524 extern
12526  SCIP* scip /**< SCIP data structure */
12527  );
12528 
12529 /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
12530  *
12531  * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis.
12532  *
12533  * @pre This method can be called if @p scip is in one of the following stages:
12534  * - \ref SCIP_STAGE_SOLVING
12535  *
12536  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12537  */
12538 extern
12540  SCIP* scip /**< SCIP data structure */
12541  );
12542 
12543 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
12544  *
12545  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12546  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12547  *
12548  * @pre This method can be called if @p scip is in one of the following stages:
12549  * - \ref SCIP_STAGE_SOLVING
12550  *
12551  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12552  */
12553 extern
12555  SCIP* scip, /**< SCIP data structure */
12556  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
12557  );
12558 
12559 /** gets a row from the inverse basis matrix B^-1
12560  *
12561  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12562  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12563  *
12564  * @pre This method can be called if @p scip is in one of the following stages:
12565  * - \ref SCIP_STAGE_SOLVING
12566  *
12567  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12568  */
12569 extern
12571  SCIP* scip, /**< SCIP data structure */
12572  int r, /**< row number */
12573  SCIP_Real* coefs, /**< array to store the coefficients of the row */
12574  int* inds, /**< array to store the non-zero indices, or NULL */
12575  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12576  * (-1: if we do not store sparsity informations) */
12577  );
12578 
12579 /** gets a column from the inverse basis matrix B^-1
12580  *
12581  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12582  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12583  *
12584  * @pre This method can be called if @p scip is in one of the following stages:
12585  * - \ref SCIP_STAGE_SOLVING
12586  *
12587  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12588  */
12589 extern
12591  SCIP* scip, /**< SCIP data structure */
12592  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
12593  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
12594  * to get the array which links the B^-1 column numbers to the row and
12595  * column numbers of the LP! c must be between 0 and nrows-1, since the
12596  * basis has the size nrows * nrows */
12597  SCIP_Real* coefs, /**< array to store the coefficients of the column */
12598  int* inds, /**< array to store the non-zero indices, or NULL */
12599  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12600  * (-1: if we do not store sparsity informations) */
12601  );
12602 
12603 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
12604  *
12605  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12606  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12607  *
12608  * @pre This method can be called if @p scip is in one of the following stages:
12609  * - \ref SCIP_STAGE_SOLVING
12610  *
12611  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12612  */
12613 extern
12615  SCIP* scip, /**< SCIP data structure */
12616  int r, /**< row number */
12617  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */
12618  SCIP_Real* coefs, /**< array to store the coefficients of the row */
12619  int* inds, /**< array to store the non-zero indices, or NULL */
12620  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12621  * (-1: if we do not store sparsity informations) */
12622  );
12623 
12624 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
12625  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
12626  *
12627  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12628  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12629  *
12630  * @pre This method can be called if @p scip is in one of the following stages:
12631  * - \ref SCIP_STAGE_SOLVING
12632  *
12633  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12634  */
12635 extern
12637  SCIP* scip, /**< SCIP data structure */
12638  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
12639  SCIP_Real* coefs, /**< array to store the coefficients of the column */
12640  int* inds, /**< array to store the non-zero indices, or NULL */
12641  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12642  * (-1: if we do not store sparsity informations) */
12643  );
12644 
12645 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
12646  * LP row are swapped in the summation
12647  *
12648  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12649  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12650  *
12651  * @pre This method can be called if @p scip is in one of the following stages:
12652  * - \ref SCIP_STAGE_SOLVING
12653  *
12654  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12655  */
12656 extern
12658  SCIP* scip, /**< SCIP data structure */
12659  SCIP_Real* weights, /**< row weights in row summation */
12660  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
12661  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
12662  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
12663  );
12664 
12665 /** calculates a MIR cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these
12666  * rows cannot participate in a MIR cut.
12667  *
12668  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12669  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12670  *
12671  * @pre This method can be called if @p scip is in one of the following stages:
12672  * - \ref SCIP_STAGE_SOLVING
12673  *
12674  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12675  */
12676 extern
12678  SCIP* scip, /**< SCIP data structure */
12679  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
12680  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
12681  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
12682  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
12683  SCIP_Bool fixintegralrhs, /**< should complementation tried to be adjusted such that rhs gets fractional? */
12684  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
12685  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
12686  * NULL for using closest bound for all variables */
12687  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
12688  * NULL for using closest bound for all variables */
12689  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
12690  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
12691  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
12692  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
12693  SCIP_Real* weights, /**< row weights in row summation; some weights might be set to zero */
12694  SCIP_Real maxweight, /**< largest magnitude of weights; set to -1.0 if sparsity information is
12695  * unknown */
12696  int* weightinds, /**< sparsity pattern of weights; size nrowinds; NULL if sparsity info is
12697  * unknown */
12698  int nweightinds, /**< number of nonzeros in weights; -1 if rowinds is NULL */
12699  int rowlensum, /**< total number of non-zeros in used rows (row associated with nonzero weight coefficient); -1 if unknown */
12700  int* sidetypes, /**< specify row side type (-1 = lhs, 0 = unkown, 1 = rhs) or NULL for automatic choices */
12701  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
12702  SCIP_Real* mksetcoefs, /**< array to store mixed knapsack set coefficients: size nvars; or NULL */
12703  SCIP_Bool* mksetcoefsvalid, /**< pointer to store whether mixed knapsack set coefficients are valid; or NULL */
12704  SCIP_Real* mircoef, /**< array to store MIR coefficients: must be of size SCIPgetNVars() */
12705  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the MIR row */
12706  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
12707  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid MIR cut */
12708  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
12709  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
12710  );
12711 
12712 /** calculates a strong CG cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these
12713  * rows cannot participate in a MIR cut.
12714  *
12715  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12716  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12717  *
12718  * @pre This method can be called if @p scip is in one of the following stages:
12719  * - \ref SCIP_STAGE_SOLVING
12720  *
12721  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12722  */
12723 extern
12725  SCIP* scip, /**< SCIP data structure */
12726  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
12727  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
12728  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
12729  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
12730  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
12731  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce strong CG cut for */
12732  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce strong CG cut for */
12733  SCIP_Real* weights, /**< row weights in row summation; some weights might be set to zero */
12734  int* inds, /**< indices of non-zero entries in weights array, or NULL */
12735  int ninds, /**< number of indices of non-zero entries in weights array, -1 if inds is
12736  * NULL */
12737  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
12738  SCIP_Real* mircoef, /**< array to store strong CG coefficients: must be of size SCIPgetNVars() */
12739  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the strong CG row */
12740  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
12741  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid strong CG cut */
12742  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
12743  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
12744  );
12745 
12746 /** writes current LP to a file
12747  *
12748  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12749  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12750  *
12751  * @pre This method can be called if @p scip is in one of the following stages:
12752  * - \ref SCIP_STAGE_SOLVING
12753  *
12754  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12755  */
12756 extern
12758  SCIP* scip, /**< SCIP data structure */
12759  const char* filename /**< file name */
12760  );
12761 
12762 /** writes MIP relaxation of the current branch-and-bound node to a file
12763  *
12764  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12765  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12766  *
12767  * @pre This method can be called if @p scip is in one of the following stages:
12768  * - \ref SCIP_STAGE_SOLVING
12769  *
12770  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12771  */
12772 extern
12774  SCIP* scip, /**< SCIP data structure */
12775  const char* filename, /**< file name */
12776  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
12777  * troubles with reserved symbols? */
12778  SCIP_Bool origobj, /**< should the original objective function be used? */
12779  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
12780  );
12781 
12782 /** gets the LP interface of SCIP;
12783  * with the LPI you can use all of the methods defined in lpi/lpi.h;
12784  *
12785  * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely
12786  * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution
12787  * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in
12788  * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make
12789  * sure, the internal solution status is recovered completely at the end of your method. This can be achieved
12790  * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it
12791  * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the
12792  * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.
12793  *
12794  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
12795  *
12796  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12797  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12798  *
12799  * @pre This method can be called if @p scip is in one of the following stages:
12800  * - \ref SCIP_STAGE_TRANSFORMED
12801  * - \ref SCIP_STAGE_INITPRESOLVE
12802  * - \ref SCIP_STAGE_PRESOLVING
12803  * - \ref SCIP_STAGE_EXITPRESOLVE
12804  * - \ref SCIP_STAGE_PRESOLVED
12805  * - \ref SCIP_STAGE_INITSOLVE
12806  * - \ref SCIP_STAGE_SOLVING
12807  * - \ref SCIP_STAGE_SOLVED
12808  * - \ref SCIP_STAGE_EXITSOLVE
12809  *
12810  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12811  */
12812 extern
12814  SCIP* scip, /**< SCIP data structure */
12815  SCIP_LPI** lpi /**< pointer to store the LP interface */
12816  );
12817 
12818 /** Displays quality information about the current LP solution. An LP solution need to be available. Information printed
12819  * is subject to what the LP solver supports
12820  *
12821  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12822  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12823  *
12824  * @pre This method can be called if @p scip is in one of the following stages:
12825  * - \ref SCIP_STAGE_INIT
12826  * - \ref SCIP_STAGE_PROBLEM
12827  * - \ref SCIP_STAGE_TRANSFORMED
12828  * - \ref SCIP_STAGE_INITPRESOLVE
12829  * - \ref SCIP_STAGE_PRESOLVING
12830  * - \ref SCIP_STAGE_EXITPRESOLVE
12831  * - \ref SCIP_STAGE_PRESOLVED
12832  * - \ref SCIP_STAGE_SOLVING
12833  * - \ref SCIP_STAGE_SOLVED
12834  * - \ref SCIP_STAGE_FREE
12835  *
12836  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12837  *
12838  * @note The printing process is done via the message handler system.
12839  */
12840 extern
12842  SCIP* scip, /**< SCIP data structure */
12843  FILE* file /**< output file (or NULL for standard output) */
12844  );
12845 
12846 /** compute relative interior point to current LP
12847  * @see SCIPlpComputeRelIntPoint
12848  *
12849  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12850  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12851  *
12852  * @pre This method can be called if @p scip is in one of the following stages:
12853  * - \ref SCIP_STAGE_TRANSFORMED
12854  * - \ref SCIP_STAGE_INITPRESOLVE
12855  * - \ref SCIP_STAGE_PRESOLVING
12856  * - \ref SCIP_STAGE_EXITPRESOLVE
12857  * - \ref SCIP_STAGE_PRESOLVED
12858  * - \ref SCIP_STAGE_SOLVING
12859  * - \ref SCIP_STAGE_SOLVED
12860  *
12861  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12862  */
12863 extern
12865  SCIP* scip, /**< SCIP data structure */
12866  SCIP_Bool relaxrows, /**< should the rows be relaxed */
12867  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
12868  SCIP_Real timelimit, /**< time limit for LP solver */
12869  int iterlimit, /**< iteration limit for LP solver */
12870  SCIP_SOL** point /**< relative interior point on exit */
12871  );
12872 
12873 /**@} */
12874 
12875 
12876 
12877 /*
12878  * LP column methods
12879  */
12880 
12881 /**@addtogroup PublicColumnMethods
12882  *
12883  * @{
12884  */
12885 
12886 /** returns the reduced costs of a column in the last (feasible) LP
12887  *
12888  * @return the reduced costs of a column in the last (feasible) LP
12889  *
12890  * @pre this method can be called in one of the following stages of the SCIP solving process:
12891  * - \ref SCIP_STAGE_SOLVING
12892  * - \ref SCIP_STAGE_SOLVED
12893  *
12894  * @note calling this method in SCIP_STAGE_SOLVED is only recommended to experienced users and should only be called
12895  * for pure LP instances (without presolving)
12896  */
12897 extern
12899  SCIP* scip, /**< SCIP data structure */
12900  SCIP_COL* col /**< LP column */
12901  );
12902 
12903 /** returns the Farkas coefficient of a column in the last (infeasible) LP
12904  *
12905  * @return the Farkas coefficient of a column in the last (infeasible) LP
12906  *
12907  * @pre this method can be called in one of the following stages of the SCIP solving process:
12908  * - \ref SCIP_STAGE_SOLVING
12909  */
12910 extern
12912  SCIP* scip, /**< SCIP data structure */
12913  SCIP_COL* col /**< LP column */
12914  );
12915 
12916 /** marks a column to be not removable from the LP in the current node
12917  *
12918  * @pre this method can be called in the following stage of the SCIP solving process:
12919  * - \ref SCIP_STAGE_SOLVING
12920  */
12921 extern
12923  SCIP* scip, /**< SCIP data structure */
12924  SCIP_COL* col /**< LP column */
12925  );
12926 
12927 /**@} */
12928 
12929 
12930 
12931 
12932 /*
12933  * LP row methods
12934  */
12935 
12936 /**@addtogroup PublicRowMethods
12937  *
12938  * @{
12939  */
12940 
12941 /** creates and captures an LP row from a constraint handler
12942  *
12943  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12944  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12945  *
12946  * @pre this method can be called in one of the following stages of the SCIP solving process:
12947  * - \ref SCIP_STAGE_INITSOLVE
12948  * - \ref SCIP_STAGE_SOLVING
12949  */
12950 extern
12952  SCIP* scip, /**< SCIP data structure */
12953  SCIP_ROW** row, /**< pointer to row */
12954  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
12955  const char* name, /**< name of row */
12956  int len, /**< number of nonzeros in the row */
12957  SCIP_COL** cols, /**< array with columns of row entries */
12958  SCIP_Real* vals, /**< array with coefficients of row entries */
12959  SCIP_Real lhs, /**< left hand side of row */
12960  SCIP_Real rhs, /**< right hand side of row */
12961  SCIP_Bool local, /**< is row only valid locally? */
12962  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12963  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12964  );
12965 
12966 /** creates and captures an LP row from a separator
12967  *
12968  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12969  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12970  *
12971  * @pre this method can be called in one of the following stages of the SCIP solving process:
12972  * - \ref SCIP_STAGE_INITSOLVE
12973  * - \ref SCIP_STAGE_SOLVING
12974  */
12975 extern
12977  SCIP* scip, /**< SCIP data structure */
12978  SCIP_ROW** row, /**< pointer to row */
12979  SCIP_SEPA* sepa, /**< separator that creates the row */
12980  const char* name, /**< name of row */
12981  int len, /**< number of nonzeros in the row */
12982  SCIP_COL** cols, /**< array with columns of row entries */
12983  SCIP_Real* vals, /**< array with coefficients of row entries */
12984  SCIP_Real lhs, /**< left hand side of row */
12985  SCIP_Real rhs, /**< right hand side of row */
12986  SCIP_Bool local, /**< is row only valid locally? */
12987  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12988  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12989  );
12990 
12991 /** creates and captures an LP row from an unspecified source
12992  *
12993  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12994  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12995  *
12996  * @pre this method can be called in one of the following stages of the SCIP solving process:
12997  * - \ref SCIP_STAGE_INITSOLVE
12998  * - \ref SCIP_STAGE_SOLVING
12999  */
13000 extern
13002  SCIP* scip, /**< SCIP data structure */
13003  SCIP_ROW** row, /**< pointer to row */
13004  const char* name, /**< name of row */
13005  int len, /**< number of nonzeros in the row */
13006  SCIP_COL** cols, /**< array with columns of row entries */
13007  SCIP_Real* vals, /**< array with coefficients of row entries */
13008  SCIP_Real lhs, /**< left hand side of row */
13009  SCIP_Real rhs, /**< right hand side of row */
13010  SCIP_Bool local, /**< is row only valid locally? */
13011  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13012  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13013  );
13014 
13015 /** creates and captures an LP row
13016  *
13017  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13018  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13019  *
13020  * @pre this method can be called in one of the following stages of the SCIP solving process:
13021  * - \ref SCIP_STAGE_INITSOLVE
13022  * - \ref SCIP_STAGE_SOLVING
13023  *
13024  * @deprecated Please use SCIPcreateRowCons() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order
13025  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().
13026  */
13027 extern
13029  SCIP* scip, /**< SCIP data structure */
13030  SCIP_ROW** row, /**< pointer to row */
13031  const char* name, /**< name of row */
13032  int len, /**< number of nonzeros in the row */
13033  SCIP_COL** cols, /**< array with columns of row entries */
13034  SCIP_Real* vals, /**< array with coefficients of row entries */
13035  SCIP_Real lhs, /**< left hand side of row */
13036  SCIP_Real rhs, /**< right hand side of row */
13037  SCIP_Bool local, /**< is row only valid locally? */
13038  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13039  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13040  );
13041 
13042 /** creates and captures an LP row without any coefficients from a constraint handler
13043  *
13044  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13045  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13046  *
13047  * @pre this method can be called in one of the following stages of the SCIP solving process:
13048  * - \ref SCIP_STAGE_INITSOLVE
13049  * - \ref SCIP_STAGE_SOLVING
13050  */
13051 extern
13053  SCIP* scip, /**< SCIP data structure */
13054  SCIP_ROW** row, /**< pointer to row */
13055  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
13056  const char* name, /**< name of row */
13057  SCIP_Real lhs, /**< left hand side of row */
13058  SCIP_Real rhs, /**< right hand side of row */
13059  SCIP_Bool local, /**< is row only valid locally? */
13060  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13061  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13062  );
13063 
13064 /** creates and captures an LP row without any coefficients from a separator
13065  *
13066  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13067  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13068  *
13069  * @pre this method can be called in one of the following stages of the SCIP solving process:
13070  * - \ref SCIP_STAGE_INITSOLVE
13071  * - \ref SCIP_STAGE_SOLVING
13072  */
13073 extern
13075  SCIP* scip, /**< SCIP data structure */
13076  SCIP_ROW** row, /**< pointer to row */
13077  SCIP_SEPA* sepa, /**< separator that creates the row */
13078  const char* name, /**< name of row */
13079  SCIP_Real lhs, /**< left hand side of row */
13080  SCIP_Real rhs, /**< right hand side of row */
13081  SCIP_Bool local, /**< is row only valid locally? */
13082  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13083  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13084  );
13085 
13086 /** creates and captures an LP row without any coefficients from an unspecified source
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  const char* name, /**< name of row */
13100  SCIP_Real lhs, /**< left hand side of row */
13101  SCIP_Real rhs, /**< right hand side of row */
13102  SCIP_Bool local, /**< is row only valid locally? */
13103  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13104  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13105  );
13106 
13107 /** creates and captures an LP row without any coefficients
13108  *
13109  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13110  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13111  *
13112  * @pre this method can be called in one of the following stages of the SCIP solving process:
13113  * - \ref SCIP_STAGE_INITSOLVE
13114  * - \ref SCIP_STAGE_SOLVING
13115  *
13116  * @deprecated Please use SCIPcreateEmptyRowCons() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order
13117  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().
13118  */
13119 extern
13121  SCIP* scip, /**< SCIP data structure */
13122  SCIP_ROW** row, /**< pointer to row */
13123  const char* name, /**< name of row */
13124  SCIP_Real lhs, /**< left hand side of row */
13125  SCIP_Real rhs, /**< right hand side of row */
13126  SCIP_Bool local, /**< is row only valid locally? */
13127  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13128  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13129  );
13130 
13131 /** increases usage counter of LP row
13132  *
13133  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13134  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13135  *
13136  * @pre this method can be called in one of the following stages of the SCIP solving process:
13137  * - \ref SCIP_STAGE_INITSOLVE
13138  * - \ref SCIP_STAGE_SOLVING
13139  */
13140 extern
13142  SCIP* scip, /**< SCIP data structure */
13143  SCIP_ROW* row /**< row to capture */
13144  );
13145 
13146 /** decreases usage counter of LP row, and frees memory if necessary
13147  *
13148  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13149  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13150  *
13151  * @pre this method can be called in one of the following stages of the SCIP solving process:
13152  * - \ref SCIP_STAGE_INITSOLVE
13153  * - \ref SCIP_STAGE_SOLVING
13154  * - \ref SCIP_STAGE_EXITSOLVE
13155  */
13156 extern
13158  SCIP* scip, /**< SCIP data structure */
13159  SCIP_ROW** row /**< pointer to LP row */
13160  );
13161 
13162 /** changes left hand side of LP row
13163  *
13164  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13165  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13166  *
13167  * @pre this method can be called in one of the following stages of the SCIP solving process:
13168  * - \ref SCIP_STAGE_INITSOLVE
13169  * - \ref SCIP_STAGE_SOLVING
13170  */
13171 extern
13173  SCIP* scip, /**< SCIP data structure */
13174  SCIP_ROW* row, /**< LP row */
13175  SCIP_Real lhs /**< new left hand side */
13176  );
13177 
13178 /** changes right hand side of LP row
13179  *
13180  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13181  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13182  *
13183  * @pre this method can be called in one of the following stages of the SCIP solving process:
13184  * - \ref SCIP_STAGE_INITSOLVE
13185  * - \ref SCIP_STAGE_SOLVING
13186  */
13187 extern
13189  SCIP* scip, /**< SCIP data structure */
13190  SCIP_ROW* row, /**< LP row */
13191  SCIP_Real rhs /**< new right hand side */
13192  );
13193 
13194 /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
13195  * after all additions were applied, SCIPflushRowExtensions() must be called;
13196  * while the caching of row extensions is activated, information methods of the row give invalid results;
13197  * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase
13198  * the performance
13199  *
13200  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13201  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13202  *
13203  * @pre this method can be called in one of the following stages of the SCIP solving process:
13204  * - \ref SCIP_STAGE_INITSOLVE
13205  * - \ref SCIP_STAGE_SOLVING
13206  */
13207 extern
13209  SCIP* scip, /**< SCIP data structure */
13210  SCIP_ROW* row /**< LP row */
13211  );
13212 
13213 /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with
13214  * equal columns into a single coefficient
13215  *
13216  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13217  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13218  *
13219  * @pre this method can be called in one of the following stages of the SCIP solving process:
13220  * - \ref SCIP_STAGE_INITSOLVE
13221  * - \ref SCIP_STAGE_SOLVING
13222  */
13223 extern
13225  SCIP* scip, /**< SCIP data structure */
13226  SCIP_ROW* row /**< LP row */
13227  );
13228 
13229 /** resolves variable to columns and adds them with the coefficient to the row
13230  *
13231  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13232  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13233  *
13234  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variable will not added.
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  * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables,
13241  * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP.
13242  * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution
13243  * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but
13244  * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the
13245  * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was
13246  * violated, the linear relaxation might not be violated anymore.)
13247  */
13248 extern
13250  SCIP* scip, /**< SCIP data structure */
13251  SCIP_ROW* row, /**< LP row */
13252  SCIP_VAR* var, /**< problem variable */
13253  SCIP_Real val /**< value of coefficient */
13254  );
13255 
13256 /** resolves variables to columns and adds them with the coefficients to the row;
13257  * this method caches the row extensions and flushes them afterwards to gain better performance
13258  *
13259  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13260  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13261  *
13262  * @attention If a coefficients absolute value is below the SCIP epsilon tolerance, the variable with its value is not added.
13263  *
13264  * @pre this method can be called in one of the following stages of the SCIP solving process:
13265  * - \ref SCIP_STAGE_INITSOLVE
13266  * - \ref SCIP_STAGE_SOLVING
13267  */
13268 extern
13270  SCIP* scip, /**< SCIP data structure */
13271  SCIP_ROW* row, /**< LP row */
13272  int nvars, /**< number of variables to add to the row */
13273  SCIP_VAR** vars, /**< problem variables to add */
13274  SCIP_Real* vals /**< values of coefficients */
13275  );
13276 
13277 /** resolves variables to columns and adds them with the same single coefficient to the row;
13278  * this method caches the row extensions and flushes them afterwards to gain better performance
13279  *
13280  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13281  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13282  *
13283  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variables will not added.
13284  *
13285  * @pre this method can be called in one of the following stages of the SCIP solving process:
13286  * - \ref SCIP_STAGE_INITSOLVE
13287  * - \ref SCIP_STAGE_SOLVING
13288  */
13289 extern
13291  SCIP* scip, /**< SCIP data structure */
13292  SCIP_ROW* row, /**< LP row */
13293  int nvars, /**< number of variables to add to the row */
13294  SCIP_VAR** vars, /**< problem variables to add */
13295  SCIP_Real val /**< unique value of all coefficients */
13296  );
13297 
13298 /** tries to find a value, such that all row coefficients, if scaled with this value become integral
13299  *
13300  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13301  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13302  *
13303  * @pre this method can be called in one of the following stages of the SCIP solving process:
13304  * - \ref SCIP_STAGE_INITSOLVE
13305  * - \ref SCIP_STAGE_SOLVING
13306  */
13307 extern
13309  SCIP* scip, /**< SCIP data structure */
13310  SCIP_ROW* row, /**< LP row */
13311  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
13312  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
13313  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
13314  SCIP_Real maxscale, /**< maximal allowed scalar */
13315  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
13316  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
13317  SCIP_Bool* success /**< stores whether returned value is valid */
13318  );
13319 
13320 /** tries to scale row, s.t. all coefficients (of integer variables) become integral
13321  *
13322  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13323  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13324  *
13325  * @pre this method can be called in one of the following stages of the SCIP solving process:
13326  * - \ref SCIP_STAGE_INITSOLVE
13327  * - \ref SCIP_STAGE_SOLVING
13328  */
13329 extern
13331  SCIP* scip, /**< SCIP data structure */
13332  SCIP_ROW* row, /**< LP row */
13333  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
13334  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
13335  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
13336  SCIP_Real maxscale, /**< maximal value to scale row with */
13337  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
13338  SCIP_Bool* success /**< stores whether row could be made rational */
13339  );
13340 
13341 /** marks a row to be not removable from the LP in the current node
13342  *
13343  * @pre this method can be called in the following stage of the SCIP solving process:
13344  * - \ref SCIP_STAGE_SOLVING
13345  */
13346 extern
13348  SCIP* scip, /**< SCIP data structure */
13349  SCIP_ROW* row /**< LP row */
13350  );
13351 
13352 /** returns minimal absolute value of row vector's non-zero coefficients
13353  *
13354  * @return minimal absolute value of row vector's non-zero coefficients
13355  *
13356  * @pre this method can be called in one of the following stages of the SCIP solving process:
13357  * - \ref SCIP_STAGE_INITSOLVE
13358  * - \ref SCIP_STAGE_SOLVING
13359  */
13360 extern
13362  SCIP* scip, /**< SCIP data structure */
13363  SCIP_ROW* row /**< LP row */
13364  );
13365 
13366 /** returns maximal absolute value of row vector's non-zero coefficients
13367  *
13368  * @return maximal absolute value of row vector's non-zero coefficients
13369  *
13370  * @pre this method can be called in one of the following stages of the SCIP solving process:
13371  * - \ref SCIP_STAGE_INITSOLVE
13372  * - \ref SCIP_STAGE_SOLVING
13373  */
13374 extern
13376  SCIP* scip, /**< SCIP data structure */
13377  SCIP_ROW* row /**< LP row */
13378  );
13379 
13380 /** returns the minimal activity of a row w.r.t. the column's bounds
13381  *
13382  * @return the minimal activity of a row w.r.t. the column's bounds
13383  *
13384  * @pre this method can be called in one of the following stages of the SCIP solving process:
13385  * - \ref SCIP_STAGE_SOLVING
13386  */
13387 extern
13389  SCIP* scip, /**< SCIP data structure */
13390  SCIP_ROW* row /**< LP row */
13391  );
13392 
13393 /** returns the maximal activity of a row w.r.t. the column's bounds
13394  *
13395  * @return the maximal activity of a row w.r.t. the column's bounds
13396  *
13397  * @pre this method can be called in one of the following stages of the SCIP solving process:
13398  * - \ref SCIP_STAGE_SOLVING
13399  */
13400 extern
13402  SCIP* scip, /**< SCIP data structure */
13403  SCIP_ROW* row /**< LP row */
13404  );
13405 
13406 /** recalculates the activity of a row in the last LP solution
13407  *
13408  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13409  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13410  *
13411  * @pre this method can be called in one of the following stages of the SCIP solving process:
13412  * - \ref SCIP_STAGE_SOLVING
13413  */
13414 extern
13416  SCIP* scip, /**< SCIP data structure */
13417  SCIP_ROW* row /**< LP row */
13418  );
13419 
13420 /** returns the activity of a row in the last LP solution
13421  *
13422  * @return activity of a row in the last LP solution
13423  *
13424  * @pre this method can be called in one of the following stages of the SCIP solving process:
13425  * - \ref SCIP_STAGE_SOLVING
13426  */
13427 extern
13429  SCIP* scip, /**< SCIP data structure */
13430  SCIP_ROW* row /**< LP row */
13431  );
13432 
13433 /** returns the feasibility of a row in the last LP solution
13434  *
13435  * @return the feasibility of a row in the last LP solution: negative value means infeasibility
13436  *
13437  * @pre this method can be called in one of the following stages of the SCIP solving process:
13438  * - \ref SCIP_STAGE_SOLVING
13439  */
13440 extern
13442  SCIP* scip, /**< SCIP data structure */
13443  SCIP_ROW* row /**< LP row */
13444  );
13445 
13446 /** recalculates the activity of a row for the current pseudo solution
13447  *
13448  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13449  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13450  *
13451  * @pre this method can be called in one of the following stages of the SCIP solving process:
13452  * - \ref SCIP_STAGE_SOLVING
13453  */
13454 extern
13456  SCIP* scip, /**< SCIP data structure */
13457  SCIP_ROW* row /**< LP row */
13458  );
13459 
13460 /** returns the activity of a row for the current pseudo solution
13461  *
13462  * @return the activity of a row for the current pseudo solution
13463  *
13464  * @pre this method can be called in one of the following stages of the SCIP solving process:
13465  * - \ref SCIP_STAGE_SOLVING
13466  */
13467 extern
13469  SCIP* scip, /**< SCIP data structure */
13470  SCIP_ROW* row /**< LP row */
13471  );
13472 
13473 /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
13474  *
13475  * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility
13476  *
13477  * @pre this method can be called in one of the following stages of the SCIP solving process:
13478  * - \ref SCIP_STAGE_SOLVING
13479  */
13480 extern
13482  SCIP* scip, /**< SCIP data structure */
13483  SCIP_ROW* row /**< LP row */
13484  );
13485 
13486 /** recalculates the activity of a row in the last LP or pseudo solution
13487  *
13488  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13489  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13490  *
13491  * @pre this method can be called in one of the following stages of the SCIP solving process:
13492  * - \ref SCIP_STAGE_SOLVING
13493  */
13494 extern
13496  SCIP* scip, /**< SCIP data structure */
13497  SCIP_ROW* row /**< LP row */
13498  );
13499 
13500 /** returns the activity of a row in the last LP or pseudo solution
13501  *
13502  * @return the activity of a row in the last LP or pseudo solution
13503  *
13504  * @pre this method can be called in one of the following stages of the SCIP solving process:
13505  * - \ref SCIP_STAGE_SOLVING
13506  */
13507 extern
13509  SCIP* scip, /**< SCIP data structure */
13510  SCIP_ROW* row /**< LP row */
13511  );
13512 
13513 /** returns the feasibility of a row in the last LP or pseudo solution
13514  *
13515  * @return the feasibility of a row in the last LP or pseudo solution
13516  *
13517  * @pre this method can be called in one of the following stages of the SCIP solving process:
13518  * - \ref SCIP_STAGE_SOLVING
13519  */
13520 extern
13522  SCIP* scip, /**< SCIP data structure */
13523  SCIP_ROW* row /**< LP row */
13524  );
13525 
13526 /** returns the activity of a row for the given primal solution
13527  *
13528  * @return the activitiy of a row for the given primal solution
13529  *
13530  * @pre this method can be called in one of the following stages of the SCIP solving process:
13531  * - \ref SCIP_STAGE_SOLVING
13532  */
13533 extern
13535  SCIP* scip, /**< SCIP data structure */
13536  SCIP_ROW* row, /**< LP row */
13537  SCIP_SOL* sol /**< primal CIP solution */
13538  );
13539 
13540 /** returns the feasibility of a row for the given primal solution
13541  *
13542  * @return the feasibility of a row for the given primal solution
13543  *
13544  * @pre this method can be called in one of the following stages of the SCIP solving process:
13545  * - \ref SCIP_STAGE_SOLVING
13546  */
13547 extern
13549  SCIP* scip, /**< SCIP data structure */
13550  SCIP_ROW* row, /**< LP row */
13551  SCIP_SOL* sol /**< primal CIP solution */
13552  );
13553 
13554 /** output row to file stream via the message handler system
13555  *
13556  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13557  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13558  *
13559  * @pre this method can be called in one of the following stages of the SCIP solving process:
13560  * - \ref SCIP_STAGE_INITSOLVE
13561  * - \ref SCIP_STAGE_SOLVING
13562  * - \ref SCIP_STAGE_SOLVED
13563  * - \ref SCIP_STAGE_EXITSOLVE
13564  */
13565 extern
13567  SCIP* scip, /**< SCIP data structure */
13568  SCIP_ROW* row, /**< LP row */
13569  FILE* file /**< output file (or NULL for standard output) */
13570  );
13571 
13572 /**@} */
13573 
13574 
13575 /*
13576  * NLP methods
13577  */
13578 
13579 /**@addtogroup PublicNLPMethods
13580  *
13581  * @{
13582  */
13583 
13584 /** returns whether the NLP relaxation has been enabled
13585  *
13586  * If the NLP relaxation is enabled, then SCIP will construct the NLP relaxation when the solving process is about to begin.
13587  * To check whether an NLP is existing, use SCIPisNLPConstructed().
13588  *
13589  * @pre This method can be called if SCIP is in one of the following stages:
13590  * - \ref SCIP_STAGE_INITPRESOLVE
13591  * - \ref SCIP_STAGE_PRESOLVING
13592  * - \ref SCIP_STAGE_EXITPRESOLVE
13593  * - \ref SCIP_STAGE_PRESOLVED
13594  * - \ref SCIP_STAGE_INITSOLVE
13595  * - \ref SCIP_STAGE_SOLVING
13596  *
13597  * @see SCIPenableNLP
13598  */
13599 extern
13601  SCIP* scip /**< SCIP data structure */
13602  );
13603 
13604 /** marks that there are constraints that are representable by nonlinear rows
13605  *
13606  * This method should be called by a constraint handler if it has constraints that have a representation as nonlinear rows.
13607  *
13608  * The function should be called before the branch-and-bound process is initialized, e.g., when presolve is exiting.
13609  *
13610  * @pre This method can be called if SCIP is in one of the following stages:
13611  * - \ref SCIP_STAGE_INITPRESOLVE
13612  * - \ref SCIP_STAGE_PRESOLVING
13613  * - \ref SCIP_STAGE_EXITPRESOLVE
13614  * - \ref SCIP_STAGE_PRESOLVED
13615  * - \ref SCIP_STAGE_INITSOLVE
13616  * - \ref SCIP_STAGE_SOLVING
13617  */
13618 extern
13619 void SCIPenableNLP(
13620  SCIP* scip /**< SCIP data structure */
13621  );
13622 
13623 /** returns, whether an NLP has been constructed
13624  *
13625  * @pre This method can be called if SCIP is in one of the following stages:
13626  * - \ref SCIP_STAGE_INITSOLVE
13627  * - \ref SCIP_STAGE_SOLVING
13628  */
13629 extern
13631  SCIP* scip /**< SCIP data structure */
13632  );
13633 
13634 /** returns whether the NLP has a continuous variable in a nonlinear term
13635  *
13636  * @pre This method can be called if SCIP is in one of the following stages:
13637  * - \ref SCIP_STAGE_INITSOLVE
13638  * - \ref SCIP_STAGE_SOLVING
13639  */
13640 extern
13642  SCIP* scip /**< SCIP data structure */
13643  );
13644 
13645 /** gets current NLP variables along with the current number of NLP variables
13646  *
13647  * @pre This method can be called if SCIP is in one of the following stages:
13648  * - \ref SCIP_STAGE_INITSOLVE
13649  * - \ref SCIP_STAGE_SOLVING
13650  */
13651 extern
13653  SCIP* scip, /**< SCIP data structure */
13654  SCIP_VAR*** vars, /**< pointer to store the array of NLP variables, or NULL */
13655  int* nvars /**< pointer to store the number of NLP variables, or NULL */
13656  );
13657 
13658 /** gets array with variables of the NLP
13659  *
13660  * @pre This method can be called if SCIP is in one of the following stages:
13661  * - \ref SCIP_STAGE_INITSOLVE
13662  * - \ref SCIP_STAGE_SOLVING
13663  */
13664 extern
13666  SCIP* scip /**< SCIP data structure */
13667  );
13668 
13669 /** gets current number of variables in NLP
13670  *
13671  * @pre This method can be called if SCIP is in one of the following stages:
13672  * - \ref SCIP_STAGE_INITSOLVE
13673  * - \ref SCIP_STAGE_SOLVING
13674  */
13675 extern
13676 int SCIPgetNNLPVars(
13677  SCIP* scip /**< SCIP data structure */
13678  );
13679 
13680 /** computes for each variables the number of NLP rows in which the variable appears in a nonlinear var
13681  *
13682  * @pre This method can be called if SCIP is in one of the following stages:
13683  * - \ref SCIP_STAGE_INITSOLVE
13684  * - \ref SCIP_STAGE_SOLVING
13685  */
13686 extern
13688  SCIP* scip, /**< SCIP data structure */
13689  int* nlcount /**< an array of length at least SCIPnlpGetNVars() to store nonlinearity counts of variables */
13690  );
13691 
13692 /** returns dual solution values associated with lower bounds of NLP variables
13693  *
13694  * @pre This method can be called if SCIP is in one of the following stages:
13695  * - \ref SCIP_STAGE_INITSOLVE
13696  * - \ref SCIP_STAGE_SOLVING
13697  */
13698 extern
13700  SCIP* scip /**< SCIP data structure */
13701  );
13702 
13703 /** returns dual solution values associated with upper bounds of NLP variables
13704  *
13705  * @pre This method can be called if SCIP is in one of the following stages:
13706  * - \ref SCIP_STAGE_INITSOLVE
13707  * - \ref SCIP_STAGE_SOLVING
13708  */
13709 extern
13711  SCIP* scip /**< SCIP data structure */
13712  );
13713 
13714 /** gets current NLP nonlinear rows along with the current number of NLP nonlinear rows
13715  *
13716  * @pre This method can be called if SCIP is in one of the following stages:
13717  * - \ref SCIP_STAGE_INITSOLVE
13718  * - \ref SCIP_STAGE_SOLVING
13719  */
13720 extern
13722  SCIP* scip, /**< SCIP data structure */
13723  SCIP_NLROW*** nlrows, /**< pointer to store the array of NLP nonlinear rows, or NULL */
13724  int* nnlrows /**< pointer to store the number of NLP nonlinear rows, or NULL */
13725  );
13726 
13727 /** gets array with nonlinear rows of the NLP
13728  *
13729  * @pre This method can be called if SCIP is in one of the following stages:
13730  * - \ref SCIP_STAGE_INITSOLVE
13731  * - \ref SCIP_STAGE_SOLVING
13732  */
13733 extern
13735  SCIP* scip /**< SCIP data structure */
13736  );
13737 
13738 /** gets current number of nonlinear rows in NLP
13739  *
13740  * @pre This method can be called if SCIP is in one of the following stages:
13741  * - \ref SCIP_STAGE_INITSOLVE
13742  * - \ref SCIP_STAGE_SOLVING
13743  */
13744 extern
13745 int SCIPgetNNLPNlRows(
13746  SCIP* scip /**< SCIP data structure */
13747  );
13748 
13749 /** adds a nonlinear row to the NLP. This row is captured by the NLP.
13750  *
13751  * @pre This method can be called if SCIP is in one of the following stages:
13752  * - \ref SCIP_STAGE_INITSOLVE
13753  * - \ref SCIP_STAGE_SOLVING
13754  */
13755 extern
13757  SCIP* scip, /**< SCIP data structure */
13758  SCIP_NLROW* nlrow /**< nonlinear row to add to NLP */
13759  );
13760 
13761 /** makes sure that the NLP of the current node is flushed
13762  *
13763  * @pre This method can be called if SCIP is in one of the following stages:
13764  * - \ref SCIP_STAGE_INITSOLVE
13765  * - \ref SCIP_STAGE_SOLVING
13766  */
13767 extern
13769  SCIP* scip /**< SCIP data structure */
13770  );
13771 
13772 /** sets or clears initial primal guess for NLP solution (start point for NLP solver)
13773  *
13774  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13775  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13776  *
13777  * @pre This method can be called if SCIP is in one of the following stages:
13778  * - \ref SCIP_STAGE_INITSOLVE
13779  * - \ref SCIP_STAGE_SOLVING
13780  */
13781 extern
13783  SCIP* scip, /**< SCIP data structure */
13784  SCIP_Real* initialguess /**< values of initial guess (corresponding to variables from SCIPgetNLPVarsData), or NULL to use no start point */
13785  );
13786 
13787 /** sets initial primal guess for NLP solution (start point for NLP solver)
13788  *
13789  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13790  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13791  *
13792  * @pre This method can be called if SCIP is in one of the following stages:
13793  * - \ref SCIP_STAGE_INITSOLVE
13794  * - \ref SCIP_STAGE_SOLVING
13795  */
13796 extern
13798  SCIP* scip, /**< SCIP data structure */
13799  SCIP_SOL* sol /**< solution which values should be taken as initial guess, or NULL for LP solution */
13800  );
13801 
13802 /** solves the current NLP
13803  *
13804  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13805  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13806  *
13807  * @pre This method can be called if SCIP is in one of the following stages:
13808  * - \ref SCIP_STAGE_INITSOLVE
13809  * - \ref SCIP_STAGE_SOLVING
13810  */
13811 extern
13813  SCIP* scip /**< SCIP data structure */
13814  );
13815 
13816 /** gets solution status of current NLP
13817  *
13818  * @pre This method can be called if SCIP is in one of the following stages:
13819  * - \ref SCIP_STAGE_INITSOLVE
13820  * - \ref SCIP_STAGE_SOLVING
13821  */
13822 extern
13824  SCIP* scip /**< SCIP data structure */
13825  );
13826 
13827 /** gets termination status of last NLP solve
13828  *
13829  * @pre This method can be called if SCIP is in one of the following stages:
13830  * - \ref SCIP_STAGE_INITSOLVE
13831  * - \ref SCIP_STAGE_SOLVING
13832  */
13833 extern
13835  SCIP* scip /**< SCIP data structure */
13836  );
13837 
13838 /** gives statistics (number of iterations, solving time, ...) of last NLP solve
13839  *
13840  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13841  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13842  *
13843  * @pre This method can be called if SCIP is in one of the following stages:
13844  * - \ref SCIP_STAGE_INITSOLVE
13845  * - \ref SCIP_STAGE_SOLVING
13846  */
13847 extern
13849  SCIP* scip, /**< SCIP data structure */
13850  SCIP_NLPSTATISTICS* statistics /**< pointer to store statistics */
13851  );
13852 
13853 /** gets objective value of current NLP
13854  *
13855  * @pre This method can be called if SCIP is in one of the following stages:
13856  * - \ref SCIP_STAGE_INITSOLVE
13857  * - \ref SCIP_STAGE_SOLVING
13858  */
13859 extern
13861  SCIP* scip /**< SCIP data structure */
13862  );
13863 
13864 /** indicates whether a feasible solution for the current NLP is available
13865  * thus, returns whether the solution status <= feasible
13866  *
13867  * @pre This method can be called if SCIP is in one of the following stages:
13868  * - \ref SCIP_STAGE_INITSOLVE
13869  * - \ref SCIP_STAGE_SOLVING
13870  */
13871 extern
13873  SCIP* scip /**< SCIP data structure */
13874  );
13875 
13876 /** gets fractional variables of last NLP solution along with solution values and fractionalities
13877  *
13878  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13879  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13880  *
13881  * @pre This method can be called if SCIP is in one of the following stages:
13882  * - \ref SCIP_STAGE_INITSOLVE
13883  * - \ref SCIP_STAGE_SOLVING
13884  */
13885 extern
13887  SCIP* scip, /**< SCIP data structure */
13888  SCIP_VAR*** fracvars, /**< pointer to store the array of NLP fractional variables, or NULL */
13889  SCIP_Real** fracvarssol, /**< pointer to store the array of NLP fractional variables solution values, or NULL */
13890  SCIP_Real** fracvarsfrac, /**< pointer to store the array of NLP fractional variables fractionalities, or NULL */
13891  int* nfracvars, /**< pointer to store the number of NLP fractional variables , or NULL */
13892  int* npriofracvars /**< pointer to store the number of NLP fractional variables with maximal branching priority, or NULL */
13893  );
13894 
13895 /** gets integer parameter of NLP
13896  *
13897  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13898  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13899  *
13900  * @pre This method can be called if SCIP is in one of the following stages:
13901  * - \ref SCIP_STAGE_INITSOLVE
13902  * - \ref SCIP_STAGE_SOLVING
13903  */
13904 extern
13906  SCIP* scip, /**< SCIP data structure */
13907  SCIP_NLPPARAM type, /**< parameter number */
13908  int* ival /**< pointer to store the parameter value */
13909  );
13910 
13911 /** sets integer parameter of NLP
13912  *
13913  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13914  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13915  *
13916  * @pre This method can be called if SCIP is in one of the following stages:
13917  * - \ref SCIP_STAGE_INITSOLVE
13918  * - \ref SCIP_STAGE_SOLVING
13919  */
13920 extern
13922  SCIP* scip, /**< SCIP data structure */
13923  SCIP_NLPPARAM type, /**< parameter number */
13924  int ival /**< parameter value */
13925  );
13926 
13927 /** gets floating point parameter of NLP
13928  *
13929  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13930  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13931  *
13932  * @pre This method can be called if SCIP is in one of the following stages:
13933  * - \ref SCIP_STAGE_INITSOLVE
13934  * - \ref SCIP_STAGE_SOLVING
13935  */
13936 extern
13938  SCIP* scip, /**< SCIP data structure */
13939  SCIP_NLPPARAM type, /**< parameter number */
13940  SCIP_Real* dval /**< pointer to store the parameter value */
13941  );
13942 
13943 /** sets floating point parameter of NLP
13944  *
13945  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13946  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13947  *
13948  * @pre This method can be called if SCIP is in one of the following stages:
13949  * - \ref SCIP_STAGE_INITSOLVE
13950  * - \ref SCIP_STAGE_SOLVING
13951  */
13952 extern
13954  SCIP* scip, /**< SCIP data structure */
13955  SCIP_NLPPARAM type, /**< parameter number */
13956  SCIP_Real dval /**< parameter value */
13957  );
13958 
13959 /** gets string parameter of NLP
13960  *
13961  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13962  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13963  *
13964  * @pre This method can be called if SCIP is in one of the following stages:
13965  * - \ref SCIP_STAGE_INITSOLVE
13966  * - \ref SCIP_STAGE_SOLVING
13967  */
13968 extern
13970  SCIP* scip, /**< SCIP data structure */
13971  SCIP_NLPPARAM type, /**< parameter number */
13972  const char** sval /**< pointer to store the parameter value */
13973  );
13974 
13975 /** sets string parameter of NLP
13976  *
13977  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13978  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13979  *
13980  * @pre This method can be called if SCIP is in one of the following stages:
13981  * - \ref SCIP_STAGE_INITSOLVE
13982  * - \ref SCIP_STAGE_SOLVING
13983  */
13984 extern
13986  SCIP* scip, /**< SCIP data structure */
13987  SCIP_NLPPARAM type, /**< parameter number */
13988  const char* sval /**< parameter value */
13989  );
13990 
13991 /** writes current NLP to a file
13992  *
13993  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13994  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13995  *
13996  * @pre This method can be called if SCIP is in one of the following stages:
13997  * - \ref SCIP_STAGE_INITSOLVE
13998  * - \ref SCIP_STAGE_SOLVING
13999  */
14000 extern
14002  SCIP* scip, /**< SCIP data structure */
14003  const char* filename /**< file name */
14004  );
14005 
14006 /** gets the NLP interface and problem used by the SCIP NLP;
14007  * with the NLPI and its problem you can use all of the methods defined in nlpi/nlpi.h;
14008  *
14009  * @warning You have to make sure, that the full internal state of the NLPI does not change or is recovered completely
14010  * after the end of the method that uses the NLPI. In particular, if you manipulate the NLP or its solution
14011  * (e.g. by calling one of the SCIPnlpiAdd...() or the SCIPnlpiSolve() method), you have to check in advance
14012  * whether the NLP is currently solved. If this is the case, you have to make sure, the internal solution
14013  * status is recovered completely at the end of your method. Additionally you have to resolve the NLP with
14014  * SCIPnlpiSolve() in order to reinstall the internal solution status.
14015  *
14016  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
14017  *
14018  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14019  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14020  *
14021  * @pre This method can be called if SCIP is in one of the following stages:
14022  * - \ref SCIP_STAGE_INITSOLVE
14023  * - \ref SCIP_STAGE_SOLVING
14024  */
14025 extern
14027  SCIP* scip, /**< SCIP data structure */
14028  SCIP_NLPI** nlpi, /**< pointer to store the NLP solver interface */
14029  SCIP_NLPIPROBLEM** nlpiproblem /**< pointer to store the NLP solver interface problem */
14030  );
14031 
14032 /**@} */
14033 
14034 
14035 /*
14036  * NLP diving methods
14037  */
14038 
14039 /**@addtogroup PublicNLPDiveMethods
14040  *
14041  * @{ */
14042 
14043 /** initiates NLP diving making methods SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), SCIPchgVarsBoundsDiveNLP(), and SCIPsolveDiveNLP() available
14044  *
14045  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14046  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14047  *
14048  * @pre This method can be called if SCIP is in one of the following stages:
14049  * - \ref SCIP_STAGE_INITSOLVE
14050  * - \ref SCIP_STAGE_SOLVING
14051  */
14052 extern
14054  SCIP* scip /**< SCIP data structure */
14055  );
14056 
14057 /** ends NLP diving
14058  *
14059  * Resets changes made by SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), and SCIPchgVarsBoundsDiveNLP().
14060  *
14061  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14062  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14063  *
14064  * @pre This method can be called if SCIP is in one of the following stages:
14065  * - \ref SCIP_STAGE_INITSOLVE
14066  * - \ref SCIP_STAGE_SOLVING
14067  */
14068 extern
14070  SCIP* scip /**< SCIP data structure */
14071  );
14072 
14073 /** changes linear objective coefficient of a variable in diving NLP
14074  *
14075  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14076  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14077  *
14078  * @pre This method can be called if SCIP is in one of the following stages:
14079  * - \ref SCIP_STAGE_INITSOLVE
14080  * - \ref SCIP_STAGE_SOLVING
14081  */
14082 extern
14084  SCIP* scip, /**< SCIP data structure */
14085  SCIP_VAR* var, /**< variable which coefficient to change */
14086  SCIP_Real coef /**< new value for coefficient */
14087  );
14088 
14089 /** changes bounds of a variable in diving NLP
14090  *
14091  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14092  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14093  *
14094  * @pre This method can be called if SCIP is in one of the following stages:
14095  * - \ref SCIP_STAGE_INITSOLVE
14096  * - \ref SCIP_STAGE_SOLVING
14097  */
14098 extern
14100  SCIP* scip, /**< SCIP data structure */
14101  SCIP_VAR* var, /**< variable which bounds to change */
14102  SCIP_Real lb, /**< new lower bound */
14103  SCIP_Real ub /**< new upper bound */
14104  );
14105 
14106 /** changes bounds of a set of variables in diving NLP
14107  *
14108  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14109  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14110  *
14111  * @pre This method can be called if SCIP is in one of the following stages:
14112  * - \ref SCIP_STAGE_INITSOLVE
14113  * - \ref SCIP_STAGE_SOLVING
14114  */
14115 extern
14117  SCIP* scip, /**< SCIP data structure */
14118  int nvars, /**< number of variables which bounds to changes */
14119  SCIP_VAR** vars, /**< variables which bounds to change */
14120  SCIP_Real* lbs, /**< new lower bounds */
14121  SCIP_Real* ubs /**< new upper bounds */
14122  );
14123 
14124 /** solves diving NLP
14125  *
14126  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14127  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14128  *
14129  * @pre This method can be called if SCIP is in one of the following stages:
14130  * - \ref SCIP_STAGE_INITSOLVE
14131  * - \ref SCIP_STAGE_SOLVING
14132  */
14133 extern
14135  SCIP* scip /**< SCIP data structure */
14136  );
14137 
14138 /**@} */
14139 
14140 
14141 /*
14142  * NLP nonlinear row methods
14143  */
14144 
14145 /**@addtogroup PublicNLRowMethods
14146  *
14147  * @{
14148  */
14149 
14150 /** creates and captures an NLP row
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_PRESOLVED
14157  * - \ref SCIP_STAGE_INITSOLVE
14158  * - \ref SCIP_STAGE_SOLVING
14159  */
14160 extern
14162  SCIP* scip, /**< SCIP data structure */
14163  SCIP_NLROW** nlrow, /**< buffer to store pointer to nonlinear row */
14164  const char* name, /**< name of nonlinear row */
14165  SCIP_Real constant, /**< constant */
14166  int nlinvars, /**< number of linear variables */
14167  SCIP_VAR** linvars, /**< linear variables, or NULL if nlinvars == 0 */
14168  SCIP_Real* lincoefs, /**< linear coefficients, or NULL if nlinvars == 0 */
14169  int nquadvars, /**< number of variables in quadratic term */
14170  SCIP_VAR** quadvars, /**< variables in quadratic terms, or NULL if nquadvars == 0 */
14171  int nquadelems, /**< number of elements in quadratic term */
14172  SCIP_QUADELEM* quadelems, /**< elements (i.e., monomials) in quadratic term, or NULL if nquadelems == 0 */
14173  SCIP_EXPRTREE* expression, /**< nonlinear expression, or NULL */
14174  SCIP_Real lhs, /**< left hand side */
14175  SCIP_Real rhs, /**< right hand side */
14176  SCIP_EXPRCURV curvature /**< curvature of the nonlinear row */
14177  );
14178 
14179 /** creates and captures an NLP nonlinear row without any coefficients
14180  *
14181  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14182  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14183  *
14184  * @pre This method can be called if SCIP is in one of the following stages:
14185  * - \ref SCIP_STAGE_PRESOLVED
14186  * - \ref SCIP_STAGE_INITSOLVE
14187  * - \ref SCIP_STAGE_SOLVING
14188  */
14189 extern
14191  SCIP* scip, /**< SCIP data structure */
14192  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
14193  const char* name, /**< name of nonlinear row */
14194  SCIP_Real lhs, /**< left hand side */
14195  SCIP_Real rhs /**< right hand side */
14196  );
14197 
14198 /** creates and captures an NLP row from a linear row
14199  *
14200  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14201  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14202  *
14203  * @pre This method can be called if SCIP is in one of the following stages:
14204  * - \ref SCIP_STAGE_PRESOLVED
14205  * - \ref SCIP_STAGE_INITSOLVE
14206  * - \ref SCIP_STAGE_SOLVING
14207  */
14208 extern
14210  SCIP* scip, /**< SCIP data structure */
14211  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
14212  SCIP_ROW* row /**< the linear row to copy */
14213  );
14214 
14215 /** increases usage counter of NLP nonlinear row
14216  *
14217  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14218  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14219  *
14220  * @pre This method can be called if SCIP is in one of the following stages:
14221  * - \ref SCIP_STAGE_PRESOLVED
14222  * - \ref SCIP_STAGE_INITSOLVE
14223  * - \ref SCIP_STAGE_SOLVING
14224  */
14225 extern
14227  SCIP* scip, /**< SCIP data structure */
14228  SCIP_NLROW* nlrow /**< nonlinear row to capture */
14229  );
14230 
14231 /** decreases usage counter of NLP nonlinear row, and frees memory if necessary
14232  *
14233  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14234  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14235  *
14236  * @pre This method can be called if SCIP is in one of the following stages:
14237  * - \ref SCIP_STAGE_PRESOLVED
14238  * - \ref SCIP_STAGE_INITSOLVE
14239  * - \ref SCIP_STAGE_SOLVING
14240  * - \ref SCIP_STAGE_EXITSOLVE
14241  */
14242 extern
14244  SCIP* scip, /**< SCIP data structure */
14245  SCIP_NLROW** nlrow /**< pointer to nonlinear row */
14246  );
14247 
14248 /** changes left hand side of NLP nonlinear row
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_PRESOLVED
14255  * - \ref SCIP_STAGE_INITSOLVE
14256  * - \ref SCIP_STAGE_SOLVING
14257  */
14258 extern
14260  SCIP* scip, /**< SCIP data structure */
14261  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14262  SCIP_Real lhs /**< new left hand side */
14263  );
14264 
14265 /** changes right hand side of NLP nonlinear row
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_PRESOLVED
14272  * - \ref SCIP_STAGE_INITSOLVE
14273  * - \ref SCIP_STAGE_SOLVING
14274  */
14275 extern
14277  SCIP* scip, /**< SCIP data structure */
14278  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14279  SCIP_Real rhs /**< new right hand side */
14280  );
14281 
14282 /** changes constant of NLP nonlinear row
14283  *
14284  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14285  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14286  *
14287  * @pre This method can be called if SCIP is in one of the following stages:
14288  * - \ref SCIP_STAGE_PRESOLVED
14289  * - \ref SCIP_STAGE_INITSOLVE
14290  * - \ref SCIP_STAGE_SOLVING
14291  */
14292 extern
14294  SCIP* scip, /**< SCIP data structure */
14295  SCIP_NLROW* nlrow, /**< NLP row */
14296  SCIP_Real constant /**< new value for constant */
14297  );
14298 
14299 /** adds variable with a linear coefficient to the nonlinear row
14300  *
14301  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14302  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14303  *
14304  * @pre This method can be called if SCIP is in one of the following stages:
14305  * - \ref SCIP_STAGE_PRESOLVED
14306  * - \ref SCIP_STAGE_INITSOLVE
14307  * - \ref SCIP_STAGE_SOLVING
14308  */
14309 extern
14311  SCIP* scip, /**< SCIP data structure */
14312  SCIP_NLROW* nlrow, /**< NLP row */
14313  SCIP_VAR* var, /**< problem variable */
14314  SCIP_Real val /**< value of coefficient in linear part of row */
14315  );
14316 
14317 /** adds variables with linear coefficients to the row
14318  *
14319  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14320  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14321  *
14322  * @pre This method can be called if SCIP is in one of the following stages:
14323  * - \ref SCIP_STAGE_PRESOLVED
14324  * - \ref SCIP_STAGE_INITSOLVE
14325  * - \ref SCIP_STAGE_SOLVING
14326  */
14327 extern
14329  SCIP* scip, /**< SCIP data structure */
14330  SCIP_NLROW* nlrow, /**< NLP row */
14331  int nvars, /**< number of variables to add to the row */
14332  SCIP_VAR** vars, /**< problem variables to add */
14333  SCIP_Real* vals /**< values of coefficients in linear part of row */
14334  );
14335 
14336 /** changes linear coefficient of a variables in a row
14337  *
14338  * Setting the coefficient to 0.0 means that it is removed from the row
14339  * the variable does not need to exists before.
14340  *
14341  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14342  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14343  *
14344  * @pre This method can be called if SCIP is in one of the following stages:
14345  * - \ref SCIP_STAGE_PRESOLVED
14346  * - \ref SCIP_STAGE_INITSOLVE
14347  * - \ref SCIP_STAGE_SOLVING
14348  */
14349 extern
14351  SCIP* scip, /**< SCIP data structure */
14352  SCIP_NLROW* nlrow, /**< NLP row */
14353  SCIP_VAR* var, /**< variable */
14354  SCIP_Real coef /**< new value of coefficient */
14355  );
14356 
14357 /** adds quadratic variable to the nonlinear row
14358  *
14359  * After adding a quadratic variable, it can be used to add quadratic elements.
14360  *
14361  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14362  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14363  *
14364  * @pre This method can be called if SCIP is in one of the following stages:
14365  * - \ref SCIP_STAGE_PRESOLVED
14366  * - \ref SCIP_STAGE_INITSOLVE
14367  * - \ref SCIP_STAGE_SOLVING
14368  */
14369 extern
14371  SCIP* scip, /**< SCIP data structure */
14372  SCIP_NLROW* nlrow, /**< NLP row */
14373  SCIP_VAR* var /**< problem variable */
14374  );
14375 
14376 /** adds quadratic variables to the nonlinear row
14377  *
14378  * After adding quadratic variables, they can be used to add quadratic elements.
14379  *
14380  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14381  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14382  *
14383  * @pre This method can be called if SCIP is in one of the following stages:
14384  * - \ref SCIP_STAGE_PRESOLVED
14385  * - \ref SCIP_STAGE_INITSOLVE
14386  * - \ref SCIP_STAGE_SOLVING
14387  */
14388 extern
14390  SCIP* scip, /**< SCIP data structure */
14391  SCIP_NLROW* nlrow, /**< NLP row */
14392  int nvars, /**< number of problem variables */
14393  SCIP_VAR** vars /**< problem variables */
14394  );
14395 
14396 /** add a quadratic element to the nonlinear row
14397  *
14398  * Variable indices of the quadratic element need to be relative to quadratic variables array of row.
14399  *
14400  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14401  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14402  *
14403  * @pre This method can be called if SCIP is in one of the following stages:
14404  * - \ref SCIP_STAGE_PRESOLVED
14405  * - \ref SCIP_STAGE_INITSOLVE
14406  * - \ref SCIP_STAGE_SOLVING
14407  */
14408 extern
14410  SCIP* scip, /**< SCIP data structure */
14411  SCIP_NLROW* nlrow, /**< NLP row */
14412  SCIP_QUADELEM quadelem /**< quadratic element */
14413  );
14414 
14415 /** adds quadratic elements to the nonlinear row
14416  *
14417  * Variable indices of the quadratic elements need to be relative to quadratic variables array of row.
14418  *
14419  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14420  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14421  *
14422  * @pre This method can be called if SCIP is in one of the following stages:
14423  * - \ref SCIP_STAGE_PRESOLVED
14424  * - \ref SCIP_STAGE_INITSOLVE
14425  * - \ref SCIP_STAGE_SOLVING
14426  */
14427 extern
14429  SCIP* scip, /**< SCIP data structure */
14430  SCIP_NLROW* nlrow, /**< NLP row */
14431  int nquadelems, /**< number of quadratic elements */
14432  SCIP_QUADELEM* quadelems /**< quadratic elements */
14433  );
14434 
14435 /** changes coefficient in quadratic part of a row
14436  *
14437  * Setting the coefficient in the quadelement to 0.0 means that it is removed from the row
14438  * the element does not need to exists before.
14439  *
14440  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14441  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14442  *
14443  * @pre This method can be called if SCIP is in one of the following stages:
14444  * - \ref SCIP_STAGE_PRESOLVED
14445  * - \ref SCIP_STAGE_INITSOLVE
14446  * - \ref SCIP_STAGE_SOLVING
14447  */
14448 extern
14450  SCIP* scip, /**< SCIP data structure */
14451  SCIP_NLROW* nlrow, /**< NLP row */
14452  SCIP_QUADELEM quadelement /**< new quadratic element, or update for existing one */
14453  );
14454 
14455 /** sets or deletes expression tree in the nonlinear row
14456  *
14457  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14458  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14459  *
14460  * @pre This method can be called if SCIP is in one of the following stages:
14461  * - \ref SCIP_STAGE_PRESOLVED
14462  * - \ref SCIP_STAGE_INITSOLVE
14463  * - \ref SCIP_STAGE_SOLVING
14464  */
14465 extern
14467  SCIP* scip, /**< SCIP data structure */
14468  SCIP_NLROW* nlrow, /**< NLP row */
14469  SCIP_EXPRTREE* exprtree /**< expression tree, or NULL */
14470  );
14471 
14472 /** sets a parameter of expression tree in the nonlinear row
14473  *
14474  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14475  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14476  *
14477  * @pre This method can be called if SCIP is in one of the following stages:
14478  * - \ref SCIP_STAGE_PRESOLVED
14479  * - \ref SCIP_STAGE_INITSOLVE
14480  * - \ref SCIP_STAGE_SOLVING
14481  */
14482 extern
14484  SCIP* scip, /**< SCIP data structure */
14485  SCIP_NLROW* nlrow, /**< NLP row */
14486  int paramidx, /**< index of parameter in expression tree */
14487  SCIP_Real paramval /**< new value of parameter in expression tree */
14488  );
14489 
14490 /** sets parameters of expression tree in the nonlinear row
14491  *
14492  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14493  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14494  *
14495  * @pre This method can be called if SCIP is in one of the following stages:
14496  * - \ref SCIP_STAGE_PRESOLVED
14497  * - \ref SCIP_STAGE_INITSOLVE
14498  * - \ref SCIP_STAGE_SOLVING
14499  */
14500 extern
14502  SCIP* scip, /**< SCIP data structure */
14503  SCIP_NLROW* nlrow, /**< NLP row */
14504  SCIP_Real* paramvals /**< new values of parameter in expression tree */
14505  );
14506 
14507 /** recalculates the activity of a nonlinear row in the last NLP solution
14508  *
14509  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14510  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14511  *
14512  * @pre This method can be called if SCIP is in one of the following stages:
14513  * - \ref SCIP_STAGE_PRESOLVED
14514  * - \ref SCIP_STAGE_INITSOLVE
14515  * - \ref SCIP_STAGE_SOLVING
14516  */
14517 extern
14519  SCIP* scip, /**< SCIP data structure */
14520  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14521  );
14522 
14523 /** returns the activity of a nonlinear row in the last NLP solution
14524  *
14525  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14526  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14527  *
14528  * @pre This method can be called if SCIP is in one of the following stages:
14529  * - \ref SCIP_STAGE_INITSOLVE
14530  * - \ref SCIP_STAGE_SOLVING
14531  */
14532 extern
14534  SCIP* scip, /**< SCIP data structure */
14535  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14536  SCIP_Real* activity /**< pointer to store activity value */
14537  );
14538 
14539 /** gives the feasibility of a nonlinear row in the last NLP solution: negative value means infeasibility
14540  *
14541  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14542  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14543  *
14544  * @pre This method can be called if SCIP is in one of the following stages:
14545  * - \ref SCIP_STAGE_INITSOLVE
14546  * - \ref SCIP_STAGE_SOLVING
14547  */
14548 extern
14550  SCIP* scip, /**< SCIP data structure */
14551  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14552  SCIP_Real* feasibility /**< pointer to store feasibility value */
14553  );
14554 
14555 /** recalculates the activity of a nonlinear row for the current pseudo solution
14556  *
14557  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14558  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14559  *
14560  * @pre This method can be called if SCIP is in one of the following stages:
14561  * - \ref SCIP_STAGE_INITSOLVE
14562  * - \ref SCIP_STAGE_SOLVING
14563  */
14564 extern
14566  SCIP* scip, /**< SCIP data structure */
14567  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14568  );
14569 
14570 /** gives the activity of a nonlinear row for the current pseudo solution
14571  *
14572  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14573  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14574  *
14575  * @pre This method can be called if SCIP is in one of the following stages:
14576  * - \ref SCIP_STAGE_INITSOLVE
14577  * - \ref SCIP_STAGE_SOLVING
14578  */
14579 extern
14581  SCIP* scip, /**< SCIP data structure */
14582  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14583  SCIP_Real* pseudoactivity /**< pointer to store pseudo activity value */
14584  );
14585 
14586 /** gives the feasibility of a nonlinear row for the current pseudo solution: negative value means infeasibility
14587  *
14588  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14589  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14590  *
14591  * @pre This method can be called if SCIP is in one of the following stages:
14592  * - \ref SCIP_STAGE_INITSOLVE
14593  * - \ref SCIP_STAGE_SOLVING
14594  */
14595 extern
14597  SCIP* scip, /**< SCIP data structure */
14598  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14599  SCIP_Real* pseudofeasibility /**< pointer to store pseudo feasibility value */
14600  );
14601 
14602 /** recalculates the activity of a nonlinear row in the last NLP or pseudo solution
14603  *
14604  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14605  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14606  *
14607  * @pre This method can be called if SCIP is in one of the following stages:
14608  * - \ref SCIP_STAGE_INITSOLVE
14609  * - \ref SCIP_STAGE_SOLVING
14610  */
14611 extern
14613  SCIP* scip, /**< SCIP data structure */
14614  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14615  );
14616 
14617 /** gives the activity of a nonlinear row in the last NLP or pseudo solution
14618  *
14619  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14620  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14621  *
14622  * @pre This method can be called if SCIP is in one of the following stages:
14623  * - \ref SCIP_STAGE_INITSOLVE
14624  * - \ref SCIP_STAGE_SOLVING
14625  */
14626 extern
14628  SCIP* scip, /**< SCIP data structure */
14629  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14630  SCIP_Real* activity /**< pointer to store activity value */
14631  );
14632 
14633 /** gives the feasibility of a nonlinear row in the last NLP or pseudo solution
14634  *
14635  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14636  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14637  *
14638  * @pre This method can be called if SCIP is in one of the following stages:
14639  * - \ref SCIP_STAGE_INITSOLVE
14640  * - \ref SCIP_STAGE_SOLVING
14641  */
14642 extern
14644  SCIP* scip, /**< SCIP data structure */
14645  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14646  SCIP_Real* feasibility /**< pointer to store feasibility value */
14647  );
14648 
14649 /** gives the activity of a nonlinear row for the given primal solution or NLP solution or pseudo solution
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_INITSOLVE
14656  * - \ref SCIP_STAGE_SOLVING
14657  */
14658 extern
14660  SCIP* scip, /**< SCIP data structure */
14661  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14662  SCIP_SOL* sol, /**< primal CIP solution, or NULL for NLP solution of pseudo solution */
14663  SCIP_Real* activity /**< pointer to store activity value */
14664  );
14665 
14666 /** gives the feasibility of a nonlinear row for the given primal 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_INITSOLVE
14673  * - \ref SCIP_STAGE_SOLVING
14674  */
14675 extern
14677  SCIP* scip, /**< SCIP data structure */
14678  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14679  SCIP_SOL* sol, /**< primal CIP solution */
14680  SCIP_Real* feasibility /**< pointer to store feasibility value */
14681  );
14682 
14683 /** gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds
14684  *
14685  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14686  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14687  *
14688  * @pre This method can be called if SCIP is in one of the following stages:
14689  * - \ref SCIP_STAGE_PRESOLVED
14690  * - \ref SCIP_STAGE_INITSOLVE
14691  * - \ref SCIP_STAGE_SOLVING
14692  */
14693 extern
14695  SCIP* scip, /**< SCIP data structure */
14696  SCIP_NLROW* nlrow, /**< NLP row */
14697  SCIP_Real* minactivity, /**< buffer to store minimal activity, or NULL */
14698  SCIP_Real* maxactivity /**< buffer to store maximal activity, or NULL */
14699  );
14700 
14701 /** output nonlinear row to file stream
14702  *
14703  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14704  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14705  *
14706  * @pre This method can be called if SCIP is in one of the following stages:
14707  * - \ref SCIP_STAGE_PRESOLVED
14708  * - \ref SCIP_STAGE_INITSOLVE
14709  * - \ref SCIP_STAGE_SOLVING
14710  */
14711 extern
14713  SCIP* scip, /**< SCIP data structure */
14714  SCIP_NLROW* nlrow, /**< NLP row */
14715  FILE* file /**< output file (or NULL for standard output) */
14716  );
14717 
14718 /**@} */
14719 
14720 /**@addtogroup PublicExpressionTreeMethods
14721  *
14722  * @{
14723  */
14724 
14725 /** replaces array of variables in expression tree by corresponding transformed variables
14726  *
14727  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14728  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14729  *
14730  * @pre This method can be called if @p scip is in one of the following stages:
14731  * - \ref SCIP_STAGE_TRANSFORMING
14732  * - \ref SCIP_STAGE_TRANSFORMED
14733  * - \ref SCIP_STAGE_INITPRESOLVE
14734  * - \ref SCIP_STAGE_PRESOLVING
14735  * - \ref SCIP_STAGE_EXITPRESOLVE
14736  * - \ref SCIP_STAGE_PRESOLVED
14737  * - \ref SCIP_STAGE_INITSOLVE
14738  * - \ref SCIP_STAGE_SOLVING
14739  * - \ref SCIP_STAGE_SOLVED
14740  * - \ref SCIP_STAGE_EXITSOLVE
14741  * - \ref SCIP_STAGE_FREETRANS
14742  *
14743  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14744  */
14745 extern
14747  SCIP* scip, /**< SCIP data structure */
14748  SCIP_EXPRTREE* tree /**< expression tree */
14749  );
14750 
14751 /** evaluates an expression tree for a primal solution or LP solution
14752  *
14753  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14754  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14755  *
14756  * @pre This method can be called if @p scip is in one of the following stages:
14757  * - \ref SCIP_STAGE_PROBLEM
14758  * - \ref SCIP_STAGE_TRANSFORMING
14759  * - \ref SCIP_STAGE_TRANSFORMED
14760  * - \ref SCIP_STAGE_INITPRESOLVE
14761  * - \ref SCIP_STAGE_PRESOLVING
14762  * - \ref SCIP_STAGE_EXITPRESOLVE
14763  * - \ref SCIP_STAGE_PRESOLVED
14764  * - \ref SCIP_STAGE_INITSOLVE
14765  * - \ref SCIP_STAGE_SOLVING
14766  * - \ref SCIP_STAGE_SOLVED
14767  * - \ref SCIP_STAGE_EXITSOLVE
14768  * - \ref SCIP_STAGE_FREETRANS
14769  *
14770  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14771  */
14772 extern
14774  SCIP* scip, /**< SCIP data structure */
14775  SCIP_EXPRTREE* tree, /**< expression tree */
14776  SCIP_SOL* sol, /**< a solution, or NULL for current LP solution */
14777  SCIP_Real* val /**< buffer to store value */
14778  );
14779 
14780 /** evaluates an expression tree w.r.t. current global bounds
14781  *
14782  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14783  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14784  *
14785  * @pre This method can be called if @p scip is in one of the following stages:
14786  * - \ref SCIP_STAGE_PROBLEM
14787  * - \ref SCIP_STAGE_TRANSFORMING
14788  * - \ref SCIP_STAGE_TRANSFORMED
14789  * - \ref SCIP_STAGE_INITPRESOLVE
14790  * - \ref SCIP_STAGE_PRESOLVING
14791  * - \ref SCIP_STAGE_EXITPRESOLVE
14792  * - \ref SCIP_STAGE_PRESOLVED
14793  * - \ref SCIP_STAGE_INITSOLVE
14794  * - \ref SCIP_STAGE_SOLVING
14795  * - \ref SCIP_STAGE_SOLVED
14796  * - \ref SCIP_STAGE_EXITSOLVE
14797  * - \ref SCIP_STAGE_FREETRANS
14798  *
14799  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14800  */
14801 extern
14803  SCIP* scip, /**< SCIP data structure */
14804  SCIP_EXPRTREE* tree, /**< expression tree */
14805  SCIP_Real infinity, /**< value to use for infinity */
14806  SCIP_INTERVAL* val /**< buffer to store result */
14807  );
14808 
14809 /** evaluates an expression tree w.r.t. current local bounds
14810  *
14811  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14812  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14813  *
14814  * @pre This method can be called if @p scip is in one of the following stages:
14815  * - \ref SCIP_STAGE_PROBLEM
14816  * - \ref SCIP_STAGE_TRANSFORMING
14817  * - \ref SCIP_STAGE_TRANSFORMED
14818  * - \ref SCIP_STAGE_INITPRESOLVE
14819  * - \ref SCIP_STAGE_PRESOLVING
14820  * - \ref SCIP_STAGE_EXITPRESOLVE
14821  * - \ref SCIP_STAGE_PRESOLVED
14822  * - \ref SCIP_STAGE_INITSOLVE
14823  * - \ref SCIP_STAGE_SOLVING
14824  * - \ref SCIP_STAGE_SOLVED
14825  * - \ref SCIP_STAGE_EXITSOLVE
14826  * - \ref SCIP_STAGE_FREETRANS
14827  *
14828  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14829  */
14830 extern
14832  SCIP* scip, /**< SCIP data structure */
14833  SCIP_EXPRTREE* tree, /**< expression tree */
14834  SCIP_Real infinity, /**< value to use for infinity */
14835  SCIP_INTERVAL* val /**< buffer to store result */
14836  );
14837 
14838 /**@} */
14839 
14840 
14841 
14842 
14843 /*
14844  * nonlinear methods
14845  */
14846 
14847 /**@addtogroup PublicNonlinearMethods
14848  *
14849  * @{
14850  */
14851 
14852 /** computes coefficients of linearization of a square term in a reference point */
14853 extern
14855  SCIP* scip, /**< SCIP data structure */
14856  SCIP_Real sqrcoef, /**< coefficient of square term */
14857  SCIP_Real refpoint, /**< point where to linearize */
14858  SCIP_Bool isint, /**< whether corresponding variable is a discrete variable, and thus linearization could be moved */
14859  SCIP_Real* lincoef, /**< buffer to add coefficient of linearization */
14860  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14861  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14862  );
14863 
14864 /** computes coefficients of secant of a square term */
14865 extern
14866 void SCIPaddSquareSecant(
14867  SCIP* scip, /**< SCIP data structure */
14868  SCIP_Real sqrcoef, /**< coefficient of square term */
14869  SCIP_Real lb, /**< lower bound on variable */
14870  SCIP_Real ub, /**< upper bound on variable */
14871  SCIP_Real refpoint, /**< point for which to compute value of linearization */
14872  SCIP_Real* lincoef, /**< buffer to add coefficient of secant */
14873  SCIP_Real* linconstant, /**< buffer to add constant of secant */
14874  SCIP_Bool* success /**< buffer to set to FALSE if secant has failed due to large numbers or unboundedness */
14875  );
14876 
14877 /** computes coefficients of linearization of a bilinear term in a reference point */
14878 extern
14880  SCIP* scip, /**< SCIP data structure */
14881  SCIP_Real bilincoef, /**< coefficient of bilinear term */
14882  SCIP_Real refpointx, /**< point where to linearize first variable */
14883  SCIP_Real refpointy, /**< point where to linearize second variable */
14884  SCIP_Real* lincoefx, /**< buffer to add coefficient of first variable in linearization */
14885  SCIP_Real* lincoefy, /**< buffer to add coefficient of second variable in linearization */
14886  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14887  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14888  );
14889 
14890 /** computes coefficients of McCormick under- or overestimation of a bilinear term */
14891 extern
14893  SCIP* scip, /**< SCIP data structure */
14894  SCIP_Real bilincoef, /**< coefficient of bilinear term */
14895  SCIP_Real lbx, /**< lower bound on first variable */
14896  SCIP_Real ubx, /**< upper bound on first variable */
14897  SCIP_Real refpointx, /**< reference point for first variable */
14898  SCIP_Real lby, /**< lower bound on second variable */
14899  SCIP_Real uby, /**< upper bound on second variable */
14900  SCIP_Real refpointy, /**< reference point for second variable */
14901  SCIP_Bool overestimate, /**< whether to compute an overestimator instead of an underestimator */
14902  SCIP_Real* lincoefx, /**< buffer to add coefficient of first variable in linearization */
14903  SCIP_Real* lincoefy, /**< buffer to add coefficient of second variable in linearization */
14904  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14905  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14906  );
14907 
14908 /** creates an NLP relaxation and stores it in a given NLPI problem; the function computes for each variable which the
14909  * number of non-linearly occurrences and stores it in the nlscore array
14910  *
14911  * @note the first row corresponds always to the cutoff row (even if cutoffbound is SCIPinfinity(scip))
14912  **/
14913 extern
14915  SCIP* scip, /**< SCIP data structure */
14916  SCIP_NLPI* nlpi, /**< interface to NLP solver */
14917  SCIP_NLROW** nlrows, /**< nonlinear rows */
14918  int nnlrows, /**< total number of nonlinear rows */
14919  SCIP_NLPIPROBLEM* nlpiprob, /**< empty nlpi problem */
14920  SCIP_HASHMAP* var2idx, /**< empty hash map to store mapping between variables and indices in nlpi
14921  * problem */
14922  SCIP_Real* nlscore, /**< array to store the score of each nonlinear variable (NULL if not
14923  * needed) */
14924  SCIP_Real cutoffbound, /**< cutoff bound */
14925  SCIP_Bool setobj, /**< should the objective function be set? */
14926  SCIP_Bool onlyconvex /**< filter only for convex constraints */
14927  );
14928 
14929 /** updates bounds of each variable and the cutoff row in the nlpiproblem */
14930 extern
14932  SCIP* scip, /**< SCIP data structure */
14933  SCIP_NLPI* nlpi, /**< interface to NLP solver */
14934  SCIP_NLPIPROBLEM* nlpiprob, /**< nlpi problem representing the convex NLP relaxation */
14935  SCIP_HASHMAP* var2nlpiidx, /**< mapping between variables and nlpi indices */
14936  SCIP_VAR** nlpivars, /**< array containing all variables of the nlpi */
14937  int nlpinvars, /**< total number of nlpi variables */
14938  SCIP_Real cutoffbound /**< new cutoff bound */
14939  );
14940 
14941 /** adds linear rows to the NLP relaxation */
14943  SCIP* scip, /**< SCIP data structure */
14944  SCIP_NLPI* nlpi, /**< interface to NLP solver */
14945  SCIP_NLPIPROBLEM* nlpiprob, /**< nlpi problem */
14946  SCIP_HASHMAP* var2idx, /**< empty hash map to store mapping between variables and indices in nlpi
14947  * problem */
14948  SCIP_ROW** rows, /**< rows to add */
14949  int nrows /**< total number of rows to add */
14950  );
14951 
14952 /**@} */
14953 
14954 
14955 
14956 
14957 /*
14958  * cutting plane methods
14959  */
14960 
14961 /**@addtogroup PublicCutMethods
14962  *
14963  * @{
14964  */
14965 
14966 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
14967  * e = -feasibility/norm
14968  *
14969  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
14970  * e = -feasibility/norm
14971  *
14972  * @pre This method can be called if @p scip is in one of the following stages:
14973  * - \ref SCIP_STAGE_SOLVING
14974  */
14975 extern
14977  SCIP* scip, /**< SCIP data structure */
14978  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
14979  SCIP_ROW* cut /**< separated cut */
14980  );
14981 
14982 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
14983  * than the minimal cut efficacy
14984  *
14985  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
14986  * than the minimal cut efficacy, otherwise FALSE
14987  *
14988  * @pre This method can be called if @p scip is in one of the following stages:
14989  * - \ref SCIP_STAGE_SOLVING
14990  */
14991 extern
14993  SCIP* scip, /**< SCIP data structure */
14994  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
14995  SCIP_ROW* cut /**< separated cut */
14996  );
14997 
14998 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
14999  *
15000  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
15001  */
15002 extern
15004  SCIP* scip, /**< SCIP data structure */
15005  SCIP_Real efficacy /**< efficacy of the cut */
15006  );
15007 
15008 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
15009  *
15010  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
15011  */
15012 extern
15014  SCIP* scip, /**< SCIP data structure */
15015  SCIP_Real* vals, /**< array of values */
15016  int nvals /**< number of values */
15017  );
15018 
15019 /** indicates whether a cut is applicable
15020  *
15021  * If the cut has only one variable and this method returns FALSE, it may
15022  * still be possible that the cut can be added to the LP (as a row instead
15023  * of a boundchange), but it will be a very weak cut. The user is asked
15024  * to avoid such cuts.
15025  *
15026  * @pre This method can be called if @p scip is in one of the following stages:
15027  * - \ref SCIP_STAGE_SOLVING
15028  *
15029  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
15030  */
15031 extern
15033  SCIP* scip, /**< SCIP data structure */
15034  SCIP_ROW* cut /**< separated cut */
15035  );
15036 
15037 /** adds cut to separation storage
15038  *
15039  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15040  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15041  *
15042  * @pre This method can be called if @p scip is in one of the following stages:
15043  * - \ref SCIP_STAGE_SOLVING
15044  */
15045 extern
15047  SCIP* scip, /**< SCIP data structure */
15048  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
15049  SCIP_ROW* cut, /**< separated cut */
15050  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
15051  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
15052  );
15053 
15054 /** if not already existing, adds row to global cut pool
15055  *
15056  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15057  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15058  *
15059  * @pre This method can be called if @p scip is in one of the following stages:
15060  * - \ref SCIP_STAGE_SOLVING
15061  */
15062 extern
15064  SCIP* scip, /**< SCIP data structure */
15065  SCIP_ROW* row /**< cutting plane to add */
15066  );
15067 
15068 /** removes the row from the global cut pool
15069  *
15070  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15071  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15072  *
15073  * @pre This method can be called if @p scip is in one of the following stages:
15074  * - \ref SCIP_STAGE_SOLVING
15075  */
15076 extern
15078  SCIP* scip, /**< SCIP data structure */
15079  SCIP_ROW* row /**< row to remove */
15080  );
15081 
15082 /** gets current cuts in the global cut pool
15083  *
15084  * @return the current cuts in the global cut pool
15085  *
15086  * @pre This method can be called if @p scip is in one of the following stages:
15087  * - \ref SCIP_STAGE_SOLVING
15088  * - \ref SCIP_STAGE_SOLVED
15089  * - \ref SCIP_STAGE_EXITSOLVE
15090  */
15091 extern
15093  SCIP* scip /**< SCIP data structure */
15094  );
15095 
15096 /** gets current number of rows in the global cut pool
15097  *
15098  * @return the current number of rows in the global cut pool
15099  *
15100  * @pre This method can be called if @p scip is in one of the following stages:
15101  * - \ref SCIP_STAGE_SOLVING
15102  * - \ref SCIP_STAGE_SOLVED
15103  * - \ref SCIP_STAGE_EXITSOLVE
15104  */
15105 extern
15106 int SCIPgetNPoolCuts(
15107  SCIP* scip /**< SCIP data structure */
15108  );
15109 
15110 /** gets the global cut pool used by SCIP
15111  *
15112  * @return the global cut pool used by SCIP
15113  *
15114  * @pre This method can be called if @p scip is in one of the following stages:
15115  * - \ref SCIP_STAGE_SOLVING
15116  * - \ref SCIP_STAGE_SOLVED
15117  * - \ref SCIP_STAGE_EXITSOLVE
15118  */
15119 extern
15121  SCIP* scip /**< SCIP data structure */
15122  );
15123 
15124 /** creates a cut pool
15125  *
15126  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15127  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15128  *
15129  * @pre This method can be called if @p scip is in one of the following stages:
15130  * - \ref SCIP_STAGE_TRANSFORMING
15131  * - \ref SCIP_STAGE_TRANSFORMED
15132  * - \ref SCIP_STAGE_INITPRESOLVE
15133  * - \ref SCIP_STAGE_PRESOLVING
15134  * - \ref SCIP_STAGE_EXITPRESOLVE
15135  * - \ref SCIP_STAGE_PRESOLVED
15136  * - \ref SCIP_STAGE_INITSOLVE
15137  * - \ref SCIP_STAGE_SOLVING
15138  */
15139 extern
15141  SCIP* scip, /**< SCIP data structure */
15142  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
15143  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
15144  );
15145 
15146 /** frees a cut pool
15147  *
15148  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15149  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15150  *
15151  * @pre This method can be called if @p scip is in one of the following stages:
15152  * - \ref SCIP_STAGE_TRANSFORMING
15153  * - \ref SCIP_STAGE_TRANSFORMED
15154  * - \ref SCIP_STAGE_INITPRESOLVE
15155  * - \ref SCIP_STAGE_PRESOLVING
15156  * - \ref SCIP_STAGE_EXITPRESOLVE
15157  * - \ref SCIP_STAGE_PRESOLVED
15158  * - \ref SCIP_STAGE_INITSOLVE
15159  * - \ref SCIP_STAGE_SOLVING
15160  * - \ref SCIP_STAGE_SOLVED
15161  * - \ref SCIP_STAGE_EXITSOLVE
15162  * - \ref SCIP_STAGE_FREETRANS
15163  */
15164 extern
15166  SCIP* scip, /**< SCIP data structure */
15167  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
15168  );
15169 
15170 /** if not already existing, adds row to a cut pool and captures it
15171  *
15172  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15173  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15174  *
15175  * @pre This method can be called if @p scip is in one of the following stages:
15176  * - \ref SCIP_STAGE_INITSOLVE
15177  * - \ref SCIP_STAGE_SOLVING
15178  */
15179 extern
15181  SCIP* scip, /**< SCIP data structure */
15182  SCIP_CUTPOOL* cutpool, /**< cut pool */
15183  SCIP_ROW* row /**< cutting plane to add */
15184  );
15185 
15186 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
15187  *
15188  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15189  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15190  *
15191  * @pre This method can be called if @p scip is in one of the following stages:
15192  * - \ref SCIP_STAGE_INITSOLVE
15193  * - \ref SCIP_STAGE_SOLVING
15194  */
15195 extern
15197  SCIP* scip, /**< SCIP data structure */
15198  SCIP_CUTPOOL* cutpool, /**< cut pool */
15199  SCIP_ROW* row /**< cutting plane to add */
15200  );
15201 
15202 /** removes the LP row from a cut pool
15203  *
15204  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15205  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15206  *
15207  * @pre This method can be called if @p scip is in one of the following stages:
15208  * - \ref SCIP_STAGE_INITSOLVE
15209  * - \ref SCIP_STAGE_SOLVING
15210  * - \ref SCIP_STAGE_SOLVED
15211  */
15212 extern
15214  SCIP* scip, /**< SCIP data structure */
15215  SCIP_CUTPOOL* cutpool, /**< cut pool */
15216  SCIP_ROW* row /**< row to remove */
15217  );
15218 
15219 /** separates cuts from a cut pool
15220  *
15221  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15222  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15223  *
15224  * @pre This method can be called if @p scip is in one of the following stages:
15225  * - \ref SCIP_STAGE_SOLVING
15226  */
15227 extern
15229  SCIP* scip, /**< SCIP data structure */
15230  SCIP_CUTPOOL* cutpool, /**< cut pool */
15231  SCIP_RESULT* result /**< pointer to store the result of the separation call */
15232  );
15233 
15234 /** separates cuts w.r.t. given solution from a cut pool
15235  *
15236  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15237  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15238  *
15239  * @pre This method can be called if @p scip is in one of the following stages:
15240  * - \ref SCIP_STAGE_SOLVING
15241  */
15242 extern
15244  SCIP* scip, /**< SCIP data structure */
15245  SCIP_CUTPOOL* cutpool, /**< cut pool */
15246  SCIP_SOL* sol, /**< solution to be separated */
15247  SCIP_RESULT* result /**< pointer to store the result of the separation call */
15248  );
15249 
15250 /** if not already existing, adds row to the delayed global cut pool
15251  *
15252  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15253  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15254  *
15255  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15256  */
15257 extern
15259  SCIP* scip, /**< SCIP data structure */
15260  SCIP_ROW* row /**< cutting plane to add */
15261  );
15262 
15263 /** removes the row from the delayed global cut pool
15264  *
15265  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15266  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15267  *
15268  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15269  */
15270 extern
15272  SCIP* scip, /**< SCIP data structure */
15273  SCIP_ROW* row /**< cutting plane to add */
15274  );
15275 
15276 /** gets current cuts in the delayed global cut pool
15277  *
15278  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15279  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15280  *
15281  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15282  */
15283 extern
15285  SCIP* scip /**< SCIP data structure */
15286  );
15287 
15288 /** gets current number of rows in the delayed global cut pool
15289  *
15290  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15291  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15292  *
15293  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15294  */
15295 extern
15297  SCIP* scip /**< SCIP data structure */
15298  );
15299 
15300 /** gets the delayed global cut pool used by SCIP
15301  *
15302  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15303  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15304  *
15305  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15306  */
15307 extern
15309  SCIP* scip /**< SCIP data structure */
15310  );
15311 
15312 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
15313  * separation methods;
15314  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
15315  * SCIPgetNCuts();
15316  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
15317  * separation storage;
15318  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
15319  * afterwards
15320  *
15321  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15322  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15323  *
15324  * @pre This method can be called if @p scip is in one of the following stages:
15325  * - \ref SCIP_STAGE_SOLVING
15326  */
15327 extern
15329  SCIP* scip, /**< SCIP data structure */
15330  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
15331  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
15332  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
15333  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
15334  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
15335  );
15336 
15337 /** gets the array of cuts currently stored in the separation storage
15338  *
15339  * @return the array of cuts currently stored in the separation storage
15340  *
15341  * @pre This method can be called if @p scip is in one of the following stages:
15342  * - \ref SCIP_STAGE_PRESOLVED
15343  * - \ref SCIP_STAGE_SOLVING
15344  * - \ref SCIP_STAGE_SOLVED
15345  */
15346 extern
15348  SCIP* scip /**< SCIP data structure */
15349  );
15350 
15351 /** get current number of cuts in the separation storage
15352  *
15353  * @return the current number of cuts in the separation storage
15354  *
15355  * @pre This method can be called if @p scip is in one of the following stages:
15356  * - \ref SCIP_STAGE_PRESOLVED
15357  * - \ref SCIP_STAGE_SOLVING
15358  * - \ref SCIP_STAGE_SOLVED
15359  */
15360 extern
15361 int SCIPgetNCuts(
15362  SCIP* scip /**< SCIP data structure */
15363  );
15364 
15365 /** clears the separation storage
15366  *
15367  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15368  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15369  *
15370  * @pre This method can be called if @p scip is in one of the following stages:
15371  * - \ref SCIP_STAGE_SOLVING
15372  */
15373 extern
15375  SCIP* scip /**< SCIP data structure */
15376  );
15377 
15378 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
15379  *
15380  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15381  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15382  *
15383  * @pre This method can be called if @p scip is in one of the following stages:
15384  * - \ref SCIP_STAGE_SOLVING
15385  */
15386 extern
15388  SCIP* scip /**< SCIP data structure */
15389  );
15390 
15391 /** returns current factor on cut infeasibility to limit feasibility tolerance for relaxation solver
15392  *
15393  * Gives value of separating/feastolfac parameter.
15394  *
15395  * @return factor on cut infeasibility to limit feasibility tolerance for relaxation solver
15396  *
15397  * @pre This method can be called if @p scip is in one of the following stages:
15398  * - \ref SCIP_STAGE_SOLVING
15399  */
15400 extern
15402  SCIP* scip /**< SCIP data structure */
15403  );
15404 
15405 /**@} */
15406 
15407 
15408 
15409 
15410 /*
15411  * LP diving methods
15412  */
15413 
15414 /**@addtogroup PublicLPDivingMethods
15415  *
15416  * @{
15417  */
15418 
15419 /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
15420  *
15421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15423  *
15424  * @pre This method can be called if @p scip is in one of the following stages:
15425  * - \ref SCIP_STAGE_SOLVING
15426  *
15427  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15428  *
15429  * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware
15430  * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from
15431  * numerical troubles during the last LP solve; because of this, most users will want to call this method only if
15432  * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL
15433  */
15434 extern
15436  SCIP* scip /**< SCIP data structure */
15437  );
15438 
15439 /** quits LP diving and resets bounds and objective values of columns to the current node's values
15440  *
15441  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15442  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15443  *
15444  * @pre This method can be called if @p scip is in one of the following stages:
15445  * - \ref SCIP_STAGE_SOLVING
15446  *
15447  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15448  */
15449 extern
15451  SCIP* scip /**< SCIP data structure */
15452  );
15453 
15454 /** changes cutoffbound in current dive
15455  *
15456  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15457  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15458  *
15459  * @pre This method can be called if @p scip is in one of the following stages:
15460  * - \ref SCIP_STAGE_SOLVING
15461  *
15462  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15463  */
15464 extern
15466  SCIP* scip, /**< SCIP data structure */
15467  SCIP_Real newcutoffbound /**< new cutoffbound */
15468  );
15469 
15470 /** changes variable's objective value in current dive
15471  *
15472  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15473  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15474  *
15475  * @pre This method can be called if @p scip is in one of the following stages:
15476  * - \ref SCIP_STAGE_SOLVING
15477  *
15478  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15479  */
15480 extern
15482  SCIP* scip, /**< SCIP data structure */
15483  SCIP_VAR* var, /**< variable to change the objective value for */
15484  SCIP_Real newobj /**< new objective value */
15485  );
15486 
15487 /** changes variable's lower bound in current dive
15488  *
15489  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15490  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15491  *
15492  * @pre This method can be called if @p scip is in one of the following stages:
15493  * - \ref SCIP_STAGE_SOLVING
15494  *
15495  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15496  */
15497 extern
15499  SCIP* scip, /**< SCIP data structure */
15500  SCIP_VAR* var, /**< variable to change the bound for */
15501  SCIP_Real newbound /**< new value for bound */
15502  );
15503 
15504 /** changes variable's upper bound in current dive
15505  *
15506  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15507  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15508  *
15509  * @pre This method can be called if @p scip is in one of the following stages:
15510  * - \ref SCIP_STAGE_SOLVING
15511  *
15512  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15513  */
15514 extern
15516  SCIP* scip, /**< SCIP data structure */
15517  SCIP_VAR* var, /**< variable to change the bound for */
15518  SCIP_Real newbound /**< new value for bound */
15519  );
15520 
15521 /** adds a row to the LP in current dive
15522  *
15523  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15524  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15525  *
15526  * @pre This method can be called if @p scip is in one of the following stages:
15527  * - \ref SCIP_STAGE_SOLVING
15528  *
15529  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15530  */
15531 extern
15533  SCIP* scip, /**< SCIP data structure */
15534  SCIP_ROW* row /**< row to be added */
15535  );
15536 
15537 /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
15538  *
15539  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15540  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15541  *
15542  * @pre This method can be called if @p scip is in one of the following stages:
15543  * - \ref SCIP_STAGE_SOLVING
15544  *
15545  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15546  */
15547 extern
15549  SCIP* scip, /**< SCIP data structure */
15550  SCIP_ROW* row, /**< row to change the lhs for */
15551  SCIP_Real newlhs /**< new value for lhs */
15552  );
15553 
15554 /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
15555  *
15556  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15557  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15558  *
15559  * @pre This method can be called if @p scip is in one of the following stages:
15560  * - \ref SCIP_STAGE_SOLVING
15561  *
15562  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15563  */
15564 extern
15566  SCIP* scip, /**< SCIP data structure */
15567  SCIP_ROW* row, /**< row to change the lhs for */
15568  SCIP_Real newrhs /**< new value for rhs */
15569  );
15570 
15571 /** gets variable's objective value in current dive
15572  *
15573  * @return the variable's objective value in current dive.
15574  *
15575  * @pre This method can be called if @p scip is in one of the following stages:
15576  * - \ref SCIP_STAGE_SOLVING
15577  *
15578  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15579  */
15580 extern
15582  SCIP* scip, /**< SCIP data structure */
15583  SCIP_VAR* var /**< variable to get the bound for */
15584  );
15585 
15586 /** gets variable's lower bound in current dive
15587  *
15588  * @return the variable's lower bound in current dive.
15589  *
15590  * @pre This method can be called if @p scip is in one of the following stages:
15591  * - \ref SCIP_STAGE_SOLVING
15592  *
15593  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15594  */
15595 extern
15597  SCIP* scip, /**< SCIP data structure */
15598  SCIP_VAR* var /**< variable to get the bound for */
15599  );
15600 
15601 /** gets variable's upper bound in current dive
15602  *
15603  * @return the variable's upper bound in current dive.
15604  *
15605  * @pre This method can be called if @p scip is in one of the following stages:
15606  * - \ref SCIP_STAGE_SOLVING
15607  *
15608  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15609  */
15610 extern
15612  SCIP* scip, /**< SCIP data structure */
15613  SCIP_VAR* var /**< variable to get the bound for */
15614  );
15615 /** solves the LP of the current dive; no separation or pricing is applied
15616  *
15617  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15618  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15619  *
15620  * @pre This method can be called if @p scip is in one of the following stages:
15621  * - \ref SCIP_STAGE_SOLVING
15622  *
15623  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15624  *
15625  * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL,
15626  * compare the explanation of SCIPstartDive()
15627  */
15628 extern
15630  SCIP* scip, /**< SCIP data structure */
15631  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
15632  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
15633  SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective
15634  * limit was reached (or NULL, if not needed) */
15635  );
15636 
15637 /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving
15638  * or probing mode
15639  *
15640  * @return the number of the node in the current branch and bound run, where the last LP was solved in diving
15641  * or probing mode.
15642  *
15643  * @pre This method can be called if @p scip is in one of the following stages:
15644  * - \ref SCIP_STAGE_TRANSFORMING
15645  * - \ref SCIP_STAGE_TRANSFORMED
15646  * - \ref SCIP_STAGE_INITPRESOLVE
15647  * - \ref SCIP_STAGE_PRESOLVING
15648  * - \ref SCIP_STAGE_EXITPRESOLVE
15649  * - \ref SCIP_STAGE_PRESOLVED
15650  * - \ref SCIP_STAGE_INITSOLVE
15651  * - \ref SCIP_STAGE_SOLVING
15652  * - \ref SCIP_STAGE_SOLVED
15653  * - \ref SCIP_STAGE_EXITSOLVE
15654  * - \ref SCIP_STAGE_FREETRANS
15655  *
15656  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15657  */
15658 extern
15660  SCIP* scip /**< SCIP data structure */
15661  );
15662 
15663 /** returns whether we are in diving mode
15664  *
15665  * @return whether we are in diving mode.
15666  *
15667  * @pre This method can be called if @p scip is in one of the following stages:
15668  * - \ref SCIP_STAGE_TRANSFORMING
15669  * - \ref SCIP_STAGE_TRANSFORMED
15670  * - \ref SCIP_STAGE_INITPRESOLVE
15671  * - \ref SCIP_STAGE_PRESOLVING
15672  * - \ref SCIP_STAGE_EXITPRESOLVE
15673  * - \ref SCIP_STAGE_PRESOLVED
15674  * - \ref SCIP_STAGE_INITSOLVE
15675  * - \ref SCIP_STAGE_SOLVING
15676  * - \ref SCIP_STAGE_SOLVED
15677  * - \ref SCIP_STAGE_EXITSOLVE
15678  * - \ref SCIP_STAGE_FREETRANS
15679  *
15680  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15681  */
15682 extern
15684  SCIP* scip /**< SCIP data structure */
15685  );
15686 
15687 /**@} */
15688 
15689 
15690 
15691 
15692 /*
15693  * probing methods
15694  */
15695 
15696 /**@addtogroup PublicProbingMethods
15697  *
15698  * @{
15699  */
15700 
15701 /** returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped
15702  * via SCIPendProbing()
15703  *
15704  * @return TRUE, if SCIP is currently in probing mode, otherwise FALSE
15705  *
15706  * @pre This method can be called if @p scip is in one of the following stages:
15707  * - \ref SCIP_STAGE_TRANSFORMED
15708  * - \ref SCIP_STAGE_INITPRESOLVE
15709  * - \ref SCIP_STAGE_PRESOLVING
15710  * - \ref SCIP_STAGE_EXITPRESOLVE
15711  * - \ref SCIP_STAGE_PRESOLVED
15712  * - \ref SCIP_STAGE_INITSOLVE
15713  * - \ref SCIP_STAGE_SOLVING
15714  * - \ref SCIP_STAGE_SOLVED
15715  * - \ref SCIP_STAGE_EXITSOLVE
15716  */
15717 extern
15719  SCIP* scip /**< SCIP data structure */
15720  );
15721 
15722 /** initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),
15723  * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available
15724  *
15725  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15726  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15727  *
15728  * @pre This method can be called if @p scip is in one of the following stages:
15729  * - \ref SCIP_STAGE_PRESOLVING
15730  * - \ref SCIP_STAGE_SOLVING
15731  *
15732  * @note The collection of variable statistics is turned off during probing. If these statistics should be collected
15733  * during probing use the method SCIPenableVarHistory() to turn the collection explicitly on.
15734  */
15735 extern
15737  SCIP* scip /**< SCIP data structure */
15738  );
15739 
15740 /** creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path
15741  * with a call to SCIPbacktrackProbing();
15742  * using a sub node for each set of probing bound changes can improve conflict analysis
15743  *
15744  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15745  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15746  *
15747  * @pre This method can be called if @p scip is in one of the following stages:
15748  * - \ref SCIP_STAGE_PRESOLVING
15749  * - \ref SCIP_STAGE_SOLVING
15750  */
15751 extern
15753  SCIP* scip /**< SCIP data structure */
15754  );
15755 
15756 /** returns the current probing depth
15757  *
15758  * @return the probing depth, i.e. the number of probing sub nodes existing in the probing path
15759  *
15760  * @pre This method can be called if @p scip is in one of the following stages:
15761  * - \ref SCIP_STAGE_PRESOLVING
15762  * - \ref SCIP_STAGE_SOLVING
15763  */
15764 extern
15766  SCIP* scip /**< SCIP data structure */
15767  );
15768 
15769 /** undoes all changes to the problem applied in probing up to the given probing depth;
15770  * the changes of the probing node of the given probing depth are the last ones that remain active;
15771  * changes that were applied before calling SCIPnewProbingNode() cannot be undone
15772  *
15773  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15774  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15775  *
15776  * @pre This method can be called if @p scip is in one of the following stages:
15777  * - \ref SCIP_STAGE_PRESOLVING
15778  * - \ref SCIP_STAGE_SOLVING
15779  */
15780 extern
15782  SCIP* scip, /**< SCIP data structure */
15783  int probingdepth /**< probing depth of the node in the probing path that should be reactivated */
15784  );
15785 
15786 /** quits probing and resets bounds and constraints to the focus node's environment
15787  *
15788  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15789  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15790  *
15791  * @pre This method can be called if @p scip is in one of the following stages:
15792  * - \ref SCIP_STAGE_PRESOLVING
15793  * - \ref SCIP_STAGE_SOLVING
15794  */
15795 extern
15797  SCIP* scip /**< SCIP data structure */
15798  );
15799 
15800 /** injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to
15801  * SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
15802  *
15803  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15804  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15805  *
15806  * @pre This method can be called if @p scip is in one of the following stages:
15807  * - \ref SCIP_STAGE_PRESOLVING
15808  * - \ref SCIP_STAGE_SOLVING
15809  */
15810 extern
15812  SCIP* scip, /**< SCIP data structure */
15813  SCIP_VAR* var, /**< variable to change the bound for */
15814  SCIP_Real newbound /**< new value for bound */
15815  );
15816 
15817 /** injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to
15818  * SCIPchgVarUb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
15819  *
15820  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15821  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15822  *
15823  * @pre This method can be called if @p scip is in one of the following stages:
15824  * - \ref SCIP_STAGE_PRESOLVING
15825  * - \ref SCIP_STAGE_SOLVING
15826  */
15827 extern
15829  SCIP* scip, /**< SCIP data structure */
15830  SCIP_VAR* var, /**< variable to change the bound for */
15831  SCIP_Real newbound /**< new value for bound */
15832  );
15833 
15834 /** gets variable's objective value in current probing
15835  *
15836  * @return the variable's objective value in current probing.
15837  *
15838  * @pre This method can be called if @p scip is in one of the following stages:
15839  * - \ref SCIP_STAGE_SOLVING
15840  *
15841  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15842  */
15843 extern
15845  SCIP* scip, /**< SCIP data structure */
15846  SCIP_VAR* var /**< variable to get the bound for */
15847  );
15848 
15849 /** injects a change of variable's bounds into current probing node to fix the variable to the specified value;
15850  * the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated
15851  * like deductions instead of branching decisions
15852  *
15853  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15854  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15855  *
15856  * @pre This method can be called if @p scip is in one of the following stages:
15857  * - \ref SCIP_STAGE_PRESOLVING
15858  * - \ref SCIP_STAGE_SOLVING
15859  */
15860 extern
15862  SCIP* scip, /**< SCIP data structure */
15863  SCIP_VAR* var, /**< variable to change the bound for */
15864  SCIP_Real fixedval /**< value to fix variable to */
15865  );
15866 
15867 /** changes (column) variable's objective value during probing mode
15868  *
15869  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15870  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15871  *
15872  * @pre This method can be called if @p scip is in one of the following stages:
15873  * - \ref SCIP_STAGE_PRESOLVING
15874  * - \ref SCIP_STAGE_SOLVING
15875  *
15876  * @pre The variable needs to be a column variable.
15877  */
15878 extern
15880  SCIP* scip, /**< SCIP data structure */
15881  SCIP_VAR* var, /**< variable to change the objective for */
15882  SCIP_Real newobj /**< new objective function value */
15883  );
15884 
15885 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
15886  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
15887  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
15888  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
15889  *
15890  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15891  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15892  *
15893  * @pre This method can be called if @p scip is in one of the following stages:
15894  * - \ref SCIP_STAGE_PRESOLVING
15895  * - \ref SCIP_STAGE_SOLVING
15896  */
15897 extern
15899  SCIP* scip, /**< SCIP data structure */
15900  int maxproprounds, /**< maximal number of propagation rounds (-1: no limit, 0: parameter settings) */
15901  SCIP_Bool* cutoff, /**< pointer to store whether the probing node can be cut off */
15902  SCIP_Longint* ndomredsfound /**< pointer to store the number of domain reductions found, or NULL */
15903  );
15904 
15905 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
15906  * only propagations of the binary variables fixed at the current probing node that are triggered by the implication
15907  * graph and the clique table are applied;
15908  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
15909  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
15910  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
15911  *
15912  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15913  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15914  *
15915  * @pre This method can be called if @p scip is in one of the following stages:
15916  * - \ref SCIP_STAGE_PRESOLVING
15917  * - \ref SCIP_STAGE_SOLVING
15918  */
15919 extern
15921  SCIP* scip, /**< SCIP data structure */
15922  SCIP_Bool* cutoff /**< pointer to store whether the probing node can be cut off */
15923  );
15924 
15925 /** solves the LP at the current probing node (cannot be applied at preprocessing stage);
15926  * no separation or pricing is applied
15927  *
15928  * The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()).
15929  *
15930  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15931  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15932  *
15933  * @pre This method can be called if @p scip is in one of the following stages:
15934  * - \ref SCIP_STAGE_SOLVING
15935  */
15936 extern
15938  SCIP* scip, /**< SCIP data structure */
15939  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
15940  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
15941  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
15942  * limit was reached (or NULL, if not needed) */
15943  );
15944 
15945 /** solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing
15946  * until the LP is solved to optimality; no separation is applied
15947  *
15948  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See \ref
15949  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15950  *
15951  * @pre This method can be called if @p scip is in one of the following stages:
15952  * - \ref SCIP_STAGE_SOLVING
15953  */
15954 extern
15956  SCIP* scip, /**< SCIP data structure */
15957  SCIP_Bool pretendroot, /**< should the pricers be called as if we are at the root node? */
15958  SCIP_Bool displayinfo, /**< should info lines be displayed after each pricing round? */
15959  int maxpricerounds, /**< maximal number of pricing rounds (-1: no limit);
15960  * a finite limit means that the LP might not be solved to optimality! */
15961  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
15962  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
15963  * limit was reached (or NULL, if not needed) */
15964 
15965  );
15966 
15967 /** adds a row to the LP in the current probing node
15968  *
15969  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15970  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15971  *
15972  * @pre This method can be called if @p scip is in one of the following stages:
15973  * - \ref SCIP_STAGE_SOLVING
15974  *
15975  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15976  */
15977 extern
15979  SCIP* scip, /**< SCIP data structure */
15980  SCIP_ROW* row /**< row to be added */
15981  );
15982 
15983 /** applies the cuts in the separation storage to the LP and clears the storage afterwards;
15984  * this method can only be applied during probing; the user should resolve the probing LP afterwards
15985  * in order to get a new solution
15986  *
15987  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15988  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15989  *
15990  * @pre This method can be called if @p scip is in one of the following stages:
15991  * - \ref SCIP_STAGE_SOLVING
15992  */
15993 extern
15995  SCIP* scip, /**< SCIP data structure */
15996  SCIP_Bool* cutoff /**< pointer to store whether an empty domain was created */
15997  );
15998 
15999 /** solves relaxation(s) at the current probing node (cannot be applied at preprocessing stage);
16000  * no separation or pricing is applied
16001  *
16002  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16003  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16004  *
16005  * @pre This method can be called if @p scip is in one of the following stages:
16006  * - \ref SCIP_STAGE_SOLVING
16007  */
16008 extern
16010  SCIP* scip, /**< SCIP data structure */
16011  SCIP_Bool* cutoff /**< pointer to store whether a relaxation was infeasible or the objective
16012  * limit was reached (or NULL, if not needed) */
16013  );
16014 
16015 /** stores the candidate score and preferred rounding direction for a candidate variable */
16016 extern
16018  SCIP* scip, /**< SCIP data structure */
16019  SCIP_DIVESET* diveset, /**< general diving settings */
16020  SCIP_DIVETYPE divetype, /**< represents different methods for a dive set to explore the next children */
16021  SCIP_VAR* divecand, /**< the candidate for which the branching direction is requested */
16022  SCIP_Real divecandsol, /**< LP solution value of the candidate */
16023  SCIP_Real divecandfrac, /**< fractionality of the candidate */
16024  SCIP_Real* candscore, /**< pointer to store the candidate score */
16025  SCIP_Bool* roundup /**< pointer to store whether preferred direction for diving is upwards */
16026  );
16027 
16028 /** update diveset LP statistics, should be called after every LP solved by this diving heuristic */
16029 extern
16031  SCIP* scip, /**< SCIP data structure */
16032  SCIP_DIVESET* diveset, /**< diving settings */
16033  SCIP_Longint niterstoadd /**< additional number of LP iterations to be added */
16034  );
16035 
16036 /** update diveset statistics and global diveset statistics */
16037 extern
16039  SCIP* scip, /**< SCIP data structure */
16040  SCIP_DIVESET* diveset, /**< diveset to be reset */
16041  int nprobingnodes, /**< the number of probing nodes explored this time */
16042  int nbacktracks, /**< the number of backtracks during probing this time */
16043  SCIP_Longint nsolsfound, /**< the number of solutions found */
16044  SCIP_Longint nbestsolsfound, /**< the number of best solutions found */
16045  SCIP_Bool leavewassol /**< was a solution found at the leaf? */
16046  );
16047 
16048 /** enforces a probing/diving solution by suggesting bound changes that maximize the score w.r.t. the current diving settings
16049  *
16050  * the process is guided by the enforcement priorities of the constraint handlers and the scoring mechanism provided by
16051  * the dive set.
16052  * Constraint handlers may suggest diving bound changes in decreasing order of their enforcement priority, based on the
16053  * solution values in the solution @p sol and the current local bounds of the variables. A diving bound change
16054  * is a triple (variable,branching direction,value) and is used inside SCIPperformGenericDivingAlgorithm().
16055  *
16056  * After a successful call, SCIP holds two arrays of suggested dive bound changes, one for the preferred child
16057  * and one for the alternative.
16058  *
16059  * @see SCIPgetDiveBoundChangeData() for retrieving the dive bound change suggestions.
16060  *
16061  * The method stops after the first constraint handler was successful
16062  *
16063  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16064  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16065  *
16066  * @pre This method can be called if @p scip is in one of the following stages:
16067  * - \ref SCIP_STAGE_SOLVING
16068  *
16069  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16070  */
16071 extern
16073  SCIP* scip, /**< SCIP data structure */
16074  SCIP_DIVESET* diveset, /**< diving settings to control scoring */
16075  SCIP_SOL* sol, /**< current solution of diving mode */
16076  SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */
16077  SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */
16078  );
16079 
16080 /** adds a diving bound change to the diving bound change storage of SCIP together with the information if this is a
16081  * bound change for the preferred direction or not
16082  *
16083  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16084  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16085  *
16086  * @pre This method can be called if @p scip is in one of the following stages:
16087  * - \ref SCIP_STAGE_SOLVING
16088  *
16089  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16090  */
16091 extern
16093  SCIP* scip, /**< SCIP data structure */
16094  SCIP_VAR* var, /**< variable to apply the bound change to */
16095  SCIP_BRANCHDIR dir, /**< direction of the bound change */
16096  SCIP_Real value, /**< value to adjust this variable bound to */
16097  SCIP_Bool preferred /**< is this a bound change for the preferred child? */
16098  );
16099 
16100 /** get the dive bound change data for the preferred or the alternative direction
16101  *
16102  * @pre This method can be called if @p scip is in one of the following stages:
16103  * - \ref SCIP_STAGE_SOLVING
16104  *
16105  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16106  */
16107 extern
16109  SCIP* scip, /**< SCIP data structure */
16110  SCIP_VAR*** variables, /**< pointer to store variables for the specified direction */
16111  SCIP_BRANCHDIR** directions, /**< pointer to store the branching directions */
16112  SCIP_Real** values, /**< pointer to store bound change values */
16113  int* ndivebdchgs, /**< pointer to store the number of dive bound changes */
16114  SCIP_Bool preferred /**< should the dive bound changes for the preferred child be output? */
16115  );
16116 
16117 /** clear the dive bound change data structures
16118  *
16119  * @pre This method can be called if @p scip is in one of the following stages:
16120  * - \ref SCIP_STAGE_SOLVING
16121  *
16122  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16123  */
16124 extern
16126  SCIP* scip /**< SCIP data structure */
16127  );
16128 
16129 /**@} */
16130 
16131 /*
16132  * branching methods
16133  */
16134 
16135 /**@addtogroup PublicBranchingMethods
16136  *
16137  * @{
16138  */
16139 
16140 /** gets branching candidates for LP solution branching (fractional variables) along with solution values,
16141  * fractionalities, and number of branching candidates; The number of branching candidates does NOT
16142  * account for fractional implicit integer variables which should not be used for branching decisions.
16143  *
16144  * Fractional implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1
16145  *
16146  * branching rules should always select the branching candidate among the first npriolpcands of the candidate
16147  * list
16148  *
16149  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16150  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16151  *
16152  * @pre This method can be called if @p scip is in one of the following stages:
16153  * - \ref SCIP_STAGE_SOLVING
16154  *
16155  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16156  */
16157 extern
16159  SCIP* scip, /**< SCIP data structure */
16160  SCIP_VAR*** lpcands, /**< pointer to store the array of LP branching candidates, or NULL */
16161  SCIP_Real** lpcandssol, /**< pointer to store the array of LP candidate solution values, or NULL */
16162  SCIP_Real** lpcandsfrac, /**< pointer to store the array of LP candidate fractionalities, or NULL */
16163  int* nlpcands, /**< pointer to store the number of LP branching candidates, or NULL */
16164  int* npriolpcands, /**< pointer to store the number of candidates with maximal priority, or NULL */
16165  int* nfracimplvars /**< pointer to store the number of fractional implicit integer variables, or NULL */
16166  );
16167 
16168 /** gets number of branching candidates for LP solution branching (number of fractional variables)
16169  *
16170  * @return the number of branching candidates for LP solution branching (number of fractional variables).
16171  *
16172  * @pre This method can be called if @p scip is in one of the following stages:
16173  * - \ref SCIP_STAGE_SOLVING
16174  *
16175  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16176  */
16177 extern
16179  SCIP* scip /**< SCIP data structure */
16180  );
16181 
16182 /** gets number of branching candidates with maximal priority for LP solution branching
16183  *
16184  * @return the number of branching candidates with maximal priority for LP solution branching.
16185  *
16186  * @pre This method can be called if @p scip is in one of the following stages:
16187  * - \ref SCIP_STAGE_SOLVING
16188  *
16189  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16190  */
16191 extern
16193  SCIP* scip /**< SCIP data structure */
16194  );
16195 
16196 /** gets external branching candidates along with solution values, scores, and number of branching candidates;
16197  * these branching candidates can be used by relaxations or nonlinear constraint handlers;
16198  * branching rules should always select the branching candidate among the first nprioexterncands of the candidate
16199  * list
16200  *
16201  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16202  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16203  *
16204  * @pre This method can be called if @p scip is in one of the following stages:
16205  * - \ref SCIP_STAGE_SOLVING
16206  *
16207  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16208  *
16209  * @note Candidate variables with maximal priority are ordered: binaries first, then integers, implicit integers and
16210  * continuous last.
16211  */
16212 extern
16214  SCIP* scip, /**< SCIP data structure */
16215  SCIP_VAR*** externcands, /**< pointer to store the array of extern branching candidates, or NULL */
16216  SCIP_Real** externcandssol, /**< pointer to store the array of extern candidate solution values, or NULL */
16217  SCIP_Real** externcandsscore, /**< pointer to store the array of extern candidate scores, or NULL */
16218  int* nexterncands, /**< pointer to store the number of extern branching candidates, or NULL */
16219  int* nprioexterncands, /**< pointer to store the number of candidates with maximal priority, or NULL */
16220  int* nprioexternbins, /**< pointer to store the number of binary candidates with maximal priority, or NULL */
16221  int* nprioexternints, /**< pointer to store the number of integer candidates with maximal priority, or NULL */
16222  int* nprioexternimpls /**< pointer to store the number of implicit integer candidates with maximal priority,
16223  * or NULL */
16224  );
16225 
16226 /** gets number of external branching candidates
16227  *
16228  * @return the number of external branching candidates.
16229  *
16230  * @pre This method can be called if @p scip is in one of the following stages:
16231  * - \ref SCIP_STAGE_SOLVING
16232  *
16233  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16234  */
16235 extern
16237  SCIP* scip /**< SCIP data structure */
16238  );
16239 
16240 /** gets number of external branching candidates with maximal branch priority
16241  *
16242  * @return the number of external branching candidates with maximal branch priority.
16243  *
16244  * @pre This method can be called if @p scip is in one of the following stages:
16245  * - \ref SCIP_STAGE_SOLVING
16246  *
16247  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16248  */
16249 extern
16251  SCIP* scip /**< SCIP data structure */
16252  );
16253 
16254 /** gets number of binary external branching candidates with maximal branch priority
16255  *
16256  * @return the number of binary external branching candidates with maximal branch priority.
16257  *
16258  * @pre This method can be called if @p scip is in one of the following stages:
16259  * - \ref SCIP_STAGE_SOLVING
16260  *
16261  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16262  */
16263 extern
16265  SCIP* scip /**< SCIP data structure */
16266  );
16267 
16268 /** gets number of integer external branching candidates with maximal branch priority
16269  *
16270  * @return the number of integer external branching candidates with maximal branch priority.
16271  *
16272  * @pre This method can be called if @p scip is in one of the following stages:
16273  * - \ref SCIP_STAGE_SOLVING
16274  *
16275  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16276  */
16277 extern
16279  SCIP* scip /**< SCIP data structure */
16280  );
16281 
16282 /** gets number of implicit integer external branching candidates with maximal branch priority
16283  *
16284  * @return the number of implicit integer external branching candidates with maximal branch priority.
16285  *
16286  * @pre This method can be called if @p scip is in one of the following stages:
16287  * - \ref SCIP_STAGE_SOLVING
16288  *
16289  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16290  */
16291 extern
16293  SCIP* scip /**< SCIP data structure */
16294  );
16295 
16296 /** gets number of continuous external branching candidates with maximal branch priority
16297  *
16298  * @return the number of continuous external branching candidates with maximal branch priority.
16299  *
16300  * @pre This method can be called if @p scip is in one of the following stages:
16301  * - \ref SCIP_STAGE_SOLVING
16302  *
16303  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16304  */
16305 extern
16307  SCIP* scip /**< SCIP data structure */
16308  );
16309 
16310 /** insert variable, its score and its solution value into the external branching candidate storage
16311  * the relative difference of the current lower and upper bounds of a continuous variable must be at least epsilon
16312  *
16313  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16314  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16315  *
16316  * @pre This method can be called if @p scip is in one of the following stages:
16317  * - \ref SCIP_STAGE_SOLVING
16318  *
16319  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16320  */
16321 extern
16323  SCIP* scip, /**< SCIP data structure */
16324  SCIP_VAR* var, /**< variable to insert */
16325  SCIP_Real score, /**< score of external candidate, e.g. infeasibility */
16326  SCIP_Real solval /**< value of the variable in the current solution */
16327  );
16328 
16329 /** removes all external candidates from the storage for external branching
16330  *
16331  * @pre This method can be called if @p scip is in one of the following stages:
16332  * - \ref SCIP_STAGE_SOLVING
16333  *
16334  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16335  */
16336 extern
16338  SCIP* scip /**< SCIP data structure */
16339  );
16340 
16341 /** checks whether the given variable is contained in the candidate storage for external branching
16342  *
16343  * @return whether the given variable is contained in the candidate storage for external branching.
16344  *
16345  * @pre This method can be called if @p scip is in one of the following stages:
16346  * - \ref SCIP_STAGE_SOLVING
16347  *
16348  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16349  */
16350 extern
16352  SCIP* scip, /**< SCIP data structure */
16353  SCIP_VAR* var /**< variable to look for */
16354  );
16355 
16356 /** gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates
16357  *
16358  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16359  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16360  *
16361  * @pre This method can be called if @p scip is in one of the following stages:
16362  * - \ref SCIP_STAGE_PRESOLVING
16363  * - \ref SCIP_STAGE_SOLVING
16364  *
16365  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16366  */
16367 extern
16369  SCIP* scip, /**< SCIP data structure */
16370  SCIP_VAR*** pseudocands, /**< pointer to store the array of pseudo branching candidates, or NULL */
16371  int* npseudocands, /**< pointer to store the number of pseudo branching candidates, or NULL */
16372  int* npriopseudocands /**< pointer to store the number of candidates with maximal priority, or NULL */
16373  );
16374 
16375 /** gets number of branching candidates for pseudo solution branching (non-fixed variables)
16376  *
16377  * @return the number branching candidates for pseudo solution branching (non-fixed variables).
16378  *
16379  * @pre This method can be called if @p scip is in one of the following stages:
16380  * - \ref SCIP_STAGE_PRESOLVING
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  );
16389 
16390 /** gets number of branching candidates with maximal branch priority for pseudo solution branching
16391  *
16392  * @return the number of branching candidates with maximal branch priority for pseudo solution branching.
16393  *
16394  * @pre This method can be called if @p scip is in one of the following stages:
16395  * - \ref SCIP_STAGE_PRESOLVING
16396  * - \ref SCIP_STAGE_SOLVING
16397  *
16398  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16399  */
16400 extern
16402  SCIP* scip /**< SCIP data structure */
16403  );
16404 
16405 /** gets number of binary branching candidates with maximal branch priority for pseudo solution branching
16406  *
16407  * @return the number of binary branching candidates with maximal branch priority for pseudo solution branching.
16408  *
16409  * @pre This method can be called if @p scip is in one of the following stages:
16410  * - \ref SCIP_STAGE_SOLVING
16411  *
16412  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16413  */
16414 extern
16416  SCIP* scip /**< SCIP data structure */
16417  );
16418 
16419 /** gets number of integer branching candidates with maximal branch priority for pseudo solution branching
16420  *
16421  * @return the number of integer branching candidates with maximal branch priority for pseudo solution branching.
16422  *
16423  * @pre This method can be called if @p scip is in one of the following stages:
16424  * - \ref SCIP_STAGE_SOLVING
16425  *
16426  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16427  */
16428 extern
16430  SCIP* scip /**< SCIP data structure */
16431  );
16432 
16433 /** gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching
16434  *
16435  * @return the number of implicit integer branching candidates with maximal branch priority for pseudo solution branching.
16436  *
16437  * @pre This method can be called if @p scip is in one of the following stages:
16438  * - \ref SCIP_STAGE_SOLVING
16439  *
16440  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16441  */
16442 extern
16444  SCIP* scip /**< SCIP data structure */
16445  );
16446 
16447 /** calculates the branching score out of the gain predictions for a binary branching
16448  *
16449  * @return the branching score out of the gain predictions for a binary branching.
16450  *
16451  * @pre This method can be called if @p scip is in one of the following stages:
16452  * - \ref SCIP_STAGE_SOLVING
16453  *
16454  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16455  */
16456 extern
16458  SCIP* scip, /**< SCIP data structure */
16459  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
16460  SCIP_Real downgain, /**< prediction of objective gain for rounding downwards */
16461  SCIP_Real upgain /**< prediction of objective gain for rounding upwards */
16462  );
16463 
16464 /** calculates the branching score out of the gain predictions for a branching with arbitrary many children
16465  *
16466  * @return the branching score out of the gain predictions for a branching with arbitrary many children.
16467  *
16468  * @pre This method can be called if @p scip is in one of the following stages:
16469  * - \ref SCIP_STAGE_SOLVING
16470  *
16471  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16472  */
16473 extern
16475  SCIP* scip, /**< SCIP data structure */
16476  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
16477  int nchildren, /**< number of children that the branching will create */
16478  SCIP_Real* gains /**< prediction of objective gain for each child */
16479  );
16480 
16481 /** computes a branching point for a continuous or discrete variable
16482  *
16483  * @see SCIPbranchGetBranchingPoint
16484  *
16485  * @return the branching point for a continuous or discrete variable.
16486  *
16487  * @pre This method can be called if @p scip is in one of the following stages:
16488  * - \ref SCIP_STAGE_SOLVING
16489  *
16490  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16491  */
16492 extern
16494  SCIP* scip, /**< SCIP data structure */
16495  SCIP_VAR* var, /**< variable, of which the branching point should be computed */
16496  SCIP_Real suggestion /**< suggestion for branching point, or SCIP_INVALID if no suggestion */
16497  );
16498 
16499 /** calculates the node selection priority for moving the given variable's LP value to the given target value;
16500  * this node selection priority can be given to the SCIPcreateChild() call
16501  *
16502  * @return the node selection priority for moving the given variable's LP value to the given target value.
16503  *
16504  * @pre This method can be called if @p scip is in one of the following stages:
16505  * - \ref SCIP_STAGE_SOLVING
16506  *
16507  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16508  */
16509 extern
16511  SCIP* scip, /**< SCIP data structure */
16512  SCIP_VAR* var, /**< variable on which the branching is applied */
16513  SCIP_BRANCHDIR branchdir, /**< type of branching that was performed: upwards, downwards, or fixed;
16514  * fixed should only be used, when both bounds changed
16515  */
16516  SCIP_Real targetvalue /**< new value of the variable in the child node */
16517  );
16518 
16519 /** calculates an estimate for the objective of the best feasible solution contained in the subtree after applying the given
16520  * branching; this estimate can be given to the SCIPcreateChild() call
16521  *
16522  * @return the estimate for the objective of the best feasible solution contained in the subtree after applying the given
16523  * branching.
16524  *
16525  * @pre This method can be called if @p scip is in one of the following stages:
16526  * - \ref SCIP_STAGE_SOLVING
16527  *
16528  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16529  */
16530 extern
16532  SCIP* scip, /**< SCIP data structure */
16533  SCIP_VAR* var, /**< variable on which the branching is applied */
16534  SCIP_Real targetvalue /**< new value of the variable in the child node */
16535  );
16536 
16537 /** creates a child node of the focus node
16538  *
16539  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16540  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16541  *
16542  * @pre This method can be called if @p scip is in one of the following stages:
16543  * - \ref SCIP_STAGE_SOLVING
16544  *
16545  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16546  */
16547 extern
16549  SCIP* scip, /**< SCIP data structure */
16550  SCIP_NODE** node, /**< pointer to node data structure */
16551  SCIP_Real nodeselprio, /**< node selection priority of new node */
16552  SCIP_Real estimate /**< estimate for (transformed) objective value of best feasible solution in subtree */
16553  );
16554 
16555 /** branches on a non-continuous variable v using the current LP or pseudo solution;
16556  * if solution value x' is fractional, two child nodes will be created
16557  * (x <= floor(x'), x >= ceil(x')),
16558  * if solution value is integral, the x' is equal to lower or upper bound of the branching
16559  * variable and the bounds of v are finite, then two child nodes will be created
16560  * (x <= x'', x >= x''+1 with x'' = floor((lb + ub)/2)),
16561  * otherwise (up to) three child nodes will be created
16562  * (x <= x'-1, x == x', x >= x'+1)
16563  *
16564  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16565  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16566  *
16567  * @pre This method can be called if @p scip is in one of the following stages:
16568  * - \ref SCIP_STAGE_SOLVING
16569  *
16570  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16571  */
16572 extern
16574  SCIP* scip, /**< SCIP data structure */
16575  SCIP_VAR* var, /**< variable to branch on */
16576  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
16577  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
16578  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
16579  );
16580 
16581 /** branches a variable x using a given domain hole; two child nodes (x <= left, x >= right) are created
16582  *
16583  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16584  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16585  *
16586  * @pre This method can be called if @p scip is in one of the following stages:
16587  * - \ref SCIP_STAGE_SOLVING
16588  *
16589  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16590  */
16591 extern
16593  SCIP* scip, /**< SCIP data structure */
16594  SCIP_VAR* var, /**< variable to branch on */
16595  SCIP_Real left, /**< left side of the domain hole */
16596  SCIP_Real right, /**< right side of the domain hole */
16597  SCIP_NODE** downchild, /**< pointer to return the left child (x <= left), or NULL */
16598  SCIP_NODE** upchild /**< pointer to return the right child (x >= right), or NULL */
16599  );
16600 
16601 /** branches on a variable x using a given value x';
16602  * for continuous variables with relative domain width larger epsilon, x' must not be one of the bounds;
16603  * two child nodes (x <= x', x >= x') are created;
16604  * for integer variables, if solution value x' is fractional, two child nodes are created
16605  * (x <= floor(x'), x >= ceil(x')),
16606  * if x' is integral, three child nodes are created
16607  * (x <= x'-1, x == x', x >= x'+1)
16608  *
16609  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16610  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16611  *
16612  * @pre This method can be called if @p scip is in one of the following stages:
16613  * - \ref SCIP_STAGE_SOLVING
16614  *
16615  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16616  */
16617 extern
16619  SCIP* scip, /**< SCIP data structure */
16620  SCIP_VAR* var, /**< variable to branch on */
16621  SCIP_Real val, /**< value to branch on */
16622  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
16623  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
16624  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
16625  );
16626 
16627 /** n-ary branching on a variable x using a given value
16628  *
16629  * Branches on variable x such that up to n/2 children are created on each side of the usual branching value.
16630  * The branching value is selected as in SCIPbranchVarVal().
16631  * The parameters minwidth and widthfactor determine the domain width of the branching variable in the child nodes.
16632  * If n is odd, one child with domain width 'width' and having the branching value in the middle is created.
16633  * Otherwise, two children with domain width 'width' and being left and right of the branching value are created.
16634  * Next further nodes to the left and right are created, where width is multiplied by widthfactor with increasing distance
16635  * from the first nodes.
16636  * The initial width is calculated such that n/2 nodes are created to the left and to the right of the branching value.
16637  * If this value is below minwidth, the initial width is set to minwidth, which may result in creating less than n nodes.
16638  *
16639  * Giving a large value for widthfactor results in creating children with small domain when close to the branching value
16640  * and large domain when closer to the current variable bounds. That is, setting widthfactor to a very large value and n to 3
16641  * results in a ternary branching where the branching variable is mostly fixed in the middle child.
16642  * Setting widthfactor to 1.0 results in children where the branching variable always has the same domain width
16643  * (except for one child if the branching value is not in the middle).
16644  *
16645  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16646  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16647  *
16648  * @pre This method can be called if @p scip is in one of the following stages:
16649  * - \ref SCIP_STAGE_SOLVING
16650  *
16651  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16652  */
16653 extern
16655  SCIP* scip, /**< SCIP data structure */
16656  SCIP_VAR* var, /**< variable to branch on */
16657  SCIP_Real val, /**< value to branch on */
16658  int n, /**< attempted number of children to be created, must be >= 2 */
16659  SCIP_Real minwidth, /**< minimal domain width in children */
16660  SCIP_Real widthfactor, /**< multiplier for children domain width with increasing distance from val, must be >= 1.0 */
16661  int* nchildren /**< pointer to store number of created children, or NULL */
16662  );
16663 
16664 /** calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN;
16665  * if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional
16666  * variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority
16667  *
16668  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16669  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16670  *
16671  * @pre This method can be called if @p scip is in one of the following stages:
16672  * - \ref SCIP_STAGE_SOLVING
16673  *
16674  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16675  */
16676 extern
16678  SCIP* scip, /**< SCIP data structure */
16679  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16680  );
16681 
16682 /** calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN
16683  *
16684  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16685  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
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  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16696  );
16697 
16698 /** calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN
16699  *
16700  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16701  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16702  *
16703  * @pre This method can be called if @p scip is in one of the following stages:
16704  * - \ref SCIP_STAGE_SOLVING
16705  *
16706  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16707  */
16708 extern
16710  SCIP* scip, /**< SCIP data structure */
16711  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16712  );
16713 
16714 /**@} */
16715 
16716 
16717 
16718 
16719 /*
16720  * primal solutions
16721  */
16722 
16723 /**@addtogroup PublicSolutionMethods
16724  *
16725  * @{
16726  */
16727 
16728 /** creates a primal solution, initialized to zero
16729  *
16730  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16731  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16732  *
16733  * @pre This method can be called if SCIP is in one of the following stages:
16734  * - \ref SCIP_STAGE_PROBLEM
16735  * - \ref SCIP_STAGE_TRANSFORMING
16736  * - \ref SCIP_STAGE_TRANSFORMED
16737  * - \ref SCIP_STAGE_INITPRESOLVE
16738  * - \ref SCIP_STAGE_PRESOLVING
16739  * - \ref SCIP_STAGE_EXITPRESOLVE
16740  * - \ref SCIP_STAGE_PRESOLVED
16741  * - \ref SCIP_STAGE_INITSOLVE
16742  * - \ref SCIP_STAGE_SOLVING
16743  */
16744 extern
16746  SCIP* scip, /**< SCIP data structure */
16747  SCIP_SOL** sol, /**< pointer to store the solution */
16748  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16749  );
16750 
16751 /** creates a primal solution, initialized to the current LP solution
16752  *
16753  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16754  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16755  *
16756  * @pre This method can be called if SCIP is in one of the following stages:
16757  * - \ref SCIP_STAGE_SOLVING
16758  */
16759 extern
16761  SCIP* scip, /**< SCIP data structure */
16762  SCIP_SOL** sol, /**< pointer to store the solution */
16763  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16764  );
16765 
16766 /** creates a primal solution, initialized to the current NLP solution
16767  *
16768  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16769  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16770  *
16771  * @pre This method can be called if SCIP is in one of the following stages:
16772  * - \ref SCIP_STAGE_SOLVING
16773  */
16774 extern
16776  SCIP* scip, /**< SCIP data structure */
16777  SCIP_SOL** sol, /**< pointer to store the solution */
16778  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16779  );
16780 
16781 /** creates a primal solution, initialized to the current relaxation solution
16782  *
16783  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16784  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16785  *
16786  * @pre This method can be called if SCIP is in one of the following stages:
16787  * - \ref SCIP_STAGE_SOLVING
16788  */
16789 extern
16791  SCIP* scip, /**< SCIP data structure */
16792  SCIP_SOL** sol, /**< pointer to store the solution */
16793  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16794  );
16795 
16796 /** creates a primal solution, initialized to the current pseudo solution
16797  *
16798  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16799  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16800  *
16801  * @pre This method can be called if SCIP is in one of the following stages:
16802  * - \ref SCIP_STAGE_SOLVING
16803  */
16804 extern
16806  SCIP* scip, /**< SCIP data structure */
16807  SCIP_SOL** sol, /**< pointer to store the solution */
16808  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16809  );
16810 
16811 /** creates a primal solution, initialized to the current LP or pseudo solution, depending on whether the LP was solved
16812  * at the current node
16813  *
16814  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16815  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16816  *
16817  * @pre This method can be called if SCIP is in one of the following stages:
16818  * - \ref SCIP_STAGE_SOLVING
16819  */
16820 extern
16822  SCIP* scip, /**< SCIP data structure */
16823  SCIP_SOL** sol, /**< pointer to store the solution */
16824  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16825  );
16826 
16827 /** creates a partial primal solution, initialized to unknown values
16828  *
16829  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16830  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16831  *
16832  * @pre This method can be called if SCIP is in one of the following stages:
16833  * - \ref SCIP_STAGE_PROBLEM
16834  */
16835 extern
16837  SCIP* scip, /**< SCIP data structure */
16838  SCIP_SOL** sol, /**< pointer to store the solution */
16839  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16840  );
16841 
16842 /** creates a primal solution, initialized to unknown values
16843  *
16844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16846  *
16847  * @pre This method can be called if SCIP is in one of the following stages:
16848  * - \ref SCIP_STAGE_TRANSFORMING
16849  * - \ref SCIP_STAGE_TRANSFORMED
16850  * - \ref SCIP_STAGE_INITPRESOLVE
16851  * - \ref SCIP_STAGE_PRESOLVING
16852  * - \ref SCIP_STAGE_EXITPRESOLVE
16853  * - \ref SCIP_STAGE_PRESOLVED
16854  * - \ref SCIP_STAGE_INITSOLVE
16855  * - \ref SCIP_STAGE_SOLVING
16856  */
16857 extern
16859  SCIP* scip, /**< SCIP data structure */
16860  SCIP_SOL** sol, /**< pointer to store the solution */
16861  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16862  );
16863 
16864 /** creates a primal solution living in the original problem space, initialized to zero;
16865  * a solution in original space allows to set original variables to values that would be invalid in the
16866  * transformed problem due to preprocessing fixings or aggregations
16867  *
16868  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16869  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16870  *
16871  * @pre This method can be called if SCIP is in one of the following stages:
16872  * - \ref SCIP_STAGE_PROBLEM
16873  * - \ref SCIP_STAGE_TRANSFORMING
16874  * - \ref SCIP_STAGE_TRANSFORMED
16875  * - \ref SCIP_STAGE_INITPRESOLVE
16876  * - \ref SCIP_STAGE_PRESOLVING
16877  * - \ref SCIP_STAGE_EXITPRESOLVE
16878  * - \ref SCIP_STAGE_PRESOLVED
16879  * - \ref SCIP_STAGE_INITSOLVE
16880  * - \ref SCIP_STAGE_SOLVING
16881  */
16882 extern
16884  SCIP* scip, /**< SCIP data structure */
16885  SCIP_SOL** sol, /**< pointer to store the solution */
16886  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16887  );
16888 
16889 /** creates a copy of a primal solution; note that a copy of a linked solution is also linked and needs to be unlinked
16890  * if it should stay unaffected from changes in the LP or pseudo solution
16891  *
16892  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16893  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16894  *
16895  * @pre This method can be called if SCIP is in one of the following stages:
16896  * - \ref SCIP_STAGE_PROBLEM
16897  * - \ref SCIP_STAGE_TRANSFORMING
16898  * - \ref SCIP_STAGE_TRANSFORMED
16899  * - \ref SCIP_STAGE_INITPRESOLVE
16900  * - \ref SCIP_STAGE_PRESOLVING
16901  * - \ref SCIP_STAGE_EXITPRESOLVE
16902  * - \ref SCIP_STAGE_PRESOLVED
16903  * - \ref SCIP_STAGE_INITSOLVE
16904  * - \ref SCIP_STAGE_SOLVING
16905  */
16906 extern
16908  SCIP* scip, /**< SCIP data structure */
16909  SCIP_SOL** sol, /**< pointer to store the solution */
16910  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
16911  );
16912 
16913 /** creates a copy of a solution in the original primal solution space
16914  *
16915  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16916  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16917  *
16918  * @pre This method can be called if SCIP is in one of the following stages:
16919  * - \ref SCIP_STAGE_PROBLEM
16920  * - \ref SCIP_STAGE_TRANSFORMING
16921  * - \ref SCIP_STAGE_TRANSFORMED
16922  * - \ref SCIP_STAGE_INITPRESOLVE
16923  * - \ref SCIP_STAGE_PRESOLVING
16924  * - \ref SCIP_STAGE_EXITPRESOLVE
16925  * - \ref SCIP_STAGE_PRESOLVED
16926  * - \ref SCIP_STAGE_INITSOLVE
16927  * - \ref SCIP_STAGE_SOLVING
16928  * - \ref SCIP_STAGE_SOLVED
16929  * - \ref SCIP_STAGE_EXITSOLVE
16930  * - \ref SCIP_STAGE_FREETRANS
16931  */
16932 extern
16934  SCIP* scip, /**< SCIP data structure */
16935  SCIP_SOL** sol, /**< pointer to store the solution */
16936  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
16937  );
16938 
16939 /** creates a copy of a primal solution, thereby replacing infinite fixings of variables by finite values;
16940  * the copy is always defined in the original variable space;
16941  * success indicates whether the objective value of the solution was changed by removing infinite values
16942  *
16943  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16944  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16945  *
16946  * @pre This method can be called if SCIP is in one of the following stages:
16947  * - \ref SCIP_STAGE_PROBLEM
16948  * - \ref SCIP_STAGE_TRANSFORMING
16949  * - \ref SCIP_STAGE_TRANSFORMED
16950  * - \ref SCIP_STAGE_INITPRESOLVE
16951  * - \ref SCIP_STAGE_PRESOLVING
16952  * - \ref SCIP_STAGE_EXITPRESOLVE
16953  * - \ref SCIP_STAGE_PRESOLVED
16954  * - \ref SCIP_STAGE_INITSOLVE
16955  * - \ref SCIP_STAGE_SOLVING
16956  * - \ref SCIP_STAGE_SOLVED
16957  * - \ref SCIP_STAGE_EXITSOLVE
16958  */
16959 extern
16961  SCIP* scip, /**< SCIP data structure */
16962  SCIP_SOL** sol, /**< pointer to store the solution */
16963  SCIP_SOL* sourcesol, /**< primal CIP solution to copy */
16964  SCIP_Bool* success /**< does the finite solution have the same objective value? */
16965  );
16966 
16967 /** frees primal CIP solution
16968  *
16969  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16970  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16971  *
16972  * @pre This method can be called if SCIP is in one of the following stages:
16973  * - \ref SCIP_STAGE_PROBLEM
16974  * - \ref SCIP_STAGE_TRANSFORMING
16975  * - \ref SCIP_STAGE_TRANSFORMED
16976  * - \ref SCIP_STAGE_INITPRESOLVE
16977  * - \ref SCIP_STAGE_PRESOLVING
16978  * - \ref SCIP_STAGE_EXITPRESOLVE
16979  * - \ref SCIP_STAGE_PRESOLVED
16980  * - \ref SCIP_STAGE_INITSOLVE
16981  * - \ref SCIP_STAGE_SOLVING
16982  * - \ref SCIP_STAGE_SOLVED
16983  * - \ref SCIP_STAGE_EXITSOLVE
16984  * - \ref SCIP_STAGE_FREETRANS
16985  */
16986 extern
16988  SCIP* scip, /**< SCIP data structure */
16989  SCIP_SOL** sol /**< pointer to the solution */
16990  );
16991 
16992 /** links a primal solution to the current LP solution
16993  *
16994  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16995  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16996  *
16997  * @pre This method can be called if SCIP is in one of the following stages:
16998  * - \ref SCIP_STAGE_SOLVING
16999  */
17000 extern
17002  SCIP* scip, /**< SCIP data structure */
17003  SCIP_SOL* sol /**< primal solution */
17004  );
17005 
17006 /** links a primal solution to the current NLP solution
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_SOLVING
17013  */
17014 extern
17016  SCIP* scip, /**< SCIP data structure */
17017  SCIP_SOL* sol /**< primal solution */
17018  );
17019 
17020 /** links a primal solution to the current relaxation solution
17021  *
17022  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17023  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17024  *
17025  * @pre This method can be called if SCIP is in one of the following stages:
17026  * - \ref SCIP_STAGE_SOLVING
17027  */
17028 extern
17030  SCIP* scip, /**< SCIP data structure */
17031  SCIP_SOL* sol /**< primal solution */
17032  );
17033 
17034 /** links a primal solution to the current pseudo solution
17035  *
17036  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17037  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17038  *
17039  * @pre This method can be called if SCIP is in one of the following stages:
17040  * - \ref SCIP_STAGE_PRESOLVING
17041  * - \ref SCIP_STAGE_SOLVING
17042  */
17043 extern
17045  SCIP* scip, /**< SCIP data structure */
17046  SCIP_SOL* sol /**< primal solution */
17047  );
17048 
17049 /** links a primal solution to the current LP or pseudo solution
17050  *
17051  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17052  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17053  *
17054  * @pre This method can be called if SCIP is in one of the following stages:
17055  * - \ref SCIP_STAGE_SOLVING
17056  */
17057 extern
17059  SCIP* scip, /**< SCIP data structure */
17060  SCIP_SOL* sol /**< primal solution */
17061  );
17062 
17063 /** clears a primal solution
17064  *
17065  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17066  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17067  *
17068  * @pre This method can be called if SCIP is in one of the following stages:
17069  * - \ref SCIP_STAGE_PROBLEM
17070  * - \ref SCIP_STAGE_TRANSFORMING
17071  * - \ref SCIP_STAGE_TRANSFORMED
17072  * - \ref SCIP_STAGE_INITPRESOLVE
17073  * - \ref SCIP_STAGE_PRESOLVING
17074  * - \ref SCIP_STAGE_EXITPRESOLVE
17075  * - \ref SCIP_STAGE_PRESOLVED
17076  * - \ref SCIP_STAGE_INITSOLVE
17077  * - \ref SCIP_STAGE_SOLVING
17078  * - \ref SCIP_STAGE_SOLVED
17079  * - \ref SCIP_STAGE_EXITSOLVE
17080  * - \ref SCIP_STAGE_FREETRANS
17081  */
17082 extern
17084  SCIP* scip, /**< SCIP data structure */
17085  SCIP_SOL* sol /**< primal solution */
17086  );
17087 
17088 /** stores solution values of variables in solution's own array
17089  *
17090  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17091  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17092  *
17093  * @pre This method can be called if SCIP is in one of the following stages:
17094  * - \ref SCIP_STAGE_TRANSFORMING
17095  * - \ref SCIP_STAGE_TRANSFORMED
17096  * - \ref SCIP_STAGE_PRESOLVING
17097  * - \ref SCIP_STAGE_PRESOLVED
17098  * - \ref SCIP_STAGE_INITSOLVE
17099  * - \ref SCIP_STAGE_SOLVING
17100  * - \ref SCIP_STAGE_SOLVED
17101  * - \ref SCIP_STAGE_EXITSOLVE
17102  * - \ref SCIP_STAGE_FREETRANS
17103  */
17104 extern
17106  SCIP* scip, /**< SCIP data structure */
17107  SCIP_SOL* sol /**< primal solution */
17108  );
17109 
17110 /** sets value of variable in primal CIP solution
17111  *
17112  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17113  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17114  *
17115  * @pre This method can be called if SCIP is in one of the following stages:
17116  * - \ref SCIP_STAGE_PROBLEM
17117  * - \ref SCIP_STAGE_TRANSFORMING
17118  * - \ref SCIP_STAGE_TRANSFORMED
17119  * - \ref SCIP_STAGE_INITPRESOLVE
17120  * - \ref SCIP_STAGE_PRESOLVING
17121  * - \ref SCIP_STAGE_EXITPRESOLVE
17122  * - \ref SCIP_STAGE_PRESOLVED
17123  * - \ref SCIP_STAGE_INITSOLVE
17124  * - \ref SCIP_STAGE_SOLVING
17125  * - \ref SCIP_STAGE_SOLVED
17126  * - \ref SCIP_STAGE_EXITSOLVE
17127  * - \ref SCIP_STAGE_FREETRANS
17128  */
17129 extern
17131  SCIP* scip, /**< SCIP data structure */
17132  SCIP_SOL* sol, /**< primal solution */
17133  SCIP_VAR* var, /**< variable to add to solution */
17134  SCIP_Real val /**< solution value of variable */
17135  );
17136 
17137 /** sets values of multiple variables in primal CIP solution
17138  *
17139  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17140  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17141  *
17142  * @pre This method can be called if SCIP is in one of the following stages:
17143  * - \ref SCIP_STAGE_PROBLEM
17144  * - \ref SCIP_STAGE_TRANSFORMING
17145  * - \ref SCIP_STAGE_TRANSFORMED
17146  * - \ref SCIP_STAGE_INITPRESOLVE
17147  * - \ref SCIP_STAGE_PRESOLVING
17148  * - \ref SCIP_STAGE_EXITPRESOLVE
17149  * - \ref SCIP_STAGE_PRESOLVED
17150  * - \ref SCIP_STAGE_INITSOLVE
17151  * - \ref SCIP_STAGE_SOLVING
17152  * - \ref SCIP_STAGE_SOLVED
17153  * - \ref SCIP_STAGE_EXITSOLVE
17154  * - \ref SCIP_STAGE_FREETRANS
17155  */
17156 extern
17158  SCIP* scip, /**< SCIP data structure */
17159  SCIP_SOL* sol, /**< primal solution */
17160  int nvars, /**< number of variables to set solution value for */
17161  SCIP_VAR** vars, /**< array with variables to add to solution */
17162  SCIP_Real* vals /**< array with solution values of variables */
17163  );
17164 
17165 /** increases value of variable in primal CIP solution
17166  *
17167  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17168  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17169  *
17170  * @pre This method can be called if SCIP is in one of the following stages:
17171  * - \ref SCIP_STAGE_PROBLEM
17172  * - \ref SCIP_STAGE_TRANSFORMING
17173  * - \ref SCIP_STAGE_TRANSFORMED
17174  * - \ref SCIP_STAGE_INITPRESOLVE
17175  * - \ref SCIP_STAGE_PRESOLVING
17176  * - \ref SCIP_STAGE_EXITPRESOLVE
17177  * - \ref SCIP_STAGE_PRESOLVED
17178  * - \ref SCIP_STAGE_INITSOLVE
17179  * - \ref SCIP_STAGE_SOLVING
17180  * - \ref SCIP_STAGE_SOLVED
17181  * - \ref SCIP_STAGE_EXITSOLVE
17182  * - \ref SCIP_STAGE_FREETRANS
17183  */
17184 extern
17186  SCIP* scip, /**< SCIP data structure */
17187  SCIP_SOL* sol, /**< primal solution */
17188  SCIP_VAR* var, /**< variable to increase solution value for */
17189  SCIP_Real incval /**< increment for solution value of variable */
17190  );
17191 
17192 /** returns value of variable in primal CIP solution, or in current LP/pseudo solution
17193  *
17194  * @return value of variable in primal CIP solution, or in current LP/pseudo solution
17195  *
17196  * @pre In case the solution pointer @p sol is @b NULL, that means it is asked for the LP or pseudo solution, this method
17197  * can only be called if @p scip is in the solving stage \ref SCIP_STAGE_SOLVING. In any other case, this method
17198  * can be called if @p scip is in one of the following stages:
17199  * - \ref SCIP_STAGE_PROBLEM
17200  * - \ref SCIP_STAGE_TRANSFORMING
17201  * - \ref SCIP_STAGE_TRANSFORMED
17202  * - \ref SCIP_STAGE_INITPRESOLVE
17203  * - \ref SCIP_STAGE_PRESOLVING
17204  * - \ref SCIP_STAGE_EXITPRESOLVE
17205  * - \ref SCIP_STAGE_PRESOLVED
17206  * - \ref SCIP_STAGE_INITSOLVE
17207  * - \ref SCIP_STAGE_SOLVING
17208  * - \ref SCIP_STAGE_SOLVED
17209  * - \ref SCIP_STAGE_EXITSOLVE
17210  * - \ref SCIP_STAGE_FREETRANS
17211  */
17212 extern
17214  SCIP* scip, /**< SCIP data structure */
17215  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17216  SCIP_VAR* var /**< variable to get value for */
17217  );
17218 
17219 /** gets values of multiple variables in primal CIP solution
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  * - \ref SCIP_STAGE_FREETRANS
17237  */
17238 extern
17240  SCIP* scip, /**< SCIP data structure */
17241  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17242  int nvars, /**< number of variables to get solution value for */
17243  SCIP_VAR** vars, /**< array with variables to get value for */
17244  SCIP_Real* vals /**< array to store solution values of variables */
17245  );
17246 
17247 /** returns objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
17248  *
17249  * @return objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
17250  *
17251  * @pre This method can be called if SCIP is in one of the following stages:
17252  * - \ref SCIP_STAGE_PROBLEM
17253  * - \ref SCIP_STAGE_TRANSFORMING
17254  * - \ref SCIP_STAGE_TRANSFORMED
17255  * - \ref SCIP_STAGE_INITPRESOLVE
17256  * - \ref SCIP_STAGE_PRESOLVING
17257  * - \ref SCIP_STAGE_EXITPRESOLVE
17258  * - \ref SCIP_STAGE_PRESOLVED
17259  * - \ref SCIP_STAGE_INITSOLVE
17260  * - \ref SCIP_STAGE_SOLVING
17261  * - \ref SCIP_STAGE_SOLVED
17262  * - \ref SCIP_STAGE_EXITSOLVE
17263  * - \ref SCIP_STAGE_FREETRANS
17264  */
17265 extern
17267  SCIP* scip, /**< SCIP data structure */
17268  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
17269  );
17270 
17271 /** returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
17272  *
17273  * @return transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
17274  *
17275  * @pre This method can be called if SCIP is in one of the following stages:
17276  * - \ref SCIP_STAGE_TRANSFORMING
17277  * - \ref SCIP_STAGE_TRANSFORMED
17278  * - \ref SCIP_STAGE_INITPRESOLVE
17279  * - \ref SCIP_STAGE_PRESOLVING
17280  * - \ref SCIP_STAGE_EXITPRESOLVE
17281  * - \ref SCIP_STAGE_PRESOLVED
17282  * - \ref SCIP_STAGE_INITSOLVE
17283  * - \ref SCIP_STAGE_SOLVING
17284  * - \ref SCIP_STAGE_SOLVED
17285  * - \ref SCIP_STAGE_EXITSOLVE
17286  * - \ref SCIP_STAGE_FREETRANS
17287  */
17288 extern
17290  SCIP* scip, /**< SCIP data structure */
17291  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
17292  );
17293 
17294 /** recomputes the objective value of an original solution, e.g., when transferring solutions
17295  * from the solution pool (objective coefficients might have changed in the meantime)
17296  *
17297  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17298  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17299  *
17300  * @pre This method can be called if SCIP is in one of the following stages:
17301  * - \ref SCIP_STAGE_PRESOLVING
17302  * - \ref SCIP_STAGE_SOLVING
17303  *
17304  */
17305 extern
17307  SCIP* scip,
17308  SCIP_SOL* sol
17309  );
17310 
17311 /** maps original space objective value into transformed objective value
17312  *
17313  * @return transformed objective value
17314  *
17315  * @pre This method can be called if SCIP is in one of the following stages:
17316  * - \ref SCIP_STAGE_TRANSFORMING
17317  * - \ref SCIP_STAGE_TRANSFORMED
17318  * - \ref SCIP_STAGE_INITPRESOLVE
17319  * - \ref SCIP_STAGE_PRESOLVING
17320  * - \ref SCIP_STAGE_EXITPRESOLVE
17321  * - \ref SCIP_STAGE_PRESOLVED
17322  * - \ref SCIP_STAGE_INITSOLVE
17323  * - \ref SCIP_STAGE_SOLVING
17324  * - \ref SCIP_STAGE_SOLVED
17325  */
17326 extern
17328  SCIP* scip, /**< SCIP data structure */
17329  SCIP_Real obj /**< original space objective value to transform */
17330  );
17331 
17332 /** maps transformed objective value into original space
17333  *
17334  * @return objective value into original space
17335  *
17336  * @pre This method can be called if SCIP is in one of the following stages:
17337  * - \ref SCIP_STAGE_TRANSFORMING
17338  * - \ref SCIP_STAGE_TRANSFORMED
17339  * - \ref SCIP_STAGE_INITPRESOLVE
17340  * - \ref SCIP_STAGE_PRESOLVING
17341  * - \ref SCIP_STAGE_EXITPRESOLVE
17342  * - \ref SCIP_STAGE_PRESOLVED
17343  * - \ref SCIP_STAGE_INITSOLVE
17344  * - \ref SCIP_STAGE_SOLVING
17345  * - \ref SCIP_STAGE_SOLVED
17346  */
17347 extern
17349  SCIP* scip, /**< SCIP data structure */
17350  SCIP_Real obj /**< transformed objective value to retransform in original space */
17351  );
17352 
17353 /** gets clock time, when this solution was found
17354  *
17355  * @return clock time, when this solution was found
17356  *
17357  * @pre This method can be called if SCIP is in one of the following stages:
17358  * - \ref SCIP_STAGE_TRANSFORMING
17359  * - \ref SCIP_STAGE_TRANSFORMED
17360  * - \ref SCIP_STAGE_INITPRESOLVE
17361  * - \ref SCIP_STAGE_PRESOLVING
17362  * - \ref SCIP_STAGE_EXITPRESOLVE
17363  * - \ref SCIP_STAGE_PRESOLVED
17364  * - \ref SCIP_STAGE_INITSOLVE
17365  * - \ref SCIP_STAGE_SOLVING
17366  * - \ref SCIP_STAGE_SOLVED
17367  * - \ref SCIP_STAGE_EXITSOLVE
17368  * - \ref SCIP_STAGE_FREETRANS
17369  */
17370 extern
17372  SCIP* scip, /**< SCIP data structure */
17373  SCIP_SOL* sol /**< primal solution */
17374  );
17375 
17376 /** gets branch and bound run number, where this solution was found
17377  *
17378  * @return branch and bound run number, where this solution was found
17379  *
17380  * @pre This method can be called if SCIP is in one of the following stages:
17381  * - \ref SCIP_STAGE_TRANSFORMING
17382  * - \ref SCIP_STAGE_TRANSFORMED
17383  * - \ref SCIP_STAGE_INITPRESOLVE
17384  * - \ref SCIP_STAGE_PRESOLVING
17385  * - \ref SCIP_STAGE_EXITPRESOLVE
17386  * - \ref SCIP_STAGE_PRESOLVED
17387  * - \ref SCIP_STAGE_INITSOLVE
17388  * - \ref SCIP_STAGE_SOLVING
17389  * - \ref SCIP_STAGE_SOLVED
17390  * - \ref SCIP_STAGE_EXITSOLVE
17391  * - \ref SCIP_STAGE_FREETRANS
17392  */
17393 extern
17394 int SCIPgetSolRunnum(
17395  SCIP* scip, /**< SCIP data structure */
17396  SCIP_SOL* sol /**< primal solution */
17397  );
17398 
17399 /** gets node number of the specific branch and bound run, where this solution was found
17400  *
17401  * @return node number of the specific branch and bound run, where this solution was found
17402  *
17403  * @pre This method can be called if SCIP is in one of the following stages:
17404  * - \ref SCIP_STAGE_TRANSFORMING
17405  * - \ref SCIP_STAGE_TRANSFORMED
17406  * - \ref SCIP_STAGE_INITPRESOLVE
17407  * - \ref SCIP_STAGE_PRESOLVING
17408  * - \ref SCIP_STAGE_EXITPRESOLVE
17409  * - \ref SCIP_STAGE_PRESOLVED
17410  * - \ref SCIP_STAGE_INITSOLVE
17411  * - \ref SCIP_STAGE_SOLVING
17412  * - \ref SCIP_STAGE_SOLVED
17413  * - \ref SCIP_STAGE_EXITSOLVE
17414  * - \ref SCIP_STAGE_FREETRANS
17415  */
17416 extern
17418  SCIP* scip, /**< SCIP data structure */
17419  SCIP_SOL* sol /**< primal solution */
17420  );
17421 
17422 /** gets heuristic, that found this solution (or NULL if it's from the tree)
17423  *
17424  * @return heuristic, that found this solution (or NULL if it's from the tree)
17425  *
17426  * @pre This method can be called if SCIP is in one of the following stages:
17427  * - \ref SCIP_STAGE_TRANSFORMING
17428  * - \ref SCIP_STAGE_TRANSFORMED
17429  * - \ref SCIP_STAGE_INITPRESOLVE
17430  * - \ref SCIP_STAGE_PRESOLVING
17431  * - \ref SCIP_STAGE_EXITPRESOLVE
17432  * - \ref SCIP_STAGE_PRESOLVED
17433  * - \ref SCIP_STAGE_INITSOLVE
17434  * - \ref SCIP_STAGE_SOLVING
17435  * - \ref SCIP_STAGE_SOLVED
17436  * - \ref SCIP_STAGE_EXITSOLVE
17437  * - \ref SCIP_STAGE_FREETRANS
17438  */
17439 extern
17441  SCIP* scip, /**< SCIP data structure */
17442  SCIP_SOL* sol /**< primal solution */
17443  );
17444 
17445 /** returns whether two given solutions are exactly equal
17446  *
17447  * @return returns whether two given solutions are exactly equal
17448  *
17449  * @pre This method can be called if SCIP is in one of the following stages:
17450  * - \ref SCIP_STAGE_PROBLEM
17451  * - \ref SCIP_STAGE_TRANSFORMING
17452  * - \ref SCIP_STAGE_TRANSFORMED
17453  * - \ref SCIP_STAGE_INITPRESOLVE
17454  * - \ref SCIP_STAGE_PRESOLVING
17455  * - \ref SCIP_STAGE_EXITPRESOLVE
17456  * - \ref SCIP_STAGE_PRESOLVED
17457  * - \ref SCIP_STAGE_INITSOLVE
17458  * - \ref SCIP_STAGE_SOLVING
17459  * - \ref SCIP_STAGE_SOLVED
17460  * - \ref SCIP_STAGE_EXITSOLVE
17461  * - \ref SCIP_STAGE_FREETRANS
17462  */
17463 extern
17465  SCIP* scip, /**< SCIP data structure */
17466  SCIP_SOL* sol1, /**< first primal CIP solution */
17467  SCIP_SOL* sol2 /**< second primal CIP solution */
17468  );
17469 
17470 /** adjusts solution values of implicit integer variables in handed solution. Solution objective value is not
17471  * deteriorated by this method.
17472  *
17473  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17474  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17475  *
17476  * @pre This method can be called if SCIP is in one of the following stages:
17477  * - \ref SCIP_STAGE_SOLVING
17478  */
17479 extern
17481  SCIP* scip, /**< SCIP data structure */
17482  SCIP_SOL* sol, /**< primal CIP solution */
17483  SCIP_Bool uselprows /**< should LP row information be considered for none-objective variables */
17484  );
17485 
17486 /** outputs non-zero variables of solution in original problem space to the given file stream
17487  *
17488  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17489  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17490  *
17491  * @pre In case the solution pointer @p sol is NULL (askinking for the current LP/pseudo solution), this method can be
17492  * called if @p scip is in one of the following stages:
17493  * - \ref SCIP_STAGE_PRESOLVING
17494  * - \ref SCIP_STAGE_EXITPRESOLVE
17495  * - \ref SCIP_STAGE_PRESOLVED
17496  * - \ref SCIP_STAGE_INITSOLVE
17497  * - \ref SCIP_STAGE_SOLVING
17498  * - \ref SCIP_STAGE_SOLVED
17499  * - \ref SCIP_STAGE_EXITSOLVE
17500  *
17501  * @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
17502  * following stages:
17503  * - \ref SCIP_STAGE_PROBLEM
17504  * - \ref SCIP_STAGE_TRANSFORMED
17505  * - \ref SCIP_STAGE_INITPRESOLVE
17506  * - \ref SCIP_STAGE_PRESOLVING
17507  * - \ref SCIP_STAGE_EXITPRESOLVE
17508  * - \ref SCIP_STAGE_PRESOLVED
17509  * - \ref SCIP_STAGE_INITSOLVE
17510  * - \ref SCIP_STAGE_SOLVING
17511  * - \ref SCIP_STAGE_SOLVED
17512  * - \ref SCIP_STAGE_EXITSOLVE
17513  */
17514 extern
17516  SCIP* scip, /**< SCIP data structure */
17517  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17518  FILE* file, /**< output file (or NULL for standard output) */
17519  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17520  );
17521 
17522 /** outputs non-zero variables of solution in transformed problem space to file stream
17523  *
17524  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17525  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17526  *
17527  * @pre This method can be called if SCIP is in one of the following stages:
17528  * - \ref SCIP_STAGE_TRANSFORMED
17529  * - \ref SCIP_STAGE_INITPRESOLVE
17530  * - \ref SCIP_STAGE_PRESOLVING
17531  * - \ref SCIP_STAGE_EXITPRESOLVE
17532  * - \ref SCIP_STAGE_PRESOLVED
17533  * - \ref SCIP_STAGE_INITSOLVE
17534  * - \ref SCIP_STAGE_SOLVING
17535  * - \ref SCIP_STAGE_SOLVED
17536  * - \ref SCIP_STAGE_EXITSOLVE
17537  */
17538 extern
17540  SCIP* scip, /**< SCIP data structure */
17541  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17542  FILE* file, /**< output file (or NULL for standard output) */
17543  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17544  );
17545 
17546 /** outputs discrete variables of solution in original problem space to the given file stream
17547  *
17548  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17549  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17550  *
17551  * @pre This method can be called if @p scip is in one of the following stages:
17552  * - \ref SCIP_STAGE_PROBLEM
17553  * - \ref SCIP_STAGE_TRANSFORMED
17554  * - \ref SCIP_STAGE_INITPRESOLVE
17555  * - \ref SCIP_STAGE_PRESOLVING
17556  * - \ref SCIP_STAGE_EXITPRESOLVE
17557  * - \ref SCIP_STAGE_PRESOLVED
17558  * - \ref SCIP_STAGE_INITSOLVE
17559  * - \ref SCIP_STAGE_SOLVING
17560  * - \ref SCIP_STAGE_SOLVED
17561  * - \ref SCIP_STAGE_EXITSOLVE
17562  */
17563 extern
17565  SCIP* scip, /**< SCIP data structure */
17566  SCIP_SOL* sol, /**< primal solution */
17567  FILE* file /**< output file (or NULL for standard output) */
17568  );
17569 
17570 /** check whether the dual solution is available
17571  *
17572  * @note This is used when calling \ref SCIPprintDualSol()
17573  *
17574  * @return is dual solution available?
17575  *
17576  * @pre This method can be called if SCIP is in one of the following stages:
17577  * - \ref SCIP_STAGE_SOLVED
17578  */
17579 extern
17581  SCIP* scip, /**< SCIP data structure */
17582  SCIP_Bool printreason /**< print warning message if dualsol is not available? */
17583  );
17584 
17585 /** outputs dual solution from LP solver to file stream
17586  *
17587  * @note This only works if no presolving has been performed, which can be checked by calling method \ref
17588  * SCIPhasPerformedPresolve().
17589  *
17590  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17591  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17592  *
17593  * @pre This method can be called if SCIP is in one of the following stages:
17594  * - \ref SCIP_STAGE_SOLVED
17595  */
17596 extern
17598  SCIP* scip, /**< SCIP data structure */
17599  FILE* file, /**< output file (or NULL for standard output) */
17600  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17601  );
17602 
17603 
17604 /** outputs non-zero variables of solution representing a ray in original problem space to file stream
17605  *
17606  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17607  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17608  *
17609  * @pre This method can be called if SCIP is in one of the following stages:
17610  * - \ref SCIP_STAGE_PROBLEM
17611  * - \ref SCIP_STAGE_TRANSFORMED
17612  * - \ref SCIP_STAGE_INITPRESOLVE
17613  * - \ref SCIP_STAGE_PRESOLVING
17614  * - \ref SCIP_STAGE_EXITPRESOLVE
17615  * - \ref SCIP_STAGE_PRESOLVED
17616  * - \ref SCIP_STAGE_INITSOLVE
17617  * - \ref SCIP_STAGE_SOLVING
17618  * - \ref SCIP_STAGE_SOLVED
17619  * - \ref SCIP_STAGE_EXITSOLVE
17620  */
17621 extern
17623  SCIP* scip, /**< SCIP data structure */
17624  SCIP_SOL* sol, /**< primal solution representing ray */
17625  FILE* file, /**< output file (or NULL for standard output) */
17626  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17627  );
17628 
17629 /** gets number of feasible primal solutions stored in the solution storage in case the problem is transformed;
17630  * in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate
17631  * storage is returned
17632  *
17633  * @return number of feasible primal solutions stored in the solution storage in case the problem is transformed; or
17634  * number of solution in the original solution candidate storage if the problem stage is SCIP_STAGE_PROBLEM
17635  *
17636  * @pre This method can be called if SCIP is in one of the following stages:
17637  * - \ref SCIP_STAGE_PROBLEM
17638  * - \ref SCIP_STAGE_TRANSFORMED
17639  * - \ref SCIP_STAGE_INITPRESOLVE
17640  * - \ref SCIP_STAGE_PRESOLVING
17641  * - \ref SCIP_STAGE_EXITPRESOLVE
17642  * - \ref SCIP_STAGE_PRESOLVED
17643  * - \ref SCIP_STAGE_INITSOLVE
17644  * - \ref SCIP_STAGE_SOLVING
17645  * - \ref SCIP_STAGE_SOLVED
17646  * - \ref SCIP_STAGE_EXITSOLVE
17647  */
17648 extern
17649 int SCIPgetNSols(
17650  SCIP* scip /**< SCIP data structure */
17651  );
17652 
17653 /** gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case
17654  * if the problem stage is in SCIP_STAGE_PROBLEM, it returns the number array of solution candidate stored
17655  *
17656  * @return array of feasible primal solutions
17657  *
17658  * @pre This method can be called if SCIP is in one of the following stages:
17659  * - \ref SCIP_STAGE_PROBLEM
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  */
17670 extern
17672  SCIP* scip /**< SCIP data structure */
17673  );
17674 
17675 /** gets best feasible primal solution found so far if the problem is transformed; in case the problem is in
17676  * SCIP_STAGE_PROBLEM it returns the best solution candidate, or NULL if no solution has been found or the candidate
17677  * store is empty;
17678  *
17679  * @return best feasible primal solution so far
17680  *
17681  * @pre This method can be called if SCIP is in one of the following stages:
17682  * - \ref SCIP_STAGE_PROBLEM
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  */
17693 extern
17695  SCIP* scip /**< SCIP data structure */
17696  );
17697 
17698 /** outputs best feasible primal solution found so far to file stream
17699  *
17700  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17701  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17702  *
17703  * @pre This method can be called if SCIP is in one of the following stages:
17704  * - \ref SCIP_STAGE_INIT
17705  * - \ref SCIP_STAGE_PROBLEM
17706  * - \ref SCIP_STAGE_TRANSFORMING
17707  * - \ref SCIP_STAGE_TRANSFORMED
17708  * - \ref SCIP_STAGE_INITPRESOLVE
17709  * - \ref SCIP_STAGE_PRESOLVING
17710  * - \ref SCIP_STAGE_EXITPRESOLVE
17711  * - \ref SCIP_STAGE_PRESOLVED
17712  * - \ref SCIP_STAGE_INITSOLVE
17713  * - \ref SCIP_STAGE_SOLVING
17714  * - \ref SCIP_STAGE_SOLVED
17715  * - \ref SCIP_STAGE_EXITSOLVE
17716  * - \ref SCIP_STAGE_FREE
17717  */
17718 extern
17720  SCIP* scip, /**< SCIP data structure */
17721  FILE* file, /**< output file (or NULL for standard output) */
17722  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17723  );
17724 
17725 /** outputs best feasible primal solution found so far in transformed variables to file stream
17726  *
17727  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17728  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17729  *
17730  * @pre This method can be called if SCIP is in one of the following stages:
17731  * - \ref SCIP_STAGE_INIT
17732  * - \ref SCIP_STAGE_PROBLEM
17733  * - \ref SCIP_STAGE_TRANSFORMING
17734  * - \ref SCIP_STAGE_TRANSFORMED
17735  * - \ref SCIP_STAGE_INITPRESOLVE
17736  * - \ref SCIP_STAGE_PRESOLVING
17737  * - \ref SCIP_STAGE_EXITPRESOLVE
17738  * - \ref SCIP_STAGE_PRESOLVED
17739  * - \ref SCIP_STAGE_INITSOLVE
17740  * - \ref SCIP_STAGE_SOLVING
17741  * - \ref SCIP_STAGE_SOLVED
17742  * - \ref SCIP_STAGE_EXITSOLVE
17743  * - \ref SCIP_STAGE_FREE
17744  */
17745 extern
17747  SCIP* scip, /**< SCIP data structure */
17748  FILE* file, /**< output file (or NULL for standard output) */
17749  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17750  );
17751 
17752 /** try to round given solution
17753  *
17754  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17755  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17756  *
17757  * @pre This method can be called if SCIP is in one of the following stages:
17758  * - \ref SCIP_STAGE_SOLVING
17759  */
17760 extern
17762  SCIP* scip, /**< SCIP data structure */
17763  SCIP_SOL* sol, /**< primal solution */
17764  SCIP_Bool* success /**< pointer to store whether rounding was successful */
17765  );
17766 
17767 /** retransforms solution to original problem space
17768  *
17769  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17770  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17771  *
17772  * @pre This method can be called if SCIP is in one of the following stages:
17773  * - \ref SCIP_STAGE_PROBLEM
17774  * - \ref SCIP_STAGE_TRANSFORMING
17775  * - \ref SCIP_STAGE_TRANSFORMED
17776  * - \ref SCIP_STAGE_INITPRESOLVE
17777  * - \ref SCIP_STAGE_PRESOLVING
17778  * - \ref SCIP_STAGE_EXITPRESOLVE
17779  * - \ref SCIP_STAGE_PRESOLVED
17780  * - \ref SCIP_STAGE_INITSOLVE
17781  * - \ref SCIP_STAGE_SOLVING
17782  * - \ref SCIP_STAGE_SOLVED
17783  * - \ref SCIP_STAGE_EXITSOLVE
17784  * - \ref SCIP_STAGE_FREETRANS
17785  */
17786 extern
17788  SCIP* scip, /**< SCIP data structure */
17789  SCIP_SOL* sol /**< primal CIP solution */
17790  );
17791 
17792 /** reads a given solution file, problem has to be transformed in advance
17793  *
17794  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17795  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17796  *
17797  * @pre This method can be called if SCIP is in one of the following stages:
17798  * - \ref SCIP_STAGE_PROBLEM
17799  * - \ref SCIP_STAGE_TRANSFORMED
17800  * - \ref SCIP_STAGE_INITPRESOLVE
17801  * - \ref SCIP_STAGE_PRESOLVING
17802  * - \ref SCIP_STAGE_EXITPRESOLVE
17803  * - \ref SCIP_STAGE_PRESOLVED
17804  * - \ref SCIP_STAGE_INITSOLVE
17805  * - \ref SCIP_STAGE_SOLVING
17806  */
17807 extern
17809  SCIP* scip, /**< SCIP data structure */
17810  const char* filename /**< name of the input file */
17811  );
17812 
17813 /** reads a given solution file and store the solution values in the given solution pointer
17814  *
17815  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17816  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17817  *
17818  * @pre This method can be called if SCIP is in one of the following stages:
17819  * - \ref SCIP_STAGE_PROBLEM
17820  * - \ref SCIP_STAGE_TRANSFORMED
17821  * - \ref SCIP_STAGE_INITPRESOLVE
17822  * - \ref SCIP_STAGE_PRESOLVING
17823  * - \ref SCIP_STAGE_EXITPRESOLVE
17824  * - \ref SCIP_STAGE_PRESOLVED
17825  * - \ref SCIP_STAGE_INITSOLVE
17826  * - \ref SCIP_STAGE_SOLVING
17827  */
17828 extern
17830  SCIP* scip, /**< SCIP data structure */
17831  const char* filename, /**< name of the input file */
17832  SCIP_SOL* sol, /**< solution pointer */
17833  SCIP_Bool xml, /**< true, iff the given solution in written in XML */
17834  SCIP_Bool* partial, /**< pointer to store if the solution is partial */
17835  SCIP_Bool* error /**< pointer store if an error occured */
17836  );
17837 
17838 /** adds feasible primal solution to solution storage by copying it
17839  *
17840  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17841  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17842  *
17843  * @pre This method can be called if SCIP is in one of the following stages:
17844  * - \ref SCIP_STAGE_PROBLEM
17845  * - \ref SCIP_STAGE_TRANSFORMED
17846  * - \ref SCIP_STAGE_INITPRESOLVE
17847  * - \ref SCIP_STAGE_PRESOLVING
17848  * - \ref SCIP_STAGE_EXITPRESOLVE
17849  * - \ref SCIP_STAGE_PRESOLVED
17850  * - \ref SCIP_STAGE_SOLVING
17851  * - \ref SCIP_STAGE_FREETRANS
17852  *
17853  * @note Do not call during propagation, use heur_trysol instead.
17854  */
17855 extern
17857  SCIP* scip, /**< SCIP data structure */
17858  SCIP_SOL* sol, /**< primal CIP solution */
17859  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
17860  );
17861 
17862 /** adds primal solution to solution storage, frees the solution afterwards
17863  *
17864  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17865  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17866  *
17867  * @pre This method can be called if SCIP is in one of the following stages:
17868  * - \ref SCIP_STAGE_PROBLEM
17869  * - \ref SCIP_STAGE_TRANSFORMED
17870  * - \ref SCIP_STAGE_INITPRESOLVE
17871  * - \ref SCIP_STAGE_PRESOLVING
17872  * - \ref SCIP_STAGE_EXITPRESOLVE
17873  * - \ref SCIP_STAGE_PRESOLVED
17874  * - \ref SCIP_STAGE_SOLVING
17875  * - \ref SCIP_STAGE_FREETRANS
17876  *
17877  * @note Do not call during propagation, use heur_trysol instead.
17878  */
17879 extern
17881  SCIP* scip, /**< SCIP data structure */
17882  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
17883  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
17884  );
17885 
17886 /** adds current LP/pseudo solution to solution storage
17887  *
17888  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17889  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17890  *
17891  * @pre This method can be called if SCIP is in one of the following stages:
17892  * - \ref SCIP_STAGE_PRESOLVED
17893  * - \ref SCIP_STAGE_SOLVING
17894  */
17895 extern
17897  SCIP* scip, /**< SCIP data structure */
17898  SCIP_HEUR* heur, /**< heuristic that found the solution */
17899  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
17900  );
17901 
17902 /** checks solution for feasibility; if possible, adds it to storage by copying
17903  *
17904  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17905  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17906  *
17907  * @pre This method can be called if SCIP is in one of the following stages:
17908  * - \ref SCIP_STAGE_TRANSFORMED
17909  * - \ref SCIP_STAGE_INITPRESOLVE
17910  * - \ref SCIP_STAGE_PRESOLVING
17911  * - \ref SCIP_STAGE_EXITPRESOLVE
17912  * - \ref SCIP_STAGE_PRESOLVED
17913  * - \ref SCIP_STAGE_SOLVING
17914  *
17915  * @note Do not call during propagation, use heur_trysol instead.
17916  */
17917 extern
17919  SCIP* scip, /**< SCIP data structure */
17920  SCIP_SOL* sol, /**< primal CIP solution */
17921  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
17922  SCIP_Bool completely, /**< Should all violations be checked? */
17923  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
17924  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
17925  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
17926  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
17927  );
17928 
17929 /** checks primal solution; if feasible, adds it to storage; solution is freed afterwards
17930  *
17931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17933  *
17934  * @pre This method can be called if SCIP is in one of the following stages:
17935  * - \ref SCIP_STAGE_TRANSFORMED
17936  * - \ref SCIP_STAGE_INITPRESOLVE
17937  * - \ref SCIP_STAGE_PRESOLVING
17938  * - \ref SCIP_STAGE_EXITPRESOLVE
17939  * - \ref SCIP_STAGE_PRESOLVED
17940  * - \ref SCIP_STAGE_SOLVING
17941  *
17942  * @note Do not call during propagation, use heur_trysol instead.
17943  */
17944 extern
17946  SCIP* scip, /**< SCIP data structure */
17947  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
17948  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
17949  SCIP_Bool completely, /**< Should all violation be checked? */
17950  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
17951  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
17952  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
17953  SCIP_Bool* stored /**< stores whether solution was feasible and good enough to keep */
17954  );
17955 
17956 /** checks current LP/pseudo solution for feasibility; if possible, adds it to storage
17957  *
17958  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17959  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17960  *
17961  * @pre This method can be called if SCIP is in one of the following stages:
17962  * - \ref SCIP_STAGE_PRESOLVED
17963  * - \ref SCIP_STAGE_SOLVING
17964  */
17965 extern
17967  SCIP* scip, /**< SCIP data structure */
17968  SCIP_HEUR* heur, /**< heuristic that found the solution */
17969  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
17970  SCIP_Bool completely, /**< Should all violation be checked? */
17971  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
17972  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
17973  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
17974  );
17975 
17976 /** returns all partial solutions
17977  *
17978  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17979  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17980  *
17981  * @pre This method can be called if SCIP is in one of the following stages:
17982  * - \ref SCIP_STAGE_PROBLEM
17983  * - \ref SCIP_STAGE_PRESOLVING
17984  * - \ref SCIP_STAGE_SOLVING
17985  * - \ref SCIP_STAGE_SOLVED
17986  */
17987 extern
17989  SCIP* scip /**< SCIP data structure */
17990  );
17991 
17992 /** returns number of partial solutions
17993  *
17994  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17995  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17996  *
17997  * @pre This method can be called if SCIP is in one of the following stages:
17998  * - \ref SCIP_STAGE_PROBLEM
17999  * - \ref SCIP_STAGE_PRESOLVING
18000  * - \ref SCIP_STAGE_SOLVING
18001  * - \ref SCIP_STAGE_SOLVED
18002  */
18004  SCIP* scip /**< SCIP data structure */
18005  );
18006 
18007 /** checks solution for feasibility without adding it to the solution store
18008  *
18009  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18010  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18011  *
18012  * @pre This method can be called if SCIP is in one of the following stages:
18013  * - \ref SCIP_STAGE_PROBLEM
18014  * - \ref SCIP_STAGE_TRANSFORMED
18015  * - \ref SCIP_STAGE_INITPRESOLVE
18016  * - \ref SCIP_STAGE_PRESOLVING
18017  * - \ref SCIP_STAGE_EXITPRESOLVE
18018  * - \ref SCIP_STAGE_PRESOLVED
18019  * - \ref SCIP_STAGE_INITSOLVE
18020  * - \ref SCIP_STAGE_SOLVING
18021  * - \ref SCIP_STAGE_SOLVED
18022  */
18023 extern
18025  SCIP* scip, /**< SCIP data structure */
18026  SCIP_SOL* sol, /**< primal CIP solution */
18027  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
18028  SCIP_Bool completely, /**< Should all violation be checked? */
18029  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
18030  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
18031  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
18032  SCIP_Bool* feasible /**< stores whether given solution is feasible */
18033  );
18034 
18035 /** checks solution for feasibility in original problem without adding it to the solution store;
18036  * this method is used to double check a solution in order to validate the presolving process
18037  *
18038  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18039  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18040  *
18041  * @pre This method can be called if SCIP is in one of the following stages:
18042  * - \ref SCIP_STAGE_PROBLEM
18043  * - \ref SCIP_STAGE_TRANSFORMED
18044  * - \ref SCIP_STAGE_INITPRESOLVE
18045  * - \ref SCIP_STAGE_PRESOLVING
18046  * - \ref SCIP_STAGE_EXITPRESOLVE
18047  * - \ref SCIP_STAGE_PRESOLVED
18048  * - \ref SCIP_STAGE_INITSOLVE
18049  * - \ref SCIP_STAGE_SOLVING
18050  * - \ref SCIP_STAGE_SOLVED
18051  */
18052 extern
18054  SCIP* scip, /**< SCIP data structure */
18055  SCIP_SOL* sol, /**< primal CIP solution */
18056  SCIP_Bool* feasible, /**< stores whether given solution is feasible */
18057  SCIP_Bool printreason, /**< should the reason for the violation be printed? */
18058  SCIP_Bool completely /**< should all violations be checked? */
18059  );
18060 
18061 /** return whether a primal ray is stored that proves unboundedness of the LP relaxation
18062  *
18063  * @return return whether a primal ray is stored that proves unboundedness of the LP relaxation
18064  *
18065  * @pre This method can be called if SCIP is in one of the following stages:
18066  * - \ref SCIP_STAGE_SOLVING
18067  * - \ref SCIP_STAGE_SOLVED
18068  */
18069 extern
18071  SCIP* scip /**< SCIP data structure */
18072  );
18073 
18074 /** gets value of given variable in primal ray causing unboundedness of the LP relaxation;
18075  * should only be called if such a ray is stored (check with SCIPhasPrimalRay())
18076  *
18077  * @return value of given variable in primal ray causing unboundedness of the LP relaxation
18078  *
18079  * @pre This method can be called if SCIP is in one of the following stages:
18080  * - \ref SCIP_STAGE_SOLVING
18081  * - \ref SCIP_STAGE_SOLVED
18082  */
18083 extern
18085  SCIP* scip, /**< SCIP data structure */
18086  SCIP_VAR* var /**< variable to get value for */
18087  );
18088 
18089 /** updates the primal ray thats proves unboundedness
18090  *
18091  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18092  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18093  *
18094  * @pre This method can be called if @p scip is in one of the following stages:
18095  * - \ref SCIP_STAGE_PRESOLVING
18096  * - \ref SCIP_STAGE_PRESOLVED
18097  * - \ref SCIP_STAGE_SOLVING
18098  * - \ref SCIP_STAGE_SOLVED
18099  *
18100  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18101  */
18102 extern
18104  SCIP* scip, /**< SCIP data structure */
18105  SCIP_SOL* primalray /**< the new primal ray */
18106  );
18107 
18108 /**@} */
18109 
18110 
18111 
18112 
18113 /*
18114  * event methods
18115  */
18116 
18117 /**@addtogroup PublicEventMethods
18118  *
18119  * @{
18120  */
18121 
18122 /** catches a global (not variable or row dependent) event
18123  *
18124  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18125  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18126  *
18127  * @pre This method can be called if @p scip is in one of the following stages:
18128  * - \ref SCIP_STAGE_TRANSFORMING
18129  * - \ref SCIP_STAGE_TRANSFORMED
18130  * - \ref SCIP_STAGE_INITPRESOLVE
18131  * - \ref SCIP_STAGE_PRESOLVING
18132  * - \ref SCIP_STAGE_EXITPRESOLVE
18133  * - \ref SCIP_STAGE_PRESOLVED
18134  * - \ref SCIP_STAGE_INITSOLVE
18135  * - \ref SCIP_STAGE_SOLVING
18136  * - \ref SCIP_STAGE_SOLVED
18137  * - \ref SCIP_STAGE_EXITSOLVE
18138  * - \ref SCIP_STAGE_FREETRANS
18139  */
18140 extern
18142  SCIP* scip, /**< SCIP data structure */
18143  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18144  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18145  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18146  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18147  );
18148 
18149 /** drops a global event (stops to track event)
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 @p scip is in one of the following stages:
18155  * - \ref SCIP_STAGE_TRANSFORMING
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_INITSOLVE
18162  * - \ref SCIP_STAGE_SOLVING
18163  * - \ref SCIP_STAGE_SOLVED
18164  * - \ref SCIP_STAGE_EXITSOLVE
18165  * - \ref SCIP_STAGE_FREETRANS
18166  */
18167 extern
18169  SCIP* scip, /**< SCIP data structure */
18170  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18171  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18172  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18173  int filterpos /**< position of event filter entry returned by SCIPcatchEvent(), or -1 */
18174  );
18175 
18176 /** catches an objective value or domain change event on the given transformed variable
18177  *
18178  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18179  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18180  *
18181  * @pre This method can be called if @p scip is in one of the following stages:
18182  * - \ref SCIP_STAGE_TRANSFORMING
18183  * - \ref SCIP_STAGE_TRANSFORMED
18184  * - \ref SCIP_STAGE_INITPRESOLVE
18185  * - \ref SCIP_STAGE_PRESOLVING
18186  * - \ref SCIP_STAGE_EXITPRESOLVE
18187  * - \ref SCIP_STAGE_PRESOLVED
18188  * - \ref SCIP_STAGE_INITSOLVE
18189  * - \ref SCIP_STAGE_SOLVING
18190  * - \ref SCIP_STAGE_SOLVED
18191  * - \ref SCIP_STAGE_EXITSOLVE
18192  * - \ref SCIP_STAGE_FREETRANS
18193  */
18194 extern
18196  SCIP* scip, /**< SCIP data structure */
18197  SCIP_VAR* var, /**< transformed variable to catch event for */
18198  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18199  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18200  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18201  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18202  );
18203 
18204 /** drops an objective value or domain change event (stops to track event) on the given transformed variable
18205  *
18206  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18207  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18208  *
18209  * @pre This method can be called if @p scip is in one of the following stages:
18210  * - \ref SCIP_STAGE_TRANSFORMING
18211  * - \ref SCIP_STAGE_TRANSFORMED
18212  * - \ref SCIP_STAGE_INITPRESOLVE
18213  * - \ref SCIP_STAGE_PRESOLVING
18214  * - \ref SCIP_STAGE_EXITPRESOLVE
18215  * - \ref SCIP_STAGE_PRESOLVED
18216  * - \ref SCIP_STAGE_INITSOLVE
18217  * - \ref SCIP_STAGE_SOLVING
18218  * - \ref SCIP_STAGE_SOLVED
18219  * - \ref SCIP_STAGE_EXITSOLVE
18220  * - \ref SCIP_STAGE_FREETRANS
18221  */
18222 extern
18224  SCIP* scip, /**< SCIP data structure */
18225  SCIP_VAR* var, /**< transformed variable to drop event for */
18226  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18227  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18228  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18229  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
18230  );
18231 
18232 /** catches a row coefficient, constant, or side change event on the given row
18233  *
18234  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18235  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18236  *
18237  * @pre This method can be called if @p scip is in one of the following stages:
18238  * - \ref SCIP_STAGE_TRANSFORMING
18239  * - \ref SCIP_STAGE_TRANSFORMED
18240  * - \ref SCIP_STAGE_INITPRESOLVE
18241  * - \ref SCIP_STAGE_PRESOLVING
18242  * - \ref SCIP_STAGE_EXITPRESOLVE
18243  * - \ref SCIP_STAGE_PRESOLVED
18244  * - \ref SCIP_STAGE_INITSOLVE
18245  * - \ref SCIP_STAGE_SOLVING
18246  * - \ref SCIP_STAGE_SOLVED
18247  * - \ref SCIP_STAGE_EXITSOLVE
18248  * - \ref SCIP_STAGE_FREETRANS
18249  */
18250 extern
18252  SCIP* scip, /**< SCIP data structure */
18253  SCIP_ROW* row, /**< linear row to catch event for */
18254  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18255  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18256  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18257  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18258  );
18259 
18260 /** drops a row coefficient, constant, or side change event (stops to track event) on the given row
18261  *
18262  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18263  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18264  *
18265  * @pre This method can be called if @p scip is in one of the following stages:
18266  * - \ref SCIP_STAGE_TRANSFORMING
18267  * - \ref SCIP_STAGE_TRANSFORMED
18268  * - \ref SCIP_STAGE_INITPRESOLVE
18269  * - \ref SCIP_STAGE_PRESOLVING
18270  * - \ref SCIP_STAGE_EXITPRESOLVE
18271  * - \ref SCIP_STAGE_PRESOLVED
18272  * - \ref SCIP_STAGE_INITSOLVE
18273  * - \ref SCIP_STAGE_SOLVING
18274  * - \ref SCIP_STAGE_SOLVED
18275  * - \ref SCIP_STAGE_EXITSOLVE
18276  * - \ref SCIP_STAGE_FREETRANS
18277  */
18278 extern
18280  SCIP* scip, /**< SCIP data structure */
18281  SCIP_ROW* row, /**< linear row to drop event for */
18282  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18283  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18284  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18285  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
18286  );
18287 
18288 /**@} */
18289 
18290 
18291 
18292 
18293 /*
18294  * tree methods
18295  */
18296 
18297 /**@addtogroup PublicTreeMethods
18298  *
18299  * @{
18300  */
18301 
18302 /** gets focus node in the tree
18303  *
18304  * if we are in probing/diving mode this method returns the node in the tree where the probing/diving mode was started.
18305  *
18306  * @return the current node of the search tree
18307  *
18308  * @pre This method can be called if @p scip is in one of the following stages:
18309  * - \ref SCIP_STAGE_INITPRESOLVE
18310  * - \ref SCIP_STAGE_PRESOLVING
18311  * - \ref SCIP_STAGE_EXITPRESOLVE
18312  * - \ref SCIP_STAGE_SOLVING
18313  */
18314 extern
18316  SCIP* scip /**< SCIP data structure */
18317  );
18318 
18319 /** gets current node in the tree
18320  *
18321  * @return the current node of the search tree
18322  *
18323  * @pre This method can be called if @p scip is in one of the following stages:
18324  * - \ref SCIP_STAGE_INITPRESOLVE
18325  * - \ref SCIP_STAGE_PRESOLVING
18326  * - \ref SCIP_STAGE_EXITPRESOLVE
18327  * - \ref SCIP_STAGE_SOLVING
18328  */
18329 extern
18331  SCIP* scip /**< SCIP data structure */
18332  );
18333 
18334 /** gets depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
18335  * such that the depth includes the probing path
18336  *
18337  * @return the depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
18338  * such that the depth includes the probing path
18339  *
18340  * @pre This method can be called if SCIP is in one of the following stages:
18341  * - \ref SCIP_STAGE_TRANSFORMED
18342  * - \ref SCIP_STAGE_INITPRESOLVE
18343  * - \ref SCIP_STAGE_PRESOLVING
18344  * - \ref SCIP_STAGE_EXITPRESOLVE
18345  * - \ref SCIP_STAGE_PRESOLVED
18346  * - \ref SCIP_STAGE_INITSOLVE
18347  * - \ref SCIP_STAGE_SOLVING
18348  * - \ref SCIP_STAGE_SOLVED
18349  * - \ref SCIP_STAGE_EXITSOLVE
18350  */
18351 extern
18352 int SCIPgetDepth(
18353  SCIP* scip /**< SCIP data structure */
18354  );
18355 
18356 /** gets depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
18357  * branching tree, excluding the nodes of the probing path
18358  *
18359  * @return the depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
18360  * branching tree, excluding the nodes of the probing path
18361  *
18362  * @pre This method can be called if SCIP is in one of the following stages:
18363  * - \ref SCIP_STAGE_TRANSFORMED
18364  * - \ref SCIP_STAGE_INITPRESOLVE
18365  * - \ref SCIP_STAGE_PRESOLVING
18366  * - \ref SCIP_STAGE_EXITPRESOLVE
18367  * - \ref SCIP_STAGE_PRESOLVED
18368  * - \ref SCIP_STAGE_INITSOLVE
18369  * - \ref SCIP_STAGE_SOLVING
18370  * - \ref SCIP_STAGE_SOLVED
18371  * - \ref SCIP_STAGE_EXITSOLVE
18372  */
18373 extern
18374 int SCIPgetFocusDepth(
18375  SCIP* scip /**< SCIP data structure */
18376  );
18377 
18378 /** gets current plunging depth (successive times, a child was selected as next node)
18379  *
18380  * @return the current plunging depth (successive times, a child was selected as next node)
18381  *
18382  * @pre This method can be called if SCIP is in one of the following stages:
18383  * - \ref SCIP_STAGE_PRESOLVED
18384  * - \ref SCIP_STAGE_SOLVING
18385  */
18386 extern
18387 int SCIPgetPlungeDepth(
18388  SCIP* scip /**< SCIP data structure */
18389  );
18390 
18391 /** gets the root node of the tree
18392  *
18393  * @return the root node of the search tree
18394  *
18395  * @pre This method can be called if @p scip is in one of the following stages:
18396  * - \ref SCIP_STAGE_INITPRESOLVE
18397  * - \ref SCIP_STAGE_PRESOLVING
18398  * - \ref SCIP_STAGE_EXITPRESOLVE
18399  * - \ref SCIP_STAGE_SOLVING
18400  */
18401 extern
18403  SCIP* scip /**< SCIP data structure */
18404  );
18405 
18406 /** gets the effective root depth, i.e., the depth of the deepest node which is part of all paths from the root node
18407  * to the unprocessed nodes.
18408  *
18409  * @return effective root depth
18410  *
18411  * @pre This method can be called if @p scip is in one of the following stages:
18412  * - \ref SCIP_STAGE_SOLVING
18413  */
18414 extern
18416  SCIP* scip /**< SCIP data structure */
18417  );
18418 
18419 /** returns whether the current node is already solved and only propagated again
18420  *
18421  * @return TRUE is returned if \SCIP performance repropagation, otherwise FALSE.
18422  *
18423  * @pre This method can be called if @p scip is in one of the following stages:
18424  * - \ref SCIP_STAGE_INITPRESOLVE
18425  * - \ref SCIP_STAGE_PRESOLVING
18426  * - \ref SCIP_STAGE_EXITPRESOLVE
18427  * - \ref SCIP_STAGE_SOLVING
18428  */
18429 extern
18431  SCIP* scip /**< SCIP data structure */
18432  );
18433 
18434 /** gets children of focus node along with the number of children
18435  *
18436  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18437  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18438  *
18439  * @pre This method can be called if @p scip is in one of the following stages:
18440  * - \ref SCIP_STAGE_SOLVING
18441  */
18442 extern
18444  SCIP* scip, /**< SCIP data structure */
18445  SCIP_NODE*** children, /**< pointer to store children array, or NULL if not needed */
18446  int* nchildren /**< pointer to store number of children, or NULL if not needed */
18447  );
18448 
18449 /** gets number of children of focus node
18450  *
18451  * @return number of children of the focus node
18452  *
18453  * @pre This method can be called if @p scip is in one of the following stages:
18454  * - \ref SCIP_STAGE_SOLVING
18455  */
18456 extern
18457 int SCIPgetNChildren(
18458  SCIP* scip /**< SCIP data structure */
18459  );
18460 
18461 /** gets siblings of focus node along with the number of siblings
18462  *
18463  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18464  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18465  *
18466  * @pre This method can be called if @p scip is in one of the following stages:
18467  * - \ref SCIP_STAGE_SOLVING
18468  */
18469 extern
18471  SCIP* scip, /**< SCIP data structure */
18472  SCIP_NODE*** siblings, /**< pointer to store siblings array, or NULL if not needed */
18473  int* nsiblings /**< pointer to store number of siblings, or NULL if not needed */
18474  );
18475 
18476 /** gets number of siblings of focus node
18477  *
18478  * @return the number of siblings of focus node
18479  *
18480  * @pre This method can be called if @p scip is in one of the following stages:
18481  * - \ref SCIP_STAGE_SOLVING
18482  */
18483 extern
18484 int SCIPgetNSiblings(
18485  SCIP* scip /**< SCIP data structure */
18486  );
18487 
18488 /** gets leaves of the tree along with the number of leaves
18489  *
18490  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18491  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18492  *
18493  * @pre This method can be called if @p scip is in one of the following stages:
18494  * - \ref SCIP_STAGE_SOLVING
18495  */
18496 extern
18498  SCIP* scip, /**< SCIP data structure */
18499  SCIP_NODE*** leaves, /**< pointer to store leaves array, or NULL if not needed */
18500  int* nleaves /**< pointer to store number of leaves, or NULL if not needed */
18501  );
18502 
18503 /** gets number of leaves in the tree
18504  *
18505  * @return the number of leaves in the tree
18506  *
18507  * @pre This method can be called if @p scip is in one of the following stages:
18508  * - \ref SCIP_STAGE_SOLVING
18509  */
18510 extern
18511 int SCIPgetNLeaves(
18512  SCIP* scip /**< SCIP data structure */
18513  );
18514 
18515 /** gets number of nodes left in the tree (children + siblings + leaves)
18516  *
18517  * @return the number of nodes left in the tree (children + siblings + leaves)
18518  *
18519  * @pre This method can be called if SCIP is in one of the following stages:
18520  * - \ref SCIP_STAGE_PRESOLVED
18521  * - \ref SCIP_STAGE_SOLVING
18522  * - \ref SCIP_STAGE_SOLVED
18523  */
18524 extern
18525 int SCIPgetNNodesLeft(
18526  SCIP* scip /**< SCIP data structure */
18527  );
18528 
18529 /** gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
18530  *
18531  * @return the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
18532  *
18533  * @pre This method can be called if @p scip is in one of the following stages:
18534  * - \ref SCIP_STAGE_SOLVING
18535  */
18536 extern
18538  SCIP* scip /**< SCIP data structure */
18539  );
18540 
18541 /** gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
18542  *
18543  * @return the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
18544  *
18545  * @pre This method can be called if @p scip is in one of the following stages:
18546  * - \ref SCIP_STAGE_SOLVING
18547  */
18548 extern
18550  SCIP* scip /**< SCIP data structure */
18551  );
18552 
18553 /** gets the best child of the focus node w.r.t. the node selection strategy
18554  *
18555  * @return the best child of the focus node w.r.t. the node selection strategy
18556  *
18557  * @pre This method can be called if @p scip is in one of the following stages:
18558  * - \ref SCIP_STAGE_SOLVING
18559  */
18560 extern
18562  SCIP* scip /**< SCIP data structure */
18563  );
18564 
18565 /** gets the best sibling of the focus node w.r.t. the node selection strategy
18566  *
18567  * @return the best sibling of the focus node w.r.t. the node selection strategy
18568  *
18569  * @pre This method can be called if @p scip is in one of the following stages:
18570  * - \ref SCIP_STAGE_SOLVING
18571  */
18572 extern
18574  SCIP* scip /**< SCIP data structure */
18575  );
18576 
18577 /** gets the best leaf from the node queue w.r.t. the node selection strategy
18578  *
18579  * @return the best leaf from the node queue w.r.t. the node selection strategy
18580  *
18581  * @pre This method can be called if @p scip is in one of the following stages:
18582  * - \ref SCIP_STAGE_SOLVING
18583  */
18584 extern
18586  SCIP* scip /**< SCIP data structure */
18587  );
18588 
18589 /** gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
18590  *
18591  * @return the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
18592  *
18593  * @pre This method can be called if @p scip is in one of the following stages:
18594  * - \ref SCIP_STAGE_SOLVING
18595  */
18596 extern
18598  SCIP* scip /**< SCIP data structure */
18599  );
18600 
18601 /** gets the node with smallest lower bound from the tree (child, sibling, or leaf)
18602  *
18603  * @return the node with smallest lower bound from the tree (child, sibling, or leaf)
18604  *
18605  * @pre This method can be called if @p scip is in one of the following stages:
18606  * - \ref SCIP_STAGE_SOLVING
18607  */
18608 extern
18610  SCIP* scip /**< SCIP data structure */
18611  );
18612 
18613 /** access to all data of open nodes (leaves, children, and siblings)
18614  *
18615  * @pre This method can be called if @p scip is in one of the following stages:
18616  * - \ref SCIP_STAGE_SOLVING
18617  */
18618 extern
18620  SCIP* scip, /**< SCIP data structure */
18621  SCIP_NODE*** leaves, /**< pointer to store the leaves, or NULL if not needed */
18622  SCIP_NODE*** children, /**< pointer to store the children, or NULL if not needed */
18623  SCIP_NODE*** siblings, /**< pointer to store the siblings, or NULL if not needed */
18624  int* nleaves, /**< pointer to store the number of leaves, or NULL */
18625  int* nchildren, /**< pointer to store the number of children, or NULL */
18626  int* nsiblings /**< pointer to store the number of siblings, or NULL */
18627  );
18628 
18629 /** cuts off node and whole sub tree from branch and bound tree
18630  *
18631  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18632  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18633  *
18634  * @pre This method can be called if @p scip is in one of the following stages:
18635  * - \ref SCIP_STAGE_SOLVING
18636  */
18637 extern
18639  SCIP* scip, /**< SCIP data structure */
18640  SCIP_NODE* node /**< node that should be cut off */
18641  );
18642 
18643 /** marks the given node to be propagated again the next time a node of its subtree is processed
18644  *
18645  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18646  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18647  *
18648  * @pre This method can be called if @p scip is in one of the following stages:
18649  * - \ref SCIP_STAGE_SOLVING
18650  */
18651 extern
18653  SCIP* scip, /**< SCIP data structure */
18654  SCIP_NODE* node /**< node that should be propagated again */
18655  );
18656 
18657 /** returns depth of first node in active path that is marked being cutoff
18658  *
18659  * @return depth of first node in active path that is marked being cutoff
18660  *
18661  * @pre This method can be called if @p scip is in one of the following stages:
18662  * - \ref SCIP_STAGE_SOLVING
18663  */
18664 extern
18665 int SCIPgetCutoffdepth(
18666  SCIP* scip /**< SCIP data structure */
18667  );
18668 
18669 /** returns depth of first node in active path that has to be propagated again
18670  *
18671  * @return depth of first node in active path that has to be propagated again
18672  *
18673  * @pre This method can be called if @p scip is in one of the following stages:
18674  * - \ref SCIP_STAGE_SOLVING
18675  */
18676 extern
18677 int SCIPgetRepropdepth(
18678  SCIP* scip /**< SCIP data structure */
18679  );
18680 
18681 /** prints all branching decisions on variables from the root to the given node
18682  *
18683  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18684  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18685  *
18686  * @pre This method can be called if @p scip is in one of the following stages:
18687  * - \ref SCIP_STAGE_SOLVING
18688  */
18689 extern
18691  SCIP* scip, /**< SCIP data structure */
18692  SCIP_NODE* node, /**< node data */
18693  FILE* file /**< output file (or NULL for standard output) */
18694  );
18695 
18696 /** sets whether the LP should be solved at the focus node
18697  *
18698  * @note In order to have an effect, this method needs to be called after a node is focused but before the LP is
18699  * solved.
18700  *
18701  * @pre This method can be called if @p scip is in one of the following stages:
18702  * - \ref SCIP_STAGE_SOLVING
18703  */
18704 extern
18705 void SCIPsetFocusnodeLP(
18706  SCIP* scip, /**< SCIP data structure */
18707  SCIP_Bool solvelp /**< should the LP be solved? */
18708  );
18709 
18710 /**@} */
18711 
18712 
18713 /*
18714  * parallel interface methods
18715  */
18716 
18717 /**@addtogroup PublicParallelMethods
18718  *
18719  * @{
18720  */
18721 
18722 /** Constructs the parallel interface to execute processes concurrently.
18723  *
18724  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18725  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18726  *
18727  * @pre This method can be called if @p scip is in one of the following stages:
18728  * - \ref SCIP_STAGE_PROBLEM
18729  * - \ref SCIP_STAGE_TRANSFORMING
18730  * - \ref SCIP_STAGE_TRANSFORMED
18731  * - \ref SCIP_STAGE_INITPRESOLVE
18732  * - \ref SCIP_STAGE_PRESOLVING
18733  * - \ref SCIP_STAGE_EXITPRESOLVE
18734  * - \ref SCIP_STAGE_PRESOLVED
18735  * - \ref SCIP_STAGE_INITSOLVE
18736  * - \ref SCIP_STAGE_SOLVING
18737  * - \ref SCIP_STAGE_SOLVED
18738  * - \ref SCIP_STAGE_EXITSOLVE
18739  * - \ref SCIP_STAGE_FREETRANS
18740  *
18741  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18742  */
18743 extern
18745  SCIP* scip /**< SCIP data structure */
18746  );
18747 
18748 /** releases the current synchronization store
18749  *
18750  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18751  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18752  *
18753  * @pre This method can be called if @p scip is in one of the following stages:
18754  * - \ref SCIP_STAGE_PROBLEM
18755  * - \ref SCIP_STAGE_TRANSFORMING
18756  * - \ref SCIP_STAGE_TRANSFORMED
18757  * - \ref SCIP_STAGE_INITPRESOLVE
18758  * - \ref SCIP_STAGE_PRESOLVING
18759  * - \ref SCIP_STAGE_EXITPRESOLVE
18760  * - \ref SCIP_STAGE_PRESOLVED
18761  * - \ref SCIP_STAGE_INITSOLVE
18762  * - \ref SCIP_STAGE_SOLVING
18763  * - \ref SCIP_STAGE_SOLVED
18764  * - \ref SCIP_STAGE_EXITSOLVE
18765  * - \ref SCIP_STAGE_FREETRANS
18766  * - \ref SCIP_STAGE_FREE
18767  *
18768  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18769  */
18771  SCIP* scip /**< SCIP data structure */
18772  );
18773 
18774 /** Gets the synchronization store.
18775  *
18776  * @return the \ref SCIP_SYNCSTORE parallel interface pointer to submit jobs for concurrent processing.
18777  *
18778  * @pre This method can be called if @p scip is in one of the following stages:
18779  * - \ref SCIP_STAGE_INIT
18780  * - \ref SCIP_STAGE_PROBLEM
18781  * - \ref SCIP_STAGE_TRANSFORMING
18782  * - \ref SCIP_STAGE_TRANSFORMED
18783  * - \ref SCIP_STAGE_INITPRESOLVE
18784  * - \ref SCIP_STAGE_PRESOLVING
18785  * - \ref SCIP_STAGE_EXITPRESOLVE
18786  * - \ref SCIP_STAGE_PRESOLVED
18787  * - \ref SCIP_STAGE_INITSOLVE
18788  * - \ref SCIP_STAGE_SOLVING
18789  * - \ref SCIP_STAGE_SOLVED
18790  * - \ref SCIP_STAGE_EXITSOLVE
18791  * - \ref SCIP_STAGE_FREETRANS
18792  *
18793  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18794  */
18795 extern
18797  SCIP* scip /**< SCIP data structure */
18798  );
18799 
18800 /**@} */
18801 
18802 
18803 
18804 /*
18805  * reoptimization methods
18806  */
18807 
18808 /**@addtogroup PublicReoptimizationMethods
18809  *
18810  * @{
18811  */
18812 
18813 /** return the ids of child nodes stored in the reoptimization tree
18814  *
18815  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18816  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18817  *
18818  * @pre This method can be called if @p scip is in one of the following stages:
18819  * - \ref SCIP_STAGE_PRESOLVED
18820  * - \ref SCIP_STAGE_SOLVING
18821  * - \ref SCIP_STAGE_SOLVED
18822  */
18823 extern
18825  SCIP* scip, /**< SCIP data structure */
18826  SCIP_NODE* node, /**< node of the search tree */
18827  unsigned int* ids, /**< array to store the ids of child nodes */
18828  int mem, /**< allocated memory */
18829  int* nids /**< number of child nodes */
18830  );
18831 
18832 /** return the ids of all leave nodes store in the reoptimization tree induced by the given node
18833  *
18834  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18835  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18836  *
18837  * @pre This method can be called if @p scip is in one of the following stages:
18838  * - \ref SCIP_STAGE_PRESOLVED
18839  * - \ref SCIP_STAGE_SOLVING
18840  * - \ref SCIP_STAGE_SOLVED
18841  */
18842 extern
18844  SCIP* scip, /**< SCIP data strcuture */
18845  SCIP_NODE* node, /**< node of the search tree */
18846  unsigned int* ids, /**< array of ids */
18847  int mem, /**< allocated memory */
18848  int* nids /**< number of child nodes */
18849  );
18850 
18851 /** returns the number of nodes in the reoptimization tree induced by @p node; if @p node == NULL, the method
18852  * returns the number of nodes of the whole reoptimization tree.
18853  */
18854 extern
18855 int SCIPgetNReoptnodes(
18856  SCIP* scip, /**< SCIP data structure */
18857  SCIP_NODE* node /**< node of the search tree */
18858  );
18859 
18860 /** returns the number of leave nodes of the subtree induced by @p node; if @p node == NULL, the method
18861  * returns the number of leaf nodes of the whole reoptimization tree.
18862  */
18863 extern
18865  SCIP* scip, /**< SCIP data structure */
18866  SCIP_NODE* node /**< node of the search tree */
18867  );
18868 
18869 /** gets the node of the reoptimization tree corresponding to the unique @p id */
18871  SCIP* scip, /**< SCIP data structure */
18872  unsigned int id /**< unique id */
18873  );
18874 
18875 /** add a variable bound change to a given reoptnode
18876  *
18877  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18878  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18879  *
18880  * @pre This method can be called if @p scip is in one of the following stages:
18881  * - \ref SCIP_STAGE_PRESOLVED
18882  * - \ref SCIP_STAGE_SOLVING
18883  * - \ref SCIP_STAGE_SOLVED
18884  */
18885 extern
18887  SCIP* scip, /**< SCIP data structure */
18888  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
18889  SCIP_VAR* var, /**< variable pointer */
18890  SCIP_Real bound, /**< variable bound to add */
18891  SCIP_BOUNDTYPE boundtype /**< bound type of the variable value */
18892  );
18893 
18894 /** set the @p representation as the new search frontier
18895  *
18896  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18897  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18898  *
18899  * @pre This method can be called if @p scip is in one of the following stages:
18900  * - \ref SCIP_STAGE_PRESOLVED
18901  */
18902 extern
18904  SCIP* scip, /**< SCIP data structure */
18905  SCIP_REOPTNODE** representation, /**< array of representatives */
18906  int nrepresentatives, /**< number of representatives */
18907  SCIP_Bool* success /**< pointer to store the result */
18908  );
18909 
18910 /** add stored constraint to a reoptimization node
18911  *
18912  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18913  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18914  *
18915  * @pre This method can be called if @p scip is in one of the following stages:
18916  * - \ref SCIP_STAGE_PRESOLVED
18917  */
18918 extern
18920  SCIP* scip, /**< SCIP data structure */
18921  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
18922  SCIP_VAR** vars, /**< array of variables */
18923  SCIP_Real* vals, /**< array of variable bounds */
18924  SCIP_BOUNDTYPE* boundtypes, /**< array of variable boundtypes */
18925  SCIP_Real lhs, /**< lhs of the constraint */
18926  SCIP_Real rhs, /**< rhs of the constraint */
18927  int nvars, /**< number of variables */
18928  REOPT_CONSTYPE constype, /**< type of the constraint */
18929  SCIP_Bool linear /**< the given constraint has a linear representation */
18930  );
18931 
18932 /** return the branching path stored in the reoptree at ID id */
18933 extern
18935  SCIP* scip, /**< SCIP data structure */
18936  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
18937  SCIP_VAR** vars, /**< array of variables */
18938  SCIP_Real* vals, /**< array of variable bounds */
18939  SCIP_BOUNDTYPE* boundtypes, /**< array of bound types */
18940  int mem, /**< allocated memory */
18941  int* nvars, /**< number of variables */
18942  int* nafterdualvars /**< number of variables directly after the first based on dual information */
18943  );
18944 
18945 /** initialize a set of empty reoptimization nodes
18946  *
18947  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18948  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18949  *
18950  * @pre This method can be called if @p scip is in one of the following stages:
18951  * - \ref SCIP_STAGE_PRESOLVED
18952  */
18953 extern
18955  SCIP* scip, /**< SCIP data structure */
18956  SCIP_REOPTNODE** representatives, /**< array of representatives */
18957  int nrepresentatives /**< number of representatives */
18958  );
18959 
18960 /** reset a set of initialized reoptimization nodes
18961  *
18962  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18963  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18964  *
18965  * @pre This method can be called if @p scip is in one of the following stages:
18966  * - \ref SCIP_STAGE_PRESOLVED
18967  */
18969  SCIP* scip, /**< SCIP data structure */
18970  SCIP_REOPTNODE** representatives, /**< array of representatives */
18971  int nrepresentatives /**< number of representatives */
18972  );
18973 
18974 /** free a set of initialized reoptimization nodes
18975  *
18976  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18977  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18978  *
18979  * @pre This method can be called if @p scip is in one of the following stages:
18980  * - \ref SCIP_STAGE_PRESOLVED
18981  */
18982 extern
18984  SCIP* scip, /**< SCIP data structure */
18985  SCIP_REOPTNODE** representatives, /**< array of representatives */
18986  int nrepresentatives /**< number of representatives */
18987  );
18988 
18989 /** reactivate the given @p reoptnode and split them into several nodes if necessary
18990  *
18991  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18992  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18993  *
18994  * @pre This method can be called if @p scip is in one of the following stages:
18995  * - \ref SCIP_STAGE_SOLVING
18996  * - \ref SCIP_STAGE_SOLVED
18997  */
18998 extern
19000  SCIP* scip, /**< SCIP data structure */
19001  SCIP_REOPTNODE* reoptnode, /**< node to reactivate */
19002  unsigned int id, /**< unique id of the reoptimization node */
19003  SCIP_Real estimate, /**< estimate of the child nodes that should be created */
19004  SCIP_NODE** childnodes, /**< array to store the created child nodes */
19005  int* ncreatedchilds, /**< pointer to store number of created child nodes */
19006  int* naddedconss, /**< pointer to store number of generated constraints */
19007  int childnodessize, /**< available size of childnodes array */
19008  SCIP_Bool* success /**< pointer store the result*/
19009  );
19010 
19011 /** remove the stored information about bound changes based in dual information
19012  *
19013  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19014  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19015  *
19016  * @pre This method can be called if @p scip is in one of the following stages:
19017  * - \ref SCIP_STAGE_SOLVING
19018  * - \ref SCIP_STAGE_SOLVED
19019  */
19020 extern
19022  SCIP* scip, /**< SCIP data structure */
19023  SCIP_NODE* node /**< node of the search tree */
19024  );
19025 
19026 /** splits the root into several nodes and moves the child nodes of the root to one of the created nodes
19027  *
19028  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19029  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19030  *
19031  * @pre This method can be called if @p scip is in one of the following stages:
19032  * - \ref SCIP_STAGE_TRANSFORMED
19033  * - \ref SCIP_STAGE_SOLVING
19034  */
19035 extern
19037  SCIP* scip, /**< SCIP data structure */
19038  int* ncreatedchilds, /**< pointer to store the number of created nodes */
19039  int* naddedconss /**< pointer to store the number added constraints */
19040  );
19041 
19042 /** returns if a node should be reoptimized */
19043 extern
19045  SCIP* scip, /**< SCIP data structure */
19046  SCIP_NODE* node /**< node of the search tree */
19047  );
19048 
19049 /** deletes the given reoptimization node
19050  *
19051  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19052  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19053  *
19054  * @pre This method can be called if @p scip is in one of the following stages:
19055  * - \ref SCIP_STAGE_SOLVING
19056  */
19057 extern
19059  SCIP* scip, /**< SCIP data structure */
19060  SCIP_REOPTNODE** reoptnode /**< node of the reoptimization tree */
19061  );
19062 
19063 /** return the similarity between two objective functions */
19064 extern
19066  SCIP* scip, /**< SCIP data structure */
19067  int run1, /**< number of run */
19068  int run2 /**< number of run */
19069  );
19070 
19071 /** check the changes of the variable coefficient in the objective function */
19072 extern
19073 void SCIPgetVarCoefChg(
19074  SCIP* scip, /**< SCIP data structure */
19075  int varidx, /**< index of variable */
19076  SCIP_Bool* negated, /**< coefficient changed the sign */
19077  SCIP_Bool* entering, /**< coefficient gets non-zero coefficient */
19078  SCIP_Bool* leaving /**< coefficient gets zero coefficient */
19079  );
19080 
19081 /* @} */
19082 
19083 /*
19084  * statistic methods
19085  */
19086 
19087 /**@addtogroup PublicSolvingStatsMethods
19088  *
19089  * @{
19090  */
19091 
19092 /** gets number of branch and bound runs performed, including the current run
19093  *
19094  * @return the number of branch and bound runs performed, including the current run
19095  *
19096  * @pre This method can be called if 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  */
19110 extern
19111 int SCIPgetNRuns(
19112  SCIP* scip /**< SCIP data structure */
19113  );
19114 
19115 /** gets number of reoptimization runs performed, including the current run
19116  *
19117  * @return the number of reoptimization runs performed, including the current run
19118  *
19119  * @pre This method can be called if SCIP is in one of the following stages:
19120  * - \ref SCIP_STAGE_PROBLEM
19121  * - \ref SCIP_STAGE_TRANSFORMING
19122  * - \ref SCIP_STAGE_TRANSFORMED
19123  * - \ref SCIP_STAGE_INITPRESOLVE
19124  * - \ref SCIP_STAGE_PRESOLVING
19125  * - \ref SCIP_STAGE_EXITPRESOLVE
19126  * - \ref SCIP_STAGE_PRESOLVED
19127  * - \ref SCIP_STAGE_INITSOLVE
19128  * - \ref SCIP_STAGE_SOLVING
19129  * - \ref SCIP_STAGE_SOLVED
19130  * - \ref SCIP_STAGE_EXITSOLVE
19131  * - \ref SCIP_STAGE_FREETRANS
19132  */
19133 extern
19134 int SCIPgetNReoptRuns(
19135  SCIP* scip /**< SCIP data structure */
19136  );
19137 
19138 /** add given number to the number of processed nodes in current run and in all runs, including the focus node
19139  *
19140  * @return the number of processed nodes in current run, including the focus node
19141  *
19142  * @pre This method can be called if SCIP is in one of the following stages:
19143  * - \ref SCIP_STAGE_PROBLEM
19144  * - \ref SCIP_STAGE_TRANSFORMING
19145  * - \ref SCIP_STAGE_TRANSFORMED
19146  * - \ref SCIP_STAGE_INITPRESOLVE
19147  * - \ref SCIP_STAGE_PRESOLVING
19148  * - \ref SCIP_STAGE_EXITPRESOLVE
19149  * - \ref SCIP_STAGE_PRESOLVED
19150  * - \ref SCIP_STAGE_INITSOLVE
19151  * - \ref SCIP_STAGE_SOLVING
19152  * - \ref SCIP_STAGE_SOLVED
19153  * - \ref SCIP_STAGE_EXITSOLVE
19154  * - \ref SCIP_STAGE_FREETRANS
19155  */
19156 extern
19157 void SCIPaddNNodes(
19158  SCIP* scip, /**< SCIP data structure */
19159  SCIP_Longint nnodes /**< number of processed nodes to add to the statistics */
19160  );
19161 
19162 /** gets number of processed nodes in current run, including the focus node
19163  *
19164  * @return the number of processed nodes in current run, including the focus node
19165  *
19166  * @pre This method can be called if SCIP is in one of the following stages:
19167  * - \ref SCIP_STAGE_PROBLEM
19168  * - \ref SCIP_STAGE_TRANSFORMING
19169  * - \ref SCIP_STAGE_TRANSFORMED
19170  * - \ref SCIP_STAGE_INITPRESOLVE
19171  * - \ref SCIP_STAGE_PRESOLVING
19172  * - \ref SCIP_STAGE_EXITPRESOLVE
19173  * - \ref SCIP_STAGE_PRESOLVED
19174  * - \ref SCIP_STAGE_INITSOLVE
19175  * - \ref SCIP_STAGE_SOLVING
19176  * - \ref SCIP_STAGE_SOLVED
19177  * - \ref SCIP_STAGE_EXITSOLVE
19178  * - \ref SCIP_STAGE_FREETRANS
19179  */
19180 extern
19182  SCIP* scip /**< SCIP data structure */
19183  );
19184 
19185 /** gets total number of processed nodes in all runs, including the focus node
19186  *
19187  * @return the total number of processed nodes in all runs, including the focus node
19188  *
19189  * @pre This method can be called if SCIP is in one of the following stages:
19190  * - \ref SCIP_STAGE_PROBLEM
19191  * - \ref SCIP_STAGE_TRANSFORMING
19192  * - \ref SCIP_STAGE_TRANSFORMED
19193  * - \ref SCIP_STAGE_INITPRESOLVE
19194  * - \ref SCIP_STAGE_PRESOLVING
19195  * - \ref SCIP_STAGE_EXITPRESOLVE
19196  * - \ref SCIP_STAGE_PRESOLVED
19197  * - \ref SCIP_STAGE_INITSOLVE
19198  * - \ref SCIP_STAGE_SOLVING
19199  * - \ref SCIP_STAGE_SOLVED
19200  * - \ref SCIP_STAGE_EXITSOLVE
19201  * - \ref SCIP_STAGE_FREETRANS
19202  */
19203 extern
19205  SCIP* scip /**< SCIP data structure */
19206  );
19207 
19208 /** gets number of leaf nodes processed with feasible relaxation solution
19209  *
19210  * @return number of leaf nodes processed with feasible relaxation solution
19211  *
19212  * @pre This method can be called if SCIP is in one of the following stages:
19213  * - \ref SCIP_STAGE_PROBLEM
19214  * - \ref SCIP_STAGE_TRANSFORMING
19215  * - \ref SCIP_STAGE_TRANSFORMED
19216  * - \ref SCIP_STAGE_INITPRESOLVE
19217  * - \ref SCIP_STAGE_PRESOLVING
19218  * - \ref SCIP_STAGE_EXITPRESOLVE
19219  * - \ref SCIP_STAGE_PRESOLVED
19220  * - \ref SCIP_STAGE_INITSOLVE
19221  * - \ref SCIP_STAGE_SOLVING
19222  * - \ref SCIP_STAGE_SOLVED
19223  * - \ref SCIP_STAGE_EXITSOLVE
19224  * - \ref SCIP_STAGE_FREETRANS
19225  */
19226 extern
19228  SCIP* scip /**< SCIP data structure */
19229  );
19230 
19231 /** gets number of infeasible leaf nodes processed
19232  *
19233  * @return number of infeasible leaf nodes processed
19234  *
19235  * @pre This method can be called if SCIP is in one of the following stages:
19236  * - \ref SCIP_STAGE_PROBLEM
19237  * - \ref SCIP_STAGE_TRANSFORMING
19238  * - \ref SCIP_STAGE_TRANSFORMED
19239  * - \ref SCIP_STAGE_INITPRESOLVE
19240  * - \ref SCIP_STAGE_PRESOLVING
19241  * - \ref SCIP_STAGE_EXITPRESOLVE
19242  * - \ref SCIP_STAGE_PRESOLVED
19243  * - \ref SCIP_STAGE_INITSOLVE
19244  * - \ref SCIP_STAGE_SOLVING
19245  * - \ref SCIP_STAGE_SOLVED
19246  * - \ref SCIP_STAGE_EXITSOLVE
19247  * - \ref SCIP_STAGE_FREETRANS
19248  */
19249 extern
19251  SCIP* scip /**< SCIP data structure */
19252  );
19253 
19254 /** gets number of processed leaf nodes that hit LP objective limit
19255  *
19256  * @return number of processed leaf nodes that hit LP objective limit
19257  *
19258  * @pre This method can be called if SCIP is in one of the following stages:
19259  * - \ref SCIP_STAGE_PROBLEM
19260  * - \ref SCIP_STAGE_TRANSFORMING
19261  * - \ref SCIP_STAGE_TRANSFORMED
19262  * - \ref SCIP_STAGE_INITPRESOLVE
19263  * - \ref SCIP_STAGE_PRESOLVING
19264  * - \ref SCIP_STAGE_EXITPRESOLVE
19265  * - \ref SCIP_STAGE_PRESOLVED
19266  * - \ref SCIP_STAGE_INITSOLVE
19267  * - \ref SCIP_STAGE_SOLVING
19268  * - \ref SCIP_STAGE_SOLVED
19269  * - \ref SCIP_STAGE_EXITSOLVE
19270  * - \ref SCIP_STAGE_FREETRANS
19271  */
19272 extern
19274  SCIP* scip /**< SCIP data structure */
19275  );
19276 
19277 /** gets number of times a selected node was from a cut off subtree
19278  *
19279  * @return number of times a selected node was from a cut off subtree
19280  *
19281  * @pre This method can be called if SCIP is in one of the following stages:
19282  * - \ref SCIP_STAGE_PROBLEM
19283  * - \ref SCIP_STAGE_TRANSFORMING
19284  * - \ref SCIP_STAGE_TRANSFORMED
19285  * - \ref SCIP_STAGE_INITPRESOLVE
19286  * - \ref SCIP_STAGE_PRESOLVING
19287  * - \ref SCIP_STAGE_EXITPRESOLVE
19288  * - \ref SCIP_STAGE_PRESOLVED
19289  * - \ref SCIP_STAGE_INITSOLVE
19290  * - \ref SCIP_STAGE_SOLVING
19291  * - \ref SCIP_STAGE_SOLVED
19292  * - \ref SCIP_STAGE_EXITSOLVE
19293  * - \ref SCIP_STAGE_FREETRANS
19294  */
19295 extern
19297  SCIP* scip /**< SCIP data structure */
19298  );
19299 
19300 /** gets total number of LPs solved so far
19301  *
19302  * @return the total number of LPs solved so far
19303  *
19304  * @pre This method can be called if SCIP is in one of the following stages:
19305  * - \ref SCIP_STAGE_PROBLEM
19306  * - \ref SCIP_STAGE_TRANSFORMING
19307  * - \ref SCIP_STAGE_TRANSFORMED
19308  * - \ref SCIP_STAGE_INITPRESOLVE
19309  * - \ref SCIP_STAGE_PRESOLVING
19310  * - \ref SCIP_STAGE_EXITPRESOLVE
19311  * - \ref SCIP_STAGE_PRESOLVED
19312  * - \ref SCIP_STAGE_INITSOLVE
19313  * - \ref SCIP_STAGE_SOLVING
19314  * - \ref SCIP_STAGE_SOLVED
19315  * - \ref SCIP_STAGE_EXITSOLVE
19316  * - \ref SCIP_STAGE_FREETRANS
19317  */
19318 extern
19320  SCIP* scip /**< SCIP data structure */
19321  );
19322 
19323 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
19324  *
19325  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
19326  *
19327  * @pre This method can be called if SCIP is in one of the following stages:
19328  * - \ref SCIP_STAGE_PRESOLVING
19329  * - \ref SCIP_STAGE_PRESOLVED
19330  * - \ref SCIP_STAGE_SOLVING
19331  * - \ref SCIP_STAGE_SOLVED
19332  */
19333 extern
19335  SCIP* scip /**< SCIP data structure */
19336  );
19337 
19338 /** gets number of active non-zeros in the current transformed problem
19339  *
19340  * @return the number of active non-zeros in the current transformed problem
19341  *
19342  * @pre This method can be called if SCIP is in one of the following stages:
19343  * - \ref SCIP_STAGE_PROBLEM
19344  * - \ref SCIP_STAGE_TRANSFORMING
19345  * - \ref SCIP_STAGE_TRANSFORMED
19346  * - \ref SCIP_STAGE_INITPRESOLVE
19347  * - \ref SCIP_STAGE_PRESOLVING
19348  * - \ref SCIP_STAGE_EXITPRESOLVE
19349  * - \ref SCIP_STAGE_PRESOLVED
19350  * - \ref SCIP_STAGE_INITSOLVE
19351  * - \ref SCIP_STAGE_SOLVING
19352  * - \ref SCIP_STAGE_SOLVED
19353  * - \ref SCIP_STAGE_EXITSOLVE
19354  */
19355 extern
19357  SCIP* scip /**< SCIP data structure */
19358  );
19359 
19360 
19361 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
19362  *
19363  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
19364  *
19365  * @pre This method can be called if SCIP is in one of the following stages:
19366  * - \ref SCIP_STAGE_PRESOLVED
19367  * - \ref SCIP_STAGE_SOLVING
19368  * - \ref SCIP_STAGE_SOLVED
19369  */
19370 extern
19372  SCIP* scip /**< SCIP data structure */
19373  );
19374 
19375 /** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
19376  * node
19377  *
19378  * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
19379  *
19380  * @pre This method can be called if SCIP is in one of the following stages:
19381  * - \ref SCIP_STAGE_PRESOLVED
19382  * - \ref SCIP_STAGE_SOLVING
19383  * - \ref SCIP_STAGE_SOLVED
19384  */
19385 extern
19387  SCIP* scip /**< SCIP data structure */
19388  );
19389 
19390 /** gets total number of primal LPs solved so far
19391  *
19392  * @return the total number of primal LPs solved so far
19393  *
19394  * @pre This method can be called if SCIP is in one of the following stages:
19395  * - \ref SCIP_STAGE_PRESOLVED
19396  * - \ref SCIP_STAGE_SOLVING
19397  * - \ref SCIP_STAGE_SOLVED
19398  */
19399 extern
19401  SCIP* scip /**< SCIP data structure */
19402  );
19403 
19404 /** gets total number of iterations used so far in primal simplex
19405  *
19406  * @return total number of iterations used so far in primal simplex
19407  *
19408  * @pre This method can be called if SCIP is in one of the following stages:
19409  * - \ref SCIP_STAGE_PRESOLVED
19410  * - \ref SCIP_STAGE_SOLVING
19411  * - \ref SCIP_STAGE_SOLVED
19412  */
19413 extern
19415  SCIP* scip /**< SCIP data structure */
19416  );
19417 
19418 /** gets total number of dual LPs solved so far
19419  *
19420  * @return the total number of dual LPs solved so far
19421  *
19422  * @pre This method can be called if SCIP is in one of the following stages:
19423  * - \ref SCIP_STAGE_PRESOLVED
19424  * - \ref SCIP_STAGE_SOLVING
19425  * - \ref SCIP_STAGE_SOLVED
19426  */
19427 extern
19429  SCIP* scip /**< SCIP data structure */
19430  );
19431 
19432 /** gets total number of iterations used so far in dual simplex
19433  *
19434  * @return the total number of iterations used so far in dual simplex
19435  *
19436  * @pre This method can be called if SCIP is in one of the following stages:
19437  * - \ref SCIP_STAGE_PRESOLVED
19438  * - \ref SCIP_STAGE_SOLVING
19439  * - \ref SCIP_STAGE_SOLVED
19440  */
19441 extern
19443  SCIP* scip /**< SCIP data structure */
19444  );
19445 
19446 /** gets total number of barrier LPs solved so far
19447  *
19448  * @return the total number of barrier LPs solved so far
19449  *
19450  * @pre This method can be called if SCIP is in one of the following stages:
19451  * - \ref SCIP_STAGE_PRESOLVED
19452  * - \ref SCIP_STAGE_SOLVING
19453  * - \ref SCIP_STAGE_SOLVED
19454  */
19455 extern
19457  SCIP* scip /**< SCIP data structure */
19458  );
19459 
19460 /** gets total number of iterations used so far in barrier algorithm
19461  *
19462  * @return the total number of iterations used so far in barrier algorithm
19463  *
19464  * @pre This method can be called if SCIP is in one of the following stages:
19465  * - \ref SCIP_STAGE_PRESOLVED
19466  * - \ref SCIP_STAGE_SOLVING
19467  * - \ref SCIP_STAGE_SOLVED
19468  */
19469 extern
19471  SCIP* scip /**< SCIP data structure */
19472  );
19473 
19474 /** gets total number of LPs solved so far that were resolved from an advanced start basis
19475  *
19476  * @return the total number of LPs solved so far that were resolved from an advanced start basis
19477  *
19478  * @pre This method can be called if SCIP is in one of the following stages:
19479  * - \ref SCIP_STAGE_PRESOLVED
19480  * - \ref SCIP_STAGE_SOLVING
19481  * - \ref SCIP_STAGE_SOLVED
19482  */
19483 extern
19485  SCIP* scip /**< SCIP data structure */
19486  );
19487 
19488 /** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
19489  * was available
19490  *
19491  * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
19492  * basis was available
19493  *
19494  * @pre This method can be called if SCIP is in one of the following stages:
19495  * - \ref SCIP_STAGE_PRESOLVED
19496  * - \ref SCIP_STAGE_SOLVING
19497  * - \ref SCIP_STAGE_SOLVED
19498  */
19499 extern
19501  SCIP* scip /**< SCIP data structure */
19502  );
19503 
19504 /** gets total number of primal LPs solved so far that were resolved from an advanced start basis
19505  *
19506  * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
19507  *
19508  * @pre This method can be called if SCIP is in one of the following stages:
19509  * - \ref SCIP_STAGE_PRESOLVED
19510  * - \ref SCIP_STAGE_SOLVING
19511  * - \ref SCIP_STAGE_SOLVED
19512  */
19513 extern
19515  SCIP* scip /**< SCIP data structure */
19516  );
19517 
19518 /** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
19519  * was available
19520  *
19521  * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
19522  * basis was available
19523  *
19524  * @pre This method can be called if SCIP is in one of the following stages:
19525  * - \ref SCIP_STAGE_PRESOLVED
19526  * - \ref SCIP_STAGE_SOLVING
19527  * - \ref SCIP_STAGE_SOLVED
19528  */
19529 extern
19531  SCIP* scip /**< SCIP data structure */
19532  );
19533 
19534 /** gets total number of dual LPs solved so far that were resolved from an advanced start basis
19535  *
19536  * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
19537  *
19538  * @pre This method can be called if SCIP is in one of the following stages:
19539  * - \ref SCIP_STAGE_PRESOLVED
19540  * - \ref SCIP_STAGE_SOLVING
19541  * - \ref SCIP_STAGE_SOLVED
19542  */
19543 extern
19545  SCIP* scip /**< SCIP data structure */
19546  );
19547 
19548 /** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
19549  * was available
19550  *
19551  * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
19552  * basis was available
19553  *
19554  * @pre This method can be called if SCIP is in one of the following stages:
19555  * - \ref SCIP_STAGE_PRESOLVED
19556  * - \ref SCIP_STAGE_SOLVING
19557  * - \ref SCIP_STAGE_SOLVED
19558  */
19559 extern
19561  SCIP* scip /**< SCIP data structure */
19562  );
19563 
19564 /** gets total number of LPs solved so far for node relaxations
19565  *
19566  * @return the total number of LPs solved so far for node relaxations
19567  *
19568  * @pre This method can be called if SCIP is in one of the following stages:
19569  * - \ref SCIP_STAGE_PRESOLVED
19570  * - \ref SCIP_STAGE_SOLVING
19571  * - \ref SCIP_STAGE_SOLVED
19572  */
19573 extern
19575  SCIP* scip /**< SCIP data structure */
19576  );
19577 
19578 /** gets total number of simplex iterations used so far for node relaxations
19579  *
19580  * @return the total number of simplex iterations used so far for node relaxations
19581  *
19582  * @pre This method can be called if SCIP is in one of the following stages:
19583  * - \ref SCIP_STAGE_PRESOLVED
19584  * - \ref SCIP_STAGE_SOLVING
19585  * - \ref SCIP_STAGE_SOLVED
19586  */
19587 extern
19589  SCIP* scip /**< SCIP data structure */
19590  );
19591 
19592 /** gets total number of LPs solved so far for initial LP in node relaxations
19593  *
19594  * @return the total number of LPs solved so far for initial LP in node relaxations
19595  *
19596  * @pre This method can be called if SCIP is in one of the following stages:
19597  * - \ref SCIP_STAGE_PRESOLVED
19598  * - \ref SCIP_STAGE_SOLVING
19599  * - \ref SCIP_STAGE_SOLVED
19600  */
19601 extern
19603  SCIP* scip /**< SCIP data structure */
19604  );
19605 
19606 /** gets total number of simplex iterations used so far for initial LP in node relaxations
19607  *
19608  * @return the total number of simplex iterations used so far for initial LP in node relaxations
19609  *
19610  * @pre This method can be called if SCIP is in one of the following stages:
19611  * - \ref SCIP_STAGE_PRESOLVED
19612  * - \ref SCIP_STAGE_SOLVING
19613  * - \ref SCIP_STAGE_SOLVED
19614  */
19615 extern
19617  SCIP* scip /**< SCIP data structure */
19618  );
19619 
19620 /** gets total number of LPs solved so far during diving and probing
19621  *
19622  * @return total number of LPs solved so far during diving and probing
19623  *
19624  * @pre This method can be called if SCIP is in one of the following stages:
19625  * - \ref SCIP_STAGE_PRESOLVED
19626  * - \ref SCIP_STAGE_SOLVING
19627  * - \ref SCIP_STAGE_SOLVED
19628  */
19629 extern
19631  SCIP* scip /**< SCIP data structure */
19632  );
19633 
19634 /** gets total number of simplex iterations used so far during diving and probing
19635  *
19636  * @return the total number of simplex iterations used so far during diving and probing
19637  *
19638  * @pre This method can be called if SCIP is in one of the following stages:
19639  * - \ref SCIP_STAGE_PRESOLVED
19640  * - \ref SCIP_STAGE_SOLVING
19641  * - \ref SCIP_STAGE_SOLVED
19642  */
19643 extern
19645  SCIP* scip /**< SCIP data structure */
19646  );
19647 
19648 /** gets total number of times, strong branching was called (each call represents solving two LPs)
19649  *
19650  * @return the total number of times, strong branching was called (each call represents solving two LPs)
19651  *
19652  * @pre This method can be called if SCIP is in one of the following stages:
19653  * - \ref SCIP_STAGE_PRESOLVED
19654  * - \ref SCIP_STAGE_SOLVING
19655  * - \ref SCIP_STAGE_SOLVED
19656  */
19657 extern
19659  SCIP* scip /**< SCIP data structure */
19660  );
19661 
19662 /** gets total number of simplex iterations used so far in strong branching
19663  *
19664  * @return the total number of simplex iterations used so far in strong branching
19665  *
19666  * @pre This method can be called if SCIP is in one of the following stages:
19667  * - \ref SCIP_STAGE_PRESOLVED
19668  * - \ref SCIP_STAGE_SOLVING
19669  * - \ref SCIP_STAGE_SOLVED
19670  */
19671 extern
19673  SCIP* scip /**< SCIP data structure */
19674  );
19675 
19676 /** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
19677  *
19678  * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
19679  *
19680  * @pre This method can be called if SCIP is in one of the following stages:
19681  * - \ref SCIP_STAGE_PRESOLVED
19682  * - \ref SCIP_STAGE_SOLVING
19683  * - \ref SCIP_STAGE_SOLVED
19684  */
19685 extern
19687  SCIP* scip /**< SCIP data structure */
19688  );
19689 
19690 /** gets total number of simplex iterations used so far in strong branching at the root node
19691  *
19692  * @return the total number of simplex iterations used so far in strong branching at the root node
19693  *
19694  * @pre This method can be called if SCIP is in one of the following stages:
19695  * - \ref SCIP_STAGE_PRESOLVED
19696  * - \ref SCIP_STAGE_SOLVING
19697  * - \ref SCIP_STAGE_SOLVED
19698  */
19699 extern
19701  SCIP* scip /**< SCIP data structure */
19702  );
19703 
19704 /** gets number of pricing rounds performed so far at the current node
19705  *
19706  * @return the number of pricing rounds performed so far at the current node
19707  *
19708  * @pre This method can be called if SCIP is in one of the following stages:
19709  * - \ref SCIP_STAGE_SOLVING
19710  */
19711 extern
19713  SCIP* scip /**< SCIP data structure */
19714  );
19715 
19716 /** get current number of variables in the pricing store
19717  *
19718  * @return the current number of variables in the pricing store
19719  *
19720  * @pre This method can be called if SCIP is in one of the following stages:
19721  * - \ref SCIP_STAGE_PRESOLVED
19722  * - \ref SCIP_STAGE_SOLVING
19723  * - \ref SCIP_STAGE_SOLVED
19724  */
19725 extern
19726 int SCIPgetNPricevars(
19727  SCIP* scip /**< SCIP data structure */
19728  );
19729 
19730 /** get total number of pricing variables found so far
19731  *
19732  * @return the total number of pricing variables found so far
19733  *
19734  * @pre This method can be called if SCIP is in one of the following stages:
19735  * - \ref SCIP_STAGE_PRESOLVED
19736  * - \ref SCIP_STAGE_SOLVING
19737  * - \ref SCIP_STAGE_SOLVED
19738  */
19739 extern
19741  SCIP* scip /**< SCIP data structure */
19742  );
19743 
19744 /** get total number of pricing variables applied to the LPs
19745  *
19746  * @return the total number of pricing variables applied to the LPs
19747  *
19748  * @pre This method can be called if SCIP is in one of the following stages:
19749  * - \ref SCIP_STAGE_PRESOLVED
19750  * - \ref SCIP_STAGE_SOLVING
19751  * - \ref SCIP_STAGE_SOLVED
19752  */
19753 extern
19755  SCIP* scip /**< SCIP data structure */
19756  );
19757 
19758 /** gets number of separation rounds performed so far at the current node
19759  *
19760  * @return the number of separation rounds performed so far at the current node
19761  *
19762  * @pre This method can be called if SCIP is in one of the following stages:
19763  * - \ref SCIP_STAGE_SOLVING
19764  */
19765 extern
19766 int SCIPgetNSepaRounds(
19767  SCIP* scip /**< SCIP data structure */
19768  );
19769 
19770 /** get total number of cuts found so far
19771  *
19772  * @return the total number of cuts found so far
19773  *
19774  * @pre This method can be called if SCIP is in one of the following stages:
19775  * - \ref SCIP_STAGE_PRESOLVED
19776  * - \ref SCIP_STAGE_SOLVING
19777  * - \ref SCIP_STAGE_SOLVED
19778  */
19779 extern
19780 int SCIPgetNCutsFound(
19781  SCIP* scip /**< SCIP data structure */
19782  );
19783 
19784 /** get number of cuts found so far in current separation round
19785  *
19786  * @return the number of cuts found so far in current separation round
19787  *
19788  * @pre This method can be called if SCIP is in one of the following stages:
19789  * - \ref SCIP_STAGE_PRESOLVED
19790  * - \ref SCIP_STAGE_SOLVING
19791  * - \ref SCIP_STAGE_SOLVED
19792  */
19793 extern
19795  SCIP* scip /**< SCIP data structure */
19796  );
19797 
19798 /** get total number of cuts applied to the LPs
19799  *
19800  * @return the total number of cuts applied to the LPs
19801  *
19802  * @pre This method can be called if SCIP is in one of the following stages:
19803  * - \ref SCIP_STAGE_PRESOLVED
19804  * - \ref SCIP_STAGE_SOLVING
19805  * - \ref SCIP_STAGE_SOLVED
19806  */
19807 extern
19809  SCIP* scip /**< SCIP data structure */
19810  );
19811 
19812 /** get total number of constraints found in conflict analysis (conflict and reconvergence constraints)
19813  *
19814  * @return the total number of constraints found in conflict analysis (conflict and reconvergence constraints)
19815  *
19816  * @pre This method can be called if SCIP is in one of the following stages:
19817  * - \ref SCIP_STAGE_TRANSFORMED
19818  * - \ref SCIP_STAGE_INITPRESOLVE
19819  * - \ref SCIP_STAGE_PRESOLVING
19820  * - \ref SCIP_STAGE_EXITPRESOLVE
19821  * - \ref SCIP_STAGE_PRESOLVED
19822  * - \ref SCIP_STAGE_INITSOLVE
19823  * - \ref SCIP_STAGE_SOLVING
19824  * - \ref SCIP_STAGE_SOLVED
19825  * - \ref SCIP_STAGE_EXITSOLVE
19826  */
19827 extern
19829  SCIP* scip /**< SCIP data structure */
19830  );
19831 
19832 /** get number of conflict constraints found so far at the current node
19833  *
19834  * @return the number of conflict constraints found so far at the current node
19835  *
19836  * @pre This method can be called if SCIP is in one of the following stages:
19837  * - \ref SCIP_STAGE_TRANSFORMED
19838  * - \ref SCIP_STAGE_INITPRESOLVE
19839  * - \ref SCIP_STAGE_PRESOLVING
19840  * - \ref SCIP_STAGE_EXITPRESOLVE
19841  * - \ref SCIP_STAGE_PRESOLVED
19842  * - \ref SCIP_STAGE_INITSOLVE
19843  * - \ref SCIP_STAGE_SOLVING
19844  * - \ref SCIP_STAGE_SOLVED
19845  * - \ref SCIP_STAGE_EXITSOLVE
19846  */
19847 extern
19849  SCIP* scip /**< SCIP data structure */
19850  );
19851 
19852 /** get total number of conflict constraints added to the problem
19853  *
19854  * @return the total number of conflict constraints added to the problem
19855  *
19856  * @pre This method can be called if SCIP is in one of the following stages:
19857  * - \ref SCIP_STAGE_TRANSFORMED
19858  * - \ref SCIP_STAGE_INITPRESOLVE
19859  * - \ref SCIP_STAGE_PRESOLVING
19860  * - \ref SCIP_STAGE_EXITPRESOLVE
19861  * - \ref SCIP_STAGE_PRESOLVED
19862  * - \ref SCIP_STAGE_INITSOLVE
19863  * - \ref SCIP_STAGE_SOLVING
19864  * - \ref SCIP_STAGE_SOLVED
19865  * - \ref SCIP_STAGE_EXITSOLVE
19866  */
19867 extern
19869  SCIP* scip /**< SCIP data structure */
19870  );
19871 
19872 /** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
19873  *
19874  * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
19875  *
19876  * @pre This method can be called if SCIP is in one of the following stages:
19877  * - \ref SCIP_STAGE_TRANSFORMED
19878  * - \ref SCIP_STAGE_INITPRESOLVE
19879  * - \ref SCIP_STAGE_PRESOLVING
19880  * - \ref SCIP_STAGE_EXITPRESOLVE
19881  * - \ref SCIP_STAGE_PRESOLVED
19882  * - \ref SCIP_STAGE_INITSOLVE
19883  * - \ref SCIP_STAGE_SOLVING
19884  * - \ref SCIP_STAGE_SOLVED
19885  * - \ref SCIP_STAGE_EXITSOLVE
19886  */
19887 extern
19888 int SCIPgetMaxDepth(
19889  SCIP* scip /**< SCIP data structure */
19890  );
19891 
19892 /** gets maximal depth of all processed nodes over all branch and bound runs
19893  *
19894  * @return the maximal depth of all processed nodes over all branch and bound runs
19895  *
19896  * @pre This method can be called if SCIP is in one of the following stages:
19897  * - \ref SCIP_STAGE_TRANSFORMED
19898  * - \ref SCIP_STAGE_INITPRESOLVE
19899  * - \ref SCIP_STAGE_PRESOLVING
19900  * - \ref SCIP_STAGE_EXITPRESOLVE
19901  * - \ref SCIP_STAGE_PRESOLVED
19902  * - \ref SCIP_STAGE_INITSOLVE
19903  * - \ref SCIP_STAGE_SOLVING
19904  * - \ref SCIP_STAGE_SOLVED
19905  * - \ref SCIP_STAGE_EXITSOLVE
19906  */
19907 extern
19909  SCIP* scip /**< SCIP data structure */
19910  );
19911 
19912 /** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
19913  *
19914  * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
19915  *
19916  * @pre This method can be called if SCIP is in one of the following stages:
19917  * - \ref SCIP_STAGE_TRANSFORMED
19918  * - \ref SCIP_STAGE_INITPRESOLVE
19919  * - \ref SCIP_STAGE_PRESOLVING
19920  * - \ref SCIP_STAGE_EXITPRESOLVE
19921  * - \ref SCIP_STAGE_PRESOLVED
19922  * - \ref SCIP_STAGE_INITSOLVE
19923  * - \ref SCIP_STAGE_SOLVING
19924  * - \ref SCIP_STAGE_SOLVED
19925  * - \ref SCIP_STAGE_EXITSOLVE
19926  */
19927 extern
19929  SCIP* scip /**< SCIP data structure */
19930  );
19931 
19932 /** gets total number of active constraints at the current node
19933  *
19934  * @return the total number of active constraints at the current node
19935  *
19936  * @pre This method can be called if SCIP is in one of the following stages:
19937  * - \ref SCIP_STAGE_PRESOLVED
19938  * - \ref SCIP_STAGE_SOLVING
19939  */
19940 extern
19942  SCIP* scip /**< SCIP data structure */
19943  );
19944 
19945 /** gets total number of enabled constraints at the current node
19946  *
19947  * @return the total number of enabled constraints at the current node
19948  *
19949  * @pre This method can be called if SCIP is in one of the following stages:
19950  * - \ref SCIP_STAGE_PRESOLVED
19951  * - \ref SCIP_STAGE_SOLVING
19952  */
19953 extern
19955  SCIP* scip /**< SCIP data structure */
19956  );
19957 
19958 /** gets average dual bound of all unprocessed nodes for original problem */
19959 extern
19961  SCIP* scip /**< SCIP data structure */
19962  );
19963 
19964 /** gets average lower (dual) bound of all unprocessed nodes in transformed problem
19965  *
19966  * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
19967  *
19968  * @pre This method can be called if SCIP is in one of the following stages:
19969  * - \ref SCIP_STAGE_PRESOLVED
19970  * - \ref SCIP_STAGE_SOLVING
19971  * - \ref SCIP_STAGE_SOLVED
19972  */
19973 extern
19975  SCIP* scip /**< SCIP data structure */
19976  );
19977 
19978 /** gets global dual bound
19979  *
19980  * @return the global dual bound
19981  *
19982  * @pre This method can be called if SCIP is in one of the following stages:
19983  * - \ref SCIP_STAGE_PRESOLVING
19984  * - \ref SCIP_STAGE_EXITPRESOLVE
19985  * - \ref SCIP_STAGE_PRESOLVED
19986  * - \ref SCIP_STAGE_INITSOLVE
19987  * - \ref SCIP_STAGE_SOLVING
19988  * - \ref SCIP_STAGE_SOLVED
19989  */
19990 extern
19992  SCIP* scip /**< SCIP data structure */
19993  );
19994 
19995 /** gets global lower (dual) bound in transformed problem
19996  *
19997  * @return the global lower (dual) bound in transformed problem
19998  *
19999  * @pre This method can be called if SCIP is in one of the following stages:
20000  * - \ref SCIP_STAGE_PRESOLVING
20001  * - \ref SCIP_STAGE_EXITPRESOLVE
20002  * - \ref SCIP_STAGE_PRESOLVED
20003  * - \ref SCIP_STAGE_INITSOLVE
20004  * - \ref SCIP_STAGE_SOLVING
20005  * - \ref SCIP_STAGE_SOLVED
20006  */
20007 extern
20009  SCIP* scip /**< SCIP data structure */
20010  );
20011 
20012 /** gets dual bound of the root node for the original problem
20013  *
20014  * @return the dual bound of the root node for the original problem
20015  *
20016  * @pre This method can be called if SCIP is in one of the following stages:
20017  * - \ref SCIP_STAGE_PRESOLVING
20018  * - \ref SCIP_STAGE_EXITPRESOLVE
20019  * - \ref SCIP_STAGE_PRESOLVED
20020  * - \ref SCIP_STAGE_INITSOLVE
20021  * - \ref SCIP_STAGE_SOLVING
20022  * - \ref SCIP_STAGE_SOLVED
20023  */
20024 extern
20026  SCIP* scip /**< SCIP data structure */
20027  );
20028 
20029 /** gets lower (dual) bound in transformed problem of the root node
20030  *
20031  * @return the lower (dual) bound in transformed problem of the root node
20032  *
20033  * @pre This method can be called if SCIP is in one of the following stages:
20034  * - \ref SCIP_STAGE_PRESOLVING
20035  * - \ref SCIP_STAGE_EXITPRESOLVE
20036  * - \ref SCIP_STAGE_PRESOLVED
20037  * - \ref SCIP_STAGE_INITSOLVE
20038  * - \ref SCIP_STAGE_SOLVING
20039  * - \ref SCIP_STAGE_SOLVED
20040  */
20041 extern
20043  SCIP* scip /**< SCIP data structure */
20044  );
20045 
20046 /** gets dual bound for the original problem obtained by the first LP solve at the root node
20047  *
20048  * @return the dual bound for the original problem of the first LP solve at the root node
20049  *
20050  * @pre This method can be called if SCIP is in one of the following stages:
20051  * - \ref SCIP_STAGE_PRESOLVING
20052  * - \ref SCIP_STAGE_EXITPRESOLVE
20053  * - \ref SCIP_STAGE_PRESOLVED
20054  * - \ref SCIP_STAGE_INITSOLVE
20055  * - \ref SCIP_STAGE_SOLVING
20056  * - \ref SCIP_STAGE_SOLVED
20057  */
20058 extern
20060  SCIP* scip /**< SCIP data structure */
20061  );
20062 
20063 /** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
20064  *
20065  * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
20066  *
20067  * @pre This method can be called if SCIP is in one of the following stages:
20068  * - \ref SCIP_STAGE_PRESOLVING
20069  * - \ref SCIP_STAGE_EXITPRESOLVE
20070  * - \ref SCIP_STAGE_PRESOLVED
20071  * - \ref SCIP_STAGE_INITSOLVE
20072  * - \ref SCIP_STAGE_SOLVING
20073  * - \ref SCIP_STAGE_SOLVED
20074  */
20075 extern
20077  SCIP* scip /**< SCIP data structure */
20078  );
20079 
20080 
20081 /** the primal bound of the very first solution */
20082 extern
20084  SCIP* scip /**< SCIP data structure */
20085  );
20086 
20087 /** gets global primal bound (objective value of best solution or user objective limit) for the original problem
20088  *
20089  * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
20090  *
20091  * @pre This method can be called if SCIP is in one of the following stages:
20092  * - \ref SCIP_STAGE_TRANSFORMED
20093  * - \ref SCIP_STAGE_INITPRESOLVE
20094  * - \ref SCIP_STAGE_PRESOLVING
20095  * - \ref SCIP_STAGE_EXITPRESOLVE
20096  * - \ref SCIP_STAGE_PRESOLVED
20097  * - \ref SCIP_STAGE_INITSOLVE
20098  * - \ref SCIP_STAGE_SOLVING
20099  * - \ref SCIP_STAGE_SOLVED
20100  * - \ref SCIP_STAGE_EXITSOLVE
20101  */
20102 extern
20104  SCIP* scip /**< SCIP data structure */
20105  );
20106 
20107 /** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
20108  *
20109  * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
20110  *
20111  * @pre This method can be called if SCIP is in one of the following stages:
20112  * - \ref SCIP_STAGE_TRANSFORMED
20113  * - \ref SCIP_STAGE_INITPRESOLVE
20114  * - \ref SCIP_STAGE_PRESOLVING
20115  * - \ref SCIP_STAGE_EXITPRESOLVE
20116  * - \ref SCIP_STAGE_PRESOLVED
20117  * - \ref SCIP_STAGE_INITSOLVE
20118  * - \ref SCIP_STAGE_SOLVING
20119  * - \ref SCIP_STAGE_SOLVED
20120  * - \ref SCIP_STAGE_EXITSOLVE
20121  */
20122 extern
20124  SCIP* scip /**< SCIP data structure */
20125  );
20126 
20127 /** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
20128  * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
20129  * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
20130  * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
20131  *
20132  * @return global cutoff bound in transformed problem
20133  *
20134  * @pre This method can be called if SCIP is in one of the following stages:
20135  * - \ref SCIP_STAGE_TRANSFORMED
20136  * - \ref SCIP_STAGE_INITPRESOLVE
20137  * - \ref SCIP_STAGE_PRESOLVING
20138  * - \ref SCIP_STAGE_EXITPRESOLVE
20139  * - \ref SCIP_STAGE_PRESOLVED
20140  * - \ref SCIP_STAGE_INITSOLVE
20141  * - \ref SCIP_STAGE_SOLVING
20142  * - \ref SCIP_STAGE_SOLVED
20143  * - \ref SCIP_STAGE_EXITSOLVE
20144  */
20145 extern
20147  SCIP* scip /**< SCIP data structure */
20148  );
20149 
20150 /** updates the cutoff bound
20151  *
20152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20154  *
20155  * @note using this method in the solving stage can lead to an erroneous SCIP solving status; in particular,
20156  * if a solution not respecting the cutoff bound was found before installing a cutoff bound which
20157  * renders the remaining problem infeasible, this solution may be reported as optimal
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_PRESOLVING
20162  * - \ref SCIP_STAGE_PRESOLVED
20163  * - \ref SCIP_STAGE_INITSOLVE
20164  * - \ref SCIP_STAGE_SOLVING
20165  *
20166  * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
20167  */
20168 extern
20170  SCIP* scip, /**< SCIP data structure */
20171  SCIP_Real cutoffbound /**< new cutoff bound */
20172  );
20173 
20174 /** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
20175  * was set from the user as objective limit
20176  *
20177  * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
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 /** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
20196  * or infinity, if they have opposite sign
20197  *
20198  * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
20199  * or infinity, if they have opposite sign
20200  *
20201  * @pre This method can be called if SCIP is in one of the following stages:
20202  * - \ref SCIP_STAGE_PRESOLVED
20203  * - \ref SCIP_STAGE_SOLVING
20204  * - \ref SCIP_STAGE_SOLVED
20205  */
20206 extern
20208  SCIP* scip /**< SCIP data structure */
20209  );
20210 
20211 /** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
20212  * have same sign, or infinity, if they have opposite sign
20213  *
20214  * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
20215  * have same sign, or infinity, if they have opposite sign
20216  *
20217  * @pre This method can be called if SCIP is in one of the following stages:
20218  * - \ref SCIP_STAGE_PRESOLVED
20219  * - \ref SCIP_STAGE_SOLVING
20220  * - \ref SCIP_STAGE_SOLVED
20221  */
20222 extern
20224  SCIP* scip /**< SCIP data structure */
20225  );
20226 
20227 /** gets number of feasible primal solutions found so far
20228  *
20229  * @return the number of feasible primal solutions found so far
20230  *
20231  * @pre This method can be called if SCIP is in one of the following stages:
20232  * - \ref SCIP_STAGE_TRANSFORMED
20233  * - \ref SCIP_STAGE_INITPRESOLVE
20234  * - \ref SCIP_STAGE_PRESOLVING
20235  * - \ref SCIP_STAGE_EXITPRESOLVE
20236  * - \ref SCIP_STAGE_PRESOLVED
20237  * - \ref SCIP_STAGE_INITSOLVE
20238  * - \ref SCIP_STAGE_SOLVING
20239  * - \ref SCIP_STAGE_SOLVED
20240  * - \ref SCIP_STAGE_EXITSOLVE
20241  */
20242 extern
20244  SCIP* scip /**< SCIP data structure */
20245  );
20246 
20247 /** gets number of feasible primal solutions respecting the objective limit found so far
20248  *
20249  * @return the number of feasible primal solutions respecting the objective limit found so far
20250  *
20251  * @pre This method can be called if SCIP is in one of the following stages:
20252  * - \ref SCIP_STAGE_INIT
20253  * - \ref SCIP_STAGE_PROBLEM
20254  * - \ref SCIP_STAGE_TRANSFORMING
20255  * - \ref SCIP_STAGE_TRANSFORMED
20256  * - \ref SCIP_STAGE_INITPRESOLVE
20257  * - \ref SCIP_STAGE_PRESOLVING
20258  * - \ref SCIP_STAGE_EXITPRESOLVE
20259  * - \ref SCIP_STAGE_PRESOLVED
20260  * - \ref SCIP_STAGE_INITSOLVE
20261  * - \ref SCIP_STAGE_SOLVING
20262  * - \ref SCIP_STAGE_SOLVED
20263  * - \ref SCIP_STAGE_EXITSOLVE
20264  */
20265 extern
20267  SCIP* scip /**< SCIP data structure */
20268  );
20269 
20270 /** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
20271  *
20272  * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
20273  *
20274  * @pre This method can be called if SCIP is in one of the following stages:
20275  * - \ref SCIP_STAGE_TRANSFORMED
20276  * - \ref SCIP_STAGE_INITPRESOLVE
20277  * - \ref SCIP_STAGE_PRESOLVING
20278  * - \ref SCIP_STAGE_EXITPRESOLVE
20279  * - \ref SCIP_STAGE_PRESOLVED
20280  * - \ref SCIP_STAGE_INITSOLVE
20281  * - \ref SCIP_STAGE_SOLVING
20282  * - \ref SCIP_STAGE_SOLVED
20283  * - \ref SCIP_STAGE_EXITSOLVE
20284  */
20285 extern
20287  SCIP* scip /**< SCIP data structure */
20288  );
20289 
20290 /** gets the average pseudo cost value for the given direction over all variables
20291  *
20292  * @return the average pseudo cost value for the given direction over all variables
20293  *
20294  * @pre This method can be called if SCIP is in one of the following stages:
20295  * - \ref SCIP_STAGE_SOLVING
20296  * - \ref SCIP_STAGE_SOLVED
20297  */
20298 extern
20300  SCIP* scip, /**< SCIP data structure */
20301  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
20302  );
20303 
20304 /** gets the average pseudo cost value for the given direction over all variables,
20305  * only using the pseudo cost information of the current run
20306  *
20307  * @return the average pseudo cost value for the given direction over all variables,
20308  * only using the pseudo cost information of the current run
20309  *
20310  * @pre This method can be called if SCIP is in one of the following stages:
20311  * - \ref SCIP_STAGE_SOLVING
20312  * - \ref SCIP_STAGE_SOLVED
20313  */
20314 extern
20316  SCIP* scip, /**< SCIP data structure */
20317  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
20318  );
20319 
20320 /** gets the average number of pseudo cost updates for the given direction over all variables
20321  *
20322  * @return the average number of pseudo cost updates for the given direction over all variables
20323  *
20324  * @pre This method can be called if SCIP is in one of the following stages:
20325  * - \ref SCIP_STAGE_SOLVING
20326  * - \ref SCIP_STAGE_SOLVED
20327  */
20328 extern
20330  SCIP* scip, /**< SCIP data structure */
20331  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20332  );
20333 
20334 /** gets the average number of pseudo cost updates for the given direction over all variables,
20335  * only using the pseudo cost information of the current run
20336  *
20337  * @return the average number of pseudo cost updates for the given direction over all variables,
20338  * only using the pseudo cost information of the current run
20339  *
20340  * @pre This method can be called if SCIP is in one of the following stages:
20341  * - \ref SCIP_STAGE_SOLVING
20342  * - \ref SCIP_STAGE_SOLVED
20343  */
20344 extern
20346  SCIP* scip, /**< SCIP data structure */
20347  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20348  );
20349 
20350 /** gets the number of pseudo cost updates for the given direction over all variables
20351  *
20352  * @return the number of pseudo cost updates for the given direction over all variables
20353  *
20354  * @pre This method can be called if SCIP is in one of the following stages:
20355  * - \ref SCIP_STAGE_SOLVING
20356  * - \ref SCIP_STAGE_SOLVED
20357  */
20358 extern
20360  SCIP* scip, /**< SCIP data structure */
20361  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
20362  SCIP_Bool onlycurrentrun /**< use only history of current run? */
20363  );
20364 
20365 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
20366  *
20367  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
20368  *
20369  * @pre This method can be called if SCIP is in one of the following stages:
20370  * - \ref SCIP_STAGE_SOLVING
20371  * - \ref SCIP_STAGE_SOLVED
20372  */
20373 extern
20375  SCIP* scip /**< SCIP data structure */
20376  );
20377 
20378 /** returns the variance of pseudo costs for all variables in the requested direction
20379  *
20380  * @return the variance of pseudo costs for all variables in the requested direction
20381  *
20382  * @pre This method can be called if SCIP is in one of the following stages:
20383  * - \ref SCIP_STAGE_SOLVING
20384  * - \ref SCIP_STAGE_SOLVED
20385  */
20386 extern
20388  SCIP* scip, /**< SCIP data structure */
20389  SCIP_BRANCHDIR branchdir, /**< the branching direction, up or down */
20390  SCIP_Bool onlycurrentrun /**< use only history of current run? */
20391  );
20392 
20393 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
20394  * only using the pseudo cost information of the current run
20395  *
20396  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
20397  * only using the pseudo cost information of the current run
20398  *
20399  * @pre This method can be called if SCIP is in one of the following stages:
20400  * - \ref SCIP_STAGE_SOLVING
20401  * - \ref SCIP_STAGE_SOLVED
20402  */
20403 extern
20405  SCIP* scip /**< SCIP data structure */
20406  );
20407 
20408 /** gets the average conflict score value over all variables */
20409 extern
20411  SCIP* scip /**< SCIP data structure */
20412  );
20413 
20414 /** gets the average conflict score value over all variables, only using the pseudo cost information of the current run
20415  *
20416  * @return the average conflict score value over all variables, only using the pseudo cost information of the current run
20417  *
20418  * @pre This method can be called if SCIP is in one of the following stages:
20419  * - \ref SCIP_STAGE_SOLVING
20420  * - \ref SCIP_STAGE_SOLVED
20421  */
20422 extern
20424  SCIP* scip /**< SCIP data structure */
20425  );
20426 
20427 /** gets the average inference score value over all variables
20428  *
20429  * @return the average inference score value over all variables
20430  *
20431  * @pre This method can be called if SCIP is in one of the following stages:
20432  * - \ref SCIP_STAGE_SOLVING
20433  * - \ref SCIP_STAGE_SOLVED
20434  */
20435 extern
20437  SCIP* scip /**< SCIP data structure */
20438  );
20439 
20440 /** gets the average conflictlength score value over all variables, only using the pseudo cost information of the
20441  * current run
20442  *
20443  * @return the average conflictlength score value over all variables, only using the pseudo cost information of the
20444  * current run
20445  *
20446  * @pre This method can be called if SCIP is in one of the following stages:
20447  * - \ref SCIP_STAGE_SOLVING
20448  * - \ref SCIP_STAGE_SOLVED
20449  */
20450 extern
20452  SCIP* scip /**< SCIP data structure */
20453  );
20454 
20455 /** returns the average number of inferences found after branching in given direction over all variables
20456  *
20457  * @return the average number of inferences found after branching in given direction over all variables
20458  *
20459  * @pre This method can be called if SCIP is in one of the following stages:
20460  * - \ref SCIP_STAGE_SOLVING
20461  * - \ref SCIP_STAGE_SOLVED
20462  */
20463 extern
20465  SCIP* scip, /**< SCIP data structure */
20466  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20467  );
20468 
20469 /** returns the average number of inferences found after branching in given direction over all variables,
20470  * only using the pseudo cost information of the current run
20471  *
20472  * @return the average number of inferences found after branching in given direction over all variables,
20473  * only using the pseudo cost information of the current run
20474  *
20475  * @pre This method can be called if SCIP is in one of the following stages:
20476  * - \ref SCIP_STAGE_SOLVING
20477  * - \ref SCIP_STAGE_SOLVED
20478  */
20479 extern
20481  SCIP* scip, /**< SCIP data structure */
20482  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20483  );
20484 
20485 /** gets the average inference score value over all variables
20486  *
20487  * @return the average inference score value over all variables
20488  *
20489  * @pre This method can be called if SCIP is in one of the following stages:
20490  * - \ref SCIP_STAGE_SOLVING
20491  * - \ref SCIP_STAGE_SOLVED
20492  */
20493 extern
20495  SCIP* scip /**< SCIP data structure */
20496  );
20497 
20498 /** gets the average inference score value over all variables, only using the inference information information of the
20499  * current run
20500  *
20501  * @return the average inference score value over all variables, only using the inference information information of the
20502  * current run
20503  *
20504  * @pre This method can be called if SCIP is in one of the following stages:
20505  * - \ref SCIP_STAGE_SOLVING
20506  * - \ref SCIP_STAGE_SOLVED
20507  */
20508 extern
20510  SCIP* scip /**< SCIP data structure */
20511  );
20512 
20513 /** returns the average number of cutoffs found after branching in given direction over all variables
20514  *
20515  * @return the average number of cutoffs found after branching in given direction over all variables
20516  *
20517  * @pre This method can be called if SCIP is in one of the following stages:
20518  * - \ref SCIP_STAGE_SOLVING
20519  * - \ref SCIP_STAGE_SOLVED
20520  */
20521 extern
20523  SCIP* scip, /**< SCIP data structure */
20524  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20525  );
20526 
20527 /** returns the average number of cutoffs found after branching in given direction over all variables,
20528  * only using the pseudo cost information of the current run
20529  *
20530  * @return the average number of cutoffs found after branching in given direction over all variables,
20531  * only using the pseudo cost information of the current run
20532  *
20533  * @pre This method can be called if SCIP is in one of the following stages:
20534  * - \ref SCIP_STAGE_SOLVING
20535  * - \ref SCIP_STAGE_SOLVED
20536  */
20537 extern
20539  SCIP* scip, /**< SCIP data structure */
20540  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20541  );
20542 
20543 /** gets the average cutoff score value over all variables
20544  *
20545  * @return the average cutoff score value over all variables
20546  *
20547  * @pre This method can be called if SCIP is in one of the following stages:
20548  * - \ref SCIP_STAGE_SOLVING
20549  * - \ref SCIP_STAGE_SOLVED
20550  */
20551 extern
20553  SCIP* scip /**< SCIP data structure */
20554  );
20555 
20556 /** gets the average cutoff score value over all variables, only using the pseudo cost information of the current run
20557  *
20558  * @return the average cutoff score value over all variables, only using the pseudo cost information of the current run
20559  *
20560  * @pre This method can be called if SCIP is in one of the following stages:
20561  * - \ref SCIP_STAGE_SOLVING
20562  * - \ref SCIP_STAGE_SOLVED
20563  */
20564 extern
20566  SCIP* scip /**< SCIP data structure */
20567  );
20568 
20569 /** gets deterministic time number of LPs solved so far
20570  *
20571  * @return the total number of LPs solved so far
20572  *
20573  * @pre This method can be called if SCIP is in one of the following stages:
20574  * - \ref SCIP_STAGE_PRESOLVED
20575  * - \ref SCIP_STAGE_SOLVING
20576  * - \ref SCIP_STAGE_SOLVED
20577  */
20578 extern
20580  SCIP* scip /**< SCIP data structure */
20581  );
20582 
20583 /** outputs original problem to file stream
20584  *
20585  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20586  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20587  *
20588  * @pre This method can be called if SCIP is in one of the following stages:
20589  * - \ref SCIP_STAGE_PROBLEM
20590  * - \ref SCIP_STAGE_TRANSFORMING
20591  * - \ref SCIP_STAGE_TRANSFORMED
20592  * - \ref SCIP_STAGE_INITPRESOLVE
20593  * - \ref SCIP_STAGE_PRESOLVING
20594  * - \ref SCIP_STAGE_EXITPRESOLVE
20595  * - \ref SCIP_STAGE_PRESOLVED
20596  * - \ref SCIP_STAGE_INITSOLVE
20597  * - \ref SCIP_STAGE_SOLVING
20598  * - \ref SCIP_STAGE_SOLVED
20599  * - \ref SCIP_STAGE_EXITSOLVE
20600  * - \ref SCIP_STAGE_FREETRANS
20601  */
20602 extern
20604  SCIP* scip, /**< SCIP data structure */
20605  FILE* file, /**< output file (or NULL for standard output) */
20606  const char* extension, /**< file format (or NULL for default CIP format)*/
20607  SCIP_Bool genericnames /**< using generic variable and constraint names? */
20608  );
20609 
20610 /** outputs transformed problem of the current node to file stream
20611  *
20612  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20613  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20614  *
20615  * @pre This method can be called if SCIP is in one of the following stages:
20616  * - \ref SCIP_STAGE_TRANSFORMED
20617  * - \ref SCIP_STAGE_INITPRESOLVE
20618  * - \ref SCIP_STAGE_PRESOLVING
20619  * - \ref SCIP_STAGE_EXITPRESOLVE
20620  * - \ref SCIP_STAGE_PRESOLVED
20621  * - \ref SCIP_STAGE_INITSOLVE
20622  * - \ref SCIP_STAGE_SOLVING
20623  * - \ref SCIP_STAGE_SOLVED
20624  * - \ref SCIP_STAGE_EXITSOLVE
20625  * - \ref SCIP_STAGE_FREETRANS
20626  */
20627 extern
20629  SCIP* scip, /**< SCIP data structure */
20630  FILE* file, /**< output file (or NULL for standard output) */
20631  const char* extension, /**< file format (or NULL for default CIP format)*/
20632  SCIP_Bool genericnames /**< using generic variable and constraint names? */
20633  );
20634 
20635 /** outputs solving statistics
20636  *
20637  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20638  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20639  *
20640  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
20641  * thus may to correspond to the original status.
20642  *
20643  * @pre This method can be called if SCIP is in one of the following stages:
20644  * - \ref SCIP_STAGE_INIT
20645  * - \ref SCIP_STAGE_PROBLEM
20646  * - \ref SCIP_STAGE_TRANSFORMED
20647  * - \ref SCIP_STAGE_INITPRESOLVE
20648  * - \ref SCIP_STAGE_PRESOLVING
20649  * - \ref SCIP_STAGE_EXITPRESOLVE
20650  * - \ref SCIP_STAGE_PRESOLVED
20651  * - \ref SCIP_STAGE_SOLVING
20652  * - \ref SCIP_STAGE_SOLVED
20653  */
20654 extern
20656  SCIP* scip, /**< SCIP data structure */
20657  FILE* file /**< output file (or NULL for standard output) */
20658  );
20659 
20660 /** outputs reoptimization statistics
20661  *
20662  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20663  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20664  *
20665  * @pre This method can be called if SCIP is in one of the following stages:
20666  * - \ref SCIP_STAGE_INIT
20667  * - \ref SCIP_STAGE_PROBLEM
20668  * - \ref SCIP_STAGE_TRANSFORMED
20669  * - \ref SCIP_STAGE_INITPRESOLVE
20670  * - \ref SCIP_STAGE_PRESOLVING
20671  * - \ref SCIP_STAGE_EXITPRESOLVE
20672  * - \ref SCIP_STAGE_PRESOLVED
20673  * - \ref SCIP_STAGE_SOLVING
20674  * - \ref SCIP_STAGE_SOLVED
20675  */
20676 extern
20678  SCIP* scip, /**< SCIP data structure */
20679  FILE* file /**< output file (or NULL for standard output) */
20680  );
20681 
20682 /** outputs history statistics about branchings on variables
20683  *
20684  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20685  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20686  *
20687  * @pre This method can be called if SCIP is in one of the following stages:
20688  * - \ref SCIP_STAGE_INIT
20689  * - \ref SCIP_STAGE_PROBLEM
20690  * - \ref SCIP_STAGE_TRANSFORMED
20691  * - \ref SCIP_STAGE_INITPRESOLVE
20692  * - \ref SCIP_STAGE_PRESOLVING
20693  * - \ref SCIP_STAGE_EXITPRESOLVE
20694  * - \ref SCIP_STAGE_PRESOLVED
20695  * - \ref SCIP_STAGE_SOLVING
20696  * - \ref SCIP_STAGE_SOLVED
20697  */
20698 extern
20700  SCIP* scip, /**< SCIP data structure */
20701  FILE* file /**< output file (or NULL for standard output) */
20702  );
20703 
20704 /** outputs node information display line
20705  *
20706  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20707  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20708  *
20709  * @pre This method can be called if SCIP is in one of the following stages:
20710  * - \ref SCIP_STAGE_SOLVING
20711  */
20712 extern
20714  SCIP* scip, /**< SCIP data structure */
20715  FILE* file, /**< output file (or NULL for standard output) */
20716  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
20717  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
20718  );
20719 
20720 /** gets total number of implications between variables that are stored in the implication graph
20721  *
20722  * @return the total number of implications between variables that are stored in the implication graph
20723  *
20724  * @pre This method can be called if SCIP is in one of the following stages:
20725  * - \ref SCIP_STAGE_INITPRESOLVE
20726  * - \ref SCIP_STAGE_PRESOLVING
20727  * - \ref SCIP_STAGE_EXITPRESOLVE
20728  * - \ref SCIP_STAGE_PRESOLVED
20729  * - \ref SCIP_STAGE_INITSOLVE
20730  * - \ref SCIP_STAGE_SOLVING
20731  * - \ref SCIP_STAGE_SOLVED
20732  */
20733 extern
20735  SCIP* scip /**< SCIP data structure */
20736  );
20737 
20738 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
20739  *
20740  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20741  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20742  *
20743  * @pre This method can be called if SCIP is in one of the following stages:
20744  * - \ref SCIP_STAGE_TRANSFORMED
20745  * - \ref SCIP_STAGE_INITPRESOLVE
20746  * - \ref SCIP_STAGE_PRESOLVING
20747  * - \ref SCIP_STAGE_EXITPRESOLVE
20748  * - \ref SCIP_STAGE_PRESOLVED
20749  * - \ref SCIP_STAGE_INITSOLVE
20750  * - \ref SCIP_STAGE_SOLVING
20751  * - \ref SCIP_STAGE_SOLVED
20752  * - \ref SCIP_STAGE_EXITSOLVE
20753  *
20754  * @deprecated because binary implications are now stored as cliques
20755  */
20756 extern
20758  SCIP* scip, /**< SCIP data structure */
20759  const char* filename /**< file name, or NULL for stdout */
20760  );
20761 
20762 
20763 /** update statistical information when a new solution was found */
20764 extern
20766  SCIP* scip /**< SCIP data structure */
20767  );
20768 
20769 /**@} */
20770 
20771 /*
20772  * timing methods
20773  */
20774 
20775 
20776 /**@addtogroup PublicTimingMethods
20777  *
20778  * @{
20779  */
20780 
20781 /** gets current time of day in seconds (standard time zone)
20782  *
20783  * @return the current time of day in seconds (standard time zone).
20784  */
20785 extern
20787  SCIP* scip /**< SCIP data structure */
20788  );
20789 
20790 /** creates a clock using the default clock type
20791  *
20792  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20793  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20794  */
20795 extern
20797  SCIP* scip, /**< SCIP data structure */
20798  SCIP_CLOCK** clck /**< pointer to clock timer */
20799  );
20800 
20801 /** creates a clock counting the CPU user seconds
20802  *
20803  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20804  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20805  */
20806 extern
20808  SCIP* scip, /**< SCIP data structure */
20809  SCIP_CLOCK** clck /**< pointer to clock timer */
20810  );
20811 
20812 /** creates a clock counting the wall clock seconds
20813  *
20814  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20815  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20816  */
20817 extern
20819  SCIP* scip, /**< SCIP data structure */
20820  SCIP_CLOCK** clck /**< pointer to clock timer */
20821  );
20822 
20823 /** frees a clock
20824  *
20825  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20826  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20827  */
20828 extern
20830  SCIP* scip, /**< SCIP data structure */
20831  SCIP_CLOCK** clck /**< pointer to clock timer */
20832  );
20833 
20834 /** resets the time measurement of a clock to zero and completely stops the clock
20835  *
20836  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20837  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20838  */
20839 extern
20841  SCIP* scip, /**< SCIP data structure */
20842  SCIP_CLOCK* clck /**< clock timer */
20843  );
20844 
20845 /** starts the time measurement of a clock
20846  *
20847  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20848  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20849  */
20850 extern
20852  SCIP* scip, /**< SCIP data structure */
20853  SCIP_CLOCK* clck /**< clock timer */
20854  );
20855 
20856 /** stops the time measurement of a clock
20857  *
20858  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20859  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20860  */
20861 extern
20863  SCIP* scip, /**< SCIP data structure */
20864  SCIP_CLOCK* clck /**< clock timer */
20865  );
20866 
20867 /** enables or disables all statistic clocks of SCIP concerning plugin statistics,
20868  * LP execution time, strong branching time, etc.
20869  *
20870  * Method reads the value of the parameter timing/statistictiming. In order to disable statistic timing,
20871  * set the parameter to FALSE.
20872  *
20873  * @note: The (pre-)solving time clocks which are relevant for the output during (pre-)solving
20874  * are not affected by this method
20875  *
20876  * @see: For completely disabling all timing of SCIP, consider setting the parameter timing/enabled to FALSE
20877  *
20878  * @pre This method can be called if SCIP is in one of the following stages:
20879  * - \ref SCIP_STAGE_PROBLEM
20880  * - \ref SCIP_STAGE_TRANSFORMING
20881  * - \ref SCIP_STAGE_TRANSFORMED
20882  * - \ref SCIP_STAGE_INITPRESOLVE
20883  * - \ref SCIP_STAGE_PRESOLVING
20884  * - \ref SCIP_STAGE_EXITPRESOLVE
20885  * - \ref SCIP_STAGE_PRESOLVED
20886  * - \ref SCIP_STAGE_INITSOLVE
20887  * - \ref SCIP_STAGE_SOLVING
20888  * - \ref SCIP_STAGE_SOLVED
20889  * - \ref SCIP_STAGE_EXITSOLVE
20890  * - \ref SCIP_STAGE_FREETRANS
20891  *
20892  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
20893  */
20894 extern
20896  SCIP* scip /**< SCIP data structure */
20897  );
20898 
20899 /** starts the current solving time
20900  *
20901  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20902  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20903  *
20904  * @pre This method can be called if SCIP is in one of the following stages:
20905  * - \ref SCIP_STAGE_PROBLEM
20906  * - \ref SCIP_STAGE_TRANSFORMING
20907  * - \ref SCIP_STAGE_TRANSFORMED
20908  * - \ref SCIP_STAGE_INITPRESOLVE
20909  * - \ref SCIP_STAGE_PRESOLVING
20910  * - \ref SCIP_STAGE_EXITPRESOLVE
20911  * - \ref SCIP_STAGE_PRESOLVED
20912  * - \ref SCIP_STAGE_INITSOLVE
20913  * - \ref SCIP_STAGE_SOLVING
20914  * - \ref SCIP_STAGE_SOLVED
20915  * - \ref SCIP_STAGE_EXITSOLVE
20916  * - \ref SCIP_STAGE_FREETRANS
20917  *
20918  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
20919  */
20920 extern
20922  SCIP* scip /**< SCIP data structure */
20923  );
20924 
20925 /** stops the current solving time in seconds
20926  *
20927  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20928  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20929  *
20930  * @pre This method can be called if SCIP is in one of the following stages:
20931  * - \ref SCIP_STAGE_PROBLEM
20932  * - \ref SCIP_STAGE_TRANSFORMING
20933  * - \ref SCIP_STAGE_TRANSFORMED
20934  * - \ref SCIP_STAGE_INITPRESOLVE
20935  * - \ref SCIP_STAGE_PRESOLVING
20936  * - \ref SCIP_STAGE_EXITPRESOLVE
20937  * - \ref SCIP_STAGE_PRESOLVED
20938  * - \ref SCIP_STAGE_INITSOLVE
20939  * - \ref SCIP_STAGE_SOLVING
20940  * - \ref SCIP_STAGE_SOLVED
20941  * - \ref SCIP_STAGE_EXITSOLVE
20942  * - \ref SCIP_STAGE_FREETRANS
20943  *
20944  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
20945  */
20946 extern
20948  SCIP* scip /**< SCIP data structure */
20949  );
20950 
20951 /** gets the measured time of a clock in seconds
20952  *
20953  * @return the measured time of a clock in seconds.
20954  */
20955 extern
20957  SCIP* scip, /**< SCIP data structure */
20958  SCIP_CLOCK* clck /**< clock timer */
20959  );
20960 
20961 /** sets the measured time of a clock to the given value in seconds
20962  *
20963  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20964  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20965  */
20966 extern
20968  SCIP* scip, /**< SCIP data structure */
20969  SCIP_CLOCK* clck, /**< clock timer */
20970  SCIP_Real sec /**< time in seconds to set the clock's timer to */
20971  );
20972 
20973 /** gets the current total SCIP time in seconds, possibly accumulated over several problems.
20974  *
20975  * @return the current total SCIP time in seconds, ie. the total time since the SCIP instance has been created
20976  */
20977 extern
20979  SCIP* scip /**< SCIP data structure */
20980  );
20981 
20982 /** gets the current solving time in seconds
20983  *
20984  * @return the current solving time in seconds.
20985  *
20986  * @pre This method can be called if SCIP is in one of the following stages:
20987  * - \ref SCIP_STAGE_PROBLEM
20988  * - \ref SCIP_STAGE_TRANSFORMING
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_INITSOLVE
20995  * - \ref SCIP_STAGE_SOLVING
20996  * - \ref SCIP_STAGE_SOLVED
20997  *
20998  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
20999  */
21000 extern
21002  SCIP* scip /**< SCIP data structure */
21003  );
21004 
21005 /** gets the current reading time in seconds
21006  *
21007  * @return the current reading time in seconds.
21008  *
21009  * @pre This method can be called if SCIP is in one of the following stages:
21010  * - \ref SCIP_STAGE_PROBLEM
21011  * - \ref SCIP_STAGE_TRANSFORMING
21012  * - \ref SCIP_STAGE_TRANSFORMED
21013  * - \ref SCIP_STAGE_INITPRESOLVE
21014  * - \ref SCIP_STAGE_PRESOLVING
21015  * - \ref SCIP_STAGE_EXITPRESOLVE
21016  * - \ref SCIP_STAGE_PRESOLVED
21017  * - \ref SCIP_STAGE_INITSOLVE
21018  * - \ref SCIP_STAGE_SOLVING
21019  * - \ref SCIP_STAGE_SOLVED
21020  *
21021  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21022  */
21023 extern
21025  SCIP* scip /**< SCIP data structure */
21026  );
21027 
21028 /** gets the current presolving time in seconds
21029  *
21030  * @return the current presolving time in seconds.
21031  *
21032  * @pre This method can be called if SCIP is in one of the following stages:
21033  * - \ref SCIP_STAGE_INITPRESOLVE
21034  * - \ref SCIP_STAGE_PRESOLVING
21035  * - \ref SCIP_STAGE_EXITPRESOLVE
21036  * - \ref SCIP_STAGE_PRESOLVED
21037  * - \ref SCIP_STAGE_INITSOLVE
21038  * - \ref SCIP_STAGE_SOLVING
21039  * - \ref SCIP_STAGE_SOLVED
21040  *
21041  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21042  */
21043 extern
21045  SCIP* scip /**< SCIP data structure */
21046  );
21047 
21048 /** gets the time need to solve the first LP in the root node
21049  *
21050  * @return the solving time for the first LP in the root node in seconds.
21051  *
21052  * @pre This method can be called if SCIP is in one of the following stages:
21053  * - \ref SCIP_STAGE_TRANSFORMING
21054  * - \ref SCIP_STAGE_TRANSFORMED
21055  * - \ref SCIP_STAGE_INITPRESOLVE
21056  * - \ref SCIP_STAGE_PRESOLVING
21057  * - \ref SCIP_STAGE_EXITPRESOLVE
21058  * - \ref SCIP_STAGE_PRESOLVED
21059  * - \ref SCIP_STAGE_INITSOLVE
21060  * - \ref SCIP_STAGE_SOLVING
21061  * - \ref SCIP_STAGE_SOLVED
21062  *
21063  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21064  */
21065 extern
21067  SCIP* scip /**< SCIP data structure */
21068  );
21069 
21070 /**@} */
21071 
21072 /*
21073  * numeric values and comparisons
21074  */
21075 
21076 /**@addtogroup PublicToleranceMethods
21077  *
21078  * @{
21079  */
21080 
21081 /** returns value treated as zero
21082  *
21083  * @return value treated as zero
21084  */
21085 extern
21087  SCIP* scip /**< SCIP data structure */
21088  );
21089 
21090 /** returns value treated as zero for sums of floating point values
21091  *
21092  * @return value treated as zero for sums of floating point values
21093  */
21094 extern
21096  SCIP* scip /**< SCIP data structure */
21097  );
21098 
21099 /** returns feasibility tolerance for constraints
21100  *
21101  * @return feasibility tolerance for constraints
21102  */
21103 extern
21105  SCIP* scip /**< SCIP data structure */
21106  );
21107 
21108 /** returns primal feasibility tolerance of LP solver
21109  *
21110  * @return primal feasibility tolerance of LP solver
21111  */
21112 extern
21114  SCIP* scip /**< SCIP data structure */
21115  );
21116 
21117 /** returns feasibility tolerance for reduced costs
21118  *
21119  * @return feasibility tolerance for reduced costs
21120  */
21121 extern
21123  SCIP* scip /**< SCIP data structure */
21124  );
21125 
21126 /** returns convergence tolerance used in barrier algorithm
21127  *
21128  * @return convergence tolerance used in barrier algorithm
21129  */
21130 extern
21132  SCIP* scip /**< SCIP data structure */
21133  );
21134 
21135 /** return the cutoff bound delta
21136  *
21137  * @return cutoff bound data
21138  */
21139 extern
21141  SCIP* scip /**< SCIP data structure */
21142  );
21143 
21144 /** sets the feasibility tolerance for constraints
21145  *
21146  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21147  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21148  */
21149 extern
21151  SCIP* scip, /**< SCIP data structure */
21152  SCIP_Real feastol /**< new feasibility tolerance for constraints */
21153  );
21154 
21155 /** sets the primal feasibility tolerance of LP solver
21156  *
21157  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21158  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21159  */
21160 extern
21162  SCIP* scip, /**< SCIP data structure */
21163  SCIP_Real lpfeastol, /**< new primal feasibility tolerance of LP solver */
21164  SCIP_Bool printnewvalue /**< should "numerics/lpfeastol = ..." be printed? */
21165  );
21166 
21167 /** sets the feasibility tolerance for reduced costs
21168  *
21169  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21170  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21171  */
21172 extern
21174  SCIP* scip, /**< SCIP data structure */
21175  SCIP_Real dualfeastol /**< new feasibility tolerance for reduced costs */
21176  );
21177 
21178 /** sets the convergence tolerance used in barrier algorithm
21179  *
21180  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21181  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21182  */
21183 extern
21185  SCIP* scip, /**< SCIP data structure */
21186  SCIP_Real barrierconvtol /**< new convergence tolerance used in barrier algorithm */
21187  );
21188 
21189 /** marks that some limit parameter was changed */
21190 extern
21192  SCIP* scip /**< SCIP data structure */
21193  );
21194 
21195 /** returns value treated as infinity */
21196 extern
21198  SCIP* scip /**< SCIP data structure */
21199  );
21200 
21201 /** returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity
21202  * computation)
21203  */
21204 extern
21206  SCIP* scip /**< SCIP data structure */
21207  );
21208 
21209 /** checks, if values are in range of epsilon */
21210 extern
21212  SCIP* scip, /**< SCIP data structure */
21213  SCIP_Real val1, /**< first value to be compared */
21214  SCIP_Real val2 /**< second value to be compared */
21215  );
21216 
21217 /** checks, if val1 is (more than epsilon) lower than val2 */
21218 extern
21220  SCIP* scip, /**< SCIP data structure */
21221  SCIP_Real val1, /**< first value to be compared */
21222  SCIP_Real val2 /**< second value to be compared */
21223  );
21224 
21225 /** checks, if val1 is not (more than epsilon) greater than val2 */
21226 extern
21228  SCIP* scip, /**< SCIP data structure */
21229  SCIP_Real val1, /**< first value to be compared */
21230  SCIP_Real val2 /**< second value to be compared */
21231  );
21232 
21233 /** checks, if val1 is (more than epsilon) greater than val2 */
21234 extern
21236  SCIP* scip, /**< SCIP data structure */
21237  SCIP_Real val1, /**< first value to be compared */
21238  SCIP_Real val2 /**< second value to be compared */
21239  );
21240 
21241 /** checks, if val1 is not (more than epsilon) lower than val2 */
21242 extern
21244  SCIP* scip, /**< SCIP data structure */
21245  SCIP_Real val1, /**< first value to be compared */
21246  SCIP_Real val2 /**< second value to be compared */
21247  );
21248 
21249 /** checks, if value is (positive) infinite */
21250 extern
21252  SCIP* scip, /**< SCIP data structure */
21253  SCIP_Real val /**< value to be compared against infinity */
21254  );
21255 
21256 /** checks, if value is huge and should be handled separately (e.g., in activity computation) */
21257 extern
21259  SCIP* scip, /**< SCIP data structure */
21260  SCIP_Real val /**< value to be checked whether it is huge */
21261  );
21262 
21263 /** checks, if value is in range epsilon of 0.0 */
21264 extern
21266  SCIP* scip, /**< SCIP data structure */
21267  SCIP_Real val /**< value to process */
21268  );
21269 
21270 /** checks, if value is greater than epsilon */
21271 extern
21273  SCIP* scip, /**< SCIP data structure */
21274  SCIP_Real val /**< value to process */
21275  );
21276 
21277 /** checks, if value is lower than -epsilon */
21278 extern
21280  SCIP* scip, /**< SCIP data structure */
21281  SCIP_Real val /**< value to process */
21282  );
21283 
21284 /** checks, if value is integral within epsilon */
21285 extern
21287  SCIP* scip, /**< SCIP data structure */
21288  SCIP_Real val /**< value to process */
21289  );
21290 
21291 /** checks whether the product val * scalar is integral in epsilon scaled by scalar */
21292 extern
21294  SCIP* scip, /**< SCIP data structure */
21295  SCIP_Real val, /**< unscaled value to check for scaled integrality */
21296  SCIP_Real scalar /**< value to scale val with for checking for integrality */
21297  );
21298 
21299 /** checks, if given fractional part is smaller than epsilon */
21300 extern
21302  SCIP* scip, /**< SCIP data structure */
21303  SCIP_Real val /**< value to process */
21304  );
21305 
21306 /** rounds value + epsilon down to the next integer */
21307 extern
21309  SCIP* scip, /**< SCIP data structure */
21310  SCIP_Real val /**< value to process */
21311  );
21312 
21313 /** rounds value - epsilon up to the next integer */
21314 extern
21316  SCIP* scip, /**< SCIP data structure */
21317  SCIP_Real val /**< value to process */
21318  );
21319 
21320 /** rounds value to the nearest integer with epsilon tolerance */
21321 extern
21323  SCIP* scip, /**< SCIP data structure */
21324  SCIP_Real val /**< value to process */
21325  );
21326 
21327 /** returns fractional part of value, i.e. x - floor(x) in epsilon tolerance */
21328 extern
21330  SCIP* scip, /**< SCIP data structure */
21331  SCIP_Real val /**< value to return fractional part for */
21332  );
21333 
21334 /** checks, if values are in range of sumepsilon */
21335 extern
21337  SCIP* scip, /**< SCIP data structure */
21338  SCIP_Real val1, /**< first value to be compared */
21339  SCIP_Real val2 /**< second value to be compared */
21340  );
21341 
21342 /** checks, if val1 is (more than sumepsilon) lower than val2 */
21343 extern
21345  SCIP* scip, /**< SCIP data structure */
21346  SCIP_Real val1, /**< first value to be compared */
21347  SCIP_Real val2 /**< second value to be compared */
21348  );
21349 
21350 /** checks, if val1 is not (more than sumepsilon) greater than val2 */
21351 extern
21353  SCIP* scip, /**< SCIP data structure */
21354  SCIP_Real val1, /**< first value to be compared */
21355  SCIP_Real val2 /**< second value to be compared */
21356  );
21357 
21358 /** checks, if val1 is (more than sumepsilon) greater than val2 */
21359 extern
21361  SCIP* scip, /**< SCIP data structure */
21362  SCIP_Real val1, /**< first value to be compared */
21363  SCIP_Real val2 /**< second value to be compared */
21364  );
21365 
21366 /** checks, if val1 is not (more than sumepsilon) lower than val2 */
21367 extern
21369  SCIP* scip, /**< SCIP data structure */
21370  SCIP_Real val1, /**< first value to be compared */
21371  SCIP_Real val2 /**< second value to be compared */
21372  );
21373 
21374 /** checks, if value is in range sumepsilon of 0.0 */
21375 extern
21377  SCIP* scip, /**< SCIP data structure */
21378  SCIP_Real val /**< value to process */
21379  );
21380 
21381 /** checks, if value is greater than sumepsilon */
21382 extern
21384  SCIP* scip, /**< SCIP data structure */
21385  SCIP_Real val /**< value to process */
21386  );
21387 
21388 /** checks, if value is lower than -sumepsilon */
21389 extern
21391  SCIP* scip, /**< SCIP data structure */
21392  SCIP_Real val /**< value to process */
21393  );
21394 
21395 /** checks, if relative difference of values is in range of feasibility tolerance */
21396 extern
21398  SCIP* scip, /**< SCIP data structure */
21399  SCIP_Real val1, /**< first value to be compared */
21400  SCIP_Real val2 /**< second value to be compared */
21401  );
21402 
21403 /** checks, if relative difference val1 and val2 is lower than feasibility tolerance */
21404 extern
21406  SCIP* scip, /**< SCIP data structure */
21407  SCIP_Real val1, /**< first value to be compared */
21408  SCIP_Real val2 /**< second value to be compared */
21409  );
21410 
21411 /** checks, if relative difference of val1 and val2 is not greater than feasibility tolerance */
21412 extern
21414  SCIP* scip, /**< SCIP data structure */
21415  SCIP_Real val1, /**< first value to be compared */
21416  SCIP_Real val2 /**< second value to be compared */
21417  );
21418 
21419 /** checks, if relative difference of val1 and val2 is greater than feastol */
21420 extern
21422  SCIP* scip, /**< SCIP data structure */
21423  SCIP_Real val1, /**< first value to be compared */
21424  SCIP_Real val2 /**< second value to be compared */
21425  );
21426 
21427 /** checks, if relative difference of val1 and val2 is not lower than -feastol */
21428 extern
21430  SCIP* scip, /**< SCIP data structure */
21431  SCIP_Real val1, /**< first value to be compared */
21432  SCIP_Real val2 /**< second value to be compared */
21433  );
21434 
21435 /** checks, if value is in range feasibility tolerance of 0.0 */
21436 extern
21438  SCIP* scip, /**< SCIP data structure */
21439  SCIP_Real val /**< value to process */
21440  );
21441 
21442 /** checks, if value is greater than feasibility tolerance */
21443 extern
21445  SCIP* scip, /**< SCIP data structure */
21446  SCIP_Real val /**< value to process */
21447  );
21448 
21449 /** checks, if value is lower than -feasibility tolerance */
21450 extern
21452  SCIP* scip, /**< SCIP data structure */
21453  SCIP_Real val /**< value to process */
21454  );
21455 
21456 /** checks, if value is integral within the LP feasibility bounds */
21457 extern
21459  SCIP* scip, /**< SCIP data structure */
21460  SCIP_Real val /**< value to process */
21461  );
21462 
21463 /** checks, if given fractional part is smaller than feastol */
21464 extern
21466  SCIP* scip, /**< SCIP data structure */
21467  SCIP_Real val /**< value to process */
21468  );
21469 
21470 /** rounds value + feasibility tolerance down to the next integer */
21471 extern
21473  SCIP* scip, /**< SCIP data structure */
21474  SCIP_Real val /**< value to process */
21475  );
21476 
21477 /** rounds value - feasibility tolerance up to the next integer */
21478 extern
21480  SCIP* scip, /**< SCIP data structure */
21481  SCIP_Real val /**< value to process */
21482  );
21483 
21484 /** rounds value to the nearest integer in feasibility tolerance */
21485 extern
21487  SCIP* scip, /**< SCIP data structure */
21488  SCIP_Real val /**< value to process */
21489  );
21490 
21491 /** returns fractional part of value, i.e. x - floor(x) */
21492 extern
21494  SCIP* scip, /**< SCIP data structure */
21495  SCIP_Real val /**< value to process */
21496  );
21497 
21498 /** checks, if relative difference of values is in range of dual feasibility tolerance */
21499 extern
21501  SCIP* scip, /**< SCIP data structure */
21502  SCIP_Real val1, /**< first value to be compared */
21503  SCIP_Real val2 /**< second value to be compared */
21504  );
21505 
21506 /** checks, if relative difference val1 and val2 is lower than dual feasibility tolerance */
21507 extern
21509  SCIP* scip, /**< SCIP data structure */
21510  SCIP_Real val1, /**< first value to be compared */
21511  SCIP_Real val2 /**< second value to be compared */
21512  );
21513 
21514 /** checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance */
21515 extern
21517  SCIP* scip, /**< SCIP data structure */
21518  SCIP_Real val1, /**< first value to be compared */
21519  SCIP_Real val2 /**< second value to be compared */
21520  );
21521 
21522 /** checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance */
21523 extern
21525  SCIP* scip, /**< SCIP data structure */
21526  SCIP_Real val1, /**< first value to be compared */
21527  SCIP_Real val2 /**< second value to be compared */
21528  );
21529 
21530 /** checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance */
21531 extern
21533  SCIP* scip, /**< SCIP data structure */
21534  SCIP_Real val1, /**< first value to be compared */
21535  SCIP_Real val2 /**< second value to be compared */
21536  );
21537 
21538 /** checks, if value is in range dual feasibility tolerance of 0.0 */
21539 extern
21541  SCIP* scip, /**< SCIP data structure */
21542  SCIP_Real val /**< value to process */
21543  );
21544 
21545 /** checks, if value is greater than dual feasibility tolerance */
21546 extern
21548  SCIP* scip, /**< SCIP data structure */
21549  SCIP_Real val /**< value to process */
21550  );
21551 
21552 /** checks, if value is lower than -dual feasibility tolerance */
21553 extern
21555  SCIP* scip, /**< SCIP data structure */
21556  SCIP_Real val /**< value to process */
21557  );
21558 
21559 /** checks, if value is integral within the LP dual feasibility tolerance */
21560 extern
21562  SCIP* scip, /**< SCIP data structure */
21563  SCIP_Real val /**< value to process */
21564  );
21565 
21566 /** checks, if given fractional part is smaller than dual feasibility tolerance */
21567 extern
21569  SCIP* scip, /**< SCIP data structure */
21570  SCIP_Real val /**< value to process */
21571  );
21572 
21573 /** rounds value + dual feasibility tolerance down to the next integer */
21574 extern
21576  SCIP* scip, /**< SCIP data structure */
21577  SCIP_Real val /**< value to process */
21578  );
21579 
21580 /** rounds value - dual feasibility tolerance up to the next integer */
21581 extern
21583  SCIP* scip, /**< SCIP data structure */
21584  SCIP_Real val /**< value to process */
21585  );
21586 
21587 /** rounds value to the nearest integer in dual feasibility tolerance */
21588 extern
21590  SCIP* scip, /**< SCIP data structure */
21591  SCIP_Real val /**< value to process */
21592  );
21593 
21594 /** returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance */
21595 extern
21597  SCIP* scip, /**< SCIP data structure */
21598  SCIP_Real val /**< value to process */
21599  );
21600 
21601 /** checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
21602 extern
21604  SCIP* scip, /**< SCIP data structure */
21605  SCIP_Real newlb, /**< new lower bound */
21606  SCIP_Real oldlb, /**< old lower bound */
21607  SCIP_Real oldub /**< old upper bound */
21608  );
21609 
21610 /** checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
21612  SCIP* scip, /**< SCIP data structure */
21613  SCIP_Real newub, /**< new upper bound */
21614  SCIP_Real oldlb, /**< old lower bound */
21615  SCIP_Real oldub /**< old upper bound */
21616  );
21617 
21618 /** checks, if relative difference of values is in range of epsilon */
21619 extern
21621  SCIP* scip, /**< SCIP data structure */
21622  SCIP_Real val1, /**< first value to be compared */
21623  SCIP_Real val2 /**< second value to be compared */
21624  );
21625 
21626 /** checks, if relative difference of val1 and val2 is lower than epsilon */
21627 extern
21629  SCIP* scip, /**< SCIP data structure */
21630  SCIP_Real val1, /**< first value to be compared */
21631  SCIP_Real val2 /**< second value to be compared */
21632  );
21633 
21634 /** checks, if relative difference of val1 and val2 is not greater than epsilon */
21635 extern
21637  SCIP* scip, /**< SCIP data structure */
21638  SCIP_Real val1, /**< first value to be compared */
21639  SCIP_Real val2 /**< second value to be compared */
21640  );
21641 
21642 /** checks, if relative difference of val1 and val2 is greater than epsilon */
21643 extern
21645  SCIP* scip, /**< SCIP data structure */
21646  SCIP_Real val1, /**< first value to be compared */
21647  SCIP_Real val2 /**< second value to be compared */
21648  );
21649 
21650 /** checks, if relative difference of val1 and val2 is not lower than -epsilon */
21651 extern
21653  SCIP* scip, /**< SCIP data structure */
21654  SCIP_Real val1, /**< first value to be compared */
21655  SCIP_Real val2 /**< second value to be compared */
21656  );
21657 
21658 /** checks, if relative difference of values is in range of sumepsilon */
21659 extern
21661  SCIP* scip, /**< SCIP data structure */
21662  SCIP_Real val1, /**< first value to be compared */
21663  SCIP_Real val2 /**< second value to be compared */
21664  );
21665 
21666 /** checks, if relative difference of val1 and val2 is lower than sumepsilon */
21667 extern
21669  SCIP* scip, /**< SCIP data structure */
21670  SCIP_Real val1, /**< first value to be compared */
21671  SCIP_Real val2 /**< second value to be compared */
21672  );
21673 
21674 /** checks, if relative difference of val1 and val2 is not greater than sumepsilon */
21675 extern
21677  SCIP* scip, /**< SCIP data structure */
21678  SCIP_Real val1, /**< first value to be compared */
21679  SCIP_Real val2 /**< second value to be compared */
21680  );
21681 
21682 /** checks, if relative difference of val1 and val2 is greater than sumepsilon */
21683 extern
21685  SCIP* scip, /**< SCIP data structure */
21686  SCIP_Real val1, /**< first value to be compared */
21687  SCIP_Real val2 /**< second value to be compared */
21688  );
21689 
21690 /** checks, if relative difference of val1 and val2 is not lower than -sumepsilon */
21691 extern
21693  SCIP* scip, /**< SCIP data structure */
21694  SCIP_Real val1, /**< first value to be compared */
21695  SCIP_Real val2 /**< second value to be compared */
21696  );
21697 
21698 /** converts the given real number representing an integer to an int; in optimized mode the function gets inlined for
21699  * performance; in debug mode we check some additional conditions
21700  */
21701 extern
21703  SCIP* scip, /**< SCIP data structure */
21704  SCIP_Real real /**< double bound to convert */
21705  );
21706 
21707 /** converts the given real number representing an integer to a long integer; in optimized mode the function gets inlined for
21708  * performance; in debug mode we check some additional conditions
21709  */
21710 extern
21712  SCIP* scip, /**< SCIP data structure */
21713  SCIP_Real real /**< double bound to convert */
21714  );
21715 
21716 /** Checks, if an iteratively updated value is reliable or should be recomputed from scratch.
21717  * This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high
21718  * absolute value during the optimization process which is later reduced significantly. In this case, the last digits
21719  * were canceled out when increasing the value and are random after decreasing it.
21720  * We do not consider the cancellations which can occur during increasing the absolute value because they just cannot
21721  * be expressed using fixed precision floating point arithmetic, anymore.
21722  * In order to get more reliable values, the idea is to always store the last reliable value, where increasing the
21723  * absolute of the value is viewed as preserving reliability. Then, after each update, the new absolute value can be
21724  * compared against the last reliable one with this method, checking whether it was decreased by a factor of at least
21725  * "lp/recompfac" and should be recomputed.
21726  */
21727 extern
21729  SCIP* scip, /**< SCIP data structure */
21730  SCIP_Real newvalue, /**< new value after update */
21731  SCIP_Real oldvalue /**< old value, i.e., last reliable value */
21732  );
21733 
21734 #ifdef NDEBUG
21735 
21736 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
21737  * speed up the algorithms.
21738  */
21739 
21740 #define SCIPinfinity(scip) SCIPsetInfinity((scip)->set)
21741 #define SCIPisInfinity(scip, val) SCIPsetIsInfinity((scip)->set, val)
21742 #define SCIPisHugeValue(scip, val) SCIPsetIsHugeValue((scip)->set, val)
21743 #define SCIPgetHugeValue(scip) SCIPsetGetHugeValue((scip)->set)
21744 #define SCIPisEQ(scip, val1, val2) SCIPsetIsEQ((scip)->set, val1, val2)
21745 #define SCIPisLT(scip, val1, val2) SCIPsetIsLT((scip)->set, val1, val2)
21746 #define SCIPisLE(scip, val1, val2) SCIPsetIsLE((scip)->set, val1, val2)
21747 #define SCIPisGT(scip, val1, val2) SCIPsetIsGT((scip)->set, val1, val2)
21748 #define SCIPisGE(scip, val1, val2) SCIPsetIsGE((scip)->set, val1, val2)
21749 #define SCIPisZero(scip, val) SCIPsetIsZero((scip)->set, val)
21750 #define SCIPisPositive(scip, val) SCIPsetIsPositive((scip)->set, val)
21751 #define SCIPisNegative(scip, val) SCIPsetIsNegative((scip)->set, val)
21752 #define SCIPisIntegral(scip, val) SCIPsetIsIntegral((scip)->set, val)
21753 #define SCIPisScalingIntegral(scip, val, scalar) SCIPsetIsScalingIntegral((scip)->set, val, scalar)
21754 #define SCIPisFracIntegral(scip, val) SCIPsetIsFracIntegral((scip)->set, val)
21755 #define SCIPfloor(scip, val) SCIPsetFloor((scip)->set, val)
21756 #define SCIPceil(scip, val) SCIPsetCeil((scip)->set, val)
21757 #define SCIPround(scip, val) SCIPsetRound((scip)->set, val)
21758 #define SCIPfrac(scip, val) SCIPsetFrac((scip)->set, val)
21759 
21760 #define SCIPisSumEQ(scip, val1, val2) SCIPsetIsSumEQ((scip)->set, val1, val2)
21761 #define SCIPisSumLT(scip, val1, val2) SCIPsetIsSumLT((scip)->set, val1, val2)
21762 #define SCIPisSumLE(scip, val1, val2) SCIPsetIsSumLE((scip)->set, val1, val2)
21763 #define SCIPisSumGT(scip, val1, val2) SCIPsetIsSumGT((scip)->set, val1, val2)
21764 #define SCIPisSumGE(scip, val1, val2) SCIPsetIsSumGE((scip)->set, val1, val2)
21765 #define SCIPisSumZero(scip, val) SCIPsetIsSumZero((scip)->set, val)
21766 #define SCIPisSumPositive(scip, val) SCIPsetIsSumPositive((scip)->set, val)
21767 #define SCIPisSumNegative(scip, val) SCIPsetIsSumNegative((scip)->set, val)
21768 
21769 #define SCIPisFeasEQ(scip, val1, val2) SCIPsetIsFeasEQ((scip)->set, val1, val2)
21770 #define SCIPisFeasLT(scip, val1, val2) SCIPsetIsFeasLT((scip)->set, val1, val2)
21771 #define SCIPisFeasLE(scip, val1, val2) SCIPsetIsFeasLE((scip)->set, val1, val2)
21772 #define SCIPisFeasGT(scip, val1, val2) SCIPsetIsFeasGT((scip)->set, val1, val2)
21773 #define SCIPisFeasGE(scip, val1, val2) SCIPsetIsFeasGE((scip)->set, val1, val2)
21774 #define SCIPisFeasZero(scip, val) SCIPsetIsFeasZero((scip)->set, val)
21775 #define SCIPisFeasPositive(scip, val) SCIPsetIsFeasPositive((scip)->set, val)
21776 #define SCIPisFeasNegative(scip, val) SCIPsetIsFeasNegative((scip)->set, val)
21777 #define SCIPisFeasIntegral(scip, val) SCIPsetIsFeasIntegral((scip)->set, val)
21778 #define SCIPisFeasFracIntegral(scip, val) SCIPsetIsFeasFracIntegral((scip)->set, val)
21779 #define SCIPfeasFloor(scip, val) SCIPsetFeasFloor((scip)->set, val)
21780 #define SCIPfeasCeil(scip, val) SCIPsetFeasCeil((scip)->set, val)
21781 #define SCIPfeasRound(scip, val) SCIPsetFeasRound((scip)->set, val)
21782 #define SCIPfeasFrac(scip, val) SCIPsetFeasFrac((scip)->set, val)
21783 
21784 #define SCIPisDualfeasEQ(scip, val1, val2) SCIPsetIsDualfeasEQ((scip)->set, val1, val2)
21785 #define SCIPisDualfeasLT(scip, val1, val2) SCIPsetIsDualfeasLT((scip)->set, val1, val2)
21786 #define SCIPisDualfeasLE(scip, val1, val2) SCIPsetIsDualfeasLE((scip)->set, val1, val2)
21787 #define SCIPisDualfeasGT(scip, val1, val2) SCIPsetIsDualfeasGT((scip)->set, val1, val2)
21788 #define SCIPisDualfeasGE(scip, val1, val2) SCIPsetIsDualfeasGE((scip)->set, val1, val2)
21789 #define SCIPisDualfeasZero(scip, val) SCIPsetIsDualfeasZero((scip)->set, val)
21790 #define SCIPisDualfeasPositive(scip, val) SCIPsetIsDualfeasPositive((scip)->set, val)
21791 #define SCIPisDualfeasNegative(scip, val) SCIPsetIsDualfeasNegative((scip)->set, val)
21792 #define SCIPisDualfeasIntegral(scip, val) SCIPsetIsDualfeasIntegral((scip)->set, val)
21793 #define SCIPisDualfeasFracIntegral(scip, val) SCIPsetIsDualfeasFracIntegral((scip)->set, val)
21794 #define SCIPdualfeasFloor(scip, val) SCIPsetDualfeasFloor((scip)->set, val)
21795 #define SCIPdualfeasCeil(scip, val) SCIPsetDualfeasCeil((scip)->set, val)
21796 #define SCIPdualfeasRound(scip, val) SCIPsetDualfeasRound((scip)->set, val)
21797 #define SCIPdualfeasFrac(scip, val) SCIPsetDualfeasFrac((scip)->set, val)
21798 
21799 #define SCIPisLbBetter(scip, newlb, oldlb, oldub) SCIPsetIsLbBetter(scip->set, newlb, oldlb, oldub)
21800 #define SCIPisUbBetter(scip, newub, oldlb, oldub) SCIPsetIsUbBetter(scip->set, newub, oldlb, oldub)
21801 
21802 #define SCIPisRelEQ(scip, val1, val2) SCIPsetIsRelEQ((scip)->set, val1, val2)
21803 #define SCIPisRelLT(scip, val1, val2) SCIPsetIsRelLT((scip)->set, val1, val2)
21804 #define SCIPisRelLE(scip, val1, val2) SCIPsetIsRelLE((scip)->set, val1, val2)
21805 #define SCIPisRelGT(scip, val1, val2) SCIPsetIsRelGT((scip)->set, val1, val2)
21806 #define SCIPisRelGE(scip, val1, val2) SCIPsetIsRelGE((scip)->set, val1, val2)
21807 
21808 #define SCIPisSumRelEQ(scip, val1, val2) SCIPsetIsSumRelEQ((scip)->set, val1, val2)
21809 #define SCIPisSumRelLT(scip, val1, val2) SCIPsetIsSumRelLT((scip)->set, val1, val2)
21810 #define SCIPisSumRelLE(scip, val1, val2) SCIPsetIsSumRelLE((scip)->set, val1, val2)
21811 #define SCIPisSumRelGT(scip, val1, val2) SCIPsetIsSumRelGT((scip)->set, val1, val2)
21812 #define SCIPisSumRelGE(scip, val1, val2) SCIPsetIsSumRelGE((scip)->set, val1, val2)
21813 #define SCIPconvertRealToInt(scip, real) ((int)((real) < 0 ? ((real) - 0.5) : ((real) + 0.5)))
21814 #define SCIPconvertRealToLongint(scip, real) ((SCIP_Longint)((real) < 0 ? ((real) - 0.5) : ((real) + 0.5)))
21815 
21816 #define SCIPisUpdateUnreliable(scip, newval, oldval) SCIPsetIsUpdateUnreliable((scip)->set, newval, oldval)
21817 
21818 #define SCIPmarkConsPropagate(scip, cons) SCIPconsMarkPropagate(cons, (scip)->set)
21819 #define SCIPgetStage(scip) (((scip)->set)->stage)
21820 #define SCIPhasPerformedPresolve(scip) ((scip)->stat->performpresol)
21821 #define SCIPisStopped(scip) SCIPsolveIsStopped((scip)->set, (scip)->stat, 0)
21822 
21823 #endif
21824 
21825 /** outputs a real number, or "+infinity", or "-infinity" to a file */
21826 extern
21827 void SCIPprintReal(
21828  SCIP* scip, /**< SCIP data structure */
21829  FILE* file, /**< output file (or NULL for standard output) */
21830  SCIP_Real val, /**< value to print */
21831  int width, /**< width of the field */
21832  int precision /**< number of significant digits printed */
21833  );
21834 
21835 /** parse a real value that was written with SCIPprintReal() */
21836 extern
21838  SCIP* scip, /**< SCIP data structure */
21839  const char* str, /**< string to search */
21840  SCIP_Real* value, /**< pointer to store the parsed value */
21841  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
21842  );
21843 
21844 /**@} */
21845 
21846 
21847 
21848 
21849 /*
21850  * memory management
21851  */
21852 
21853 /**@name Standard Memory Management Macros */
21854 /**@{ */
21855 
21856 #define SCIPallocMemory(scip,ptr) ( (BMSallocMemory((ptr)) == NULL) \
21857  ? SCIP_NOMEMORY : SCIP_OKAY )
21858 #define SCIPallocMemoryArray(scip,ptr,num) ( (BMSallocMemoryArray((ptr), (num)) == NULL) \
21859  ? SCIP_NOMEMORY : SCIP_OKAY )
21860 #define SCIPallocClearMemoryArray(scip,ptr,num) ( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \
21861  ? SCIP_NOMEMORY : SCIP_OKAY )
21862 #define SCIPallocMemorySize(scip,ptr,size) ( (BMSallocMemorySize((ptr), (size)) == NULL) \
21863  ? SCIP_NOMEMORY : SCIP_OKAY )
21864 #define SCIPreallocMemoryArray(scip,ptr,newnum) ( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \
21865  ? SCIP_NOMEMORY : SCIP_OKAY )
21866 #define SCIPreallocMemorySize(scip,ptr,newsize) ( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \
21867  ? SCIP_NOMEMORY : SCIP_OKAY )
21868 #define SCIPduplicateMemory(scip, ptr, source) ( (BMSduplicateMemory((ptr), (source)) == NULL) \
21869  ? SCIP_NOMEMORY : SCIP_OKAY )
21870 #define SCIPduplicateMemoryArray(scip, ptr, source, num) ( (BMSduplicateMemoryArray((ptr), (source), (num)) == NULL) \
21871  ? SCIP_NOMEMORY : SCIP_OKAY )
21872 #define SCIPfreeMemory(scip,ptr) BMSfreeMemory(ptr)
21873 #define SCIPfreeMemoryNull(scip,ptr) BMSfreeMemoryNull(ptr)
21874 #define SCIPfreeMemoryArray(scip,ptr) BMSfreeMemoryArray(ptr)
21875 #define SCIPfreeMemoryArrayNull(scip,ptr) BMSfreeMemoryArrayNull(ptr)
21876 #define SCIPfreeMemorySize(scip,ptr) BMSfreeMemorySize(ptr)
21877 #define SCIPfreeMemorySizeNull(scip,ptr) BMSfreeMemorySizeNull(ptr)
21878 /**@} */
21879 
21880 
21881 /**@addtogroup PublicMemoryMethods
21882  *
21883  * @{
21884  */
21885 
21886 /**@name Block Memory Management Macros
21887  * @{
21888  */
21889 
21890 #define SCIPallocBlockMemory(scip,ptr) ( (BMSallocBlockMemory(SCIPblkmem(scip), (ptr)) == NULL) \
21891  ? SCIP_NOMEMORY : SCIP_OKAY )
21892 #define SCIPallocBlockMemoryArray(scip,ptr,num) ( (BMSallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
21893  ? SCIP_NOMEMORY : SCIP_OKAY )
21894 #define SCIPallocBlockMemorySize(scip,ptr,size) ( (BMSallocBlockMemorySize(SCIPblkmem(scip), (ptr), (size)) == NULL) \
21895  ? SCIP_NOMEMORY : SCIP_OKAY )
21896 #define SCIPallocClearBlockMemoryArray(scip,ptr,num) ( (BMSallocClearBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
21897  ? SCIP_NOMEMORY : SCIP_OKAY )
21898 #define SCIPreallocBlockMemoryArray(scip,ptr,oldnum,newnum) ( (BMSreallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (oldnum), (newnum)) == NULL) \
21899  ? SCIP_NOMEMORY : SCIP_OKAY )
21900 #define SCIPreallocBlockMemorySize(scip,ptr,oldsize,newsize) ( (BMSreallocBlockMemorySize(SCIPblkmem(scip), (ptr), (oldsize), (newsize)) == NULL) \
21901  ? SCIP_NOMEMORY : SCIP_OKAY )
21902 #define SCIPduplicateBlockMemory(scip, ptr, source) ( (BMSduplicateBlockMemory(SCIPblkmem(scip), (ptr), (source)) == NULL) \
21903  ? SCIP_NOMEMORY : SCIP_OKAY )
21904 #define SCIPduplicateBlockMemoryArray(scip, ptr, source, num) ( (BMSduplicateBlockMemoryArray(SCIPblkmem(scip), (ptr), (source), (num)) == NULL) \
21905  ? SCIP_NOMEMORY : SCIP_OKAY )
21906 #define SCIPensureBlockMemoryArray(scip,ptr,arraysizeptr,minsize) ( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), (arraysizeptr), (minsize))) )
21907 #define SCIPfreeBlockMemory(scip,ptr) BMSfreeBlockMemory(SCIPblkmem(scip), (ptr))
21908 #define SCIPfreeBlockMemoryNull(scip,ptr) BMSfreeBlockMemoryNull(SCIPblkmem(scip), (ptr))
21909 #define SCIPfreeBlockMemoryArray(scip,ptr,num) BMSfreeBlockMemoryArray(SCIPblkmem(scip), (ptr), (num))
21910 #define SCIPfreeBlockMemoryArrayNull(scip,ptr,num) BMSfreeBlockMemoryArrayNull(SCIPblkmem(scip), (ptr), (num))
21911 #define SCIPfreeBlockMemorySize(scip,ptr,size) BMSfreeBlockMemorySize(SCIPblkmem(scip), (ptr), (size))
21912 #define SCIPfreeBlockMemorySizeNull(scip,ptr,size) BMSfreeBlockMemorySizeNull(SCIPblkmem(scip), (ptr), (size))
21913 
21914 /**@} */
21915 
21916 
21917 /**@name Buffer Memory Management Macros
21918  *
21919  * @{
21920  */
21921 
21922 
21923 #define SCIPallocBuffer(scip,ptr) ( (BMSallocBufferMemory(SCIPbuffer(scip), (ptr)) == NULL) \
21924  ? SCIP_NOMEMORY : SCIP_OKAY )
21925 #define SCIPallocBufferArray(scip,ptr,num) ( (BMSallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
21926  ? SCIP_NOMEMORY : SCIP_OKAY )
21927 #define SCIPallocClearBufferArray(scip,ptr,num) ( (BMSallocClearBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
21928  ? SCIP_NOMEMORY : SCIP_OKAY )
21929 #define SCIPreallocBufferArray(scip,ptr,num) ( (BMSreallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
21930  ? SCIP_NOMEMORY : SCIP_OKAY )
21931 #define SCIPduplicateBuffer(scip,ptr,source) ( (BMSduplicateBufferMemory(SCIPbuffer(scip), (ptr), (source), (size_t)sizeof(**(ptr))) \
21932  ? SCIP_NOMEMORY : SCIP_OKAY )
21933 #define SCIPduplicateBufferArray(scip,ptr,source,num) ( (BMSduplicateBufferMemoryArray(SCIPbuffer(scip), (ptr), (source), (num)) == NULL) \
21934  ? SCIP_NOMEMORY : SCIP_OKAY )
21935 #define SCIPfreeBuffer(scip,ptr) BMSfreeBufferMemorySize(SCIPbuffer(scip), (ptr))
21936 #define SCIPfreeBufferNull(scip,ptr) BMSfreeBufferMemoryNull(SCIPbuffer(scip), (ptr))
21937 #define SCIPfreeBufferArray(scip,ptr) BMSfreeBufferMemoryArray(SCIPbuffer(scip), (ptr))
21938 #define SCIPfreeBufferArrayNull(scip,ptr) BMSfreeBufferMemoryArrayNull(SCIPbuffer(scip), (ptr))
21939 
21940 
21941 #define SCIPallocCleanBuffer(scip,ptr) ( (BMSallocBufferMemory(SCIPcleanbuffer(scip), (ptr)) == NULL) \
21942  ? SCIP_NOMEMORY : SCIP_OKAY )
21943 #define SCIPallocCleanBufferArray(scip,ptr,num) ( (BMSallocBufferMemoryArray(SCIPcleanbuffer(scip), (ptr), (num)) == NULL) \
21944  ? SCIP_NOMEMORY : SCIP_OKAY )
21945 #define SCIPfreeCleanBuffer(scip,ptr) BMSfreeBufferMemorySize(SCIPcleanbuffer(scip), (ptr))
21946 #define SCIPfreeCleanBufferNull(scip,ptr) BMSfreeBufferMemoryNull(SCIPcleanbuffer(scip), (ptr))
21947 #define SCIPfreeCleanBufferArray(scip,ptr) BMSfreeBufferMemoryArray(SCIPcleanbuffer(scip), (ptr))
21948 #define SCIPfreeCleanBufferArrayNull(scip,ptr) BMSfreeBufferMemoryArrayNull(SCIPcleanbuffer(scip), (ptr))
21949 
21950 /**@} */
21951 
21952 
21953 /**@name Memory Management Functions
21954  *
21955  * @{
21956  */
21957 
21958 /** returns block memory to use at the current time
21959  *
21960  * @return the block memory to use at the current time.
21961  */
21962 extern
21964  SCIP* scip /**< SCIP data structure */
21965  );
21966 
21967 /** returns buffer memory for short living temporary objects
21968  *
21969  * @return the buffer memory for short living temporary objects
21970  */
21971 extern
21973  SCIP* scip /**< SCIP data structure */
21974  );
21975 
21976 /** returns clean buffer memory for short living temporary objects initialized to all zero
21977  *
21978  * @return the buffer memory for short living temporary objects initialized to all zero
21979  */
21980 extern
21982  SCIP* scip /**< SCIP data structure */
21983  );
21984 
21985 /** returns the total number of bytes used in block and buffer memory
21986  *
21987  * @return the total number of bytes used in block and buffer memory.
21988  */
21989 extern
21991  SCIP* scip /**< SCIP data structure */
21992  );
21993 
21994 /** returns the total number of bytes in block and buffer memory
21995  *
21996  * @return the total number of bytes in block and buffer memory.
21997  */
21998 extern
22000  SCIP* scip /**< SCIP data structure */
22001  );
22002 
22003 /** returns the estimated number of bytes used by external software, e.g., the LP solver
22004  *
22005  * @return the estimated number of bytes used by external software, e.g., the LP solver.
22006  */
22007 extern
22009  SCIP* scip /**< SCIP data structure */
22010  );
22011 
22012 /** calculate memory size for dynamically allocated arrays
22013  *
22014  * @return the memory size for dynamically allocated arrays.
22015  */
22016 extern
22018  SCIP* scip, /**< SCIP data structure */
22019  int num /**< minimum number of entries to store */
22020  );
22021 
22022 /** extends a dynamically allocated block memory array to be able to store at least the given number of elements;
22023  * use SCIPensureBlockMemoryArray() define to call this method!
22024  *
22025  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22026  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22027  */
22028 extern
22030  SCIP* scip, /**< SCIP data structure */
22031  void** arrayptr, /**< pointer to dynamically sized array */
22032  size_t elemsize, /**< size in bytes of each element in array */
22033  int* arraysize, /**< pointer to current array size */
22034  int minsize /**< required minimal array size */
22035  );
22036 
22037 /** prints output about used memory */
22038 extern
22040  SCIP* scip /**< SCIP data structure */
22041  );
22042 
22043 /* @} */
22044 
22045 /* @} */
22046 
22047 
22048 /*
22049  * dynamic arrays
22050  */
22051 
22052 /**@defgroup PublicDynamicArrayMethods Dynamic Arrays
22053  * @ingroup DataStructures
22054  * @brief methods for the creation and access of dynamic arrays
22055  *
22056  * @{
22057  */
22058 
22059 /** creates a dynamic array of real values
22060  *
22061  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22062  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22063  */
22064 extern
22066  SCIP* scip, /**< SCIP data structure */
22067  SCIP_REALARRAY** realarray /**< pointer to store the real array */
22068  );
22069 
22070 /** frees a dynamic array of real values
22071  *
22072  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22073  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22074  */
22075 extern
22077  SCIP* scip, /**< SCIP data structure */
22078  SCIP_REALARRAY** realarray /**< pointer to the real array */
22079  );
22080 
22081 /** extends dynamic array to be able to store indices from minidx to maxidx
22082  *
22083  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22084  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22085  */
22086 extern
22088  SCIP* scip, /**< SCIP data structure */
22089  SCIP_REALARRAY* realarray, /**< dynamic real array */
22090  int minidx, /**< smallest index to allocate storage for */
22091  int maxidx /**< largest index to allocate storage for */
22092  );
22093 
22094 /** clears a dynamic real array
22095  *
22096  * @return clears a dynamic real array
22097  */
22098 extern
22100  SCIP* scip, /**< SCIP data structure */
22101  SCIP_REALARRAY* realarray /**< dynamic real array */
22102  );
22103 
22104 /** gets value of entry in dynamic array */
22105 extern
22107  SCIP* scip, /**< SCIP data structure */
22108  SCIP_REALARRAY* realarray, /**< dynamic real array */
22109  int idx /**< array index to get value for */
22110  );
22111 
22112 /** sets value of entry in dynamic array
22113  *
22114  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22115  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22116  */
22117 extern
22119  SCIP* scip, /**< SCIP data structure */
22120  SCIP_REALARRAY* realarray, /**< dynamic real array */
22121  int idx, /**< array index to set value for */
22122  SCIP_Real val /**< value to set array index to */
22123  );
22124 
22125 /** increases value of entry in dynamic array
22126  *
22127  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22128  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22129  */
22130 extern
22132  SCIP* scip, /**< SCIP data structure */
22133  SCIP_REALARRAY* realarray, /**< dynamic real array */
22134  int idx, /**< array index to increase value for */
22135  SCIP_Real incval /**< value to increase array index */
22136  );
22137 
22138 /** returns the minimal index of all stored non-zero elements
22139  *
22140  * @return the minimal index of all stored non-zero elements
22141  */
22142 extern
22144  SCIP* scip, /**< SCIP data structure */
22145  SCIP_REALARRAY* realarray /**< dynamic real array */
22146  );
22147 
22148 /** returns the maximal index of all stored non-zero elements
22149  *
22150  * @return the maximal index of all stored non-zero elements
22151  */
22152 extern
22154  SCIP* scip, /**< SCIP data structure */
22155  SCIP_REALARRAY* realarray /**< dynamic real array */
22156  );
22157 
22158 /** creates a dynamic array of int values
22159  *
22160  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22161  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22162  */
22163 extern
22165  SCIP* scip, /**< SCIP data structure */
22166  SCIP_INTARRAY** intarray /**< pointer to store the int array */
22167  );
22168 
22169 /** frees a dynamic array of int values
22170  *
22171  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22172  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22173  */
22174 extern
22176  SCIP* scip, /**< SCIP data structure */
22177  SCIP_INTARRAY** intarray /**< pointer to the int array */
22178  );
22179 
22180 /** extends dynamic array to be able to store indices from minidx to maxidx
22181  *
22182  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22183  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22184  */
22185 extern
22187  SCIP* scip, /**< SCIP data structure */
22188  SCIP_INTARRAY* intarray, /**< dynamic int array */
22189  int minidx, /**< smallest index to allocate storage for */
22190  int maxidx /**< largest index to allocate storage for */
22191  );
22192 
22193 /** clears a dynamic int array
22194  *
22195  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22196  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22197  */
22198 extern
22200  SCIP* scip, /**< SCIP data structure */
22201  SCIP_INTARRAY* intarray /**< dynamic int array */
22202  );
22203 
22204 /** gets value of entry in dynamic array
22205  *
22206  * @return value of entry in dynamic array
22207  */
22208 extern
22209 int SCIPgetIntarrayVal(
22210  SCIP* scip, /**< SCIP data structure */
22211  SCIP_INTARRAY* intarray, /**< dynamic int array */
22212  int idx /**< array index to get value for */
22213  );
22214 
22215 /** sets value of entry in dynamic array
22216  *
22217  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22218  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22219  */
22220 extern
22222  SCIP* scip, /**< SCIP data structure */
22223  SCIP_INTARRAY* intarray, /**< dynamic int array */
22224  int idx, /**< array index to set value for */
22225  int val /**< value to set array index to */
22226  );
22227 
22228 /** increases value of entry in dynamic array
22229  *
22230  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22231  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22232  */
22233 extern
22235  SCIP* scip, /**< SCIP data structure */
22236  SCIP_INTARRAY* intarray, /**< dynamic int array */
22237  int idx, /**< array index to increase value for */
22238  int incval /**< value to increase array index */
22239  );
22240 
22241 /** returns the minimal index of all stored non-zero elements
22242  *
22243  * @return the minimal index of all stored non-zero elements
22244  */
22245 extern
22247  SCIP* scip, /**< SCIP data structure */
22248  SCIP_INTARRAY* intarray /**< dynamic int array */
22249  );
22250 
22251 /** returns the maximal index of all stored non-zero elements
22252  *
22253  * @return the maximal index of all stored non-zero elements
22254  */
22255 extern
22257  SCIP* scip, /**< SCIP data structure */
22258  SCIP_INTARRAY* intarray /**< dynamic int array */
22259  );
22260 
22261 /** creates a dynamic array of bool values
22262  *
22263  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22264  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22265  */
22266 extern
22268  SCIP* scip, /**< SCIP data structure */
22269  SCIP_BOOLARRAY** boolarray /**< pointer to store the bool array */
22270  );
22271 
22272 /** frees a dynamic array of bool values
22273  *
22274  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22275  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22276  */
22277 extern
22279  SCIP* scip, /**< SCIP data structure */
22280  SCIP_BOOLARRAY** boolarray /**< pointer to the bool array */
22281  );
22282 
22283 /** extends dynamic array to be able to store indices from minidx to maxidx
22284  *
22285  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22286  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22287  */
22288 extern
22290  SCIP* scip, /**< SCIP data structure */
22291  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
22292  int minidx, /**< smallest index to allocate storage for */
22293  int maxidx /**< largest index to allocate storage for */
22294  );
22295 
22296 /** clears a dynamic bool array
22297  *
22298  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22299  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22300  */
22301 extern
22303  SCIP* scip, /**< SCIP data structure */
22304  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
22305  );
22306 
22307 /** gets value of entry in dynamic array
22308  *
22309  * @return value of entry in dynamic array at position idx
22310  */
22311 extern
22313  SCIP* scip, /**< SCIP data structure */
22314  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
22315  int idx /**< array index to get value for */
22316  );
22317 
22318 /** sets value of entry in dynamic array
22319  *
22320  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22321  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22322  */
22323 extern
22325  SCIP* scip, /**< SCIP data structure */
22326  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
22327  int idx, /**< array index to set value for */
22328  SCIP_Bool val /**< value to set array index to */
22329  );
22330 
22331 /** returns the minimal index of all stored non-zero elements
22332  *
22333  * @return the minimal index of all stored non-zero elements
22334  */
22335 extern
22337  SCIP* scip, /**< SCIP data structure */
22338  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
22339  );
22340 
22341 /** returns the maximal index of all stored non-zero elements
22342  *
22343  * @return the maximal index of all stored non-zero elements
22344  */
22345 extern
22347  SCIP* scip, /**< SCIP data structure */
22348  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
22349  );
22350 
22351 /** creates a dynamic array of pointers
22352  *
22353  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22354  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22355  */
22356 extern
22358  SCIP* scip, /**< SCIP data structure */
22359  SCIP_PTRARRAY** ptrarray /**< pointer to store the int array */
22360  );
22361 
22362 /** frees a dynamic array of pointers
22363  *
22364  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22365  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22366  */
22367 extern
22369  SCIP* scip, /**< SCIP data structure */
22370  SCIP_PTRARRAY** ptrarray /**< pointer to the int array */
22371  );
22372 
22373 /** extends dynamic array to be able to store indices from minidx to maxidx
22374  *
22375  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22376  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22377  */
22378 extern
22380  SCIP* scip, /**< SCIP data structure */
22381  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
22382  int minidx, /**< smallest index to allocate storage for */
22383  int maxidx /**< largest index to allocate storage for */
22384  );
22385 
22386 /** clears a dynamic pointer array
22387  *
22388  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22389  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22390  */
22391 extern
22393  SCIP* scip, /**< SCIP data structure */
22394  SCIP_PTRARRAY* ptrarray /**< dynamic int array */
22395  );
22396 
22397 /** gets value of entry in dynamic array */
22398 extern
22399 void* SCIPgetPtrarrayVal(
22400  SCIP* scip, /**< SCIP data structure */
22401  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
22402  int idx /**< array index to get value for */
22403  );
22404 
22405 /** sets value of entry in dynamic array
22406  *
22407  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22408  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22409  */
22410 extern
22412  SCIP* scip, /**< SCIP data structure */
22413  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
22414  int idx, /**< array index to set value for */
22415  void* val /**< value to set array index to */
22416  );
22417 
22418 /** returns the minimal index of all stored non-zero elements
22419  *
22420  * @return the minimal index of all stored non-zero elements
22421  */
22422 extern
22424  SCIP* scip, /**< SCIP data structure */
22425  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
22426  );
22427 
22428 /** returns the maximal index of all stored non-zero elements
22429  *
22430  * @return the maximal index of all stored non-zero elements
22431  */
22432 extern
22434  SCIP* scip, /**< SCIP data structure */
22435  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
22436  );
22437 
22438 /**@} */
22439 #ifdef __cplusplus
22440 }
22441 #endif
22442 
22443 #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:28488
SCIP_RETCODE SCIPaddLinearCoefsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:32016
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_RETCODE SCIPclearConflictStore(SCIP *scip, SCIP_EVENT *event)
Definition: scip.c:12923
SCIP_RETCODE SCIPsetNodeselCopy(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELCOPY((*nodeselcopy)))
Definition: scip.c:8776
SCIP_Real SCIPdualfeasRound(SCIP *scip, SCIP_Real val)
Definition: scip.c:46408
SCIP_RETCODE SCIPcreatePartialSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37182
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
Definition: scip.c:8124
SCIP_RETCODE SCIPsetPropPresol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPPRESOL((*proppresol)), int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming)
Definition: scip.c:7738
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44535
SCIP_RETCODE SCIPprintBestSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:38997
SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
Definition: scip.c:36128
SCIP_RETCODE SCIPsetPricerPriority(SCIP *scip, SCIP_PRICER *pricer, int priority)
Definition: scip.c:5666
#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:30360
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:6854
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:42796
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
Definition: scip.c:29200
SCIP_RETCODE SCIPclearCuts(SCIP *scip)
Definition: scip.c:34404
int SCIPgetNIntVars(SCIP *scip)
Definition: scip.c:11721
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
Definition: scip.c:42426
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:29924
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:46151
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:30111
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
Definition: scip.c:5115
SCIP_RETCODE SCIPgetStringParam(SCIP *scip, const char *name, char **value)
Definition: scip.c:4464
int SCIPgetNPrioPseudoBranchBins(SCIP *scip)
Definition: scip.c:36529
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:27934
int SCIPgetFocusDepth(SCIP *scip)
Definition: scip.c:42120
SCIP_RETCODE SCIPsetRelaxCopy(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXCOPY((*relaxcopy)))
Definition: scip.c:7122
int SCIPgetNCheckConss(SCIP *scip)
Definition: scip.c:12821
SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
Definition: scip.c:27905
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:18829
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
Definition: scip.c:4445
SCIP_Bool SCIPinRepropagation(SCIP *scip)
Definition: scip.c:40508
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: scip.c:6228
#define SCIP_DECL_NODESELCOMP(x)
Definition: type_nodesel.h:126
int SCIPgetNNLPNlRows(SCIP *scip)
Definition: scip.c:31064
SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29309
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21877
SCIP_RETCODE SCIPlinkLPSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37672
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip.c:45137
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
Definition: scip.c:41426
struct SCIP_PresolData SCIP_PRESOLDATA
Definition: type_presol.h:37
#define SCIP_DECL_HEURINITSOL(x)
Definition: type_heur.h:95
SCIP_RETCODE SCIPgetNlRowPseudoActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudoactivity)
Definition: scip.c:32407
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
Definition: scip.c:42889
SCIP_RETCODE SCIPdisableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28074
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5095
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:8953
SCIP_RETCODE SCIPincIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int incval)
Definition: scip.c:46907
SCIP_RETCODE SCIPsetComprFree(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRFREE((*comprfree)))
Definition: scip.c:8294
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:46360
enum SCIP_NlpTermStat SCIP_NLPTERMSTAT
Definition: type_nlpi.h:85
SCIP_Real SCIPfeastol(SCIP *scip)
Definition: scip.c:45274
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26198
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26452
SCIP_RETCODE SCIPcomputeLPRelIntPoint(SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)
Definition: scip.c:29762
int SCIPgetPlungeDepth(SCIP *scip)
Definition: scip.c:42209
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
Definition: scip.c:30835
int SCIPgetNDelayedPoolCuts(SCIP *scip)
Definition: scip.c:34297
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22118
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30233
SCIP_Bool SCIPisDualfeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46298
SCIP_Bool SCIPisSumRelLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46540
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19263
SCIP_RETCODE SCIPlinkCurrentSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37777
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:3919
SCIP_RETCODE SCIPsetPresolFree(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLFREE((*presolfree)))
Definition: scip.c:6905
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46086
public methods for branching and inference history structure
SCIP_RETCODE SCIPsetEventhdlrInitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINITSOL((*eventinitsol)))
Definition: scip.c:8614
SCIP_VAR ** SCIPgetNLPVars(SCIP *scip)
Definition: scip.c:30902
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition: scip.c:40453
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip.c:814
int SCIPgetSolRunnum(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38276
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
Definition: scip.c:42413
#define SCIP_DECL_CONCSOLVERSYNCREAD(x)
SCIP_RETCODE SCIPextendBoolarray(SCIP *scip, SCIP_BOOLARRAY *boolarray, int minidx, int maxidx)
Definition: scip.c:46988
SCIP_RETCODE SCIPchgBarrierconvtol(SCIP *scip, SCIP_Real barrierconvtol)
Definition: scip.c:45414
SCIP_NODESEL ** SCIPgetNodesels(SCIP *scip)
Definition: scip.c:8885
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:37964
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: scip.c:6251
public methods for branch and bound tree
SCIP_RETCODE SCIPgetNLPIntPar(SCIP *scip, SCIP_NLPPARAM type, int *ival)
Definition: scip.c:31369
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
Definition: scip.c:18733
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
Definition: scip.c:35152
SCIP_RETCODE SCIPsetBranchruleExecPs(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECPS((*branchexecps)))
Definition: scip.c:9168
internal methods for branch and bound tree
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
Definition: scip.c:41382
SCIP_RETCODE SCIPcopyOrigProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name)
Definition: scip.c:1783
type definitions for miscellaneous datastructures
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip.c:26569
int SCIPgetNRelaxs(SCIP *scip)
Definition: scip.c:7245
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:30080
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46099
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
Definition: scip.c:21497
SCIP_RETCODE SCIPrecalcRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30543
SCIP_Bool SCIPisSumGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46037
void SCIPdialogMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip.c:1319
SCIP_Bool SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46462
#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:19123
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:36778
SCIP_RETCODE SCIPcreateBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
Definition: scip.c:46954
SCIP_RETCODE SCIPgetNLPNlRowsData(SCIP *scip, SCIP_NLROW ***nlrows, int *nnlrows)
Definition: scip.c:31014
SCIP_RETCODE SCIPgetSolVarsData(SCIP *scip, SCIP_SOL *sol, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip.c:12260
SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
Definition: scip.c:45093
#define SCIP_DECL_DIALOGCOPY(x)
Definition: type_dialog.h:53
SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)
Definition: scip.c:10946
SCIP_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)
Definition: scip.c:9669
SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26226
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
Definition: scip.c:42344
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:40275
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
Definition: scip.c:6541
int SCIPgetProbingDepth(SCIP *scip)
Definition: scip.c:35125
SCIP_RETCODE SCIPsetPresolExit(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXIT((*presolexit)))
Definition: scip.c:6937
SCIP_Real SCIPgetReadingTime(SCIP *scip)
Definition: scip.c:45164
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
Definition: scip.c:42499
SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
Definition: scip.c:29569
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26113
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30256
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
Definition: scip.c:42448
#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:46449
SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:35805
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:33265
#define SCIP_DECL_PROBINITSOL(x)
Definition: type_prob.h:97
SCIP_RETCODE SCIPcalcStrongCG(SCIP *scip, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, int maxmksetcoefs, SCIP_Real maxweightrange, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real *weights, int *inds, int ninds, SCIP_Real scale, SCIP_Real *mircoef, SCIP_Real *mirrhs, SCIP_Real *cutactivity, SCIP_Bool *success, SCIP_Bool *cutislocal, int *cutrank)
Definition: scip.c:29529
public methods for implications, variable bounds, and cliques
int SCIPgetIntarrayMaxIdx(SCIP *scip, SCIP_INTARRAY *intarray)
Definition: scip.c:46939
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:38378
SCIP_Real * SCIPgetNLPVarsUbDualsol(SCIP *scip)
Definition: scip.c:30992
SCIP_Bool SCIPisFeasFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:46199
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
Definition: scip.c:7788
int SCIPgetNEventhdlrs(SCIP *scip)
Definition: scip.c:8680
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:29958
#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:6481
SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)
Definition: scip.c:13183
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip.c:4426
SCIP_RETCODE SCIPsetComprInit(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINIT((*comprinit)))
Definition: scip.c:8310
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
Definition: scip.c:42527
SCIP_RETCODE SCIPgetLeaves(SCIP *scip, SCIP_NODE ***leaves, int *nleaves)
Definition: scip.c:40610
SCIP_SEPA * SCIPfindSepa(SCIP *scip, const char *name)
Definition: scip.c:7463
SCIP_RETCODE SCIPsetMessagehdlr(SCIP *scip, SCIP_MESSAGEHDLR *messagehdlr)
Definition: scip.c:1193
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip.c:25593
#define SCIP_DECL_PROBDELORIG(x)
Definition: type_prob.h:55
#define SCIP_DECL_CONSINITPRE(x)
Definition: type_cons.h:114
SCIP_RETCODE SCIPsetProbCopy(SCIP *scip, SCIP_DECL_PROBCOPY((*probcopy)))
Definition: scip.c:9965
SCIP_RETCODE SCIPsetEventhdlrExitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXITSOL((*eventexitsol)))
Definition: scip.c:8628
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
Definition: scip.c:45471
int SCIPgetNPrioPseudoBranchImpls(SCIP *scip)
Definition: scip.c:36565
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
Definition: scip.c:42664
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
Definition: scip.c:41535
SCIP_RETCODE SCIPaddSolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool *stored)
Definition: scip.c:39639
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
Definition: scip.c:5973
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:9778
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:27962
SCIP_RETCODE SCIPchgConsName(SCIP *scip, SCIP_CONS *cons, const char *name)
Definition: scip.c:27374
SCIP_RETCODE SCIPsetParam(SCIP *scip, const char *name, void *value)
Definition: scip.c:4522
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition: type_cons.h:867
#define SCIP_DECL_CONSPRESOL(x)
Definition: type_cons.h:511
SCIP_RETCODE SCIPsetEventhdlrExit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXIT((*eventexit)))
Definition: scip.c:8600
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:12481
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
Definition: scip.c:8092
SCIP_RETCODE SCIPsetRelaxInit(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINIT((*relaxinit)))
Definition: scip.c:7154
int SCIPcalcMemGrowSize(SCIP *scip, int num)
Definition: scip.c:45601
static long bound
SCIP_Bool SCIPisSumPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:46062
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:30288
SCIP_RETCODE SCIPrecomputeSolObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38168
SCIP_RETCODE SCIPcreateCPUClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:44861
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:18997
SCIP_RETCODE SCIPevalExprtreeGlobalBounds(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
Definition: scip.c:32768
SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
Definition: scip.c:27521
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:76
SCIP_Real SCIPgetRowPseudoFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30633
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:45876
SCIP_Bool SCIPisSumRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46527
SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
Definition: scip.c:18696
int SCIPgetNOrigVars(SCIP *scip)
Definition: scip.c:12071
#define SCIP_DECL_NODESELINITSOL(x)
Definition: type_nodesel.h:83
int SCIPgetNSiblings(SCIP *scip)
Definition: scip.c:40592
SCIP_Bool SCIPisStringParamValid(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip.c:4872
SCIP_Bool SCIPisUpdateUnreliable(SCIP *scip, SCIP_Real newvalue, SCIP_Real oldvalue)
Definition: scip.c:46634
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:21112
SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)
Definition: scip.c:29820
SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
Definition: scip.c:34281
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26950
SCIP_RETCODE SCIPchgNlRowRhs(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real rhs)
Definition: scip.c:31946
SCIP_RELAX ** SCIPgetRelaxs(SCIP *scip)
Definition: scip.c:7232
int SCIPgetNPseudoBranchCands(SCIP *scip)
Definition: scip.c:36492
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:8740
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:45803
char ** SCIPgetExternalCodeDescriptions(SCIP *scip)
Definition: scip.c:9501
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:22806
SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28131
#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:6343
int SCIPgetNLeaves(SCIP *scip)
Definition: scip.c:40634
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21781
SCIP_Bool SCIPreoptimizeNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:17077
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
Definition: scip.c:43157
SCIP_Bool SCIPisDualfeasFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:46372
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
Definition: scip.c:8526
SCIP_RETCODE SCIPdelConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)
Definition: scip.c:13061
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
Definition: type_branch.h:43
SCIP_RETCODE SCIPcreateRealarray(SCIP *scip, SCIP_REALARRAY **realarray)
Definition: scip.c:46652
SCIP_NLPSOLSTAT SCIPgetNLPSolstat(SCIP *scip)
Definition: scip.c:31218
SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:25838
enum SCIP_DispMode SCIP_DISPMODE
Definition: type_disp.h:59
#define SCIP_DECL_PRESOLINITPRE(x)
Definition: type_presol.h:84
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
Definition: scip.c:42912
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip.c:18575
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:43309
SCIP_RETCODE SCIPcatchRowEvent(SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:40361
SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip.c:34139
SCIP_Real SCIPfeasRound(SCIP *scip, SCIP_Real val)
Definition: scip.c:46235
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
Definition: scip.c:27674
SCIP_RETCODE SCIPsetNlRowExprtreeParam(SCIP *scip, SCIP_NLROW *nlrow, int paramidx, SCIP_Real paramval)
Definition: scip.c:32256
SCIP_DECL_EVENTEXIT(EventhdlrNewSol::scip_exit)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
Definition: scip.c:17656
SCIP_RETCODE SCIPsetBranchruleInitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINITSOL((*branchinitsol)))
Definition: scip.c:9102
SCIP_RETCODE SCIPextendIntarray(SCIP *scip, SCIP_INTARRAY *intarray, int minidx, int maxidx)
Definition: scip.c:46837
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
Definition: scip.c:41499
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip.c:18384
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:31668
SCIP_Real SCIPgetBranchingPoint(SCIP *scip, SCIP_VAR *var, SCIP_Real suggestion)
Definition: scip.c:36631
SCIP_RETCODE SCIPgetOpenNodesData(SCIP *scip, SCIP_NODE ***leaves, SCIP_NODE ***children, SCIP_NODE ***siblings, int *nleaves, int *nchildren, int *nsiblings)
Definition: scip.c:40760
#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:6142
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:44946
SCIP_RETCODE SCIPaddRowDive(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34706
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:46175
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip.c:29653
SCIP_RETCODE SCIPsetBranchruleExit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))
Definition: scip.c:9086
SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34243
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
Definition: scip.c:22084
SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
SCIP_RETCODE SCIPincRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real incval)
Definition: scip.c:46756
SCIP_Real SCIPdualfeastol(SCIP *scip)
Definition: scip.c:45302
SCIP_RETCODE SCIPsetRelaxExitsol(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXITSOL((*relaxexitsol)))
Definition: scip.c:7202
int SCIPgetMaxDepth(SCIP *scip)
Definition: scip.c:42144
SCIP_RETCODE SCIPconvertCutsToConss(SCIP *scip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
Definition: scip.c:2996
SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip.c:27775
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25729
SCIP_RETCODE SCIPsetNlRowExprtree(SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPRTREE *exprtree)
Definition: scip.c:32230
#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:32053
void SCIPgetDiveBoundChangeData(SCIP *scip, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
Definition: scip.c:36068
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip.c:25920
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46138
SCIP_RETCODE SCIPextendRealarray(SCIP *scip, SCIP_REALARRAY *realarray, int minidx, int maxidx)
Definition: scip.c:46686
SCIP_RETCODE SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
Definition: scip.c:9054
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
Definition: scip.c:44712
#define SCIP_DECL_BRANCHFREE(x)
Definition: type_branch.h:60
int SCIPmajorVersion(void)
Definition: scip.c:565
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip.c:11505
SCIP_Real SCIPgetRelaxFeastolFactor(SCIP *scip)
Definition: scip.c:34449
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
Definition: scip.c:41609
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:562
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5043
SCIP_RETCODE SCIPsetProbExitsol(SCIP *scip, SCIP_DECL_PROBEXITSOL((*probexitsol)))
Definition: scip.c:9944
#define SCIP_DECL_CONCSOLVEREXEC(x)
SCIP_Bool SCIPisSumNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:46074
SCIP_RETCODE SCIPchgReoptObjective(SCIP *scip, SCIP_OBJSENSE objsense, SCIP_VAR **vars, SCIP_Real *coefs, int nvars)
Definition: scip.c:10776
SCIP_SOL ** SCIPgetSols(SCIP *scip)
Definition: scip.c:38881
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
Definition: scip.c:21580
#define SCIP_DECL_PRESOLCOPY(x)
Definition: type_presol.h:46
SCIP_Real SCIPgetDeterministicTime(SCIP *scip)
Definition: scip.c:43182
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
Definition: scip.c:41793
SCIP_RETCODE SCIPsetNodeselMemsavePriority(SCIP *scip, SCIP_NODESEL *nodesel, int priority)
Definition: scip.c:8922
common methods used to generate and strengthen cuts
#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:36876
SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25956
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:4230
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:8197
SCIP_Bool SCIPhasNLPContinuousNonlinearity(SCIP *scip)
Definition: scip.c:30850
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:23027
#define SCIP_DECL_RELAXINIT(x)
Definition: type_relax.h:63
SCIP_RETCODE SCIPcopyLimits(SCIP *sourcescip, SCIP *targetscip)
Definition: scip.c:4126
SCIP_NODE * SCIPgetBestSibling(SCIP *scip)
Definition: scip.c:40698
#define SCIP_DECL_RELAXINITSOL(x)
Definition: type_relax.h:82
int SCIPgetSubscipDepth(SCIP *scip)
Definition: scip.c:3533
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:5831
int SCIPgetNPartialSols(SCIP *scip)
Definition: scip.c:40002
SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:33984
SCIP_Bool SCIPisIntParamValid(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip.c:4640
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:27230
int SCIPgetNActivePricers(SCIP *scip)
Definition: scip.c:5655
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23498
SCIP_COMPR * SCIPfindCompr(SCIP *scip, const char *name)
Definition: scip.c:8374
SCIP_RETCODE SCIPaddQuadElementToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelem)
Definition: scip.c:32140
SCIP_RETCODE SCIPsetNodeselExit(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXIT((*nodeselexit)))
Definition: scip.c:8824
SCIP_RETCODE SCIPpropagateProbingImplications(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:35583
void SCIPprintExternalCodes(SCIP *scip, FILE *file)
Definition: scip.c:9526
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:3843
SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:40796
SCIP_Real SCIPinfinity(SCIP *scip)
Definition: scip.c:45816
SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip.c:25621
SCIP_VERBLEVEL SCIPgetVerbLevel(SCIP *scip)
Definition: scip.c:1377
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:45888
SCIP_RETCODE SCIPenableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28046
SCIP_Bool SCIPexistsDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9590
SCIP_PRICER * SCIPfindPricer(SCIP *scip, const char *name)
Definition: scip.c:5618
void SCIPclearExternBranchCands(SCIP *scip)
Definition: scip.c:36423
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:8240
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28192
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:27036
SCIP_RETCODE SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
Definition: scip.c:9038
#define SCIP_DECL_HEURCOPY(x)
Definition: type_heur.h:60
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)
Definition: scip.c:13222
#define SCIP_DECL_PROPEXITPRE(x)
Definition: type_prop.h:100
#define SCIP_DECL_HEUREXEC(x)
Definition: type_heur.h:126
SCIP_Real SCIPgetSolTime(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38249
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:26813
SCIP_RETCODE SCIPsolveNLP(SCIP *scip)
Definition: scip.c:31195
#define SCIP_DECL_CONSGETNVARS(x)
Definition: type_cons.h:832
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
Definition: scip.c:21255
methods commonly used by primal heuristics
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21156
SCIP_RETCODE SCIPcreateIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
Definition: scip.c:46803
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:7949
SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip.c:10268
SCIP_Real SCIPgetBranchScoreMultiple(SCIP *scip, SCIP_VAR *var, int nchildren, SCIP_Real *gains)
Definition: scip.c:36606
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5069
SCIP_RETCODE SCIPsetComprInitsol(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINITSOL((*comprinitsol)))
Definition: scip.c:8342
int SCIPgetNReoptnodes(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:16440
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
Definition: scip.c:9184
char ** SCIPgetExternalCodeNames(SCIP *scip)
Definition: scip.c:9487
SCIP_DECL_READERWRITE(ReaderTSP::scip_write)
Definition: ReaderTSP.cpp:472
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip.c:8153
SCIP_RETCODE SCIPsetProbData(SCIP *scip, SCIP_PROBDATA *probdata)
Definition: scip.c:10671
SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:34642
SCIP_RETCODE SCIPfreeIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
Definition: scip.c:46820
int SCIPgetNPrioPseudoBranchInts(SCIP *scip)
Definition: scip.c:36547
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
Definition: scip.c:42280
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
Definition: scip.c:41445
SCIP_RETCODE SCIPgetLPBInvCol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29344
#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:17317
SCIP_Longint SCIPgetNNZs(SCIP *scip)
Definition: scip.c:41408
SCIP_RETCODE SCIPisConflictVarUsed(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
Definition: scip.c:26984
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26480
SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
Definition: scip.c:33793
SCIP_Bool SCIPisDualfeasZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:46324
SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
Definition: scip.c:12044
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25988
SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip.c:4715
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26537
struct SCIP_HeurData SCIP_HEURDATA
Definition: type_heur.h:51
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
Definition: scip.c:41847
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:174
public methods for displaying runtime statistics
int SCIPgetNActiveConss(SCIP *scip)
Definition: scip.c:42226
int SCIPgetNNodesLeft(SCIP *scip)
Definition: scip.c:41227
public methods for problem variables
SCIP_RETCODE SCIPevalExprtreeSol(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_SOL *sol, SCIP_Real *val)
Definition: scip.c:32713
void SCIPdebugMessagePrint(SCIP *scip, const char *formatstr,...)
Definition: scip.c:1303
SCIP_RETCODE SCIPcalcMIR(SCIP *scip, SCIP_SOL *sol, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Bool fixintegralrhs, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, int maxmksetcoefs, SCIP_Real maxweightrange, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real *weights, SCIP_Real maxweight, int *weightinds, int nweightinds, int rowlensum, int *sidetypes, SCIP_Real scale, SCIP_Real *mksetcoefs, SCIP_Bool *mksetcoefsvalid, SCIP_Real *mircoef, SCIP_Real *mirrhs, SCIP_Real *cutactivity, SCIP_Bool *success, SCIP_Bool *cutislocal, int *cutrank)
Definition: scip.c:29473
SCIP_RETCODE SCIPsetSepaPriority(SCIP *scip, SCIP_SEPA *sepa, int priority)
Definition: scip.c:7500
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
Definition: scip.c:26780
SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
Definition: scip.c:36042
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:25857
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:6737
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
Definition: scip.c:26717
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip)
Definition: scip.c:19503
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
Definition: scip.c:42192
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22234
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
Definition: scip.c:41775
#define SCIP_DECL_BRANCHEXECEXT(x)
Definition: type_branch.h:140
SCIP_Real SCIPgetRelaxSolObj(SCIP *scip)
Definition: scip.c:19751
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:7999
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:4313
SCIP_Bool SCIPgetVarWasFixedAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19421
SCIP_RETCODE SCIPenableOrDisableStatisticTiming(SCIP *scip)
Definition: scip.c:44986
SCIP_READER * SCIPfindReader(SCIP *scip, const char *name)
Definition: scip.c:5327
SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28101
SCIP_Bool SCIPallVarsInProb(SCIP *scip)
Definition: scip.c:12383
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:33011
SCIP_RETCODE SCIPinitRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:16603
type definitions for return codes for SCIP methods
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25647
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:5885
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:35220
SCIP_RETCODE SCIPrecalcRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30651
#define SCIP_DECL_PRICEREXITSOL(x)
Definition: type_pricer.h:92
int SCIPgetPtrarrayMaxIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
Definition: scip.c:47200
SCIP_RETCODE SCIPgetOrigVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip.c:11996
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:32537
SCIP_RETCODE SCIPwriteParam(SCIP *scip, SCIP_PARAM *param, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip.c:4907
public methods for branching rules
SCIP_RETCODE SCIPgetNLPVarsNonlinearity(SCIP *scip, int *nlcount)
Definition: scip.c:30946
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
Definition: scip.c:8656
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
Definition: scip.c:1228
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:9001
void SCIPprintReal(SCIP *scip, FILE *file, SCIP_Real val, int width, int precision)
Definition: scip.c:45444
SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
SCIP_RETCODE SCIPsetPricerExit(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXIT((*pricerexit)))
Definition: scip.c:5554
#define SCIP_DECL_SEPAEXECLP(x)
Definition: type_sepa.h:115
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21825
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:17527
void SCIPresetReoptSolMarks(SCIP *scip)
Definition: scip.c:17017
SCIP_RETCODE SCIPsetPricerExitsol(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXITSOL((*pricerexitsol)))
Definition: scip.c:5602
SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23468
#define SCIP_DECL_PROBCOPY(x)
Definition: type_prob.h:140
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:44895
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip.c:45519
SCIP_RETCODE SCIPflushNLP(SCIP *scip)
Definition: scip.c:31110
int SCIPgetNCutsFoundRound(SCIP *scip)
Definition: scip.c:41969
enum SCIP_NlpParam SCIP_NLPPARAM
Definition: type_nlpi.h:56
SCIP_CONS ** SCIPgetConss(SCIP *scip)
Definition: scip.c:12725
type definitions for presolvers
SCIP_RETCODE SCIPsetNLPIntPar(SCIP *scip, SCIP_NLPPARAM type, int ival)
Definition: scip.c:31397
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:29992
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21611
int SCIPgetNPresols(SCIP *scip)
Definition: scip.c:7011
SCIP_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:46247
SCIP_RETCODE SCIPsetNLPStringPar(SCIP *scip, SCIP_NLPPARAM type, const char *sval)
Definition: scip.c:31509
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:45751
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:23568
SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:28810
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:36244
#define SCIP_DECL_BRANCHEXITSOL(x)
Definition: type_branch.h:98
SCIP_RETCODE SCIPcaptureDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9605
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37047
SCIP_RETCODE SCIPmarkRelaxSolInvalid(SCIP *scip)
Definition: scip.c:19701
SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
Definition: scip.c:21548
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
SCIP_RETCODE SCIPcreate(SCIP **scip)
Definition: scip.c:696
SCIP_RETCODE SCIPaddCurrentSol(SCIP *scip, SCIP_HEUR *heur, SCIP_Bool *stored)
Definition: scip.c:39709
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:6625
#define SCIP_DECL_PROPEXEC(x)
Definition: type_prop.h:203
SCIP_Bool SCIPisTransformed(SCIP *scip)
Definition: scip.c:1010
int SCIPgetNLPBranchCands(SCIP *scip)
Definition: scip.c:36161
SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
Definition: scip.c:29087
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:23627
SCIP_Bool SCIPpressedCtrlC(SCIP *scip)
Definition: scip.c:1125
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
Definition: scip.c:7367
SCIP_RETCODE SCIPsetConshdlrDelvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: scip.c:6412
SCIP_RETCODE SCIPdropRowEvent(SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:40401
#define SCIP_DECL_PRICERCOPY(x)
Definition: type_pricer.h:46
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
Definition: scip.c:4741
#define SCIP_DECL_DIVESETGETSCORE(x)
Definition: type_heur.h:147
SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip.c:4831
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: scip.c:6274
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
Definition: scip.c:40472
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip.c:1260
SCIP_SOL ** SCIPgetPartialSols(SCIP *scip)
Definition: scip.c:39979
int SCIPgetNPrioExternBranchImpls(SCIP *scip)
Definition: scip.c:36357
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21964
#define SCIP_DECL_NODESELEXITSOL(x)
Definition: type_nodesel.h:94
#define SCIP_DECL_CONFLICTEXIT(x)
Definition: type_conflict.h:85
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:4202
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip.c:18616
#define SCIP_DECL_COMPRINIT(x)
Definition: type_compr.h:65
SCIP_RETCODE SCIPcopyParamSettings(SCIP *sourcescip, SCIP *targetscip)
Definition: scip.c:3492
SCIP_Bool SCIPisRootLPRelax(SCIP *scip)
Definition: scip.c:29001
SCIP_Bool SCIPisSumZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:46050
int SCIPgetIntarrayMinIdx(SCIP *scip, SCIP_INTARRAY *intarray)
Definition: scip.c:46925
SCIP_RETCODE SCIPaddLinearCoefToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:31992
SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
Definition: scip.c:34005
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: scip.c:6458
SCIP_RETCODE SCIPfreeReoptSolve(SCIP *scip)
Definition: scip.c:16807
SCIP_Real SCIPgetPresolvingTime(SCIP *scip)
Definition: scip.c:45201
#define SCIP_DECL_CONSINITLP(x)
Definition: type_cons.h:217
SCIP_RETCODE SCIPensureBlockMemoryArray_call(SCIP *scip, void **arrayptr, size_t elemsize, int *arraysize, int minsize)
Definition: scip.c:45617
#define SCIP_DECL_CONCSOLVERDESTROYINST(x)
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44425
type definitions for branching rules
SCIP_RETCODE SCIPactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28585
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43096
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip.c:1336
int SCIPgetNContVars(SCIP *scip)
Definition: scip.c:11811
SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30693
#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:27146
SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)
Definition: scip.c:9839
SCIP_Real SCIPgetObjNorm(SCIP *scip)
Definition: scip.c:11284
SCIP_NLROW ** SCIPgetNLPNlRows(SCIP *scip)
Definition: scip.c:31042
SCIP_DISP * SCIPfindDisp(SCIP *scip, const char *name)
Definition: scip.c:9308
SCIP_Real SCIPepsilon(SCIP *scip)
Definition: scip.c:45246
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:17832
SCIP_DECL_EVENTINITSOL(EventhdlrNewSol::scip_initsol)
SCIP_RETCODE SCIPcreateOrigSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37242
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: scip.c:23516
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:26746
SCIP_RETCODE SCIPgetSiblings(SCIP *scip, SCIP_NODE ***siblings, int *nsiblings)
Definition: scip.c:40568
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
Definition: scip.c:42368
SCIP_Real SCIPbarrierconvtol(SCIP *scip)
Definition: scip.c:45316
SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30491
SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23391
SCIP_RETCODE SCIPdeleteReoptnode(SCIP *scip, SCIP_REOPTNODE **reoptnode)
Definition: scip.c:17117
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
Definition: scip.c:46223
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23412
SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip)
Definition: scip.c:19679
SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30525
SCIP_RETCODE SCIPrepropagateNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:40817
SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip.c:18525
SCIP_RETCODE SCIPcreateNlRowFromRow(SCIP *scip, SCIP_NLROW **nlrow, SCIP_ROW *row)
Definition: scip.c:31855
SCIP_RETCODE SCIPsetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx, SCIP_Bool val)
Definition: scip.c:47039
#define SCIP_DECL_COMPRFREE(x)
Definition: type_compr.h:57
SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip.c:25882
SCIP_Bool SCIPisRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46501
SCIP_RETCODE SCIPchgChildPrio(SCIP *scip, SCIP_NODE *child, SCIP_Real priority)
Definition: scip.c:13428
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
Definition: scip.c:24792
enum SCIP_ParamSetting SCIP_PARAMSETTING
Definition: type_paramset.h:56
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:46211
SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
Definition: scip.c:9136
#define SCIP_DECL_NODESELINIT(x)
Definition: type_nodesel.h:64
SCIP_RETCODE SCIPconstructSyncstore(SCIP *scip)
Definition: scip.c:41001
public methods for expressions, expression trees, expression graphs, and related stuff ...
SCIP_RETCODE SCIPclearRealarray(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:46705
int SCIPgetNConshdlrs(SCIP *scip)
Definition: scip.c:6565
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:142
type definitions for LP management
#define SCIP_DECL_SEPACOPY(x)
Definition: type_sepa.h:47
SCIP_Bool SCIPisRelLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46475
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44597
SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)
SCIP_RETCODE SCIPfreeRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:16662
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
Definition: scip.c:41667
const char * SCIPgetProbName(SCIP *scip)
Definition: scip.c:10724
SCIP_RETCODE SCIPclearPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray)
Definition: scip.c:47139
SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:44878
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: scip.c:25559
SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition: scip.c:36583
#define SCIP_DECL_DIALOGDESC(x)
Definition: type_dialog.h:73
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
Definition: scip.c:26695
SCIP_RETCODE SCIPsetHeurPriority(SCIP *scip, SCIP_HEUR *heur, int priority)
Definition: scip.c:8177
SCIP_RETCODE SCIPcopyOrigConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip.c:2863
SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19403
SCIP_RETCODE SCIPlinkNLPSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37698
int SCIPgetNFixedVars(SCIP *scip)
Definition: scip.c:11948
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:159
SCIP_Bool SCIPisLPConstructed(SCIP *scip)
Definition: scip.c:28787
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
Definition: scip.c:46434
SCIP_Bool SCIPisLPRelax(SCIP *scip)
Definition: scip.c:28875
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
Definition: scip.c:12325
SCIP_RETCODE SCIPsetConflicthdlrInit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)))
Definition: scip.c:6689
void * SCIPgetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx)
Definition: scip.c:47152
SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:27987
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
Definition: scip.c:11905
SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
Definition: scip.c:27446
SCIP_RETCODE SCIPsetReoptCompression(SCIP *scip, SCIP_REOPTNODE **representation, int nrepresentatives, SCIP_Bool *success)
Definition: scip.c:16518
SCIP_Bool SCIPisCharParamValid(SCIP *scip, SCIP_PARAM *param, const char value)
Definition: scip.c:4814
void SCIPclearDiveBoundChanges(SCIP *scip)
Definition: scip.c:36095
int SCIPgetNPrioLPBranchCands(SCIP *scip)
Definition: scip.c:36199
#define SCIP_DECL_CONCSOLVERSTOP(x)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip.c:25045
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
Definition: scip.c:42392
struct SCIP_NodeselData SCIP_NODESELDATA
Definition: type_nodesel.h:38
SCIP_RETCODE SCIPresetParams(SCIP *scip)
Definition: scip.c:4970
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip.c:23815
SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
Definition: scip.c:29262
SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)
Definition: scip.c:9655
SCIP_RETCODE SCIPenableConsCompression(SCIP *scip)
Definition: scip.c:1821
SCIP_READER ** SCIPgetReaders(SCIP *scip)
Definition: scip.c:5340
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: scip.c:6094
#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:7138
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:9557
void SCIPprintMemoryDiagnostic(SCIP *scip)
Definition: scip.c:45643
#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:25384
SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
Definition: scip.c:11429
#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:33761
public methods for managing constraints
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
Definition: scip.c:10898
SCIP_Bool SCIPisBoolParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip.c:4582
SCIP_RETCODE SCIPsetPropExitpre(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITPRE((*propexitpre)))
Definition: scip.c:7722
SCIP_RETCODE SCIPchgRowLhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)
Definition: scip.c:34745
SCIP_RETCODE SCIPaddReoptDualBndchg(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_Real oldbound)
Definition: scip.c:16292
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:7863
SCIP_RETCODE SCIPsolveProbingRelax(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:35834
#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:17733
int SCIPgetNNLPVars(SCIP *scip)
Definition: scip.c:30924
SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: scip.c:6527
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
Definition: scip.c:37295
SCIP_NLPTERMSTAT SCIPgetNLPTermstat(SCIP *scip)
Definition: scip.c:31240
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
Definition: scip.c:45534
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:7277
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
Definition: scip.c:1047
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:44
SCIP_RETCODE SCIPdelRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip.c:34162
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)
Definition: scip.c:6766
SCIP_Real SCIPgetLPLooseObjval(SCIP *scip)
Definition: scip.c:28933
SCIP_Bool SCIPisSumRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46566
SCIP_RETCODE SCIPsetObjIntegral(SCIP *scip)
Definition: scip.c:11162
SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:34868
SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
Definition: scip.c:27624
#define SCIP_DECL_CONFLICTINITSOL(x)
Definition: type_conflict.h:96
SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
Definition: scip.c:34065
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:4001
int SCIPgetNCutsApplied(SCIP *scip)
Definition: scip.c:41987
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
Definition: scip.c:8108
void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30455
SCIP_RETCODE SCIPsolve(SCIP *scip)
Definition: scip.c:15777
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: scip.c:5997
SCIP_PROP ** SCIPgetProps(SCIP *scip)
Definition: scip.c:7801
#define SCIP_DECL_BRANCHCOPY(x)
Definition: type_branch.h:52
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:44844
#define SCIP_DECL_CONFLICTEXEC(x)
SCIP_Bool SCIPisRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46514
SCIP_RETCODE SCIPsetNodeselExitsol(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)))
Definition: scip.c:8856
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:33058
SCIP_RETCODE SCIPdeactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
Definition: scip.c:5712
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
Definition: scip.c:8140
SCIP_RETCODE SCIPsetComprCopy(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRCOPY((*comprcopy)))
Definition: scip.c:8278
SCIP_RETCODE SCIPbranchVar(SCIP *scip, SCIP_VAR *var, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
Definition: scip.c:36737
SCIP_RETCODE SCIPsetNlRowExprtreeParams(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *paramvals)
Definition: scip.c:32280
SCIP_Real SCIPdualfeasCeil(SCIP *scip, SCIP_Real val)
Definition: scip.c:46396
SCIP_RETCODE SCIPsolveDiveNLP(SCIP *scip)
Definition: scip.c:31759
SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
Definition: scip.c:34096
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip.c:25755
type definitions for variable pricers
SCIP_Bool SCIPisSumRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46553
SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30473
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
Definition: scip.c:18780
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
Definition: scip.c:41685
SCIP_RETCODE SCIPchgNlRowQuadElement(SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelement)
Definition: scip.c:32207
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
Definition: scip.c:4338
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
Definition: scip.c:28737
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:12410
SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
Definition: scip.c:6554
#define SCIP_DECL_PRESOLFREE(x)
Definition: type_presol.h:54
void SCIPstoreSolutionGap(SCIP *scip)
Definition: scip.c:44781
int SCIPgetCutoffdepth(SCIP *scip)
Definition: scip.c:40836
SCIP_RETCODE SCIPgetReoptChildIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
Definition: scip.c:16383
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:5434
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
Definition: scip.c:22051
SCIP_RETCODE SCIPsetEventhdlrFree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))
Definition: scip.c:8572
SCIP_RETCODE SCIPrecalcNlRowPseudoActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32386
SCIP_RETCODE SCIPsetEventhdlrCopy(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTCOPY((*eventcopy)))
Definition: scip.c:8558
SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:34901
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: scip.c:8060
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:45764
SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
Definition: scip.c:13030
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:31086
SCIP_RETCODE SCIPwriteNLP(SCIP *scip, const char *filename)
Definition: scip.c:31537
#define SCIP_DECL_PRICERFARKAS(x)
Definition: type_pricer.h:165
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:25434
type definitions for primal heuristics
SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
Definition: scip.c:34183
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
Definition: scip.c:35477
#define SCIP_DECL_COMPRCOPY(x)
Definition: type_compr.h:49
#define SCIP_DECL_CONSPARSE(x)
Definition: type_cons.h:792
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:39936
SCIP_RETCODE SCIPfreeProb(SCIP *scip)
Definition: scip.c:10361
SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)
Definition: scip.c:9998
int SCIPgetNCutsFound(SCIP *scip)
Definition: scip.c:41951
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:13111
SCIP_RETCODE SCIPsetSepaExit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))
Definition: scip.c:7415
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:38044
SCIP_RETCODE SCIPaddDialogHistoryLine(SCIP *scip, const char *inputline)
Definition: scip.c:9707
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:22345
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
Definition: scip.c:35337
SCIP_Bool SCIPisFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:45925
SCIP_RETCODE SCIPrecalcRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30597
int SCIPgetNConflicthdlrs(SCIP *scip)
Definition: scip.c:6779
SCIP_RETCODE SCIPreadSol(SCIP *scip, const char *filename)
Definition: scip.c:39167
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:26316
SCIP_RETCODE SCIPlinkPseudoSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37757
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:653
SCIP_RETCODE SCIPgetChildren(SCIP *scip, SCIP_NODE ***children, int *nchildren)
Definition: scip.c:40526
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
Definition: scip.c:31901
SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)
Definition: scip.c:4773
SCIP_Real SCIPgetDualbound(SCIP *scip)
Definition: scip.c:42302
#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:18929
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:28523
SCIP_Bool SCIPisDualfeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46311
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:2332
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:23687
SCIP_RETCODE SCIPchgCutoffboundDive(SCIP *scip, SCIP_Real newcutoffbound)
Definition: scip.c:34571
SCIP_Bool SCIPisDualSolAvailable(SCIP *scip, SCIP_Bool printreason)
Definition: scip.c:38700
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
Definition: scip.c:4567
SCIP_STATUS SCIPgetStatus(SCIP *scip)
Definition: scip.c:921
SCIP_RETCODE SCIPpresolve(SCIP *scip)
Definition: scip.c:15616
SCIP_CONS * SCIPfindOrigCons(SCIP *scip, const char *name)
Definition: scip.c:12536
SCIP_Real SCIPversion(void)
Definition: scip.c:554
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
Definition: scip.c:33779
#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:3056
SCIP_Real SCIPgetTransGap(SCIP *scip)
Definition: scip.c:42612
int SCIPgetNDisps(SCIP *scip)
Definition: scip.c:9332
SCIP_RETCODE SCIPgetReoptSolsRun(SCIP *scip, int run, SCIP_SOL **sols, int allocmem, int *nsols)
Definition: scip.c:16991
SCIP_RETCODE SCIPsetEventhdlrInit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINIT((*eventinit)))
Definition: scip.c:8586
SCIP_RETCODE SCIPchgVarBoundsDiveNLP(SCIP *scip, SCIP_VAR *var, SCIP_Real lb, SCIP_Real ub)
Definition: scip.c:31698
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:28252
SCIP_Bool SCIPisReoptEnabled(SCIP *scip)
Definition: scip.c:16981
SCIP_RETCODE SCIPprintTransSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:38503
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:27012
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
Definition: scip.c:41591
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip.c:21383
#define SCIP_DECL_PROPEXITSOL(x)
Definition: type_prop.h:127
SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
Definition: scip.c:27496
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21701
#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:6921
SCIP_RETCODE SCIPsetConsDynamic(SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: scip.c:27599
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:25777
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
Definition: scip.c:40086
#define SCIP_DECL_BRANCHEXECLP(x)
Definition: type_branch.h:119
SCIP_RETCODE SCIPprintStage(SCIP *scip, FILE *file)
Definition: scip.c:836
SCIP_RETCODE SCIPgetNLPRealPar(SCIP *scip, SCIP_NLPPARAM type, SCIP_Real *dval)
Definition: scip.c:31425
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:25494
int SCIPgetNChildren(SCIP *scip)
Definition: scip.c:40550
SCIP_Real SCIPdualfeasFloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:46384
SCIP_RETCODE SCIPsumLPRows(SCIP *scip, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
Definition: scip.c:29447
SCIP_RETCODE SCIPendProbing(SCIP *scip)
Definition: scip.c:35187
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:155
SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)
Definition: scip.c:12798
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: scip.c:6022
SCIP_PRESOL * SCIPfindPresol(SCIP *scip, const char *name)
Definition: scip.c:6985
#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:32606
SCIP_RETCODE SCIPmergeVariableStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **sourcevars, SCIP_VAR **targetvars, int nvars)
Definition: scip.c:2419
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:6811
SCIP_RETCODE SCIPsetBranchruleMaxbounddist(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_Real maxbounddist)
Definition: scip.c:9251
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23135
void SCIPprintDebugMessage(SCIP *scip, const char *sourcefile, int sourceline, const char *formatstr,...)
Definition: scip.c:1276
SCIP_Real SCIPgetNodeDualbound(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:13242
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip.c:4369
SCIP_RETCODE SCIPaddNlpiProbRows(SCIP *scip, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *nlpiprob, SCIP_HASHMAP *var2idx, SCIP_ROW **rows, int nrows)
Definition: scip.c:33640
SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
Definition: scip.c:12584
SCIP_Bool SCIPisNLPEnabled(SCIP *scip)
Definition: scip.c:30797
SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip.c:28341
SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)
Definition: scip.c:41336
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:43265
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:20787
SCIP_RETCODE SCIPgetExprtreeTransformedVars(SCIP *scip, SCIP_EXPRTREE *tree)
Definition: scip.c:32674
#define SCIP_DECL_RELAXCOPY(x)
Definition: type_relax.h:47
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28164
SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26082
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38137
SCIP_RETCODE SCIPsetNLPInitialGuess(SCIP *scip, SCIP_Real *initialguess)
Definition: scip.c:31136
SCIP_RETCODE SCIPclearBoolarray(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:47007
int SCIPgetNNlpis(SCIP *scip)
Definition: scip.c:9444
int SCIPgetNPrioExternBranchCands(SCIP *scip)
Definition: scip.c:36296
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:683
SCIP_RETCODE SCIPchgDualfeastol(SCIP *scip, SCIP_Real dualfeastol)
Definition: scip.c:45389
SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
Definition: scip.c:13203
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
Definition: scip.c:4388
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
Definition: scip.c:4504
SCIP_RETCODE SCIPsetNLPInitialGuessSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:31163
void SCIPupdateDivesetLPStats(SCIP *scip, SCIP_DIVESET *diveset, SCIP_Longint niterstoadd)
Definition: scip.c:35927
SCIP_PARAM * SCIPgetParam(SCIP *scip, const char *name)
Definition: scip.c:4353
SCIP_RETCODE SCIPsetPresolPriority(SCIP *scip, SCIP_PRESOL *presol, int priority)
Definition: scip.c:7022
SCIP_RETCODE SCIPsetBranchrulePriority(SCIP *scip, SCIP_BRANCHRULE *branchrule, int priority)
Definition: scip.c:9221
SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip.c:27734
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26283
SCIP_RETCODE SCIPaddConflictRelaxedBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
Definition: scip.c:26916
int SCIPgetEffectiveRootDepth(SCIP *scip)
Definition: scip.c:40489
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
Definition: scip.c:36704
SCIP_RETCODE SCIPsetSepaInitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
Definition: scip.c:7431
int SCIPgetNLPRows(SCIP *scip)
Definition: scip.c:29221
SCIP_RETCODE SCIPfreeBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
Definition: scip.c:46971
public methods for primal CIP solutions
SCIP_Bool SCIPareSolsEqual(SCIP *scip, SCIP_SOL *sol1, SCIP_SOL *sol2)
Definition: scip.c:38358
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
Definition: scip.c:34313
SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))
Definition: scip.c:6673
SCIP_Bool SCIPisSumEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:45985
SCIP_RETCODE SCIPcopyOrigVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars)
Definition: scip.c:2389
SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:35307
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:7825
SCIP_RETCODE SCIPgetNLPI(SCIP *scip, SCIP_NLPI **nlpi, SCIP_NLPIPROBLEM **nlpiproblem)
Definition: scip.c:31574
SCIP_Real SCIPgetLowerbound(SCIP *scip)
Definition: scip.c:42323
SCIP_SOL * SCIPgetReoptLastOptSol(SCIP *scip)
Definition: scip.c:16310
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
Definition: scip.c:42559
SCIP_RETCODE SCIPrecalcNlRowActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32451
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:52
SCIP main data structure.
SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
Definition: scip.c:34423
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip.c:42755
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:25808
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
Definition: scip.c:41209
int SCIPgetNTotalVars(SCIP *scip)
Definition: scip.c:12208
#define SCIP_DECL_CONCSOLVERINITSEEDS(x)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46125
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:35713
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23433
int SCIPgetNOrigConss(SCIP *scip)
Definition: scip.c:12771
SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)
Definition: scip.c:944
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:22919
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:18873
SCIP_RETCODE SCIPbranchVarVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
Definition: scip.c:36813
SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26144
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:24730
#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:40746
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
Definition: scip.c:23539
type definitions for problem variables
#define SCIP_DECL_CONSENABLE(x)
Definition: type_cons.h:668
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
Definition: scip.c:4998
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21190
int SCIPgetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx)
Definition: scip.c:46872
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46112
SCIP_NODESEL * SCIPgetNodesel(SCIP *scip)
Definition: scip.c:8937
#define SCIP_DECL_CONFLICTCOPY(x)
Definition: type_conflict.h:61
void SCIPmarkLimitChanged(SCIP *scip)
Definition: scip.c:45433
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
Definition: scip.c:27097
BMS_BUFMEM * SCIPcleanbuffer(SCIP *scip)
Definition: scip.c:45548
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
Definition: scip.c:1353
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
Definition: scip.c:41553
SCIP_RETCODE SCIPgetNLPStringPar(SCIP *scip, SCIP_NLPPARAM type, const char **sval)
Definition: scip.c:31481
SCIP_RETCODE SCIPfreeRealarray(SCIP *scip, SCIP_REALARRAY **realarray)
Definition: scip.c:46669
type definitions for relaxators
SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30562
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:29890
SCIP_RETCODE SCIPsetPricerInit(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINIT((*pricerinit)))
Definition: scip.c:5530
SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip.c:27824
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:27288
SCIP_Bool SCIPisLongintParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip.c:4698
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
Definition: scip.c:41629
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: scip.c:6297
SCIP_RETCODE SCIPsetRelaxPriority(SCIP *scip, SCIP_RELAX *relax, int priority)
Definition: scip.c:7256
SCIP_RETCODE SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)
Definition: scip.c:4407
SCIP_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip.c:33869
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:3308
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:50
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28021
SCIP_RETCODE SCIPgetPseudoBranchCands(SCIP *scip, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
Definition: scip.c:36467
SCIP_RETCODE SCIPsetPresolInitpre(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINITPRE((*presolinitpre)))
Definition: scip.c:6953
type definitions for conflict analysis
SCIP_RETCODE SCIPsetConflicthdlrInitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)))
Definition: scip.c:6721
int SCIPgetNPrioExternBranchBins(SCIP *scip)
Definition: scip.c:36316
int SCIPgetNPrioExternBranchInts(SCIP *scip)
Definition: scip.c:36337
int SCIPgetRealarrayMaxIdx(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:46788
SCIP_RETCODE SCIPsetConflicthdlrExit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)))
Definition: scip.c:6705
type definitions for managing events
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: scip.c:28693
SCIP_RETCODE SCIPsetRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real val)
Definition: scip.c:46737
SCIP_Bool SCIPisDualfeasNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:46348
SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25701
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip.c:28769
SCIP_Bool SCIPhasPrimalRay(SCIP *scip)
Definition: scip.c:40124
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:32961
SCIP_RETCODE SCIPstopSolvingTime(SCIP *scip)
Definition: scip.c:45062
int SCIPgetBoolarrayMinIdx(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:47057
SCIP_RETCODE SCIPgetLPBInvACol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29414
SCIP_Longint SCIPgetLastDivenode(SCIP *scip)
Definition: scip.c:34969
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
Definition: scip.c:41703
SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25675
public methods for NLP management
SCIP_RETCODE SCIPsetRelaxExit(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXIT((*relaxexit)))
Definition: scip.c:7170
public methods for node selectors
SCIP_RETCODE SCIPchgNlRowLhs(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real lhs)
Definition: scip.c:31923
wrapper functions to map file i/o to standard or zlib file i/o
SCIP_NODE * SCIPgetBestNode(SCIP *scip)
Definition: scip.c:40730
#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:3148
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:2524
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
Definition: scip.c:45839
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:7325
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
Definition: scip.c:12960
#define SCIP_DECL_PROBTRANS(x)
Definition: type_prob.h:74
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:21448
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43030
internal methods for problem variables
SCIP_RETCODE SCIPsetNLPRealPar(SCIP *scip, SCIP_NLPPARAM type, SCIP_Real dval)
Definition: scip.c:31453
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:814
SCIP_RETCODE SCIPactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
Definition: scip.c:5691
SCIP_RETCODE SCIPpropCons(SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: scip.c:28457
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:94
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
Definition: scip.c:19781
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:37867
SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29380
SCIP_RETCODE SCIPgetNlRowFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
Definition: scip.c:32508
SCIP_RETCODE SCIPresetReoptnodeDualcons(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:17169
SCIP_RETCODE SCIPclearSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37808
SCIP_RETCODE SCIPsetPropInit(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINIT((*propinit)))
Definition: scip.c:7642
SCIP_RETCODE SCIPcheckReoptRestart(SCIP *scip, SCIP_NODE *node, SCIP_Bool *restart)
Definition: scip.c:17041
public data structures and miscellaneous methods
SCIP_COMPR ** SCIPgetComprs(SCIP *scip)
Definition: scip.c:8387
SCIP_Bool SCIPisSumGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46024
int SCIPgetNPrioExternBranchConts(SCIP *scip)
Definition: scip.c:36377
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
Definition: scip.c:16873
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:10438
SCIP_RETCODE SCIPincludeNlpi(SCIP *scip, SCIP_NLPI *nlpi)
Definition: scip.c:9382
SCIP_RETCODE SCIPsetSepaExitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
Definition: scip.c:7447
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:40029
int SCIPgetNExternalCodes(SCIP *scip)
Definition: scip.c:9512
#define SCIP_Bool
Definition: def.h:61
SCIP_RETCODE SCIPsetProbTrans(SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))
Definition: scip.c:9880
SCIP_RETCODE SCIPgetNLPStatistics(SCIP *scip, SCIP_NLPSTATISTICS *statistics)
Definition: scip.c:31265
#define SCIP_DECL_SEPAINIT(x)
Definition: type_sepa.h:63
SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
Definition: scip.c:30205
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:22737
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:40207
#define SCIP_DECL_PRICERINITSOL(x)
Definition: type_pricer.h:81
int SCIPgetMaxTotalDepth(SCIP *scip)
Definition: scip.c:42168
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip.c:28854
SCIP_RETCODE SCIPfreeSyncstore(SCIP *scip)
Definition: scip.c:41034
SCIP_RETCODE SCIPsetConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)
Definition: scip.c:27548
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
int SCIPgetNImplVars(SCIP *scip)
Definition: scip.c:11766
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:9266
#define SCIP_DECL_PRESOLEXITPRE(x)
Definition: type_presol.h:102
SCIP_Real SCIPgetObjlimit(SCIP *scip)
Definition: scip.c:11135
#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:5201
SCIP_RETCODE SCIPcreateSolCopyOrig(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
Definition: scip.c:37335
#define SCIP_DECL_NODESELEXIT(x)
Definition: type_nodesel.h:72
SCIP_Real SCIPgetRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30616
SCIP_Real SCIPgetOrigObjscale(SCIP *scip)
Definition: scip.c:11000
SCIP_RETCODE SCIPchgNlRowConstant(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real constant)
Definition: scip.c:31969
public methods for storing cuts in a cut pool
void SCIPprintVersion(SCIP *scip, FILE *file)
Definition: scip.c:609
type definitions for input file readers
SCIP_RETCODE SCIPseparateSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
Definition: scip.c:34337
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip.c:10315
SCIP_Bool SCIPisSumLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46011
SCIP_RETCODE SCIPrecalcNlRowNLPActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32303
SCIP_RETCODE SCIPprintRay(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:38796
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:41
SCIP_RETCODE SCIPprintBestTransSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39037
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:8358
#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:30022
SCIP_RETCODE SCIProundSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *success)
Definition: scip.c:39073
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
Definition: scip.c:11078
SCIP_RETCODE SCIPautoselectDisps(SCIP *scip)
Definition: scip.c:9343
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:45078
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:33588
int SCIPgetNPricers(SCIP *scip)
Definition: scip.c:5644
SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
Definition: scip.c:42838
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
Definition: scip.c:41066
int SCIPgetDepth(SCIP *scip)
Definition: scip.c:42094
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:16546
SCIP_Real SCIPlpfeastol(SCIP *scip)
Definition: scip.c:45288
SCIP_RETCODE SCIPupdateNodeDualbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip.c:13372
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:8484
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip.c:13394
SCIP_Real SCIPgetGap(SCIP *scip)
Definition: scip.c:42581
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
Definition: scip.c:42987
SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:34674
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:2660
SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip.c:4657
int SCIPgetNPrioPseudoBranchCands(SCIP *scip)
Definition: scip.c:36511
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
Definition: scip.c:28652
SCIP_RETCODE SCIPcaptureRow(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30138
SCIP_RETCODE SCIPstartSolvingTime(SCIP *scip)
Definition: scip.c:45029
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:20465
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
Definition: scip.c:44770
SCIP_RETCODE SCIPgetNLPVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars)
Definition: scip.c:30872
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:138
SCIP_RETCODE SCIPchgVarsBoundsDiveNLP(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *lbs, SCIP_Real *ubs)
Definition: scip.c:31729
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:39843
void SCIPsetMessagehdlrQuiet(SCIP *scip, SCIP_Bool quiet)
Definition: scip.c:1248
#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:35980
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
Definition: scip.c:41463
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:33964
SCIP_RETCODE SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip.c:24152
SCIP_RETCODE SCIPgetNlRowPseudoFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudofeasibility)
Definition: scip.c:32429
SCIP_RETCODE SCIPgetNlRowActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
Definition: scip.c:32479
methods for debugging
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
Definition: scip.c:26848
SCIP_RETCODE SCIPaddConflictBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:26881
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:5159
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
Definition: scip.c:4625
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:8436
int SCIPsubversion(void)
Definition: scip.c:598
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:30051
SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
Definition: scip.c:30181
unsigned int SCIPinitializeRandomSeed(SCIP *scip, int initialseedvalue)
Definition: scip.c:25467
#define SCIP_DECL_PROPINITSOL(x)
Definition: type_prop.h:115
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip.c:33738
SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: scip.c:6389
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip.c:24581
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:40241
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
Definition: scip.c:37631
SCIP_RETCODE SCIPsetBranchruleExitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))
Definition: scip.c:9118
void SCIPenableVarHistory(SCIP *scip)
Definition: scip.c:25520
SCIP_RETCODE SCIPsetPricerFree(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERFREE((*pricerfree)))
Definition: scip.c:5506
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23370
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip.c:26613
SCIP_RETCODE SCIPsetBranchruleExecExt(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECEXT((*branchexecext)))
Definition: scip.c:9152
SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPCOPY((*propcopy)))
Definition: scip.c:7610
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:40321
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:20985
SCIP_RETCODE SCIPsetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int val)
Definition: scip.c:46888
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:6582
SCIP_RETCODE SCIPaddReoptnodeBndchg(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR *var, SCIP_Real bound, SCIP_BOUNDTYPE boundtype)
Definition: scip.c:16490
SCIP_Real SCIPcalcNodeselPriority(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
Definition: scip.c:36654
SCIP_Real SCIPgetLPRootLooseObjval(SCIP *scip)
Definition: scip.c:29068
SCIP_RETCODE SCIPsetBranchruleMaxdepth(SCIP *scip, SCIP_BRANCHRULE *branchrule, int maxdepth)
Definition: scip.c:9236
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:17237
void SCIPmarkColNotRemovableLocal(SCIP *scip, SCIP_COL *col)
Definition: scip.c:29867
SCIP_Real SCIPgetReoptSimilarity(SCIP *scip, int run1, int run2)
Definition: scip.c:17060
SCIP_RETCODE SCIPprintDualSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:38763
SCIP_RETCODE SCIPaddExternBranchCand(SCIP *scip, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
Definition: scip.c:36399
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
Definition: scip.c:42011
#define SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA(x)
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43116
SCIP_RETCODE SCIPsetStringParam(SCIP *scip, const char *name, const char *value)
Definition: scip.c:4857
type definitions for branch and bound tree
int SCIPgetNSols(SCIP *scip)
Definition: scip.c:38832
SCIP_RETCODE SCIPsetReaderWrite(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERWRITE((*readerwrite)))
Definition: scip.c:5311
SCIP_RETCODE SCIPsetNodeselInitsol(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELINITSOL((*nodeselinitsol)))
Definition: scip.c:8840
SCIP_Real SCIPgetLPRootColumnObjval(SCIP *scip)
Definition: scip.c:29045
SCIP_RETCODE SCIPretransformSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:39109
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
Definition: scip.c:41647
SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip.c:28427
SCIP_RETCODE SCIPupdateLocalDualbound(SCIP *scip, SCIP_Real newbound)
Definition: scip.c:13283
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip.c:25141
#define SCIP_DECL_DIALOGFREE(x)
Definition: type_dialog.h:61
SCIP_RETCODE SCIPincludeRelax(SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_Bool includeslp, 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:7043
#define SCIP_DECL_COMPREXIT(x)
Definition: type_compr.h:73
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
Definition: scip.c:41517
int SCIPgetNRuns(SCIP *scip)
Definition: scip.c:41099
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip.c:24851
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:16574
SCIP_RETCODE SCIPsetPropPresolPriority(SCIP *scip, SCIP_PROP *prop, int presolpriority)
Definition: scip.c:7840
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip.c:21309
SCIP_RETCODE SCIPcreateEmptyNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real lhs, SCIP_Real rhs)
Definition: scip.c:31829
SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
Definition: scip.c:29281
SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip.c:28311
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38090
int SCIPtechVersion(void)
Definition: scip.c:587
SCIP_RETCODE SCIPcaptureNlRow(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:31878
SCIP_COL ** SCIPgetLPCols(SCIP *scip)
Definition: scip.c:29122
SCIP_RETCODE SCIPstartInteraction(SCIP *scip)
Definition: scip.c:9740
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: scip.c:6435
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
Definition: scip.c:45345
SCIP_RETCODE SCIPsetConflicthdlrCopy(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)))
Definition: scip.c:6657
SCIP_RETCODE SCIPfixParam(SCIP *scip, const char *name)
Definition: scip.c:4486
SCIP_RETCODE SCIPflushLP(SCIP *scip)
Definition: scip.c:28834
SCIP_RETCODE SCIPcreateUnknownSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37210
int SCIPgetNObjVars(SCIP *scip)
Definition: scip.c:11859
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
Definition: scip.c:42068
datastructures for problem statistics
SCIP_Bool SCIPisRealParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip.c:4756
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
Definition: scip.c:33851
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
Definition: scip.c:41308
#define SCIP_DECL_SEPAEXITSOL(x)
Definition: type_sepa.h:93
SCIP_Real SCIPdualfeasFrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:46420
SCIP_Bool SCIPisSumRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46579
#define SCIP_DECL_SEPAEXECSOL(x)
Definition: type_sepa.h:138
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
Definition: scip.c:45827
SCIP_Real SCIPgetTimeOfDay(SCIP *scip)
Definition: scip.c:44830
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip.c:30713
#define SCIP_DECL_CONCSOLVERTYPEFREEDATA(x)
type definitions for clocks and timing issues
int SCIPconvertRealToInt(SCIP *scip, SCIP_Real real)
Definition: scip.c:46594
SCIP_RETCODE SCIPchgLpfeastol(SCIP *scip, SCIP_Real lpfeastol, SCIP_Bool printnewvalue)
Definition: scip.c:45363
SCIP_Longint SCIPconvertRealToLongint(SCIP *scip, SCIP_Real real)
Definition: scip.c:46610
SCIP_RETCODE SCIPcreateRelaxSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37110
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:22414
int SCIPgetNOrigContVars(SCIP *scip)
Definition: scip.c:12179
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:39749
SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: scip.c:6366
SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))
Definition: scip.c:5239
SCIP_NODE * SCIPgetFocusNode(SCIP *scip)
Definition: scip.c:40434
void SCIPchgDispMode(SCIP_DISP *disp, SCIP_DISPMODE mode)
Definition: scip.c:9356
SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
Definition: scip.c:36681
SCIP_Real * SCIPgetNLPVarsLbDualsol(SCIP *scip)
Definition: scip.c:30970
SCIP_EVENTHDLR ** SCIPgetEventhdlrs(SCIP *scip)
Definition: scip.c:8669
SCIP_RETCODE SCIPextendPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray, int minidx, int maxidx)
Definition: scip.c:47120
int SCIPgetNConcsolverTypes(SCIP *scip)
Definition: scip.c:7926
SCIP_RETCODE SCIPcreatePseudoSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37137
SCIP_Real SCIPgetTransObjscale(SCIP *scip)
Definition: scip.c:11046
SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITSOL((*propexitsol)))
Definition: scip.c:7690
int SCIPgetNBinVars(SCIP *scip)
Definition: scip.c:11676
SCIP_RETCODE SCIPsetPricerInitsol(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINITSOL((*pricerinitsol)))
Definition: scip.c:5578
type definitions for storing and manipulating the main problem
SCIP_Bool SCIPinProbing(SCIP *scip)
Definition: scip.c:35033
SCIP_CONCSOLVERTYPE ** SCIPgetConcsolverTypes(SCIP *scip)
Definition: scip.c:7915
SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:19575
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
Definition: scip.c:4799
SCIP_NODE * SCIPgetPrioSibling(SCIP *scip)
Definition: scip.c:40666
#define SCIP_DECL_READERCOPY(x)
Definition: type_reader.h:46
int SCIPgetNVars(SCIP *scip)
Definition: scip.c:11631
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
Definition: type_paramset.h:73
SCIP_RETCODE SCIPsetComprPriority(SCIP *scip, SCIP_COMPR *compr, int priority)
Definition: scip.c:8411
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23483
SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34262
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
Definition: scip.c:17466
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:109
void SCIPenableNLP(SCIP *scip)
Definition: scip.c:30820
SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)
Definition: scip.c:13333
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
Definition: scip.c:42261
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
Definition: scip.c:6998
SCIP_RETCODE SCIPaddPricedVar(SCIP *scip, SCIP_VAR *var, SCIP_Real score)
Definition: scip.c:11376
int SCIPgetBoolarrayMaxIdx(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:47071
SCIP_RETCODE SCIPaddSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *stored)
Definition: scip.c:39549
SCIP_Bool SCIPinDive(SCIP *scip)
Definition: scip.c:34999
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
Definition: scip.c:41571
type definitions for propagators
SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip.c:34117
#define SCIP_DECL_DIALOGEXEC(x)
Definition: type_dialog.h:87
SCIP_Bool SCIPhasNLPSolution(SCIP *scip)
Definition: scip.c:31313
SCIP_RETCODE SCIPgetReoptOldObjCoef(SCIP *scip, SCIP_VAR *var, int run, SCIP_Real *objcoef)
Definition: scip.c:16337
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: scip.c:6166
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
Definition: scip.c:43134
SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
Definition: scip.c:24499
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26170
enum SCIP_ExprCurv SCIP_EXPRCURV
Definition: type_expr.h:93
SCIP_Real SCIPgetTransObjoffset(SCIP *scip)
Definition: scip.c:11023
SCIP_RETCODE SCIPprintNodeRootPath(SCIP *scip, SCIP_NODE *node, FILE *file)
Definition: scip.c:40869
SCIP_RETCODE SCIPsetProbInitsol(SCIP *scip, SCIP_DECL_PROBINITSOL((*probinitsol)))
Definition: scip.c:9922
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
Definition: scip.c:24820
int SCIPgetNHeurs(SCIP *scip)
Definition: scip.c:8166
SCIP_Bool SCIPisDualfeasPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:46336
SCIP_RETCODE SCIPsetConsStickingAtNode(SCIP *scip, SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: scip.c:27649
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
Definition: scip.c:21090
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
Definition: scip.c:30160
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
Definition: scip.c:11205
SCIP_RETCODE SCIPcopyProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, const char *name)
Definition: scip.c:1730
public methods for presolvers
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
Definition: scip.c:17415
public methods for managing events
#define SCIP_DECL_DISPEXITSOL(x)
Definition: type_disp.h:117
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
Definition: scip.c:41739
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
Definition: scip.c:41721
SCIP_RETCODE SCIPincludeRelaxBasic(SCIP *scip, SCIP_RELAX **relaxptr, const char *name, const char *desc, int priority, int freq, SCIP_Bool includeslp, SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)
Definition: scip.c:7087
SCIP_RETCODE SCIPreadSolFile(SCIP *scip, const char *filename, SCIP_SOL *sol, SCIP_Bool xml, SCIP_Bool *partial, SCIP_Bool *error)
Definition: scip.c:39509
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
Definition: scip.c:45575
SCIP_RETCODE SCIPcreateNLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37075
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
Definition: scip.c:42962
SCIP_RETCODE SCIPcreatePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
Definition: scip.c:47086
SCIP_RETCODE SCIPaddQuadVarToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var)
Definition: scip.c:32081
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
Definition: scip.c:7383
SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)
Definition: scip.c:29689
int SCIPgetNOrigIntVars(SCIP *scip)
Definition: scip.c:12125
SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPRESPROP((*propresprop)))
Definition: scip.c:7771
SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip.c:28897
SCIP_RETCODE SCIPsetSepaInit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
Definition: scip.c:7399
SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
Definition: scip.c:29603
SCIP_RETCODE SCIPbranchPseudo(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:36969
SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:19545
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition: scip.c:38931
SCIP_RETCODE SCIPaddQuadVarsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars)
Definition: scip.c:32106
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:45790
#define SCIP_DECL_RELAXEXEC(x)
Definition: type_relax.h:118
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:66
struct SCIP_ProbData SCIP_PROBDATA
Definition: type_prob.h:44
SCIP_RETCODE SCIPsetProbName(SCIP *scip, const char *name)
Definition: scip.c:10752
SCIP_RETCODE SCIPsolveProbingLPWithPricing(SCIP *scip, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:35737
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:45900
SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:34601
SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
Definition: scip.c:19040
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:4286
SCIP_RETCODE SCIPgetNlRowSolFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Real *feasibility)
Definition: scip.c:32571
SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: scip.c:28280
SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
Definition: scip.c:28400
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
Definition: scip.c:18294
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
Definition: scip.c:45562
SCIP_RETCODE SCIPprintMIPStart(SCIP *scip, SCIP_SOL *sol, FILE *file)
Definition: scip.c:38560
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
Definition: scip.c:41811
static const SCIP_Real scalars[]
Definition: lp.c:5563
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:1911
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:11311
SCIP_NLPI * SCIPfindNlpi(SCIP *scip, const char *name)
Definition: scip.c:9418
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:22527
int SCIPgetNNodesels(SCIP *scip)
Definition: scip.c:8896
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:20874
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:6046
SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)
Definition: scip.c:10621
SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:19466
SCIP_Real SCIPtransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip.c:38197
int SCIPgetNReoptRuns(SCIP *scip)
Definition: scip.c:41126
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
Definition: scip.c:41757
SCIP_RETCODE SCIPsetEventhdlrDelete(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTDELETE((*eventdelete)))
Definition: scip.c:8642
SCIP_Real SCIPgetHugeValue(SCIP *scip)
Definition: scip.c:45853
SCIP_RETCODE SCIPrestartSolve(SCIP *scip)
Definition: scip.c:16968
SCIP_Real SCIPgetRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx)
Definition: scip.c:46721
SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
Definition: scip.c:27471
int SCIPgetNReaders(SCIP *scip)
Definition: scip.c:5351
SCIP_RETCODE SCIPendDiveNLP(SCIP *scip)
Definition: scip.c:31642
#define SCIP_DECL_SEPAEXIT(x)
Definition: type_sepa.h:71
int SCIPgetNBranchrules(SCIP *scip)
Definition: scip.c:9210
SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
Definition: scip.c:6070
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:44912
int SCIPgetNPricevars(SCIP *scip)
Definition: scip.c:41881
public methods for conflict analysis handlers
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
Definition: scip.c:41481
int SCIPgetNConss(SCIP *scip)
Definition: scip.c:12679
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:74
SCIP_BRANCHRULE ** SCIPgetBranchrules(SCIP *scip)
Definition: scip.c:9199
SCIP_Bool SCIPisConsCompressionEnabled(SCIP *scip)
Definition: scip.c:1861
public methods for tree compressions
void SCIPsetMessagehdlrLogfile(SCIP *scip, const char *filename)
Definition: scip.c:1236
type definitions for separators
SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)
Definition: scip.c:19840
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip.c:27323
SCIP_RETCODE SCIPsetComprExit(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPREXIT((*comprexit)))
Definition: scip.c:8326
#define SCIP_DECL_DISPEXIT(x)
Definition: type_disp.h:95
SCIP_RETCODE SCIPreadParams(SCIP *scip, const char *filename)
Definition: scip.c:4889
SCIP_RETCODE SCIPsetPresolCopy(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLCOPY((*presolcopy)))
Definition: scip.c:6889
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:42775
int SCIPgetRealarrayMinIdx(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:46774
#define SCIP_DECL_SEPAINITSOL(x)
Definition: type_sepa.h:82
SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
Definition: scip.c:19659
#define SCIP_DECL_PROPRESPROP(x)
Definition: type_prop.h:244
#define SCIP_DECL_HEUREXIT(x)
Definition: type_heur.h:84
SCIP_RETCODE SCIPclearIntarray(SCIP *scip, SCIP_INTARRAY *intarray)
Definition: scip.c:46856
SCIP_Bool SCIPallowDualReds(SCIP *scip)
Definition: scip.c:25447
int SCIPgetNCuts(SCIP *scip)
Definition: scip.c:34387
int SCIPgetNPriceRounds(SCIP *scip)
Definition: scip.c:41863
SCIP_RETCODE SCIPsetNodeselFree(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELFREE((*nodeselfree)))
Definition: scip.c:8792
int SCIPgetRepropdepth(SCIP *scip)
Definition: scip.c:40852
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: scip.c:6190
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:3757
SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:35765
public methods for message output
#define SCIP_DECL_HEURINIT(x)
Definition: type_heur.h:76
int SCIPgetNUpgrConss(SCIP *scip)
Definition: scip.c:12637
int SCIPgetNCliques(SCIP *scip)
Definition: scip.c:24472
SCIP_RETCODE SCIPsplitReoptRoot(SCIP *scip, int *ncreatedchilds, int *naddedconss)
Definition: scip.c:17142
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30579
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
Definition: scip.c:8076
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
Definition: scip.c:24925
#define SCIP_DECL_CONSINIT(x)
Definition: type_cons.h:84
#define SCIP_DECL_PROPPRESOL(x)
Definition: type_prop.h:179
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip.c:38222
SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
SCIP_DECL_EVENTEXEC(EventhdlrNewSol::scip_exec)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:46163
int SCIPgetNImplications(SCIP *scip)
Definition: scip.c:44742
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
Definition: scip.c:43073
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
Definition: scip.c:45588
SCIP_NODESEL * SCIPfindNodesel(SCIP *scip, const char *name)
Definition: scip.c:8872
SCIP_VAR ** SCIPgetVars(SCIP *scip)
Definition: scip.c:11586
SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITSOL((*propinitsol)))
Definition: scip.c:7674
SCIP_RETCODE SCIPgetNLPFracVars(SCIP *scip, SCIP_VAR ***fracvars, SCIP_Real **fracvarssol, SCIP_Real **fracvarsfrac, int *nfracvars, int *npriofracvars)
Definition: scip.c:31338
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:16696
SCIP_HEUR * SCIPgetSolHeur(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38330
type definitions for handling parameter settings
enum SCIP_DispStatus SCIP_DISPSTATUS
Definition: type_disp.h:50
SCIP_RETCODE SCIPupdatePrimalRay(SCIP *scip, SCIP_SOL *primalray)
Definition: scip.c:40169
SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip.c:24372
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:25250
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:346
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
Definition: scip.c:42718
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:18350
#define SCIP_Real
Definition: def.h:135
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:30314
int SCIPgetNPricevarsFound(SCIP *scip)
Definition: scip.c:41899
SCIP_RETCODE SCIPgetNlRowNLPFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
Definition: scip.c:32358
type definitions for user interface dialog
enum SCIP_Stage SCIP_STAGE
Definition: type_set.h:50
public methods for relaxation handlers
SCIP_RETCODE SCIPsetRelaxSolValsSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:19614
SCIP_RETCODE SCIPsolveParallel(SCIP *scip)
Definition: scip.c:16057
struct SCIP_PropData SCIP_PROPDATA
Definition: type_prop.h:38
SCIP_Bool SCIPisStopped(SCIP *scip)
Definition: scip.c:1138
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:53
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
Definition: scip.c:24956
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: scip.c:6504
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:7520
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:5376
SCIP_Bool SCIPisScalingIntegral(SCIP *scip, SCIP_Real val, SCIP_Real scalar)
Definition: scip.c:45912
public methods for input file readers
SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30508
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:24529
#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:9070
SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
Definition: scip.c:28958
#define SCIP_DECL_HEURFREE(x)
Definition: type_heur.h:68
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
Definition: scip.c:25414
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip.c:34023
SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip.c:18485
SCIP_RETCODE SCIPgetReoptLeaveIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
Definition: scip.c:16415
#define SCIP_DECL_CONFLICTINIT(x)
Definition: type_conflict.h:77
SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)
Definition: scip.c:13164
internal methods for constraints and constraint handlers
SCIP_RETCODE SCIPsetPropFree(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPFREE((*propfree)))
Definition: scip.c:7626
SCIP_DECL_READERREAD(ReaderTSP::scip_read)
Definition: ReaderTSP.cpp:150
int SCIPgetNConflictConssFoundNode(SCIP *scip)
Definition: scip.c:42044
SCIP_Bool SCIPisDualfeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46285
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
Definition: scip.c:30762
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:30402
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:638
SCIP_RETCODE SCIPsetConsModifiable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: scip.c:27574
SCIP_RETCODE SCIPlinkRelaxSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37730
SCIP_RETCODE SCIPprintNlRow(SCIP *scip, SCIP_NLROW *nlrow, FILE *file)
Definition: scip.c:32630
SCIP_RETCODE SCIPaddConsLocks(SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
Definition: scip.c:28222
SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)
Definition: scip.c:10975
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))
Definition: scip.c:5287
int SCIPgetNCompr(SCIP *scip)
Definition: scip.c:8400
SCIP_Real SCIPcutoffbounddelta(SCIP *scip)
Definition: scip.c:45330
SCIP_RETCODE SCIPcreateCurrentSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37160
#define SCIP_Longint
Definition: def.h:120
SCIP_Bool SCIPallColsInLP(SCIP *scip)
Definition: scip.c:29244
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:8808
SCIP_Real SCIPgetTotalTime(SCIP *scip)
Definition: scip.c:45110
SCIP_NODE * SCIPgetPrioChild(SCIP *scip)
Definition: scip.c:40650
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip.c:30736
SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:34839
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37836
SCIP_RETCODE SCIPbranchLP(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:36921
SCIP_NODE * SCIPgetBestChild(SCIP *scip)
Definition: scip.c:40682
SCIP_Real SCIPfrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:45973
SCIP_RETCODE SCIPcheckCopyLimits(SCIP *sourcescip, SCIP_Bool *success)
Definition: scip.c:4090
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
Definition: scip.c:10881
SCIP_RETCODE SCIPreleaseDialog(SCIP *scip, SCIP_DIALOG **dialog)
Definition: scip.c:9622
SCIP_RETCODE SCIPstartDive(SCIP *scip)
Definition: scip.c:34477
SCIP_RETCODE SCIPincludeExternalCodeInformation(SCIP *scip, const char *name, const char *description)
Definition: scip.c:9470
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:37909
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:17942
SCIP_Real SCIPgetNodeLowerbound(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:13259
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
Definition: scip.c:13668
SCIP_RETCODE SCIPsetNlpiPriority(SCIP *scip, SCIP_NLPI *nlpi, int priority)
Definition: scip.c:9455
SCIP_Bool SCIPgetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx)
Definition: scip.c:47023
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:45864
SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
Definition: scip.c:25424
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26051
struct SCIP_PricerData SCIP_PRICERDATA
Definition: type_pricer.h:36
SCIP_RETCODE SCIPbranchExtern(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:36945
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition: scip.c:7476
SCIP_Real SCIPgetNLPObjval(SCIP *scip)
Definition: scip.c:31289
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:45777
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition: type_cons.h:66
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:42815
SCIP_Real SCIPgetLPRootObjval(SCIP *scip)
Definition: scip.c:29022
SCIP_DECL_EVENTDELETE(EventhdlrNewSol::scip_delete)
SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19446
SCIP_RETCODE SCIPstartDiveNLP(SCIP *scip)
Definition: scip.c:31614
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
Definition: scip.c:42691
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:12152
SCIP_RETCODE SCIPsetProbDeltrans(SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))
Definition: scip.c:9901
SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)
Definition: scip.c:29845
int SCIPgetNLPCols(SCIP *scip)
Definition: scip.c:29143
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: scip.c:8044
SCIP_RETCODE SCIPsetPricerCopy(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERCOPY((*pricercopy)))
Definition: scip.c:5482
#define nnodes
Definition: gastrans.c:65
SCIP_Bool SCIPhasPerformedPresolve(SCIP *scip)
Definition: scip.c:1109
int SCIPgetPtrarrayMinIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
Definition: scip.c:47186
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23453
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
Definition: scip.c:35092
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:35902
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:46187
SCIP_Bool SCIPisDualfeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46259
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip.c:4930
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23255
int SCIPgetNPricevarsApplied(SCIP *scip)
Definition: scip.c:41917
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip.c:42735
SCIP_Real SCIPsumepsilon(SCIP *scip)
Definition: scip.c:45260
#define SCIP_DECL_RELAXEXITSOL(x)
Definition: type_relax.h:93
SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)
Definition: scip.c:16942
SCIP_NLPI ** SCIPgetNlpis(SCIP *scip)
Definition: scip.c:9431
SCIP_Real SCIPgetUpperbound(SCIP *scip)
Definition: scip.c:42472
SCIP_NODE * SCIPgetBestLeaf(SCIP *scip)
Definition: scip.c:40714
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:26387
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
Definition: scip.c:35055
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:5738
SCIP_DISP ** SCIPgetDisps(SCIP *scip)
Definition: scip.c:9321
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:20012
SCIP_Bool SCIPisSumLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:45998
public methods for primal heuristics
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
Definition: scip.c:29165
int SCIPgetNSepas(SCIP *scip)
Definition: scip.c:7489
SCIP_RETCODE SCIPgetTransformedConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip.c:27864
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:6320
int SCIPgetNExternBranchCands(SCIP *scip)
Definition: scip.c:36276
int SCIPgetNOrigBinVars(SCIP *scip)
Definition: scip.c:12098
SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip.c:24892
SCIP_RETCODE SCIPsetProbDelorig(SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))
Definition: scip.c:9859
#define SCIP_DECL_DISPOUTPUT(x)
Definition: type_disp.h:126
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
Definition: scip.c:28983
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:31793
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:392
void SCIPdisableDebugSol(SCIP *scip)
Definition: scip.c:1168
SCIP_RETCODE SCIPendDive(SCIP *scip)
Definition: scip.c:34520
void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)
Definition: scip.c:41153
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
Definition: scip.c:12866
#define SCIP_DECL_CONFLICTFREE(x)
Definition: type_conflict.h:69
SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
Definition: scip.c:34041
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
Definition: scip.c:45949
void SCIPprintError(SCIP_RETCODE retcode)
Definition: scip.c:670
SCIP_RETCODE SCIPsetPropInitpre(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITPRE((*propinitpre)))
Definition: scip.c:7706
SCIP_RETCODE SCIPfreeSolve(SCIP *scip, SCIP_Bool restart)
Definition: scip.c:16740
type definitions for node selectors
SCIP_RETCODE SCIPchgRowRhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)
Definition: scip.c:34778
int SCIPgetNEnabledConss(SCIP *scip)
Definition: scip.c:42243
SCIP_REOPTNODE * SCIPgetReoptnode(SCIP *scip, unsigned int id)
Definition: scip.c:16468
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
Definition: scip.c:24429
SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19085
SCIP_Bool SCIPisDualfeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46272
SCIP_RETCODE SCIPgetNlRowNLPActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
Definition: scip.c:32330
SCIP_RETCODE SCIPsetConflicthdlrPriority(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)
Definition: scip.c:6790
SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip.c:4599
#define SCIP_DECL_CONCSOLVERSYNCWRITE(x)
int SCIPgetNReoptLeaves(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:16455
SCIP_RETCODE SCIPresetParam(SCIP *scip, const char *name)
Definition: scip.c:4952
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: scip.c:6118
SCIP_Longint SCIPgetNNodes(SCIP *scip)
Definition: scip.c:41182
SCIP_RETCODE SCIPsetPropExit(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXIT((*propexit)))
Definition: scip.c:7658
SCIP_Longint SCIPgetNLPs(SCIP *scip)
Definition: scip.c:41363
SCIP_RETCODE SCIPresetRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:16633
SCIP_ROW ** SCIPgetCuts(SCIP *scip)
Definition: scip.c:34369
SCIP_RETCODE SCIPsetRootDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9639
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
Definition: scip.c:17353
#define SCIP_DECL_PRICERREDCOST(x)
Definition: type_pricer.h:130
SCIP_Real SCIPround(SCIP *scip, SCIP_Real val)
Definition: scip.c:45961
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
Definition: scip.c:41281
#define SCIP_DECL_HEUREXITSOL(x)
Definition: type_heur.h:106
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21222
SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: scip.c:18965
#define SCIP_DECL_NODESELSELECT(x)
Definition: type_nodesel.h:109
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:35264
#define SCIP_DECL_CONCSOLVERCREATEINST(x)
int SCIPminorVersion(void)
Definition: scip.c:576
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
Definition: scip.c:42937
int SCIPgetNParams(SCIP *scip)
Definition: scip.c:5129
SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)
Definition: scip.c:41254
void SCIPupdateDivesetStats(SCIP *scip, SCIP_DIVESET *diveset, int nprobingnodes, int nbacktracks, SCIP_Longint nsolsfound, SCIP_Longint nbestsolsfound, SCIP_Bool leavewassol)
Definition: scip.c:35940
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:30431
void SCIPdisableVarHistory(SCIP *scip)
Definition: scip.c:25539
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:44929
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition: scip.c:38007
SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26252
SCIP_RETCODE SCIPaddObjoffset(SCIP *scip, SCIP_Real addval)
Definition: scip.c:10924
SCIP_Real SCIPgetVarObjDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:34810
SCIP_RETCODE SCIPdeactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28613
SCIP_Bool SCIPisInRestart(SCIP *scip)
Definition: scip.c:17200
void SCIPprintBuildOptions(SCIP *scip, FILE *file)
Definition: scip.c:644
SCIP_Bool SCIPisExactSolve(SCIP *scip)
Definition: scip.c:1025
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:40965
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip.c:4541
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:4258
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:22634
SCIP_Bool SCIPisRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46488
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:17597
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
Definition: scip.c:41829
SCIP_CONCSOLVERTYPE * SCIPfindConcsolverType(SCIP *scip, const char *name)
Definition: scip.c:7902
SCIP_Real SCIPgetFirstLPTime(SCIP *scip)
Definition: scip.c:45227
int SCIPgetNProps(SCIP *scip)
Definition: scip.c:7814
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
Definition: scip.c:5020
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:45937
SCIP_RETCODE SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
Definition: scip.c:27066
SCIP_RETCODE SCIPsetRelaxInitsol(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINITSOL((*relaxinitsol)))
Definition: scip.c:7186
SCIP_RETCODE SCIPaddDialogInputLine(SCIP *scip, const char *inputline)
Definition: scip.c:9690
#define SCIP_DECL_SEPAFREE(x)
Definition: type_sepa.h:55
SCIP_RETCODE SCIPsetNodeselStdPriority(SCIP *scip, SCIP_NODESEL *nodesel, int priority)
Definition: scip.c:8907
SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
Definition: scip.c:24764
SCIP_RETCODE SCIPaddQuadElementsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nquadelems, SCIP_QUADELEM *quadelems)
Definition: scip.c:32169
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip.c:26664
SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))
Definition: scip.c:5263
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
Definition: scip.c:4683
SCIP_Real SCIPgetPrimalRayVal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:40142
SCIP_RETCODE SCIPenableReoptimization(SCIP *scip, SCIP_Bool enable)
Definition: scip.c:16230
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 copynlpis, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip.c:1561
SCIP_RETCODE SCIPevalExprtreeLocalBounds(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
Definition: scip.c:32833
struct SCIP_SepaData SCIP_SEPADATA
Definition: type_sepa.h:38
SCIP_Bool SCIPallowObjProp(SCIP *scip)
Definition: scip.c:25457
SCIP_RETCODE SCIPsetPresolExitpre(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXITPRE((*presolexitpre)))
Definition: scip.c:6969
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
Definition: scip.c:43048
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
Definition: scip.c:18663
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:8696
SCIP_RETCODE SCIPinitlpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
Definition: scip.c:28373
SCIP_RETCODE SCIPsetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx, void *val)
Definition: scip.c:47168
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:4176
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26020
int SCIPgetNSepaRounds(SCIP *scip)
Definition: scip.c:41933
SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip.c:42863
SCIP_Bool SCIPcontainsExternBranchCand(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:36443
SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30673
public methods for propagators
SCIP_Real SCIPgetLPColumnObjval(SCIP *scip)
Definition: scip.c:28915
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43010
SCIP_RETCODE SCIPfree(SCIP **scip)
Definition: scip.c:774
SCIP_RETCODE SCIPcreateFiniteSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol, SCIP_Bool *success)
Definition: scip.c:37393
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:32893
SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19722
#define SCIP_DECL_PROPINIT(x)
Definition: type_prop.h:63
SCIP_RELAX * SCIPfindRelax(SCIP *scip, const char *name)
Definition: scip.c:7219
type definitions for specific NLP solver interfaces
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37005
SCIP_Longint SCIPgetSolNodenum(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38303
SCIP_CONFLICTHDLR * SCIPfindConflicthdlr(SCIP *scip, const char *name)
Definition: scip.c:6753
uint64_t SCIP_EVENTTYPE
Definition: type_event.h:134
void SCIPenableDebugSol(SCIP *scip)
Definition: scip.c:1155
#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:7573
SCIP_RETCODE SCIPfreePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
Definition: scip.c:47103
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
Definition: scip.c:5931
SCIP_PRICER ** SCIPgetPricers(SCIP *scip)
Definition: scip.c:5631
type definitions for concurrent solvers
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
Definition: scip.c:27421
SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
Definition: scip.c:18435
SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip.c:34213
type definitions for displaying runtime statistics
memory allocation routines
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:35393
SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26506
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:38421