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  * The source problem depends on the stage of the \p sourcescip - In SCIP_STAGE_PROBLEM, the original problem is copied,
1357  * otherwise, the transformed problem is copied. For an explicit copy of the original problem, use SCIPcopyOrig().
1358  *
1359  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1360  *
1361  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1362  * Also, 'passmessagehdlr' should be set to FALSE.
1363  * @note Do not change the source SCIP environment during the copying process
1364  *
1365  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1366  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1367  *
1368  * @pre This method can be called if sourcescip is in one of the following stages:
1369  * - \ref SCIP_STAGE_PROBLEM
1370  * - \ref SCIP_STAGE_TRANSFORMED
1371  * - \ref SCIP_STAGE_INITPRESOLVE
1372  * - \ref SCIP_STAGE_PRESOLVING
1373  * - \ref SCIP_STAGE_EXITPRESOLVE
1374  * - \ref SCIP_STAGE_PRESOLVED
1375  * - \ref SCIP_STAGE_INITSOLVE
1376  * - \ref SCIP_STAGE_SOLVING
1377  * - \ref SCIP_STAGE_SOLVED
1378  *
1379  * @pre This method can be called if targetscip is in one of the following stages:
1380  * - \ref SCIP_STAGE_INIT
1381  * - \ref SCIP_STAGE_FREE
1382  *
1383  * @note sourcescip stage does not get changed
1384  *
1385  * @note targetscip stage does not get changed
1386  *
1387  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1388  */
1389 extern
1391  SCIP* sourcescip, /**< source SCIP data structure */
1392  SCIP* targetscip, /**< target SCIP data structure */
1393  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1394  * target variables, or NULL */
1395  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1396  * target constraints, or NULL */
1397  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1398  SCIP_Bool global, /**< create a global or a local copy? */
1399  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1400  * plugins will be copied and activated, and the modifiable flag of
1401  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1402  * there are pricers present */
1403  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1404  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1405  );
1406 
1407 /** copies source SCIP to target SCIP but compresses constraints
1408  *
1409  * constraint compression is performed by removing fixed variables immediately
1410  * during constraint creation if the involved constraint handlers support
1411  * compression
1412  *
1413  * the copying process is done in the following order:
1414  * 1) copy the plugins
1415  * 2) copy the settings
1416  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1417  * 4) copy all active variables
1418  * a) fix all variable copies specified by \p fixedvars, \p fixedvals, and \p nfixedvars
1419  * b) enable constraint compression
1420  * 5) copy all constraints
1421  *
1422  * The source problem depends on the stage of the \p sourcescip - In SCIP_STAGE_PROBLEM, the original problem is copied,
1423  * otherwise, the transformed problem is copied. For an explicit copy of the original problem, use SCIPcopyOrigConsCompression().
1424  *
1425  * @note: in case that a combination of local bounds and explicit fixing values should be used,
1426  * the fixing value of a variable is preferred if local bounds and fixing value disagree.
1427  *
1428  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1429  *
1430  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1431  * Also, 'passmessagehdlr' should be set to FALSE.
1432  * @note Do not change the source SCIP environment during the copying process
1433  *
1434  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1435  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1436  *
1437  * @pre This method can be called if sourcescip is in one of the following stages:
1438  * - \ref SCIP_STAGE_PROBLEM
1439  * - \ref SCIP_STAGE_TRANSFORMED
1440  * - \ref SCIP_STAGE_INITPRESOLVE
1441  * - \ref SCIP_STAGE_PRESOLVING
1442  * - \ref SCIP_STAGE_EXITPRESOLVE
1443  * - \ref SCIP_STAGE_PRESOLVED
1444  * - \ref SCIP_STAGE_INITSOLVE
1445  * - \ref SCIP_STAGE_SOLVING
1446  * - \ref SCIP_STAGE_SOLVED
1447  *
1448  * @pre This method can be called if targetscip is in one of the following stages:
1449  * - \ref SCIP_STAGE_INIT
1450  * - \ref SCIP_STAGE_FREE
1451  *
1452  * @note sourcescip stage does not get changed
1453  *
1454  * @note targetscip stage does not get changed
1455  *
1456  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1457  */
1458 extern
1460  SCIP* sourcescip, /**< source SCIP data structure */
1461  SCIP* targetscip, /**< target SCIP data structure */
1462  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1463  * target variables, or NULL */
1464  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1465  * target constraints, or NULL */
1466  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1467  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
1468  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
1469  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
1470  SCIP_Bool global, /**< create a global or a local copy? */
1471  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1472  * plugins will be copied and activated, and the modifiable flag of
1473  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1474  * there are pricers present */
1475  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1476  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1477  );
1478 
1479 /** copies source SCIP original problem to target SCIP; the copying process is done in the following order:
1480  * 1) copy the plugins
1481  * 2) copy the settings
1482  * 3) create problem data in target-SCIP and copy the original problem data of the source-SCIP
1483  * 4) copy all original variables
1484  * 5) copy all original constraints
1485  *
1486  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1487  *
1488  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1489  * Also, 'passmessagehdlr' should be set to FALSE.
1490  * @note Do not change the source SCIP environment during the copying process
1491  *
1492  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1493  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1494  *
1495  * @pre This method can be called if sourcescip is in one of the following stages:
1496  * - \ref SCIP_STAGE_PROBLEM
1497  * - \ref SCIP_STAGE_TRANSFORMED
1498  * - \ref SCIP_STAGE_INITPRESOLVE
1499  * - \ref SCIP_STAGE_PRESOLVING
1500  * - \ref SCIP_STAGE_EXITPRESOLVE
1501  * - \ref SCIP_STAGE_PRESOLVED
1502  * - \ref SCIP_STAGE_INITSOLVE
1503  * - \ref SCIP_STAGE_SOLVING
1504  * - \ref SCIP_STAGE_SOLVED
1505  *
1506  * @pre This method can be called if targetscip is in one of the following stages:
1507  * - \ref SCIP_STAGE_INIT
1508  * - \ref SCIP_STAGE_FREE
1509  *
1510  * @note sourcescip stage does not get changed
1511  *
1512  * @note targetscip stage does not get changed
1513  *
1514  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1515  */
1516 extern
1518  SCIP* sourcescip, /**< source SCIP data structure */
1519  SCIP* targetscip, /**< target SCIP data structure */
1520  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1521  * target variables, or NULL */
1522  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1523  * target constraints, or NULL */
1524  const char* suffix, /**< suffix which will be added to the names of the target SCIP, might be empty */
1525  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1526  * plugins will be copied and activated, and the modifiable flag of
1527  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1528  * there are pricers present */
1529  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1530  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1531  );
1532 
1533 /** copies source SCIP original problem to target SCIP but compresses constraints
1534  *
1535  * constraint compression is performed by removing fixed variables immediately
1536  * during constraint creation if the involved constraint handlers support
1537  * compression
1538  *
1539  * the copying process is done in the following order:
1540  * 1) copy the plugins
1541  * 2) copy the settings
1542  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1543  * 4) copy all original variables
1544  * a) fix all variable copies specified by \p fixedvars, \p fixedvals, and \p nfixedvars
1545  * b) enable constraint compression
1546  * 5) copy all constraints
1547  *
1548  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1549  *
1550  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1551  * Also, 'passmessagehdlr' should be set to FALSE.
1552  * @note Do not change the source SCIP environment during the copying process
1553  *
1554  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1555  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1556  *
1557  * @pre This method can be called if sourcescip is in one of the following stages:
1558  * - \ref SCIP_STAGE_PROBLEM
1559  * - \ref SCIP_STAGE_TRANSFORMED
1560  * - \ref SCIP_STAGE_INITPRESOLVE
1561  * - \ref SCIP_STAGE_PRESOLVING
1562  * - \ref SCIP_STAGE_EXITPRESOLVE
1563  * - \ref SCIP_STAGE_PRESOLVED
1564  * - \ref SCIP_STAGE_INITSOLVE
1565  * - \ref SCIP_STAGE_SOLVING
1566  * - \ref SCIP_STAGE_SOLVED
1567  *
1568  * @pre This method can be called if targetscip is in one of the following stages:
1569  * - \ref SCIP_STAGE_INIT
1570  * - \ref SCIP_STAGE_FREE
1571  *
1572  * @note sourcescip stage does not get changed
1573  *
1574  * @note targetscip stage does not get changed
1575  *
1576  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1577  */
1578 extern
1580  SCIP* sourcescip, /**< source SCIP data structure */
1581  SCIP* targetscip, /**< target SCIP data structure */
1582  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1583  * target variables, or NULL */
1584  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1585  * target constraints, or NULL */
1586  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1587  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
1588  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
1589  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
1590  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1591  * plugins will be copied and activated, and the modifiable flag of
1592  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1593  * there are pricers present */
1594  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1595  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1596  );
1597 
1598 /** checks if there is enough time and memory left for copying the sourcescip into a sub-SCIP and solve the sub-SCIP
1599  *
1600  * This is the case if the time and memory limit that would be passed to the sub-SCIP are larger than 0.0
1601  *
1602  * @pre This method can be called if sourcescip is in one of the following stages:
1603  * - \ref SCIP_STAGE_PROBLEM
1604  * - \ref SCIP_STAGE_TRANSFORMED
1605  * - \ref SCIP_STAGE_INITPRESOLVE
1606  * - \ref SCIP_STAGE_PRESOLVING
1607  * - \ref SCIP_STAGE_EXITPRESOLVE
1608  * - \ref SCIP_STAGE_PRESOLVED
1609  * - \ref SCIP_STAGE_INITSOLVE
1610  * - \ref SCIP_STAGE_SOLVING
1611  * - \ref SCIP_STAGE_SOLVED
1612  *
1613  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1614  */
1615 extern
1617  SCIP* sourcescip, /**< source SCIP data structure */
1618  SCIP_Bool* success /**< pointer to store whether there is time and memory left to copy the
1619  * problem and run the sub-SCIP */
1620  );
1621 
1622 /** copies limits from source SCIP to target SCIP
1623  *
1624  * @note time and memory limit are reduced by the amount already spent in the source SCIP before installing the limit
1625  * in the target SCIP
1626  * @note all other limits are disabled and need to be enabled afterwards, if needed
1627  *
1628  * @pre This method can be called if sourcescip is in one of the following stages:
1629  * - \ref SCIP_STAGE_PROBLEM
1630  * - \ref SCIP_STAGE_TRANSFORMED
1631  * - \ref SCIP_STAGE_INITPRESOLVE
1632  * - \ref SCIP_STAGE_PRESOLVING
1633  * - \ref SCIP_STAGE_EXITPRESOLVE
1634  * - \ref SCIP_STAGE_PRESOLVED
1635  * - \ref SCIP_STAGE_INITSOLVE
1636  * - \ref SCIP_STAGE_SOLVING
1637  * - \ref SCIP_STAGE_SOLVED
1638  *
1639  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1640  */
1641 extern
1643  SCIP* sourcescip, /**< source SCIP data structure */
1644  SCIP* targetscip /**< target SCIP data structure */
1645  );
1646 
1647 
1648 /**@} */
1649 
1650 /*
1651  * parameter settings
1652  */
1653 
1654 /**@addtogroup ParameterMethods
1655  *
1656  * @{
1657  */
1658 
1659 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
1660  *
1661  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1662  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1663  */
1664 extern
1666  SCIP* scip, /**< SCIP data structure */
1667  const char* name, /**< name of the parameter */
1668  const char* desc, /**< description of the parameter */
1669  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
1670  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1671  SCIP_Bool defaultvalue, /**< default value of the parameter */
1672  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1673  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1674  );
1675 
1676 /** creates a int parameter, sets it to its default value, and adds it to the parameter set
1677  *
1678  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1679  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1680  */
1681 extern
1683  SCIP* scip, /**< SCIP data structure */
1684  const char* name, /**< name of the parameter */
1685  const char* desc, /**< description of the parameter */
1686  int* valueptr, /**< pointer to store the current parameter value, or NULL */
1687  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1688  int defaultvalue, /**< default value of the parameter */
1689  int minvalue, /**< minimum value for parameter */
1690  int maxvalue, /**< maximum value for parameter */
1691  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1692  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1693  );
1694 
1695 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
1696  *
1697  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1698  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1699  */
1700 extern
1702  SCIP* scip, /**< SCIP data structure */
1703  const char* name, /**< name of the parameter */
1704  const char* desc, /**< description of the parameter */
1705  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
1706  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1707  SCIP_Longint defaultvalue, /**< default value of the parameter */
1708  SCIP_Longint minvalue, /**< minimum value for parameter */
1709  SCIP_Longint maxvalue, /**< maximum value for parameter */
1710  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1711  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1712  );
1713 
1714 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
1715  *
1716  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1717  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1718  */
1719 extern
1721  SCIP* scip, /**< SCIP data structure */
1722  const char* name, /**< name of the parameter */
1723  const char* desc, /**< description of the parameter */
1724  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
1725  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1726  SCIP_Real defaultvalue, /**< default value of the parameter */
1727  SCIP_Real minvalue, /**< minimum value for parameter */
1728  SCIP_Real maxvalue, /**< maximum value for parameter */
1729  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1730  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1731  );
1732 
1733 /** creates a char parameter, sets it to its default value, and adds it to the parameter set
1734  *
1735  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1736  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1737  */
1738 extern
1740  SCIP* scip, /**< SCIP data structure */
1741  const char* name, /**< name of the parameter */
1742  const char* desc, /**< description of the parameter */
1743  char* valueptr, /**< pointer to store the current parameter value, or NULL */
1744  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1745  char defaultvalue, /**< default value of the parameter */
1746  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
1747  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1748  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1749  );
1750 
1751 /** creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
1752  *
1753  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1754  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1755  */
1756 extern
1758  SCIP* scip, /**< SCIP data structure */
1759  const char* name, /**< name of the parameter */
1760  const char* desc, /**< description of the parameter */
1761  char** valueptr, /**< pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL */
1762  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1763  const char* defaultvalue, /**< default value of the parameter */
1764  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1765  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1766  );
1767 
1768 /** gets the fixing status of an existing parameter
1769  *
1770  * @return TRUE if the parameter is fixed to a value, otherwise FALSE.
1771  */
1772 extern
1774  SCIP* scip, /**< SCIP data structure */
1775  const char* name /**< name of the parameter */
1776  );
1777 
1778 /** returns the pointer to the SCIP parameter with the given name
1779  *
1780  * @return pointer to the parameter with the given name
1781  */
1782 extern
1784  SCIP* scip, /**< SCIP data structure */
1785  const char* name /**< name of the parameter */
1786  );
1787 
1788 /** gets the value of an existing SCIP_Bool parameter
1789  *
1790  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1791  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1792  */
1793 extern
1795  SCIP* scip, /**< SCIP data structure */
1796  const char* name, /**< name of the parameter */
1797  SCIP_Bool* value /**< pointer to store the parameter */
1798  );
1799 
1800 /** gets the value of an existing int parameter
1801  *
1802  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1803  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1804  */
1805 extern
1807  SCIP* scip, /**< SCIP data structure */
1808  const char* name, /**< name of the parameter */
1809  int* value /**< pointer to store the parameter */
1810  );
1811 
1812 /** gets the value of an existing SCIP_Longint parameter
1813  *
1814  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1815  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1816  */
1817 extern
1819  SCIP* scip, /**< SCIP data structure */
1820  const char* name, /**< name of the parameter */
1821  SCIP_Longint* value /**< pointer to store the parameter */
1822  );
1823 
1824 /** gets the value of an existing SCIP_Real parameter
1825  *
1826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1828  */
1829 extern
1831  SCIP* scip, /**< SCIP data structure */
1832  const char* name, /**< name of the parameter */
1833  SCIP_Real* value /**< pointer to store the parameter */
1834  );
1835 
1836 /** gets the value of an existing char parameter
1837  *
1838  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1839  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1840  */
1841 extern
1843  SCIP* scip, /**< SCIP data structure */
1844  const char* name, /**< name of the parameter */
1845  char* value /**< pointer to store the parameter */
1846  );
1847 
1848 /** gets the value of an existing string(char*) parameter
1849  *
1850  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1851  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1852  */
1853 extern
1855  SCIP* scip, /**< SCIP data structure */
1856  const char* name, /**< name of the parameter */
1857  char** value /**< pointer to store the parameter */
1858  );
1859 
1860 /** fixes the value of an existing parameter
1861  *
1862  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1863  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1864  *
1865  * @note: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because
1866  * they have to be changed for sub-SCIPs.
1867  */
1868 extern
1870  SCIP* scip, /**< SCIP data structure */
1871  const char* name /**< name of the parameter */
1872  );
1873 
1874 /** unfixes the value of an existing parameter
1875  *
1876  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1877  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1878  */
1879 extern
1881  SCIP* scip, /**< SCIP data structure */
1882  const char* name /**< name of the parameter */
1883  );
1884 
1885 /** changes the value of an existing parameter
1886  *
1887  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1888  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1889  */
1890 extern
1892  SCIP* scip, /**< SCIP data structure */
1893  const char* name, /**< name of the parameter */
1894  void* value /**< new value of the parameter */
1895  );
1896 
1897 /** changes the value of an existing SCIP_Bool parameter
1898  *
1899  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1900  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1901  */
1902 extern
1904  SCIP* scip, /**< SCIP data structure */
1905  SCIP_PARAM* param, /**< parameter */
1906  SCIP_Bool value /**< new value of the parameter */
1907  );
1908 
1909 /** changes the value of an existing SCIP_Bool parameter
1910  *
1911  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1912  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1913  */
1914 extern
1916  SCIP* scip, /**< SCIP data structure */
1917  const char* name, /**< name of the parameter */
1918  SCIP_Bool value /**< new value of the parameter */
1919  );
1920 
1921 /** checks whether the value of an existing SCIP_Bool parameter is valid */
1922 extern
1924  SCIP* scip, /**< SCIP data structure */
1925  SCIP_PARAM* param, /**< parameter */
1926  SCIP_Bool value /**< value to check */
1927  );
1928 
1929 /** changes the value of an existing int parameter
1930  *
1931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1933  */
1934 extern
1936  SCIP* scip, /**< SCIP data structure */
1937  SCIP_PARAM* param, /**< parameter */
1938  int value /**< new value of the parameter */
1939  );
1940 
1941 /** changes the value of an existing int parameter
1942  *
1943  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1944  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1945  */
1946 extern
1948  SCIP* scip, /**< SCIP data structure */
1949  const char* name, /**< name of the parameter */
1950  int value /**< new value of the parameter */
1951  );
1952 
1953 /** checks whether the value of an existing int parameter is valid */
1954 extern
1956  SCIP* scip, /**< SCIP data structure */
1957  SCIP_PARAM* param, /**< parameter */
1958  int value /**< value to check */
1959  );
1960 
1961 /** changes the value of an existing SCIP_Longint parameter
1962  *
1963  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1964  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1965  */
1966 extern
1968  SCIP* scip, /**< SCIP data structure */
1969  SCIP_PARAM* param, /**< parameter */
1970  SCIP_Longint value /**< new value of the parameter */
1971  );
1972 
1973 /** changes the value of an existing SCIP_Longint parameter
1974  *
1975  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1976  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1977  */
1978 extern
1980  SCIP* scip, /**< SCIP data structure */
1981  const char* name, /**< name of the parameter */
1982  SCIP_Longint value /**< new value of the parameter */
1983  );
1984 
1985 /** checks whether parameter value of an existing SCIP_Longint paramter is valid */
1986 extern
1988  SCIP* scip, /**< SCIP data structure */
1989  SCIP_PARAM* param, /**< parameter */
1990  SCIP_Longint value /**< value to check */
1991  );
1992 
1993 /** changes the value of an existing SCIP_Real parameter
1994  *
1995  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1996  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1997  */
1998 extern
2000  SCIP* scip, /**< SCIP data structure */
2001  SCIP_PARAM* param, /**< parameter */
2002  SCIP_Real value /**< new value of the parameter */
2003  );
2004 
2005 /** changes the value of an existing SCIP_Real parameter
2006  *
2007  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2008  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2009  */
2010 extern
2012  SCIP* scip, /**< SCIP data structure */
2013  const char* name, /**< name of the parameter */
2014  SCIP_Real value /**< new value of the parameter */
2015  );
2016 
2017 /** checks whether parameter value of an existing SCIP_Real paramter is valid */
2018 extern
2020  SCIP* scip, /**< SCIP data structure */
2021  SCIP_PARAM* param, /**< parameter */
2022  SCIP_Real value /**< value to check */
2023  );
2024 
2025 /** changes the value of an existing char parameter
2026  *
2027  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2028  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2029  */
2030 extern
2032  SCIP* scip, /**< SCIP data structure */
2033  SCIP_PARAM* param, /**< parameter */
2034  char value /**< new value of the parameter */
2035  );
2036 
2037 /** changes the value of an existing char parameter
2038  *
2039  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2040  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2041  */
2042 extern
2044  SCIP* scip, /**< SCIP data structure */
2045  const char* name, /**< name of the parameter */
2046  char value /**< new value of the parameter */
2047  );
2048 
2049 /** checks whether parameter value for a given SCIP_Real parameter is valid */
2050 extern
2052  SCIP* scip, /**< SCIP data structure */
2053  SCIP_PARAM* param, /**< parameter */
2054  const char value /**< value to check */
2055  );
2056 
2057 /** changes the value of an existing string(char*) parameter
2058  *
2059  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2060  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2061  */
2062 extern
2064  SCIP* scip, /**< SCIP data structure */
2065  SCIP_PARAM* param, /**< parameter */
2066  const char* value /**< new value of the parameter */
2067  );
2068 
2069 /** changes the value of an existing string(char*) parameter
2070  *
2071  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2072  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2073  */
2074 extern
2076  SCIP* scip, /**< SCIP data structure */
2077  const char* name, /**< name of the parameter */
2078  const char* value /**< new value of the parameter */
2079  );
2080 
2081 /** checks whether parameter value for a given string parameter is valid */
2082 extern
2084  SCIP* scip, /**< SCIP data structure */
2085  SCIP_PARAM* param, /**< parameter */
2086  const char* value /**< value to check */
2087  );
2088 
2089 /** reads parameters from a file
2090  *
2091  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2092  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2093  */
2094 extern
2096  SCIP* scip, /**< SCIP data structure */
2097  const char* filename /**< file name */
2098  );
2099 
2100 /** writes a single parameter to a file
2101  *
2102  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2103  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2104  */
2105 extern
2107  SCIP* scip, /**< SCIP data structure */
2108  SCIP_PARAM* param, /**< parameter */
2109  const char* filename, /**< file name, or NULL for stdout */
2110  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
2111  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
2112  * default value?
2113  */
2114  );
2115 
2116 /** writes all parameters in the parameter set to a file
2117  *
2118  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2119  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2120  */
2121 extern
2123  SCIP* scip, /**< SCIP data structure */
2124  const char* filename, /**< file name, or NULL for stdout */
2125  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
2126  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
2127  * default value?
2128  */
2129  );
2130 
2131 /** resets a single parameter to its default value
2132  *
2133  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2134  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2135  */
2136 extern
2138  SCIP* scip, /**< SCIP data structure */
2139  const char* name /**< name of the parameter */
2140  );
2141 
2142 /** resets all parameters to their default values
2143  *
2144  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2145  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2146  */
2147 extern
2149  SCIP* scip /**< SCIP data structure */
2150  );
2151 
2152 /** sets parameters to
2153  *
2154  * - \ref SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
2155  * - \ref SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
2156  * - \ref SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
2157  * - \ref SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
2158  * - \ref SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
2159  * - \ref SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
2160  * - \ref SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
2161  * - \ref SCIP_PARAMEMPHASIS_PHASEFEAS to find feasible solutions during a 3 phase solution process
2162  * - \ref SCIP_PARAMEMPHASIS_PHASEIMPROVE to find improved solutions during a 3 phase solution process
2163  * - \ref SCIP_PARAMEMPHASIS_PHASEPROOF to proof optimality during a 3 phase solution process
2164  *
2165  *
2166  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2167  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2168  */
2169 extern
2171  SCIP* scip, /**< SCIP data structure */
2172  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
2173  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2174  );
2175 
2176 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
2177  * auxiliary SCIP instances to avoid recursion
2178  *
2179  * @note only deactivates plugins which could cause recursion, some plugins which use sub-SCIPs stay activated
2180  *
2181  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2182  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2183  */
2184 extern
2186  SCIP* scip, /**< (auxiliary) SCIP data structure */
2187  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2188  );
2189 
2190 /** sets heuristic parameters values to
2191  *
2192  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
2193  * - SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
2194  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
2195  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
2196  *
2197  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2198  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2199  */
2200 extern
2202  SCIP* scip, /**< SCIP data structure */
2203  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2204  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2205  );
2206 
2207 /** sets presolving parameters to
2208  *
2209  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
2210  * - SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
2211  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
2212  * - SCIP_PARAMSETTING_OFF which turn off all presolving
2213  *
2214  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2215  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2216  */
2217 extern
2219  SCIP* scip, /**< SCIP data structure */
2220  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2221  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2222  );
2223 
2224 /** sets separating parameters to
2225  *
2226  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
2227  * - SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
2228  * - SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
2229  * - SCIP_PARAMSETTING_OFF which turn off all separating
2230  *
2231  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2232  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2233  */
2234 extern
2236  SCIP* scip, /**< SCIP data structure */
2237  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
2238  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
2239  );
2240 
2241 /** returns the array of all available SCIP parameters
2242  *
2243  * @return SCIP_PARAM* array, containing all SCIP parameters.
2244  */
2245 extern
2247  SCIP* scip /**< SCIP data structure */
2248  );
2249 
2250 /** returns the total number of all available SCIP parameters
2251  *
2252  * @return number of all SCIP parameters.
2253  */
2254 extern
2255 int SCIPgetNParams(
2256  SCIP* scip /**< SCIP data structure */
2257  );
2258 
2259 /**@} */
2260 
2261 
2262 /*
2263  * SCIP user functionality methods: managing plugins
2264  */
2265 
2266 /**@addtogroup PublicReaderMethods
2267  *
2268  * @{
2269  */
2270 
2271 /** creates a reader and includes it in SCIP
2272  *
2273  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2274  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2275  *
2276  * @pre This method can be called if SCIP is in one of the following stages:
2277  * - \ref SCIP_STAGE_INIT
2278  * - \ref SCIP_STAGE_PROBLEM
2279  *
2280  * @note method has all reader callbacks as arguments and is thus changed every time a new callback is added
2281  * in future releases; consider using SCIPincludeReaderBasic() and setter functions
2282  * if you seek for a method which is less likely to change in future releases
2283  */
2284 extern
2286  SCIP* scip, /**< SCIP data structure */
2287  const char* name, /**< name of reader */
2288  const char* desc, /**< description of reader */
2289  const char* extension, /**< file extension that reader processes */
2290  SCIP_DECL_READERCOPY ((*readercopy)), /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
2291  SCIP_DECL_READERFREE ((*readerfree)), /**< destructor of reader */
2292  SCIP_DECL_READERREAD ((*readerread)), /**< read method */
2293  SCIP_DECL_READERWRITE ((*readerwrite)), /**< write method */
2294  SCIP_READERDATA* readerdata /**< reader data */
2295  );
2296 
2297 /** creates a reader and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2298  * Optional callbacks can be set via specific setter functions, see
2299  * SCIPsetReaderCopy(), SCIPsetReaderFree(), SCIPsetReaderRead(), SCIPsetReaderWrite().
2300  *
2301  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2302  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2303  *
2304  * @pre This method can be called if SCIP is in one of the following stages:
2305  * - \ref SCIP_STAGE_INIT
2306  * - \ref SCIP_STAGE_PROBLEM
2307  *
2308  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeReader() instead
2309  */
2310 extern
2312  SCIP* scip, /**< SCIP data structure */
2313  SCIP_READER** readerptr, /**< reference to reader pointer, or NULL */
2314  const char* name, /**< name of reader */
2315  const char* desc, /**< description of reader */
2316  const char* extension, /**< file extension that reader processes */
2317  SCIP_READERDATA* readerdata /**< reader data */
2318  );
2319 
2320 /** set copy method of reader
2321  *
2322  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2323  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2324  *
2325  * @pre This method can be called if SCIP is in one of the following stages:
2326  * - \ref SCIP_STAGE_INIT
2327  * - \ref SCIP_STAGE_PROBLEM
2328  */
2329 extern
2331  SCIP* scip, /**< SCIP data structure */
2332  SCIP_READER* reader, /**< reader */
2333  SCIP_DECL_READERCOPY ((*readercopy)) /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
2334  );
2335 
2336 /** set deinitialization method of reader
2337  *
2338  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2339  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2340  *
2341  * @pre This method can be called if SCIP is in one of the following stages:
2342  * - \ref SCIP_STAGE_INIT
2343  * - \ref SCIP_STAGE_PROBLEM
2344  */
2345 extern
2347  SCIP* scip, /**< SCIP data structure */
2348  SCIP_READER* reader, /**< reader */
2349  SCIP_DECL_READERFREE ((*readerfree)) /**< destructor of reader */
2350  );
2351 
2352 /** set read method of reader
2353  *
2354  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2355  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2356  *
2357  * @pre This method can be called if SCIP is in one of the following stages:
2358  * - \ref SCIP_STAGE_INIT
2359  * - \ref SCIP_STAGE_PROBLEM
2360  */
2361 extern
2363  SCIP* scip, /**< SCIP data structure */
2364  SCIP_READER* reader, /**< reader */
2365  SCIP_DECL_READERREAD ((*readerread)) /**< read method of reader */
2366  );
2367 
2368 /** set write method of reader
2369  *
2370  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2371  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2372  *
2373  * @pre This method can be called if SCIP is in one of the following stages:
2374  * - \ref SCIP_STAGE_INIT
2375  * - \ref SCIP_STAGE_PROBLEM
2376  */
2377 extern
2379  SCIP* scip, /**< SCIP data structure */
2380  SCIP_READER* reader, /**< reader */
2381  SCIP_DECL_READERWRITE ((*readerwrite)) /**< write method of reader */
2382  );
2383 
2384 /** returns the reader of the given name, or NULL if not existing */
2385 extern
2387  SCIP* scip, /**< SCIP data structure */
2388  const char* name /**< name of reader */
2389  );
2390 
2391 /** returns the array of currently available readers */
2392 extern
2394  SCIP* scip /**< SCIP data structure */
2395  );
2396 
2397 /** returns the number of currently available readers */
2398 extern
2399 int SCIPgetNReaders(
2400  SCIP* scip /**< SCIP data structure */
2401  );
2402 
2403 /* @} */
2404 
2405 /**@addtogroup PublicPricerMethods
2406  *
2407  * @{
2408  */
2409 
2410 /** creates a variable pricer and includes it in SCIP
2411  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2412  * This should be done during the problem creation stage.
2413  *
2414  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2415  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2416  *
2417  * @pre This method can be called if SCIP is in one of the following stages:
2418  * - \ref SCIP_STAGE_INIT
2419  * - \ref SCIP_STAGE_PROBLEM
2420  *
2421  * @note method has all pricer callbacks as arguments and is thus changed every time a new callback is added
2422  * in future releases; consider using SCIPincludePricerBasic() and setter functions
2423  * if you seek for a method which is less likely to change in future releases
2424  */
2425 extern
2427  SCIP* scip, /**< SCIP data structure */
2428  const char* name, /**< name of variable pricer */
2429  const char* desc, /**< description of variable pricer */
2430  int priority, /**< priority of the variable pricer */
2431  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2432  * problem variables with negative reduced costs are found?
2433  * if this is set to FALSE it may happen that the pricer produces columns
2434  * that already exist in the problem (which are also priced in by the
2435  * default problem variable pricing in the same round) */
2436  SCIP_DECL_PRICERCOPY ((*pricercopy)), /**< copy method of variable pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2437  SCIP_DECL_PRICERFREE ((*pricerfree)), /**< destructor of variable pricer */
2438  SCIP_DECL_PRICERINIT ((*pricerinit)), /**< initialize variable pricer */
2439  SCIP_DECL_PRICEREXIT ((*pricerexit)), /**< deinitialize variable pricer */
2440  SCIP_DECL_PRICERINITSOL((*pricerinitsol)),/**< solving process initialization method of variable pricer */
2441  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)),/**< solving process deinitialization method of variable pricer */
2442  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2443  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2444  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2445  );
2446 
2447 /** creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL;
2448  * if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(),
2449  * SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(),
2450  * SCIPsetPricerFarkas();
2451  *
2452  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2453  * This should be done during the problem creation stage.
2454  *
2455  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2456  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2457  *
2458  * @pre This method can be called if SCIP is in one of the following stages:
2459  * - \ref SCIP_STAGE_INIT
2460  * - \ref SCIP_STAGE_PROBLEM
2461  *
2462  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePricer() instead
2463  */
2464 extern
2466  SCIP* scip, /**< SCIP data structure */
2467  SCIP_PRICER** pricerptr, /**< reference to a pricer, or NULL */
2468  const char* name, /**< name of variable pricer */
2469  const char* desc, /**< description of variable pricer */
2470  int priority, /**< priority of the variable pricer */
2471  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2472  * problem variables with negative reduced costs are found?
2473  * if this is set to FALSE it may happen that the pricer produces columns
2474  * that already exist in the problem (which are also priced in by the
2475  * default problem variable pricing in the same round) */
2476  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2477  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2478  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2479  );
2480 
2481 /** sets copy method of pricer
2482  *
2483  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2484  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2485  *
2486  * @pre This method can be called if SCIP is in one of the following stages:
2487  * - \ref SCIP_STAGE_INIT
2488  * - \ref SCIP_STAGE_PROBLEM
2489  */
2490 extern
2492  SCIP* scip, /**< SCIP data structure */
2493  SCIP_PRICER* pricer, /**< pricer */
2494  SCIP_DECL_PRICERCOPY ((*pricercopy)) /**< copy method of pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2495  );
2496 
2497 /** sets destructor method of pricer
2498  *
2499  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2500  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2501  *
2502  * @pre This method can be called if SCIP is in one of the following stages:
2503  * - \ref SCIP_STAGE_INIT
2504  * - \ref SCIP_STAGE_PROBLEM
2505  */
2506 extern
2508  SCIP* scip, /**< SCIP data structure */
2509  SCIP_PRICER* pricer, /**< pricer */
2510  SCIP_DECL_PRICERFREE ((*pricerfree)) /**< destructor of pricer */
2511  );
2512 
2513 /** sets initialization method of pricer
2514  *
2515  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2516  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2517  *
2518  * @pre This method can be called if SCIP is in one of the following stages:
2519  * - \ref SCIP_STAGE_INIT
2520  * - \ref SCIP_STAGE_PROBLEM
2521  */
2522 extern
2524  SCIP* scip, /**< SCIP data structure */
2525  SCIP_PRICER* pricer, /**< pricer */
2526  SCIP_DECL_PRICERINIT ((*pricerinit)) /**< initialize pricer */
2527  );
2528 
2529 /** sets deinitialization method of pricer
2530  *
2531  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2532  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2533  *
2534  * @pre This method can be called if SCIP is in one of the following stages:
2535  * - \ref SCIP_STAGE_INIT
2536  * - \ref SCIP_STAGE_PROBLEM
2537  */
2538 extern
2540  SCIP* scip, /**< SCIP data structure */
2541  SCIP_PRICER* pricer, /**< pricer */
2542  SCIP_DECL_PRICEREXIT ((*pricerexit)) /**< deinitialize pricer */
2543  );
2544 
2545 /** sets solving process initialization method of pricer
2546  *
2547  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2548  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2549  *
2550  * @pre This method can be called if SCIP is in one of the following stages:
2551  * - \ref SCIP_STAGE_INIT
2552  * - \ref SCIP_STAGE_PROBLEM
2553  */
2554 extern
2556  SCIP* scip, /**< SCIP data structure */
2557  SCIP_PRICER* pricer, /**< pricer */
2558  SCIP_DECL_PRICERINITSOL ((*pricerinitsol))/**< solving process initialization method of pricer */
2559  );
2560 
2561 /** sets solving process deinitialization method of pricer
2562  *
2563  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2564  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2565  *
2566  * @pre This method can be called if SCIP is in one of the following stages:
2567  * - \ref SCIP_STAGE_INIT
2568  * - \ref SCIP_STAGE_PROBLEM
2569  */
2570 extern
2572  SCIP* scip, /**< SCIP data structure */
2573  SCIP_PRICER* pricer, /**< pricer */
2574  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)) /**< solving process deinitialization method of pricer */
2575  );
2576 
2577 /** returns the variable pricer of the given name, or NULL if not existing */
2578 extern
2580  SCIP* scip, /**< SCIP data structure */
2581  const char* name /**< name of variable pricer */
2582  );
2583 
2584 /** returns the array of currently available variable pricers; active pricers are in the first slots of the array */
2585 extern
2587  SCIP* scip /**< SCIP data structure */
2588  );
2589 
2590 /** returns the number of currently available variable pricers */
2591 extern
2592 int SCIPgetNPricers(
2593  SCIP* scip /**< SCIP data structure */
2594  );
2595 
2596 /** returns the number of currently active variable pricers, that are used in the LP solving loop */
2597 extern
2599  SCIP* scip /**< SCIP data structure */
2600  );
2601 
2602 /** sets the priority of a variable pricer */
2603 extern
2605  SCIP* scip, /**< SCIP data structure */
2606  SCIP_PRICER* pricer, /**< variable pricer */
2607  int priority /**< new priority of the variable pricer */
2608  );
2609 
2610 /** activates pricer to be used for the current problem
2611  * This method should be called during the problem creation stage for all pricers that are necessary to solve
2612  * the problem model.
2613  * The pricers are automatically deactivated when the problem is freed.
2614  *
2615  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2616  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2617  *
2618  * @pre This method can be called if SCIP is in one of the following stages:
2619  * - \ref SCIP_STAGE_PROBLEM
2620  */
2621 extern
2623  SCIP* scip, /**< SCIP data structure */
2624  SCIP_PRICER* pricer /**< variable pricer */
2625  );
2626 
2627 /** deactivates pricer
2628  *
2629  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2630  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2631  *
2632  * @pre This method can be called if SCIP is in one of the following stages:
2633  * - \ref SCIP_STAGE_PROBLEM
2634  * - \ref SCIP_STAGE_EXITSOLVE
2635  */
2636 extern
2638  SCIP* scip, /**< SCIP data structure */
2639  SCIP_PRICER* pricer /**< variable pricer */
2640  );
2641 
2642 /* @} */
2643 
2644 /**@addtogroup PublicConshdlrMethods
2645  *
2646  * @{
2647  */
2648 
2649 /** creates a constraint handler and includes it in SCIP.
2650  *
2651  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2652  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2653  *
2654  * @pre This method can be called if SCIP is in one of the following stages:
2655  * - \ref SCIP_STAGE_INIT
2656  * - \ref SCIP_STAGE_PROBLEM
2657  *
2658  * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
2659  * callback is added
2660  * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
2661  * if you seek for a method which is less likely to change in future releases
2662  */
2663 extern
2665  SCIP* scip, /**< SCIP data structure */
2666  const char* name, /**< name of constraint handler */
2667  const char* desc, /**< description of constraint handler */
2668  int sepapriority, /**< priority of the constraint handler for separation */
2669  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2670  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2671  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2672  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2673  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2674  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2675  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2676  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
2677  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2678  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2679  SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
2680  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
2681  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2682  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
2683  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
2684  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
2685  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
2686  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
2687  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
2688  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
2689  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
2690  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
2691  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
2692  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2693  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2694  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2695  SCIP_DECL_CONSENFORELAX ((*consenforelax)), /**< enforcing constraints for relaxation solutions */
2696  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2697  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2698  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2699  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
2700  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
2701  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2702  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
2703  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
2704  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
2705  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
2706  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
2707  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
2708  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
2709  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
2710  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
2711  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
2712  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
2713  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2714  );
2715 
2716 /** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2717  * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
2718  * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
2719  * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
2720  * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
2721  * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
2722  * SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and
2723  * SCIPsetConshdlrGetDiveBdChgs().
2724  *
2725  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2726  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2727  *
2728  * @pre This method can be called if SCIP is in one of the following stages:
2729  * - \ref SCIP_STAGE_INIT
2730  * - \ref SCIP_STAGE_PROBLEM
2731  *
2732  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
2733  */
2734 extern
2736  SCIP* scip, /**< SCIP data structure */
2737  SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
2738  const char* name, /**< name of constraint handler */
2739  const char* desc, /**< description of constraint handler */
2740  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2741  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2742  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2743  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2744  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2745  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2746  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2747  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2748  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2749  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2750  );
2751 
2752 /** sets all separation related callbacks/parameters of the constraint handler
2753  *
2754  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2755  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2756  *
2757  * @pre This method can be called if SCIP is in one of the following stages:
2758  * - \ref SCIP_STAGE_INIT
2759  * - \ref SCIP_STAGE_PROBLEM
2760  */
2761 extern
2763  SCIP* scip, /**< SCIP data structure */
2764  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2765  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2766  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2767  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2768  int sepapriority, /**< priority of the constraint handler for separation */
2769  SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
2770  );
2771 
2772 /** sets both the propagation callback and the propagation frequency of the constraint handler
2773  *
2774  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2775  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2776  *
2777  * @pre This method can be called if SCIP is in one of the following stages:
2778  * - \ref SCIP_STAGE_INIT
2779  * - \ref SCIP_STAGE_PROBLEM
2780  */
2781 extern
2783  SCIP* scip, /**< SCIP data structure */
2784  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2785  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2786  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2787  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2788  SCIP_PROPTIMING proptiming /**< positions in the node solving loop where propagation should be executed */
2789  );
2790 
2791 /** sets relaxation enforcement method of the constraint handler
2792  *
2793  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2794  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2795  *
2796  * @pre This method can be called if SCIP is in one of the following stages:
2797  * - \ref SCIP_STAGE_INIT
2798  * - \ref SCIP_STAGE_PROBLEM
2799  */
2800 extern
2802  SCIP* scip, /**< SCIP data structure */
2803  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2804  SCIP_DECL_CONSENFORELAX ((*consenforelax)) /**< enforcement method for relaxation solution of constraint handler (might be NULL) */
2805  );
2806 
2807 /** sets copy method of both the constraint handler and each associated constraint
2808  *
2809  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2810  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2811  *
2812  * @pre This method can be called if SCIP is in one of the following stages:
2813  * - \ref SCIP_STAGE_INIT
2814  * - \ref SCIP_STAGE_PROBLEM
2815  */
2816 extern
2818  SCIP* scip, /**< SCIP data structure */
2819  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2820  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2821  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
2822  );
2823 
2824 /** sets destructor method of constraint handler
2825  *
2826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2828  *
2829  * @pre This method can be called if SCIP is in one of the following stages:
2830  * - \ref SCIP_STAGE_INIT
2831  * - \ref SCIP_STAGE_PROBLEM
2832  */
2833 extern
2835  SCIP* scip, /**< SCIP data structure */
2836  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2837  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
2838  );
2839 
2840 /** sets initialization method of constraint handler
2841  *
2842  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2843  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2844  *
2845  * @pre This method can be called if SCIP is in one of the following stages:
2846  * - \ref SCIP_STAGE_INIT
2847  * - \ref SCIP_STAGE_PROBLEM
2848  */
2849 extern
2851  SCIP* scip, /**< SCIP data structure */
2852  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2853  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
2854  );
2855 
2856 /** sets deinitialization method of constraint handler
2857  *
2858  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2859  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2860  *
2861  * @pre This method can be called if SCIP is in one of the following stages:
2862  * - \ref SCIP_STAGE_INIT
2863  * - \ref SCIP_STAGE_PROBLEM
2864  */
2865 extern
2867  SCIP* scip, /**< SCIP data structure */
2868  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2869  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
2870  );
2871 
2872 /** sets solving process initialization method of constraint handler
2873  *
2874  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2875  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2876  *
2877  * @pre This method can be called if SCIP is in one of the following stages:
2878  * - \ref SCIP_STAGE_INIT
2879  * - \ref SCIP_STAGE_PROBLEM
2880  */
2881 extern
2883  SCIP* scip, /**< SCIP data structure */
2884  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2885  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
2886  );
2887 
2888 /** sets solving process deinitialization method of constraint handler
2889  *
2890  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2891  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2892  *
2893  * @pre This method can be called if SCIP is in one of the following stages:
2894  * - \ref SCIP_STAGE_INIT
2895  * - \ref SCIP_STAGE_PROBLEM
2896  */
2897 extern
2899  SCIP* scip, /**< SCIP data structure */
2900  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2901  SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
2902  );
2903 
2904 /** sets preprocessing initialization method of constraint handler
2905  *
2906  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2907  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2908  *
2909  * @pre This method can be called if SCIP is in one of the following stages:
2910  * - \ref SCIP_STAGE_INIT
2911  * - \ref SCIP_STAGE_PROBLEM
2912  */
2913 extern
2915  SCIP* scip, /**< SCIP data structure */
2916  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2917  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
2918  );
2919 
2920 /** sets preprocessing deinitialization method of constraint handler
2921  *
2922  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2923  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2924  *
2925  * @pre This method can be called if SCIP is in one of the following stages:
2926  * - \ref SCIP_STAGE_INIT
2927  * - \ref SCIP_STAGE_PROBLEM
2928  */
2929 extern
2931  SCIP* scip, /**< SCIP data structure */
2932  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2933  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
2934  );
2935 
2936 /** sets presolving method of constraint handler
2937  *
2938  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2939  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2940  *
2941  * @pre This method can be called if SCIP is in one of the following stages:
2942  * - \ref SCIP_STAGE_INIT
2943  * - \ref SCIP_STAGE_PROBLEM
2944  */
2945 extern
2947  SCIP* scip, /**< SCIP data structure */
2948  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2949  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
2950  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2951  SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
2952  );
2953 
2954 /** sets method of constraint handler to free specific constraint data
2955  *
2956  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2957  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2958  *
2959  * @pre This method can be called if SCIP is in one of the following stages:
2960  * - \ref SCIP_STAGE_INIT
2961  * - \ref SCIP_STAGE_PROBLEM
2962  */
2963 extern
2965  SCIP* scip, /**< SCIP data structure */
2966  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2967  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
2968  );
2969 
2970 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
2971  *
2972  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2973  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2974  *
2975  * @pre This method can be called if SCIP is in one of the following stages:
2976  * - \ref SCIP_STAGE_INIT
2977  * - \ref SCIP_STAGE_PROBLEM
2978  */
2979 extern
2981  SCIP* scip, /**< SCIP data structure */
2982  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2983  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
2984  );
2985 
2986 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
2987  *
2988  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2989  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2990  *
2991  * @pre This method can be called if SCIP is in one of the following stages:
2992  * - \ref SCIP_STAGE_INIT
2993  * - \ref SCIP_STAGE_PROBLEM
2994  */
2995 extern
2997  SCIP* scip, /**< SCIP data structure */
2998  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2999  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
3000  );
3001 
3002 /** sets propagation conflict resolving method of constraint handler
3003  *
3004  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3005  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3006  *
3007  * @pre This method can be called if SCIP is in one of the following stages:
3008  * - \ref SCIP_STAGE_INIT
3009  * - \ref SCIP_STAGE_PROBLEM
3010  */
3011 extern
3013  SCIP* scip, /**< SCIP data structure */
3014  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3015  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
3016  );
3017 
3018 /** sets activation notification method of constraint handler
3019  *
3020  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3021  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3022  *
3023  * @pre This method can be called if SCIP is in one of the following stages:
3024  * - \ref SCIP_STAGE_INIT
3025  * - \ref SCIP_STAGE_PROBLEM
3026  */
3027 extern
3029  SCIP* scip, /**< SCIP data structure */
3030  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3031  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
3032  );
3033 
3034 /** sets deactivation notification method of constraint handler
3035  *
3036  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3037  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3038  *
3039  * @pre This method can be called if SCIP is in one of the following stages:
3040  * - \ref SCIP_STAGE_INIT
3041  * - \ref SCIP_STAGE_PROBLEM
3042  */
3043 extern
3045  SCIP* scip, /**< SCIP data structure */
3046  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3047  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
3048  );
3049 
3050 /** sets enabling notification method of constraint handler
3051  *
3052  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3053  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3054  *
3055  * @pre This method can be called if SCIP is in one of the following stages:
3056  * - \ref SCIP_STAGE_INIT
3057  * - \ref SCIP_STAGE_PROBLEM
3058  */
3059 extern
3061  SCIP* scip, /**< SCIP data structure */
3062  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3063  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
3064  );
3065 
3066 /** sets disabling notification method of constraint handler
3067  *
3068  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3069  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3070  *
3071  * @pre This method can be called if SCIP is in one of the following stages:
3072  * - \ref SCIP_STAGE_INIT
3073  * - \ref SCIP_STAGE_PROBLEM
3074  */
3075 extern
3077  SCIP* scip, /**< SCIP data structure */
3078  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3079  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
3080  );
3081 
3082 /** sets variable deletion method of constraint handler
3083  *
3084  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3085  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3086  *
3087  * @pre This method can be called if SCIP is in one of the following stages:
3088  * - \ref SCIP_STAGE_INIT
3089  * - \ref SCIP_STAGE_PROBLEM
3090  */
3091 extern
3093  SCIP* scip, /**< SCIP data structure */
3094  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3095  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
3096  );
3097 
3098 /** sets constraint display method of constraint handler
3099  *
3100  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3101  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3102  *
3103  * @pre This method can be called if SCIP is in one of the following stages:
3104  * - \ref SCIP_STAGE_INIT
3105  * - \ref SCIP_STAGE_PROBLEM
3106  */
3107 extern
3109  SCIP* scip, /**< SCIP data structure */
3110  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3111  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
3112  );
3113 
3114 /** sets constraint parsing method of constraint handler
3115  *
3116  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3117  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3118  *
3119  * @pre This method can be called if SCIP is in one of the following stages:
3120  * - \ref SCIP_STAGE_INIT
3121  * - \ref SCIP_STAGE_PROBLEM
3122  */
3123 extern
3125  SCIP* scip, /**< SCIP data structure */
3126  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3127  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
3128  );
3129 
3130 /** sets constraint variable getter method of constraint handler
3131  *
3132  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3133  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3134  *
3135  * @pre This method can be called if SCIP is in one of the following stages:
3136  * - \ref SCIP_STAGE_INIT
3137  * - \ref SCIP_STAGE_PROBLEM
3138  */
3139 extern
3141  SCIP* scip, /**< SCIP data structure */
3142  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3143  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
3144  );
3145 
3146 /** sets constraint variable number getter method of constraint handler
3147  *
3148  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3149  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3150  *
3151  * @pre This method can be called if SCIP is in one of the following stages:
3152  * - \ref SCIP_STAGE_INIT
3153  * - \ref SCIP_STAGE_PROBLEM
3154  */
3155 extern
3157  SCIP* scip, /**< SCIP data structure */
3158  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3159  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
3160  );
3161 
3162 /** sets diving enforcement method of constraint handler
3163  *
3164  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3165  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3166  *
3167  * @pre This method can be called if SCIP is in one of the following stages:
3168  * - \ref SCIP_STAGE_INIT
3169  * - \ref SCIP_STAGE_PROBLEM
3170  */
3171 extern
3173  SCIP* scip, /**< SCIP data structure */
3174  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
3175  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
3176  );
3177 
3178 /** returns the constraint handler of the given name, or NULL if not existing */
3179 extern
3181  SCIP* scip, /**< SCIP data structure */
3182  const char* name /**< name of constraint handler */
3183  );
3184 
3185 /** returns the array of currently available constraint handlers */
3186 extern
3188  SCIP* scip /**< SCIP data structure */
3189  );
3190 
3191 /** returns the number of currently available constraint handlers */
3192 extern
3193 int SCIPgetNConshdlrs(
3194  SCIP* scip /**< SCIP data structure */
3195  );
3196 
3197 /* @} */
3198 
3199 /**@addtogroup PublicConflictMethods
3200  *
3201  * @{
3202  */
3203 
3204 /** creates a conflict handler and includes it in SCIP
3205  *
3206  * @note method has all conflict handler callbacks as arguments and is thus changed every time a new
3207  * callback is added
3208  * in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions
3209  * if you seek for a method which is less likely to change in future releases
3210  */
3211 extern
3213  SCIP* scip, /**< SCIP data structure */
3214  const char* name, /**< name of conflict handler */
3215  const char* desc, /**< description of conflict handler */
3216  int priority, /**< priority of the conflict handler */
3217  SCIP_DECL_CONFLICTCOPY((*conflictcopy)), /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3218  SCIP_DECL_CONFLICTFREE((*conflictfree)), /**< destructor of conflict handler */
3219  SCIP_DECL_CONFLICTINIT((*conflictinit)), /**< initialize conflict handler */
3220  SCIP_DECL_CONFLICTEXIT((*conflictexit)), /**< deinitialize conflict handler */
3221  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
3222  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
3223  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
3224  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
3225  );
3226 
3227 /** creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3228  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3229  * Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(),
3230  * SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(),
3231  * and SCIPsetConflicthdlrExitsol()
3232  *
3233  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead
3234  */
3235 extern
3237  SCIP* scip, /**< SCIP data structure */
3238  SCIP_CONFLICTHDLR** conflicthdlrptr, /**< reference to a conflict handler pointer, or NULL */
3239  const char* name, /**< name of conflict handler */
3240  const char* desc, /**< description of conflict handler */
3241  int priority, /**< priority of the conflict handler */
3242  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
3243  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
3244  );
3245 
3246 /** set copy method of conflict handler */
3247 extern
3249  SCIP* scip, /**< SCIP data structure */
3250  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3251  SCIP_DECL_CONFLICTCOPY((*conflictcopy)) /**< copy method of conflict handler */
3252  );
3253 
3254 /** set destructor of conflict handler */
3255 extern
3257  SCIP* scip, /**< SCIP data structure */
3258  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3259  SCIP_DECL_CONFLICTFREE((*conflictfree)) /**< destructor of conflict handler */
3260  );
3261 
3262 /** set initialization method of conflict handler */
3263 extern
3265  SCIP* scip, /**< SCIP data structure */
3266  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3267  SCIP_DECL_CONFLICTINIT((*conflictinit)) /**< initialize conflict handler */
3268  );
3269 
3270 /** set deinitialization method of conflict handler */
3271 extern
3273  SCIP* scip, /**< SCIP data structure */
3274  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3275  SCIP_DECL_CONFLICTEXIT((*conflictexit)) /**< deinitialize conflict handler */
3276  );
3277 
3278 /** set solving process initialization method of conflict handler */
3279 extern
3281  SCIP* scip, /**< SCIP data structure */
3282  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3283  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
3284  );
3285 
3286 /** set solving process deinitialization method of conflict handler */
3287 extern
3289  SCIP* scip, /**< SCIP data structure */
3290  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3291  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
3292  );
3293 
3294 /** returns the conflict handler of the given name, or NULL if not existing */
3295 extern
3297  SCIP* scip, /**< SCIP data structure */
3298  const char* name /**< name of conflict handler */
3299  );
3300 
3301 /** returns the array of currently available conflict handlers */
3302 extern
3304  SCIP* scip /**< SCIP data structure */
3305  );
3306 
3307 /** returns the number of currently available conflict handlers */
3308 extern
3310  SCIP* scip /**< SCIP data structure */
3311  );
3312 
3313 /** sets the priority of a conflict handler */
3314 extern
3316  SCIP* scip, /**< SCIP data structure */
3317  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
3318  int priority /**< new priority of the conflict handler */
3319  );
3320 
3321 /* @} */
3322 
3323 /**@addtogroup PublicPresolverMethods
3324  *
3325  * @{
3326  */
3327 
3328 /** creates a presolver and includes it in SCIP
3329  *
3330  * @note method has all presolver callbacks as arguments and is thus changed every time a new
3331  * callback is added
3332  * in future releases; consider using SCIPincludePresolBasic() and setter functions
3333  * if you seek for a method which is less likely to change in future releases
3334  */
3335 extern
3337  SCIP* scip, /**< SCIP data structure */
3338  const char* name, /**< name of presolver */
3339  const char* desc, /**< description of presolver */
3340  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
3341  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
3342  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
3343  SCIP_DECL_PRESOLCOPY ((*presolcopy)), /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
3344  SCIP_DECL_PRESOLFREE ((*presolfree)), /**< destructor of presolver to free user data (called when SCIP is exiting) */
3345  SCIP_DECL_PRESOLINIT ((*presolinit)), /**< initialization method of presolver (called after problem was transformed) */
3346  SCIP_DECL_PRESOLEXIT ((*presolexit)), /**< deinitialization method of presolver (called before transformed problem is freed) */
3347  SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
3348  SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
3349  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
3350  SCIP_PRESOLDATA* presoldata /**< presolver data */
3351  );
3352 
3353 /** Creates a presolver and includes it in SCIP with its fundamental callback. All non-fundamental (or optional)
3354  * callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter
3355  * functions. These are SCIPsetPresolCopy(), SCIPsetPresolFree(), SCIPsetPresolInit(), SCIPsetPresolExit(),
3356  * SCIPsetPresolInitpre(), and SCIPsetPresolExitPre().
3357  *
3358  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePresol() instead
3359  */
3360 extern
3362  SCIP* scip, /**< SCIP data structure */
3363  SCIP_PRESOL** presolptr, /**< reference to presolver, or NULL */
3364  const char* name, /**< name of presolver */
3365  const char* desc, /**< description of presolver */
3366  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
3367  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
3368  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
3369  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
3370  SCIP_PRESOLDATA* presoldata /**< presolver data */
3371  );
3372 
3373 /** sets copy method of presolver */
3374 extern
3376  SCIP* scip, /**< SCIP data structure */
3377  SCIP_PRESOL* presol, /**< presolver */
3378  SCIP_DECL_PRESOLCOPY ((*presolcopy)) /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
3379  );
3380 
3381 /** sets destructor method of presolver */
3382 extern
3384  SCIP* scip, /**< SCIP data structure */
3385  SCIP_PRESOL* presol, /**< presolver */
3386  SCIP_DECL_PRESOLFREE ((*presolfree)) /**< destructor of presolver */
3387  );
3388 
3389 /** sets initialization method of presolver */
3390 extern
3392  SCIP* scip, /**< SCIP data structure */
3393  SCIP_PRESOL* presol, /**< presolver */
3394  SCIP_DECL_PRESOLINIT ((*presolinit)) /**< initialize presolver */
3395  );
3396 
3397 /** sets deinitialization method of presolver */
3398 extern
3400  SCIP* scip, /**< SCIP data structure */
3401  SCIP_PRESOL* presol, /**< presolver */
3402  SCIP_DECL_PRESOLEXIT ((*presolexit)) /**< deinitialize presolver */
3403  );
3404 
3405 /** sets solving process initialization method of presolver */
3406 extern
3408  SCIP* scip, /**< SCIP data structure */
3409  SCIP_PRESOL* presol, /**< presolver */
3410  SCIP_DECL_PRESOLINITPRE ((*presolinitpre))/**< solving process initialization method of presolver */
3411  );
3412 
3413 /** sets solving process deinitialization method of presolver */
3415  SCIP* scip, /**< SCIP data structure */
3416  SCIP_PRESOL* presol, /**< presolver */
3417  SCIP_DECL_PRESOLEXITPRE ((*presolexitpre))/**< solving process deinitialization method of presolver */
3418  );
3419 
3420 /** returns the presolver of the given name, or NULL if not existing */
3421 extern
3423  SCIP* scip, /**< SCIP data structure */
3424  const char* name /**< name of presolver */
3425  );
3426 
3427 /** returns the array of currently available presolvers */
3428 extern
3430  SCIP* scip /**< SCIP data structure */
3431  );
3432 
3433 /** returns the number of currently available presolvers */
3434 extern
3435 int SCIPgetNPresols(
3436  SCIP* scip /**< SCIP data structure */
3437  );
3438 
3439 /** sets the priority of a presolver */
3440 extern
3442  SCIP* scip, /**< SCIP data structure */
3443  SCIP_PRESOL* presol, /**< presolver */
3444  int priority /**< new priority of the presolver */
3445  );
3446 
3447 /* @} */
3448 
3449 /**@addtogroup PublicRelaxatorMethods
3450  *
3451  * @{
3452  */
3453 
3454 /** creates a relaxation handler and includes it in SCIP
3455  *
3456  * @note method has all relaxation handler callbacks as arguments and is thus changed every time a new
3457  * callback is added
3458  * in future releases; consider using SCIPincludeRelaxBasic() and setter functions
3459  * if you seek for a method which is less likely to change in future releases
3460  */
3461 extern
3463  SCIP* scip, /**< SCIP data structure */
3464  const char* name, /**< name of relaxation handler */
3465  const char* desc, /**< description of relaxation handler */
3466  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3467  int freq, /**< frequency for calling relaxation handler */
3468  SCIP_Bool includeslp, /**< Does the relaxator contain all cuts in the LP? */
3469  SCIP_DECL_RELAXCOPY ((*relaxcopy)), /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3470  SCIP_DECL_RELAXFREE ((*relaxfree)), /**< destructor of relaxation handler */
3471  SCIP_DECL_RELAXINIT ((*relaxinit)), /**< initialize relaxation handler */
3472  SCIP_DECL_RELAXEXIT ((*relaxexit)), /**< deinitialize relaxation handler */
3473  SCIP_DECL_RELAXINITSOL((*relaxinitsol)), /**< solving process initialization method of relaxation handler */
3474  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), /**< solving process deinitialization method of relaxation handler */
3475  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3476  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3477  );
3478 
3479 /** creates a relaxation handler and includes it in SCIP. All non fundamental
3480  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3481  * Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(),
3482  * SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()
3483  *
3484  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeRelax() instead
3485  */
3486 extern
3488  SCIP* scip, /**< SCIP data structure */
3489  SCIP_RELAX** relaxptr, /**< reference to relaxation pointer, or NULL */
3490  const char* name, /**< name of relaxation handler */
3491  const char* desc, /**< description of relaxation handler */
3492  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3493  int freq, /**< frequency for calling relaxation handler */
3494  SCIP_Bool includeslp, /**< Does the relaxator contain all cuts in the LP? */
3495  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3496  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3497  );
3498 
3499 /** sets copy method of relaxation handler */
3500 extern
3502  SCIP* scip, /**< SCIP data structure */
3503  SCIP_RELAX* relax, /**< relaxation handler */
3504  SCIP_DECL_RELAXCOPY ((*relaxcopy)) /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3505  );
3506 
3507 /** sets destructor method of relaxation handler */
3508 extern
3510  SCIP* scip, /**< SCIP data structure */
3511  SCIP_RELAX* relax, /**< relaxation handler */
3512  SCIP_DECL_RELAXFREE ((*relaxfree)) /**< destructor of relaxation handler */
3513  );
3514 
3515 /** sets initialization method of relaxation handler */
3516 extern
3518  SCIP* scip, /**< SCIP data structure */
3519  SCIP_RELAX* relax, /**< relaxation handler */
3520  SCIP_DECL_RELAXINIT ((*relaxinit)) /**< initialize relaxation handler */
3521  );
3522 
3523 /** sets deinitialization method of relaxation handler */
3524 extern
3526  SCIP* scip, /**< SCIP data structure */
3527  SCIP_RELAX* relax, /**< relaxation handler */
3528  SCIP_DECL_RELAXEXIT ((*relaxexit)) /**< deinitialize relaxation handler */
3529  );
3530 
3531 /** sets solving process initialization method of relaxation handler */
3532 extern
3534  SCIP* scip, /**< SCIP data structure */
3535  SCIP_RELAX* relax, /**< relaxation handler */
3536  SCIP_DECL_RELAXINITSOL((*relaxinitsol)) /**< solving process initialization method of relaxation handler */
3537  );
3538 
3539 /** sets solving process deinitialization method of relaxation handler */
3540 extern
3542  SCIP* scip, /**< SCIP data structure */
3543  SCIP_RELAX* relax, /**< relaxation handler */
3544  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)) /**< solving process deinitialization method of relaxation handler */
3545  );
3546 
3547 /** returns the relaxation handler of the given name, or NULL if not existing */
3548 extern
3550  SCIP* scip, /**< SCIP data structure */
3551  const char* name /**< name of relaxation handler */
3552  );
3553 
3554 /** returns the array of currently available relaxation handlers */
3555 extern
3557  SCIP* scip /**< SCIP data structure */
3558  );
3559 
3560 /** returns the number of currently available relaxation handlers */
3561 extern
3562 int SCIPgetNRelaxs(
3563  SCIP* scip /**< SCIP data structure */
3564  );
3565 
3566 /** sets the priority of a relaxation handler*/
3567 extern
3569  SCIP* scip, /**< SCIP data structure */
3570  SCIP_RELAX* relax, /**< relaxation handler */
3571  int priority /**< new priority of the relaxation handler */
3572  );
3573 
3574 /* @} */
3575 
3576 /**@addtogroup PublicSeparatorMethods
3577  *
3578  * @{
3579  */
3580 
3581 /** creates a separator and includes it in SCIP.
3582  *
3583  * @note method has all separator callbacks as arguments and is thus changed every time a new
3584  * callback is added
3585  * in future releases; consider using SCIPincludeSepaBasic() and setter functions
3586  * if you seek for a method which is less likely to change in future releases
3587  */
3588 extern
3590  SCIP* scip, /**< SCIP data structure */
3591  const char* name, /**< name of separator */
3592  const char* desc, /**< description of separator */
3593  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3594  int freq, /**< frequency for calling separator */
3595  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3596  * to best node's dual bound for applying separation */
3597  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3598  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3599  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3600  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
3601  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
3602  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
3603  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
3604  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
3605  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3606  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3607  SCIP_SEPADATA* sepadata /**< separator data */
3608  );
3609 
3610 /** creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3611  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3612  * Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(),
3613  * SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().
3614  *
3615  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeSepa() instead
3616  */
3617 extern
3619  SCIP* scip, /**< SCIP data structure */
3620  SCIP_SEPA** sepa, /**< reference to a separator, or NULL */
3621  const char* name, /**< name of separator */
3622  const char* desc, /**< description of separator */
3623  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3624  int freq, /**< frequency for calling separator */
3625  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3626  * to best node's dual bound for applying separation */
3627  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3628  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3629  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3630  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3631  SCIP_SEPADATA* sepadata /**< separator data */
3632  );
3633 
3634 /** sets copy method of separator */
3635 extern
3637  SCIP* scip, /**< SCIP data structure */
3638  SCIP_SEPA* sepa, /**< separator */
3639  SCIP_DECL_SEPACOPY ((*sepacopy)) /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3640  );
3641 
3642 /** sets destructor method of separator */
3643 extern
3645  SCIP* scip, /**< SCIP data structure */
3646  SCIP_SEPA* sepa, /**< separator */
3647  SCIP_DECL_SEPAFREE ((*sepafree)) /**< destructor of separator */
3648  );
3649 
3650 /** sets initialization method of separator */
3651 extern
3653  SCIP* scip, /**< SCIP data structure */
3654  SCIP_SEPA* sepa, /**< separator */
3655  SCIP_DECL_SEPAINIT ((*sepainit)) /**< initialize separator */
3656  );
3657 
3658 /** sets deinitialization method of separator */
3659 extern
3661  SCIP* scip, /**< SCIP data structure */
3662  SCIP_SEPA* sepa, /**< separator */
3663  SCIP_DECL_SEPAEXIT ((*sepaexit)) /**< deinitialize separator */
3664  );
3665 
3666 /** sets solving process initialization method of separator */
3667 extern
3669  SCIP* scip, /**< SCIP data structure */
3670  SCIP_SEPA* sepa, /**< separator */
3671  SCIP_DECL_SEPAINITSOL ((*sepainitsol)) /**< solving process initialization method of separator */
3672  );
3673 
3674 /** sets solving process deinitialization method of separator */
3675 extern
3677  SCIP* scip, /**< SCIP data structure */
3678  SCIP_SEPA* sepa, /**< separator */
3679  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)) /**< solving process deinitialization method of separator */
3680  );
3681 
3682 /** returns the separator of the given name, or NULL if not existing */
3683 extern
3685  SCIP* scip, /**< SCIP data structure */
3686  const char* name /**< name of separator */
3687  );
3688 
3689 /** returns the array of currently available separators */
3690 extern
3692  SCIP* scip /**< SCIP data structure */
3693  );
3694 
3695 /** returns the number of currently available separators */
3696 extern
3697 int SCIPgetNSepas(
3698  SCIP* scip /**< SCIP data structure */
3699  );
3700 
3701 /** sets the priority of a separator */
3702 extern
3704  SCIP* scip, /**< SCIP data structure */
3705  SCIP_SEPA* sepa, /**< separator */
3706  int priority /**< new priority of the separator */
3707  );
3708 
3709 /* @} */
3710 
3711 /**@addtogroup PublicPropagatorMethods
3712  *
3713  * @{
3714  */
3715 
3716 /** creates a propagator and includes it in SCIP.
3717  *
3718 
3719  * @note method has all propagator callbacks as arguments and is thus changed every time a new
3720  * callback is added in future releases; consider using SCIPincludePropBasic() and setter functions
3721  * if you seek for a method which is less likely to change in future releases
3722  */
3723 extern
3725  SCIP* scip, /**< SCIP data structure */
3726  const char* name, /**< name of propagator */
3727  const char* desc, /**< description of propagator */
3728  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3729  int freq, /**< frequency for calling propagator */
3730  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3731  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagator should be executed */
3732  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3733  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3734  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the propagator's presolving method */
3735  SCIP_DECL_PROPCOPY ((*propcopy)), /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3736  SCIP_DECL_PROPFREE ((*propfree)), /**< destructor of propagator */
3737  SCIP_DECL_PROPINIT ((*propinit)), /**< initialize propagator */
3738  SCIP_DECL_PROPEXIT ((*propexit)), /**< deinitialize propagator */
3739  SCIP_DECL_PROPINITPRE ((*propinitpre)), /**< presolving initialization method of propagator */
3740  SCIP_DECL_PROPEXITPRE ((*propexitpre)), /**< presolving deinitialization method of propagator */
3741  SCIP_DECL_PROPINITSOL ((*propinitsol)), /**< solving process initialization method of propagator */
3742  SCIP_DECL_PROPEXITSOL ((*propexitsol)), /**< solving process deinitialization method of propagator */
3743  SCIP_DECL_PROPPRESOL ((*proppresol)), /**< presolving method */
3744  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3745  SCIP_DECL_PROPRESPROP ((*propresprop)), /**< propagation conflict resolving method */
3746  SCIP_PROPDATA* propdata /**< propagator data */
3747  );
3748 
3749 /** creates a propagator and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
3750  * Optional callbacks can be set via specific setter functions, see SCIPsetPropInit(), SCIPsetPropExit(),
3751  * SCIPsetPropCopy(), SCIPsetPropFree(), SCIPsetPropInitsol(), SCIPsetPropExitsol(),
3752  * SCIPsetPropInitpre(), SCIPsetPropExitpre(), SCIPsetPropPresol(), and SCIPsetPropResprop().
3753  *
3754  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeProp() instead
3755  */
3756 extern
3758  SCIP* scip, /**< SCIP data structure */
3759  SCIP_PROP** propptr, /**< reference to a propagator pointer, or NULL */
3760  const char* name, /**< name of propagator */
3761  const char* desc, /**< description of propagator */
3762  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3763  int freq, /**< frequency for calling propagator */
3764  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3765  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagators should be executed */
3766  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3767  SCIP_PROPDATA* propdata /**< propagator data */
3768  );
3769 
3770 /** sets copy method of propagator */
3771 extern
3773  SCIP* scip, /**< SCIP data structure */
3774  SCIP_PROP* prop, /**< propagator */
3775  SCIP_DECL_PROPCOPY ((*propcopy)) /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3776  );
3777 
3778 /** sets destructor method of propagator */
3779 extern
3781  SCIP* scip, /**< SCIP data structure */
3782  SCIP_PROP* prop, /**< propagator */
3783  SCIP_DECL_PROPFREE ((*propfree)) /**< destructor of propagator */
3784  );
3785 
3786 /** sets initialization method of propagator */
3787 extern
3789  SCIP* scip, /**< SCIP data structure */
3790  SCIP_PROP* prop, /**< propagator */
3791  SCIP_DECL_PROPINIT ((*propinit)) /**< initialize propagator */
3792  );
3793 
3794 /** sets deinitialization method of propagator */
3795 extern
3797  SCIP* scip, /**< SCIP data structure */
3798  SCIP_PROP* prop, /**< propagator */
3799  SCIP_DECL_PROPEXIT ((*propexit)) /**< deinitialize propagator */
3800  );
3801 
3802 /** sets solving process initialization method of propagator */
3803 extern
3805  SCIP* scip, /**< SCIP data structure */
3806  SCIP_PROP* prop, /**< propagator */
3807  SCIP_DECL_PROPINITSOL((*propinitsol)) /**< solving process initialization method of propagator */
3808  );
3809 
3810 /** sets solving process deinitialization method of propagator */
3811 extern
3813  SCIP* scip, /**< SCIP data structure */
3814  SCIP_PROP* prop, /**< propagator */
3815  SCIP_DECL_PROPEXITSOL ((*propexitsol)) /**< solving process deinitialization method of propagator */
3816  );
3817 
3818 /** sets preprocessing initialization method of propagator */
3819 extern
3821  SCIP* scip, /**< SCIP data structure */
3822  SCIP_PROP* prop, /**< propagator */
3823  SCIP_DECL_PROPINITPRE((*propinitpre)) /**< preprocessing initialization method of propagator */
3824  );
3825 
3826 /** sets preprocessing deinitialization method of propagator */
3827 extern
3829  SCIP* scip, /**< SCIP data structure */
3830  SCIP_PROP* prop, /**< propagator */
3831  SCIP_DECL_PROPEXITPRE((*propexitpre)) /**< preprocessing deinitialization method of propagator */
3832  );
3833 
3834 /** sets presolving method of propagator */
3835 extern
3837  SCIP* scip, /**< SCIP data structure */
3838  SCIP_PROP* prop, /**< propagator */
3839  SCIP_DECL_PROPPRESOL((*proppresol)), /**< presolving method of propagator */
3840  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3841  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3842  SCIP_PRESOLTIMING presoltiming /**< timing mask of the propagator's presolving method */
3843  );
3844 
3845 /** sets propagation conflict resolving callback of propagator */
3846 extern
3848  SCIP* scip, /**< SCIP data structure */
3849  SCIP_PROP* prop, /**< propagator */
3850  SCIP_DECL_PROPRESPROP ((*propresprop)) /**< propagation conflict resolving callback */
3851  );
3852 
3853 /** returns the propagator of the given name, or NULL if not existing */
3854 extern
3856  SCIP* scip, /**< SCIP data structure */
3857  const char* name /**< name of propagator */
3858  );
3859 
3860 /** returns the array of currently available propagators */
3861 extern
3863  SCIP* scip /**< SCIP data structure */
3864  );
3865 
3866 /** returns the number of currently available propagators */
3867 extern
3868 int SCIPgetNProps(
3869  SCIP* scip /**< SCIP data structure */
3870  );
3871 
3872 /** sets the priority of a propagator */
3873 extern
3875  SCIP* scip, /**< SCIP data structure */
3876  SCIP_PROP* prop, /**< propagator */
3877  int priority /**< new priority of the propagator */
3878  );
3879 
3880 /** sets the presolving priority of a propagator */
3881 extern
3883  SCIP* scip, /**< SCIP data structure */
3884  SCIP_PROP* prop, /**< propagator */
3885  int presolpriority /**< new presol priority of the propagator */
3886  );
3887 
3888 /* @} */
3889 
3890 /**@addtogroup PublicConcsolverTypeMethods
3891  *
3892  * @{
3893  */
3894 
3895 /** creates a concurrent solver type and includes it in SCIP.
3896  *
3897  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3898  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3899  *
3900  * @pre This method can be called if @p scip is in one of the following stages:
3901  * - \ref SCIP_STAGE_INIT
3902  * - \ref SCIP_STAGE_PROBLEM
3903  */
3904 extern
3906  SCIP* scip, /**< SCIP data structure */
3907  const char* name, /**< name of concurrent_solver */
3908  SCIP_Real prefpriodefault, /**< the default preferred priority of this concurrent solver type */
3909  SCIP_DECL_CONCSOLVERCREATEINST ((*concsolvercreateinst)), /**< data copy method of concurrent solver */
3910  SCIP_DECL_CONCSOLVERDESTROYINST ((*concsolverdestroyinst)), /**< data copy method of concurrent solver */
3911  SCIP_DECL_CONCSOLVERINITSEEDS ((*concsolverinitseeds)), /**< initialize random seeds of concurrent solver */
3912  SCIP_DECL_CONCSOLVEREXEC ((*concsolverexec)), /**< execution method of concurrent solver */
3913  SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA ((*concsolvercopysolvdata)),/**< method to copy solving data */
3914  SCIP_DECL_CONCSOLVERSTOP ((*concsolverstop)), /**< terminate solving in concurrent solver */
3915  SCIP_DECL_CONCSOLVERSYNCWRITE ((*concsolversyncwrite)), /**< synchronization method of concurrent solver */
3916  SCIP_DECL_CONCSOLVERSYNCREAD ((*concsolversyncread)), /**< synchronization method of concurrent solver */
3917  SCIP_DECL_CONCSOLVERTYPEFREEDATA ((*concsolvertypefreedata)),/**< method to free data of concurrent solver type */
3918  SCIP_CONCSOLVERTYPEDATA* data /**< the concurent solver type's data */
3919  );
3920 
3921 /** returns the concurrent solver type with the given name, or NULL if not existing */
3922 extern
3924  SCIP* scip, /**< SCIP data structure */
3925  const char* name /**< name of concurrent_solver */
3926  );
3927 
3928 /** returns the array of included concurrent solver types */
3929 extern
3931  SCIP* scip /**< SCIP data structure */
3932  );
3933 
3934 /** returns the number of included concurrent solver types */
3935 extern
3937  SCIP* scip /**< SCIP data structure */
3938  );
3939 
3940 /* @} */
3941 
3942 /**@addtogroup PublicHeuristicMethods
3943  *
3944  * @{
3945  */
3946 
3947 /** creates a primal heuristic and includes it in SCIP.
3948  *
3949  * @note method has all heuristic callbacks as arguments and is thus changed every time a new
3950  * callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions
3951  * if you seek for a method which is less likely to change in future releases
3952  *
3953  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3954  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3955  *
3956  * @pre This method can be called if @p scip is in one of the following stages:
3957  * - \ref SCIP_STAGE_INIT
3958  * - \ref SCIP_STAGE_PROBLEM
3959  */
3960 extern
3962  SCIP* scip, /**< SCIP data structure */
3963  const char* name, /**< name of primal heuristic */
3964  const char* desc, /**< description of primal heuristic */
3965  char dispchar, /**< display character of primal heuristic */
3966  int priority, /**< priority of the primal heuristic */
3967  int freq, /**< frequency for calling primal heuristic */
3968  int freqofs, /**< frequency offset for calling primal heuristic */
3969  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3970  SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
3971  * see definition of SCIP_HEURTIMING for possible values */
3972  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3973  SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
3974  SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
3975  SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
3976  SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
3977  SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
3978  SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
3979  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
3980  SCIP_HEURDATA* heurdata /**< primal heuristic data */
3981  );
3982 
3983 /** creates a primal heuristic and includes it in SCIP with its most fundamental callbacks.
3984  * All non-fundamental (or optional) callbacks
3985  * as, e. g., init and exit callbacks, will be set to NULL.
3986  * Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(),
3987  * SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
3988  *
3989 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead
3990  */
3991 extern
3993  SCIP* scip, /**< SCIP data structure */
3994  SCIP_HEUR** heur, /**< pointer to the heuristic */
3995  const char* name, /**< name of primal heuristic */
3996  const char* desc, /**< description of primal heuristic */
3997  char dispchar, /**< display character of primal heuristic */
3998  int priority, /**< priority of the primal heuristic */
3999  int freq, /**< frequency for calling primal heuristic */
4000  int freqofs, /**< frequency offset for calling primal heuristic */
4001  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
4002  SCIP_HEURTIMING timingmask, /**< positions in the node solving loop where heuristic should be executed;
4003  * see definition of SCIP_HEURTIMING for possible values */
4004  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
4005  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
4006  SCIP_HEURDATA* heurdata /**< primal heuristic data */
4007  );
4008 
4009 /** sets copy method of primal heuristic */
4010 extern
4012  SCIP* scip, /**< SCIP data structure */
4013  SCIP_HEUR* heur, /**< primal heuristic */
4014  SCIP_DECL_HEURCOPY ((*heurcopy)) /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
4015  );
4016 
4017 /** sets destructor method of primal heuristic */
4018 extern
4020  SCIP* scip, /**< SCIP data structure */
4021  SCIP_HEUR* heur, /**< primal heuristic */
4022  SCIP_DECL_HEURFREE ((*heurfree)) /**< destructor of primal heuristic */
4023  );
4024 
4025 /** sets initialization method of primal heuristic */
4026 extern
4028  SCIP* scip, /**< SCIP data structure */
4029  SCIP_HEUR* heur, /**< primal heuristic */
4030  SCIP_DECL_HEURINIT ((*heurinit)) /**< initialize primal heuristic */
4031  );
4032 
4033 /** sets deinitialization method of primal heuristic */
4034 extern
4036  SCIP* scip, /**< SCIP data structure */
4037  SCIP_HEUR* heur, /**< primal heuristic */
4038  SCIP_DECL_HEUREXIT ((*heurexit)) /**< deinitialize primal heuristic */
4039  );
4040 
4041 /** sets solving process initialization method of primal heuristic */
4042 extern
4044  SCIP* scip, /**< SCIP data structure */
4045  SCIP_HEUR* heur, /**< primal heuristic */
4046  SCIP_DECL_HEURINITSOL ((*heurinitsol)) /**< solving process initialization method of primal heuristic */
4047  );
4048 
4049 /** sets solving process deinitialization method of primal heuristic */
4050 extern
4052  SCIP* scip, /**< SCIP data structure */
4053  SCIP_HEUR* heur, /**< primal heuristic */
4054  SCIP_DECL_HEUREXITSOL ((*heurexitsol)) /**< solving process deinitialization method of primal heuristic */
4055  );
4056 
4057 /** returns the primal heuristic of the given name, or NULL if not existing */
4058 extern
4060  SCIP* scip, /**< SCIP data structure */
4061  const char* name /**< name of primal heuristic */
4062  );
4063 
4064 /** returns the array of currently available primal heuristics */
4065 extern
4067  SCIP* scip /**< SCIP data structure */
4068  );
4069 
4070 /** returns the number of currently available primal heuristics */
4071 extern
4072 int SCIPgetNHeurs(
4073  SCIP* scip /**< SCIP data structure */
4074  );
4075 
4076 /** sets the priority of a primal heuristic */
4077 extern
4079  SCIP* scip, /**< SCIP data structure */
4080  SCIP_HEUR* heur, /**< primal heuristic */
4081  int priority /**< new priority of the primal heuristic */
4082  );
4083 
4084 /* @} */
4085 
4086 /**@addtogroup PublicCompressionMethods
4087  *
4088  * @{
4089  */
4090 /** creates a tree compression and includes it in SCIP.
4091  *
4092  * @note method has all compression callbacks as arguments and is thus changed every time a new
4093  * callback is added in future releases; consider using SCIPincludeComprBasic() and setter functions
4094  * if you seek for a method which is less likely to change in future releases
4095  */
4096 extern
4098  SCIP* scip, /**< SCIP data structure */
4099  const char* name, /**< name of tree compression */
4100  const char* desc, /**< description of tree compression */
4101  int priority, /**< priority of the tree compression */
4102  int minnnodes, /**< minimal number of nodes to call compression */
4103  SCIP_DECL_COMPRCOPY ((*comprcopy)), /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
4104  SCIP_DECL_COMPRFREE ((*comprfree)), /**< destructor of tree compression */
4105  SCIP_DECL_COMPRINIT ((*comprinit)), /**< initialize tree compression */
4106  SCIP_DECL_COMPREXIT ((*comprexit)), /**< deinitialize tree compression */
4107  SCIP_DECL_COMPRINITSOL ((*comprinitsol)), /**< solving process initialization method of tree compression */
4108  SCIP_DECL_COMPREXITSOL ((*comprexitsol)), /**< solving process deinitialization method of tree compression */
4109  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
4110  SCIP_COMPRDATA* comprdata /**< tree compression data */
4111  );
4112 
4113 /** creates a tree compression and includes it in SCIP with its most fundamental callbacks.
4114  * All non-fundamental (or optional) callbacks
4115  * as, e. g., init and exit callbacks, will be set to NULL.
4116  * Optional callbacks can be set via specific setter functions, see SCIPsetComprCopy(), SCIPsetComprFree(),
4117  * SCIPsetComprInit(), SCIPsetComprExit(), SCIPsetComprInitsol(), and SCIPsetComprExitsol()
4118  *
4119  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeCompr() instead
4120  */
4121 extern
4123  SCIP* scip, /**< SCIP data structure */
4124  SCIP_COMPR** compr, /**< pointer to tree compression */
4125  const char* name, /**< name of tree compression */
4126  const char* desc, /**< description of tree compression */
4127  int priority, /**< priority of the tree compression */
4128  int minnnodes, /**< minimal number of nodes to call the compression */
4129  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
4130  SCIP_COMPRDATA* comprdata /**< tree compression data */
4131  );
4132 
4133 /** sets copy method of tree compression */
4134 extern
4136  SCIP* scip, /**< SCIP data structure */
4137  SCIP_COMPR* compr, /**< tree compression */
4138  SCIP_DECL_COMPRCOPY ((*comprcopy)) /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
4139  );
4140 
4141 /** sets destructor method of tree compression */
4142 extern
4144  SCIP* scip, /**< SCIP data structure */
4145  SCIP_COMPR* compr, /**< tree compression */
4146  SCIP_DECL_COMPRFREE ((*comprfree)) /**< destructor of tree compression */
4147  );
4148 
4149 /** sets initialization method of tree compression */
4150 extern
4152  SCIP* scip, /**< SCIP data structure */
4153  SCIP_COMPR* compr, /**< tree compression */
4154  SCIP_DECL_COMPRINIT ((*comprinit)) /**< initialize tree compression */
4155  );
4156 
4157 /** sets deinitialization method of tree compression */
4158 extern
4160  SCIP* scip, /**< SCIP data structure */
4161  SCIP_COMPR* compr, /**< tree compression */
4162  SCIP_DECL_COMPREXIT ((*comprexit)) /**< deinitialize tree compression */
4163  );
4164 
4165 /** sets solving process initialization method of tree compression */
4166 extern
4168  SCIP* scip, /**< SCIP data structure */
4169  SCIP_COMPR* compr, /**< tree compression */
4170  SCIP_DECL_COMPRINITSOL ((*comprinitsol)) /**< solving process initialization method of tree compression */
4171  );
4172 
4173 /** sets solving process deinitialization method of tree compression */
4174 extern
4176  SCIP* scip, /**< SCIP data structure */
4177  SCIP_COMPR* compr, /**< tree compression */
4178  SCIP_DECL_COMPREXITSOL ((*comprexitsol)) /**< solving process deinitialization method of tree compression */
4179  );
4180 
4181 /** returns the tree compression of the given name, or NULL if not existing */
4182 extern
4184  SCIP* scip, /**< SCIP data structure */
4185  const char* name /**< name of tree compression */
4186  );
4187 
4188 /** returns the array of currently available tree compression */
4189 extern
4191  SCIP* scip /**< SCIP data structure */
4192  );
4193 
4194 /** returns the number of currently available tree compression */
4195 extern
4196 int SCIPgetNCompr(
4197  SCIP* scip /**< SCIP data structure */
4198  );
4199 
4200 /** set the priority of a tree compression method */
4202  SCIP* scip, /**< SCIP data structure */
4203  SCIP_COMPR* compr, /**< compression */
4204  int priority /**< new priority of the tree compression */
4205  );
4206 
4207 /* @} */
4208 
4209 /**@addtogroup PublicDivesetMethods
4210  *
4211  * @{
4212  */
4213 
4214 /** create a diving set associated with a primal heuristic. The primal heuristic needs to be included
4215  * before this method can be called. The diveset is installed in the array of divesets of the heuristic
4216  * and can be retrieved later by accessing SCIPheurGetDivesets()
4217  *
4218  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4219  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4220  *
4221  * @pre This method can be called if @p scip is in one of the following stages:
4222  * - \ref SCIP_STAGE_INIT
4223  * - \ref SCIP_STAGE_PROBLEM
4224  */
4225 extern
4227  SCIP* scip, /**< SCIP data structure */
4228  SCIP_DIVESET** diveset, /**< pointer to created diving heuristic settings, or NULL if not needed */
4229  SCIP_HEUR* heur, /**< primal heuristic to which the diveset belongs */
4230  const char* name, /**< name for the diveset, or NULL if the name of the heuristic should be used */
4231  SCIP_Real minreldepth, /**< minimal relative depth to start diving */
4232  SCIP_Real maxreldepth, /**< maximal relative depth to start diving */
4233  SCIP_Real maxlpiterquot, /**< maximal fraction of diving LP iterations compared to node LP iterations */
4234  SCIP_Real maxdiveubquot, /**< maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound)
4235  * where diving is performed (0.0: no limit) */
4236  SCIP_Real maxdiveavgquot, /**< maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound)
4237  * where diving is performed (0.0: no limit) */
4238  SCIP_Real maxdiveubquotnosol, /**< maximal UBQUOT when no solution was found yet (0.0: no limit) */
4239  SCIP_Real maxdiveavgquotnosol,/**< maximal AVGQUOT when no solution was found yet (0.0: no limit) */
4240  SCIP_Real lpresolvedomchgquot,/**< percentage of immediate domain changes during probing to trigger LP resolve */
4241  int lpsolvefreq, /**< LP solve frequency for (0: only if enough domain reductions are found by propagation)*/
4242  int maxlpiterofs, /**< additional number of allowed LP iterations */
4243  unsigned int initialseed, /**< initial seed for random number generation */
4244  SCIP_Bool backtrack, /**< use one level of backtracking if infeasibility is encountered? */
4245  SCIP_Bool onlylpbranchcands, /**< should only LP branching candidates be considered instead of the slower but
4246  * more general constraint handler diving variable selection? */
4247  SCIP_Bool specificsos1score, /**< should SOS1 variables be scored by the diving heuristics specific score function;
4248  * otherwise use the score function of the SOS1 constraint handler */
4249  SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)) /**< method for candidate score and rounding direction */
4250 
4251  );
4252 
4253 /* @} */
4254 
4255 /**@addtogroup PublicEventHandlerMethods
4256  *
4257  * @{
4258  */
4259 
4260 /** creates an event handler and includes it in SCIP
4261  *
4262  * @note method has all event handler callbacks as arguments and is thus changed every time a new
4263  * callback is added in future releases; consider using SCIPincludeEventhdlrBasic() and setter functions
4264  * if you seek for a method which is less likely to change in future releases
4265  */
4266 extern
4268  SCIP* scip, /**< SCIP data structure */
4269  const char* name, /**< name of event handler */
4270  const char* desc, /**< description of event handler */
4271  SCIP_DECL_EVENTCOPY ((*eventcopy)), /**< copy method of event handler or NULL if you don't want to copy your plugin into sub-SCIPs */
4272  SCIP_DECL_EVENTFREE ((*eventfree)), /**< destructor of event handler */
4273  SCIP_DECL_EVENTINIT ((*eventinit)), /**< initialize event handler */
4274  SCIP_DECL_EVENTEXIT ((*eventexit)), /**< deinitialize event handler */
4275  SCIP_DECL_EVENTINITSOL((*eventinitsol)), /**< solving process initialization method of event handler */
4276  SCIP_DECL_EVENTEXITSOL((*eventexitsol)), /**< solving process deinitialization method of event handler */
4277  SCIP_DECL_EVENTDELETE ((*eventdelete)), /**< free specific event data */
4278  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
4279  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
4280  );
4281 
4282 /** creates an event handler and includes it in SCIP with all its non-fundamental callbacks set
4283  * to NULL; if needed, non-fundamental callbacks can be set afterwards via setter functions
4284  * SCIPsetEventhdlrCopy(), SCIPsetEventhdlrFree(), SCIPsetEventhdlrInit(), SCIPsetEventhdlrExit(),
4285  * SCIPsetEventhdlrInitsol(), SCIPsetEventhdlrExitsol(), and SCIPsetEventhdlrDelete()
4286  *
4287  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeEventhdlr() instead
4288  */
4289 extern
4291  SCIP* scip, /**< SCIP data structure */
4292  SCIP_EVENTHDLR** eventhdlrptr, /**< reference to an event handler, or NULL */
4293  const char* name, /**< name of event handler */
4294  const char* desc, /**< description of event handler */
4295  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
4296  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
4297  );
4298 
4299 /** sets copy callback of the event handler */
4300 extern
4302  SCIP* scip, /**< scip instance */
4303  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4304  SCIP_DECL_EVENTCOPY ((*eventcopy)) /**< copy callback of the event handler */
4305  );
4306 
4307 /** sets deinitialization callback of the event handler */
4308 extern
4310  SCIP* scip, /**< scip instance */
4311  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4312  SCIP_DECL_EVENTFREE ((*eventfree)) /**< deinitialization callback of the event handler */
4313  );
4314 
4315 /** sets initialization callback of the event handler */
4316 extern
4318  SCIP* scip, /**< scip instance */
4319  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4320  SCIP_DECL_EVENTINIT ((*eventinit)) /**< initialize event handler */
4321  );
4322 
4323 /** sets deinitialization callback of the event handler */
4324 extern
4326  SCIP* scip, /**< scip instance */
4327  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4328  SCIP_DECL_EVENTEXIT ((*eventexit)) /**< deinitialize event handler */
4329  );
4330 
4331 /** sets solving process initialization callback of the event handler */
4332 extern
4334  SCIP* scip, /**< scip instance */
4335  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4336  SCIP_DECL_EVENTINITSOL((*eventinitsol)) /**< solving process initialization callback of event handler */
4337  );
4338 
4339 /** sets solving process deinitialization callback of the event handler */
4340 extern
4342  SCIP* scip, /**< scip instance */
4343  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4344  SCIP_DECL_EVENTEXITSOL((*eventexitsol)) /**< solving process deinitialization callback of event handler */
4345  );
4346 
4347 /** sets callback of the event handler to free specific event data */
4348 extern
4350  SCIP* scip, /**< scip instance */
4351  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
4352  SCIP_DECL_EVENTDELETE ((*eventdelete)) /**< free specific event data */
4353  );
4354 
4355 /** returns the event handler of the given name, or NULL if not existing */
4356 extern
4358  SCIP* scip, /**< SCIP data structure */
4359  const char* name /**< name of event handler */
4360  );
4361 
4362 /** returns the array of currently available event handlers */
4363 extern
4365  SCIP* scip /**< SCIP data structure */
4366  );
4367 
4368 /** returns the number of currently available event handlers */
4369 extern
4370 int SCIPgetNEventhdlrs(
4371  SCIP* scip /**< SCIP data structure */
4372  );
4373 
4374 /* @} */
4375 
4376 /**@addtogroup PublicNodeSelectorMethods
4377  *
4378  * @{
4379  */
4380 
4381 /** creates a node selector and includes it in SCIP.
4382  *
4383  * @note method has all node selector callbacks as arguments and is thus changed every time a new
4384  * callback is added in future releases; consider using SCIPincludeNodeselBasic() and setter functions
4385  * if you seek for a method which is less likely to change in future releases
4386  */
4387 extern
4389  SCIP* scip, /**< SCIP data structure */
4390  const char* name, /**< name of node selector */
4391  const char* desc, /**< description of node selector */
4392  int stdpriority, /**< priority of the node selector in standard mode */
4393  int memsavepriority, /**< priority of the node selector in memory saving mode */
4394  SCIP_DECL_NODESELCOPY ((*nodeselcopy)), /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
4395  SCIP_DECL_NODESELFREE ((*nodeselfree)), /**< destructor of node selector */
4396  SCIP_DECL_NODESELINIT ((*nodeselinit)), /**< initialize node selector */
4397  SCIP_DECL_NODESELEXIT ((*nodeselexit)), /**< deinitialize node selector */
4398  SCIP_DECL_NODESELINITSOL((*nodeselinitsol)),/**< solving process initialization method of node selector */
4399  SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)),/**< solving process deinitialization method of node selector */
4400  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
4401  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
4402  SCIP_NODESELDATA* nodeseldata /**< node selector data */
4403  );
4404 
4405 /** Creates a node selector and includes it in SCIP with its most fundamental callbacks. All non-fundamental
4406  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
4407  * Optional callbacks can be set via specific setter functions, see SCIPsetNodeselCopy(), SCIPsetNodeselFree(),
4408  * SCIPsetNodeselInit(), SCIPsetNodeselExit(), SCIPsetNodeselInitsol(), and SCIPsetNodeselExitsol()
4409  *
4410  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeNodesel() instead
4411  */
4412 extern
4414  SCIP* scip, /**< SCIP data structure */
4415  SCIP_NODESEL** nodesel, /**< reference to a node selector, or NULL */
4416  const char* name, /**< name of node selector */
4417  const char* desc, /**< description of node selector */
4418  int stdpriority, /**< priority of the node selector in standard mode */
4419  int memsavepriority, /**< priority of the node selector in memory saving mode */
4420  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
4421  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
4422  SCIP_NODESELDATA* nodeseldata /**< node selector data */
4423  );
4424 
4425 /** sets copy method of node selector */
4426 extern
4428  SCIP* scip, /**< SCIP data structure */
4429  SCIP_NODESEL* nodesel, /**< node selector */
4430  SCIP_DECL_NODESELCOPY ((*nodeselcopy)) /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
4431  );
4432 
4433 /** sets destructor method of node selector */
4434 extern
4436  SCIP* scip, /**< SCIP data structure */
4437  SCIP_NODESEL* nodesel, /**< node selector */
4438  SCIP_DECL_NODESELFREE ((*nodeselfree)) /**< destructor of node selector */
4439  );
4440 
4441 /** sets initialization method of node selector */
4442 extern
4444  SCIP* scip, /**< SCIP data structure */
4445  SCIP_NODESEL* nodesel, /**< node selector */
4446  SCIP_DECL_NODESELINIT ((*nodeselinit)) /**< initialize node selector */
4447  );
4448 
4449 /** sets deinitialization method of node selector */
4450 extern
4452  SCIP* scip, /**< SCIP data structure */
4453  SCIP_NODESEL* nodesel, /**< node selector */
4454  SCIP_DECL_NODESELEXIT ((*nodeselexit)) /**< deinitialize node selector */
4455  );
4456 
4457 /** sets solving process initialization method of node selector */
4458 extern
4460  SCIP* scip, /**< SCIP data structure */
4461  SCIP_NODESEL* nodesel, /**< node selector */
4462  SCIP_DECL_NODESELINITSOL ((*nodeselinitsol))/**< solving process initialization method of node selector */
4463  );
4464 
4465 /** sets solving process deinitialization method of node selector */
4466 extern
4468  SCIP* scip, /**< SCIP data structure */
4469  SCIP_NODESEL* nodesel, /**< node selector */
4470  SCIP_DECL_NODESELEXITSOL ((*nodeselexitsol))/**< solving process deinitialization method of node selector */
4471  );
4472 
4473 /** returns the node selector of the given name, or NULL if not existing */
4474 extern
4476  SCIP* scip, /**< SCIP data structure */
4477  const char* name /**< name of node selector */
4478  );
4479 
4480 /** returns the array of currently available node selectors */
4481 extern
4483  SCIP* scip /**< SCIP data structure */
4484  );
4485 
4486 /** returns the number of currently available node selectors */
4487 extern
4488 int SCIPgetNNodesels(
4489  SCIP* scip /**< SCIP data structure */
4490  );
4491 
4492 /** sets the priority of a node selector in standard mode */
4493 extern
4495  SCIP* scip, /**< SCIP data structure */
4496  SCIP_NODESEL* nodesel, /**< node selector */
4497  int priority /**< new standard priority of the node selector */
4498  );
4499 
4500 /** sets the priority of a node selector in memory saving mode */
4501 extern
4503  SCIP* scip, /**< SCIP data structure */
4504  SCIP_NODESEL* nodesel, /**< node selector */
4505  int priority /**< new memory saving priority of the node selector */
4506  );
4507 
4508 /** returns the currently used node selector */
4509 extern
4511  SCIP* scip /**< SCIP data structure */
4512  );
4513 
4514 /* @} */
4515 
4516 /**@addtogroup PublicBranchRuleMethods
4517  *
4518  * @{
4519  */
4520 
4521 /** creates a branching rule and includes it in SCIP
4522  *
4523  * @note method has all branching rule callbacks as arguments and is thus changed every time a new
4524  * callback is added in future releases; consider using SCIPincludeBranchruleBasic() and setter functions
4525  * if you seek for a method which is less likely to change in future releases
4526  */
4527 extern
4529  SCIP* scip, /**< SCIP data structure */
4530  const char* name, /**< name of branching rule */
4531  const char* desc, /**< description of branching rule */
4532  int priority, /**< priority of the branching rule */
4533  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
4534  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
4535  * compared to best node's dual bound for applying branching rule
4536  * (0.0: only on current best node, 1.0: on all nodes) */
4537  SCIP_DECL_BRANCHCOPY ((*branchcopy)), /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
4538  SCIP_DECL_BRANCHFREE ((*branchfree)), /**< destructor of branching rule */
4539  SCIP_DECL_BRANCHINIT ((*branchinit)), /**< initialize branching rule */
4540  SCIP_DECL_BRANCHEXIT ((*branchexit)), /**< deinitialize branching rule */
4541  SCIP_DECL_BRANCHINITSOL((*branchinitsol)),/**< solving process initialization method of branching rule */
4542  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)),/**< solving process deinitialization method of branching rule */
4543  SCIP_DECL_BRANCHEXECLP((*branchexeclp)), /**< branching execution method for fractional LP solutions */
4544  SCIP_DECL_BRANCHEXECEXT((*branchexecext)),/**< branching execution method for external candidates */
4545  SCIP_DECL_BRANCHEXECPS((*branchexecps)), /**< branching execution method for not completely fixed pseudo solutions */
4546  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
4547  );
4548 
4549 /** creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
4550  * Optional callbacks can be set via specific setter functions, see SCIPsetBranchruleInit(), SCIPsetBranchruleExit(),
4551  * SCIPsetBranchruleCopy(), SCIPsetBranchruleFree(), SCIPsetBranchruleInitsol(), SCIPsetBranchruleExitsol(),
4552  * SCIPsetBranchruleExecLp(), SCIPsetBranchruleExecExt(), and SCIPsetBranchruleExecPs().
4553  *
4554  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeBranchrule() instead
4555  */
4556 extern
4558  SCIP* scip, /**< SCIP data structure */
4559  SCIP_BRANCHRULE** branchruleptr, /**< pointer to branching rule, or NULL */
4560  const char* name, /**< name of branching rule */
4561  const char* desc, /**< description of branching rule */
4562  int priority, /**< priority of the branching rule */
4563  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
4564  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
4565  * compared to best node's dual bound for applying branching rule
4566  * (0.0: only on current best node, 1.0: on all nodes) */
4567  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
4568  );
4569 
4570 /** sets copy method of branching rule */
4571 extern
4573  SCIP* scip, /**< SCIP data structure */
4574  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4575  SCIP_DECL_BRANCHCOPY ((*branchcopy)) /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
4576  );
4577 
4578 /** sets destructor method of branching rule */
4579 extern
4581  SCIP* scip, /**< SCIP data structure */
4582  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4583  SCIP_DECL_BRANCHFREE ((*branchfree)) /**< destructor of branching rule */
4584  );
4585 
4586 /** sets initialization method of branching rule */
4587 extern
4589  SCIP* scip, /**< SCIP data structure */
4590  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4591  SCIP_DECL_BRANCHINIT ((*branchinit)) /**< initialize branching rule */
4592  );
4593 
4594 /** sets deinitialization method of branching rule */
4595 extern
4597  SCIP* scip, /**< SCIP data structure */
4598  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4599  SCIP_DECL_BRANCHEXIT ((*branchexit)) /**< deinitialize branching rule */
4600  );
4601 
4602 /** sets solving process initialization method of branching rule */
4603 extern
4605  SCIP* scip, /**< SCIP data structure */
4606  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4607  SCIP_DECL_BRANCHINITSOL((*branchinitsol)) /**< solving process initialization method of branching rule */
4608  );
4609 
4610 /** sets solving process deinitialization method of branching rule */
4611 extern
4613  SCIP* scip, /**< SCIP data structure */
4614  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4615  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)) /**< solving process deinitialization method of branching rule */
4616  );
4617 
4618 /** sets branching execution method for fractional LP solutions */
4619 extern
4621  SCIP* scip, /**< SCIP data structure */
4622  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4623  SCIP_DECL_BRANCHEXECLP((*branchexeclp)) /**< branching execution method for fractional LP solutions */
4624  );
4625 
4626 /** sets branching execution method for external candidates */
4627 extern
4629  SCIP* scip, /**< SCIP data structure */
4630  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4631  SCIP_DECL_BRANCHEXECEXT((*branchexecext)) /**< branching execution method for external candidates */
4632  );
4633 
4634 /** sets branching execution method for not completely fixed pseudo solutions */
4635 extern
4637  SCIP* scip, /**< SCIP data structure */
4638  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4639  SCIP_DECL_BRANCHEXECPS((*branchexecps)) /**< branching execution method for not completely fixed pseudo solutions */
4640  );
4641 
4642 /** returns the branching rule of the given name, or NULL if not existing */
4643 extern
4645  SCIP* scip, /**< SCIP data structure */
4646  const char* name /**< name of branching rule */
4647  );
4648 
4649 /** returns the array of currently available branching rules */
4650 extern
4652  SCIP* scip /**< SCIP data structure */
4653  );
4654 
4655 /** returns the number of currently available branching rules */
4656 extern
4658  SCIP* scip /**< SCIP data structure */
4659  );
4660 
4661 /** sets the priority of a branching rule */
4662 extern
4664  SCIP* scip, /**< SCIP data structure */
4665  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4666  int priority /**< new priority of the branching rule */
4667  );
4668 
4669 /** sets maximal depth level, up to which this branching rule should be used (-1 for no limit) */
4670 extern
4672  SCIP* scip, /**< SCIP data structure */
4673  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4674  int maxdepth /**< new maxdepth of the branching rule */
4675  );
4676 
4677 /** sets maximal relative distance from current node's dual bound to primal bound for applying branching rule */
4678 extern
4680  SCIP* scip, /**< SCIP data structure */
4681  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4682  SCIP_Real maxbounddist /**< new maxbounddist of the branching rule */
4683  );
4684 
4685 /* @} */
4686 
4687 /**@addtogroup PublicDisplayMethods
4688  *
4689  * @{
4690  */
4691 
4692 /** creates a display column and includes it in SCIP */
4693 extern
4695  SCIP* scip, /**< SCIP data structure */
4696  const char* name, /**< name of display column */
4697  const char* desc, /**< description of display column */
4698  const char* header, /**< head line of display column */
4699  SCIP_DISPSTATUS dispstatus, /**< display activation status of display column */
4700  SCIP_DECL_DISPCOPY ((*dispcopy)), /**< copy method of display column or NULL if you don't want to copy your plugin into sub-SCIPs */
4701  SCIP_DECL_DISPFREE ((*dispfree)), /**< destructor of display column */
4702  SCIP_DECL_DISPINIT ((*dispinit)), /**< initialize display column */
4703  SCIP_DECL_DISPEXIT ((*dispexit)), /**< deinitialize display column */
4704  SCIP_DECL_DISPINITSOL ((*dispinitsol)), /**< solving process initialization method of display column */
4705  SCIP_DECL_DISPEXITSOL ((*dispexitsol)), /**< solving process deinitialization method of display column */
4706  SCIP_DECL_DISPOUTPUT ((*dispoutput)), /**< output method */
4707  SCIP_DISPDATA* dispdata, /**< display column data */
4708  int width, /**< width of display column (no. of chars used) */
4709  int priority, /**< priority of display column */
4710  int position, /**< relative position of display column */
4711  SCIP_Bool stripline /**< should the column be separated with a line from its right neighbor? */
4712  );
4713 
4714 /** returns the display column of the given name, or NULL if not existing */
4715 extern
4717  SCIP* scip, /**< SCIP data structure */
4718  const char* name /**< name of display column */
4719  );
4720 
4721 /** returns the array of currently available display columns */
4722 extern
4724  SCIP* scip /**< SCIP data structure */
4725  );
4726 
4727 /** returns the number of currently available display columns */
4728 extern
4729 int SCIPgetNDisps(
4730  SCIP* scip /**< SCIP data structure */
4731  );
4732 
4733 /** automatically selects display columns for being shown w.r.t. the display width parameter */
4734 extern
4736  SCIP* scip /**< SCIP data structure */
4737  );
4738 
4739 /** changes the display column mode */
4740 extern
4741 void SCIPchgDispMode(
4742  SCIP_DISP* disp, /**< display column */
4743  SCIP_DISPMODE mode /**< the display column mode */
4744  );
4745 
4746 /* @} */
4747 
4748 /**@addtogroup PublicNLPInterfaceMethods
4749  *
4750  * @{
4751  */
4752 
4753 /** includes an NLPI in SCIP */
4754 extern
4756  SCIP* scip, /**< SCIP data structure */
4757  SCIP_NLPI* nlpi /**< NLPI data structure */
4758  );
4759 
4760 /** returns the NLPI of the given name, or NULL if not existing */
4761 extern
4763  SCIP* scip, /**< SCIP data structure */
4764  const char* name /**< name of NLPI */
4765  );
4766 
4767 /** returns the array of currently available NLPIs (sorted by priority) */
4768 extern
4770  SCIP* scip /**< SCIP data structure */
4771  );
4772 
4773 /** returns the number of currently available NLPIs */
4774 extern
4775 int SCIPgetNNlpis(
4776  SCIP* scip /**< SCIP data structure */
4777  );
4778 
4779 /** sets the priority of an NLPI */
4780 extern
4782  SCIP* scip, /**< SCIP data structure */
4783  SCIP_NLPI* nlpi, /**< NLPI */
4784  int priority /**< new priority of the NLPI */
4785  );
4786 
4787 /* @} */
4788 
4789 /**@addtogroup PublicExternalCodeMethods
4790  *
4791  * @{
4792  */
4793 
4794 
4795 
4796 /** includes information about an external code linked into the SCIP library */
4797 extern
4799  SCIP* scip, /**< SCIP data structure */
4800  const char* name, /**< name of external code */
4801  const char* description /**< description of external code, or NULL */
4802  );
4803 
4804 /** returns an array of names of currently included external codes */
4805 extern
4807  SCIP* scip /**< SCIP data structure */
4808  );
4809 
4810 /** returns an array of the descriptions of currently included external codes
4811  *
4812  * @note some descriptions may be NULL
4813  */
4814 extern
4816  SCIP* scip /**< SCIP data structure */
4817  );
4818 
4819 /** returns the number of currently included information on external codes */
4820 extern
4822  SCIP* scip /**< SCIP data structure */
4823  );
4824 
4825 /** prints information on external codes to a file stream via the message handler system
4826  *
4827  * @note If the message handler is set to a NULL pointer nothing will be printed
4828  */
4829 extern
4831  SCIP* scip, /**< SCIP data structure */
4832  FILE* file /**< output file (or NULL for standard output) */
4833  );
4834 
4835 /* @} */
4836 
4837 /*
4838  * user interactive dialog methods
4839  */
4840 
4841 /**@addtogroup PublicDialogMethods
4842  *
4843  * @{
4844  */
4845 
4846 /** creates and includes dialog
4847  *
4848  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4849  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4850  */
4851 extern
4853  SCIP* scip, /**< SCIP data structure */
4854  SCIP_DIALOG** dialog, /**< pointer to store the dialog */
4855  SCIP_DECL_DIALOGCOPY ((*dialogcopy)), /**< copy method of dialog or NULL if you don't want to copy your plugin into sub-SCIPs */
4856  SCIP_DECL_DIALOGEXEC ((*dialogexec)), /**< execution method of dialog */
4857  SCIP_DECL_DIALOGDESC ((*dialogdesc)), /**< description output method of dialog, or NULL */
4858  SCIP_DECL_DIALOGFREE ((*dialogfree)), /**< destructor of dialog to free user data, or NULL */
4859  const char* name, /**< name of dialog: command name appearing in parent's dialog menu */
4860  const char* desc, /**< description of dialog used if description output method is NULL */
4861  SCIP_Bool issubmenu, /**< is the dialog a submenu? */
4862  SCIP_DIALOGDATA* dialogdata /**< user defined dialog data */
4863  );
4864 
4865 /** returns if the dialog already exists
4866  *
4867  * @return TRUE is returned if the dialog exists, otherwise FALSE.
4868  */
4869 extern
4871  SCIP* scip, /**< SCIP data structure */
4872  SCIP_DIALOG* dialog /**< dialog */
4873  );
4874 
4875 /** captures a dialog
4876  *
4877  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4878  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4879  */
4880 extern
4882  SCIP* scip, /**< SCIP data structure */
4883  SCIP_DIALOG* dialog /**< dialog */
4884  );
4885 
4886 /** releases a dialog
4887  *
4888  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4889  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4890  */
4891 extern
4893  SCIP* scip, /**< SCIP data structure */
4894  SCIP_DIALOG** dialog /**< pointer to the dialog */
4895  );
4896 
4897 /** makes given dialog the root dialog of SCIP's interactive user shell; captures dialog and releases former root dialog
4898  *
4899  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4900  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4901  */
4902 extern
4904  SCIP* scip, /**< SCIP data structure */
4905  SCIP_DIALOG* dialog /**< dialog to be the root */
4906  );
4907 
4908 /** returns the root dialog of SCIP's interactive user shell
4909  *
4910  * @return the root dialog of SCIP's interactive user shell is returned.
4911  */
4912 extern
4914  SCIP* scip /**< SCIP data structure */
4915  );
4916 
4917 /** adds a sub dialog to the given dialog as menu entry and captures it
4918  *
4919  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4920  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4921  */
4922 extern
4924  SCIP* scip, /**< SCIP data structure */
4925  SCIP_DIALOG* dialog, /**< dialog to extend, or NULL for root dialog */
4926  SCIP_DIALOG* subdialog /**< subdialog to add as menu entry in dialog */
4927  );
4928 
4929 /** adds a single line of input which is treated as if the user entered the command line
4930  *
4931  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4933  */
4934 extern
4936  SCIP* scip, /**< SCIP data structure */
4937  const char* inputline /**< input line to add */
4938  );
4939 
4940 /** adds a single line of input to the command history which can be accessed with the cursor keys
4941  *
4942  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4943  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4944  */
4945 extern
4947  SCIP* scip, /**< SCIP data structure */
4948  const char* inputline /**< input line to add */
4949  );
4950 
4951 /** starts interactive mode of SCIP by executing the root dialog
4952  *
4953  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4954  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4955  *
4956  * @pre This method can be called if @p scip is in one of the following stages:
4957  * - \ref SCIP_STAGE_INIT
4958  * - \ref SCIP_STAGE_FREE
4959  *
4960  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the
4961  * interactive shell was closed:
4962  * - \ref SCIP_STAGE_PROBLEM if the interactive shell was closed after the problem was created
4963  * - \ref SCIP_STAGE_TRANSFORMED if the interactive shell was closed after the problem was transformed
4964  * - \ref SCIP_STAGE_PRESOLVING if the interactive shell was closed during presolving
4965  * - \ref SCIP_STAGE_PRESOLVED if the interactive shell was closed after presolve
4966  * - \ref SCIP_STAGE_SOLVING if the interactive shell was closed during the tree search
4967  * - \ref SCIP_STAGE_SOLVED if the interactive shell was closed after the problem was solved
4968  * - \ref SCIP_STAGE_FREE if the interactive shell was closed after the problem was freed
4969  *
4970  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
4971  */
4972 extern
4974  SCIP* scip /**< SCIP data structure */
4975  );
4976 
4977 /**@} */
4978 
4979 /*
4980  * global problem methods
4981  */
4982 
4983 /**@addtogroup GlobalProblemMethods
4984  *
4985  * @{
4986  */
4987 
4988 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
4989  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
4990  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
4991  *
4992  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4993  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4994  *
4995  * @pre This method can be called if @p scip is in one of the following stages:
4996  * - \ref SCIP_STAGE_INIT
4997  * - \ref SCIP_STAGE_PROBLEM
4998  * - \ref SCIP_STAGE_TRANSFORMED
4999  * - \ref SCIP_STAGE_PRESOLVING
5000  * - \ref SCIP_STAGE_PRESOLVED
5001  * - \ref SCIP_STAGE_SOLVING
5002  * - \ref SCIP_STAGE_SOLVED
5003  * - \ref SCIP_STAGE_FREE
5004  *
5005  * @post After calling this method, \SCIP reaches the following stage:
5006  * - \ref SCIP_STAGE_PROBLEM
5007  */
5008 extern
5010  SCIP* scip, /**< SCIP data structure */
5011  const char* name, /**< problem name */
5012  SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
5013  SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
5014  SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
5015  SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
5016  SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
5017  SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
5018  SCIP_PROBDATA* probdata /**< user problem data set by the reader */
5019  );
5020 
5021 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
5022  * all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(),
5023  * SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and
5024  * SCIPsetProbCopy()
5025  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
5026  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
5027  *
5028  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5029  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5030  *
5031  * @pre This method can be called if @p scip is in one of the following stages:
5032  * - \ref SCIP_STAGE_INIT
5033  * - \ref SCIP_STAGE_PROBLEM
5034  * - \ref SCIP_STAGE_TRANSFORMED
5035  * - \ref SCIP_STAGE_PRESOLVING
5036  * - \ref SCIP_STAGE_PRESOLVED
5037  * - \ref SCIP_STAGE_SOLVING
5038  * - \ref SCIP_STAGE_SOLVED
5039  * - \ref SCIP_STAGE_FREE
5040  *
5041  * @post After calling this method, \SCIP reaches the following stage:
5042  * - \ref SCIP_STAGE_PROBLEM
5043  */
5044 extern
5046  SCIP* scip, /**< SCIP data structure */
5047  const char* name /**< problem name */
5048  );
5049 
5050 /** sets callback to free user data of original problem
5051  *
5052  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5053  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5054  *
5055  * @pre This method can be called if @p scip is in one of the following stages:
5056  * - \ref SCIP_STAGE_PROBLEM
5057  */
5059  SCIP* scip, /**< SCIP data structure */
5060  SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
5061  );
5062 
5063 /** sets callback to create user data of transformed problem by transforming original user data
5064  *
5065  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5066  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5067  *
5068  * @pre This method can be called if @p scip is in one of the following stages:
5069  * - \ref SCIP_STAGE_PROBLEM
5070  */
5071 extern
5073  SCIP* scip, /**< SCIP data structure */
5074  SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
5075  );
5076 
5077 /** sets callback to free user data of transformed problem
5078  *
5079  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5080  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5081  *
5082  * @pre This method can be called if @p scip is in one of the following stages:
5083  * - \ref SCIP_STAGE_PROBLEM
5084  */
5085 extern
5087  SCIP* scip, /**< SCIP data structure */
5088  SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
5089  );
5090 
5091 /** sets solving process initialization callback of transformed data
5092  *
5093  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5094  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5095  *
5096  * @pre This method can be called if @p scip is in one of the following stages:
5097  * - \ref SCIP_STAGE_PROBLEM
5098  */
5099 extern
5101  SCIP* scip, /**< SCIP data structure */
5102  SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization method of transformed data */
5103  );
5104 
5105 /** sets solving process deinitialization callback of transformed data
5106  *
5107  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5108  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5109  *
5110  * @pre This method can be called if @p scip is in one of the following stages:
5111  * - \ref SCIP_STAGE_PROBLEM
5112  */
5113 extern
5115  SCIP* scip, /**< SCIP data structure */
5116  SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization method of transformed data */
5117  );
5118 
5119 /** sets callback to copy user data to a subscip
5120  *
5121  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5122  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5123  *
5124  * @pre This method can be called if @p scip is in one of the following stages:
5125  * - \ref SCIP_STAGE_PROBLEM
5126  */
5127 extern
5129  SCIP* scip, /**< SCIP data structure */
5130  SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
5131  );
5132 
5133 /** reads problem from file and initializes all solving data structures
5134  *
5135  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5136  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5137  *
5138  * @pre This method can be called if @p scip is in one of the following stages:
5139  * - \ref SCIP_STAGE_INIT
5140  * - \ref SCIP_STAGE_PROBLEM
5141  * - \ref SCIP_STAGE_TRANSFORMED
5142  * - \ref SCIP_STAGE_INITPRESOLVE
5143  * - \ref SCIP_STAGE_PRESOLVING
5144  * - \ref SCIP_STAGE_EXITPRESOLVE
5145  * - \ref SCIP_STAGE_PRESOLVED
5146  * - \ref SCIP_STAGE_SOLVING
5147  * - \ref SCIP_STAGE_EXITSOLVE
5148  *
5149  * @post After the method was called, \SCIP is in one of the following stages:
5150  * - \ref SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
5151  * - \ref SCIP_STAGE_PROBLEM if the problem file was successfully read
5152  */
5153 extern
5155  SCIP* scip, /**< SCIP data structure */
5156  const char* filename, /**< problem file name */
5157  const char* extension /**< extension of the desired file reader,
5158  * or NULL if file extension should be used */
5159  );
5160 
5161 /** writes original problem to file
5162  *
5163  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5164  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5165  *
5166  * @pre This method can be called if @p scip is in one of the following stages:
5167  * - \ref SCIP_STAGE_PROBLEM
5168  * - \ref SCIP_STAGE_TRANSFORMING
5169  * - \ref SCIP_STAGE_TRANSFORMED
5170  * - \ref SCIP_STAGE_INITPRESOLVE
5171  * - \ref SCIP_STAGE_PRESOLVING
5172  * - \ref SCIP_STAGE_EXITPRESOLVE
5173  * - \ref SCIP_STAGE_PRESOLVED
5174  * - \ref SCIP_STAGE_INITSOLVE
5175  * - \ref SCIP_STAGE_SOLVING
5176  * - \ref SCIP_STAGE_SOLVED
5177  * - \ref SCIP_STAGE_EXITSOLVE
5178  * - \ref SCIP_STAGE_FREETRANS
5179  */
5180 extern
5182  SCIP* scip, /**< SCIP data structure */
5183  const char* filename, /**< output file (or NULL for standard output) */
5184  const char* extension, /**< extension of the desired file reader,
5185  * or NULL if file extension should be used */
5186  SCIP_Bool genericnames /**< use generic variable and constraint names? */
5187  );
5188 
5189 /** writes transformed problem which are valid in the current node to file
5190  *
5191  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5192  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5193  *
5194  * @pre This method can be called if @p scip is in one of the following stages:
5195  * - \ref SCIP_STAGE_TRANSFORMED
5196  * - \ref SCIP_STAGE_INITPRESOLVE
5197  * - \ref SCIP_STAGE_PRESOLVING
5198  * - \ref SCIP_STAGE_EXITPRESOLVE
5199  * - \ref SCIP_STAGE_PRESOLVED
5200  * - \ref SCIP_STAGE_INITSOLVE
5201  * - \ref SCIP_STAGE_SOLVING
5202  * - \ref SCIP_STAGE_SOLVED
5203  * - \ref SCIP_STAGE_EXITSOLVE
5204  *
5205  * @note If you want the write all constraints (including the once which are redundant for example), you need to set
5206  * the parameter <write/allconss> to TRUE
5207  */
5208 extern
5210  SCIP* scip, /**< SCIP data structure */
5211  const char* filename, /**< output file (or NULL for standard output) */
5212  const char* extension, /**< extension of the desired file reader,
5213  * or NULL if file extension should be used */
5214  SCIP_Bool genericnames /**< using generic variable and constraint names? */
5215  );
5216 
5217 /** frees problem and solution process data
5218  *
5219  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5220  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5221  *
5222  * @pre This method can be called if @p scip is in one of the following stages:
5223  * - \ref SCIP_STAGE_INIT
5224  * - \ref SCIP_STAGE_PROBLEM
5225  * - \ref SCIP_STAGE_TRANSFORMED
5226  * - \ref SCIP_STAGE_PRESOLVING
5227  * - \ref SCIP_STAGE_PRESOLVED
5228  * - \ref SCIP_STAGE_SOLVING
5229  * - \ref SCIP_STAGE_SOLVED
5230  * - \ref SCIP_STAGE_FREE
5231  *
5232  * @post After this method was called, SCIP is in the following stage:
5233  * - \ref SCIP_STAGE_INIT
5234  */
5235 extern
5237  SCIP* scip /**< SCIP data structure */
5238  );
5239 
5240 /** permutes parts of the problem data structure
5241  *
5242  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5243  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5244  *
5245  * @pre This method can be called if @p scip is in one of the following stages:
5246  * - \ref SCIP_STAGE_PROBLEM
5247  * - \ref SCIP_STAGE_TRANSFORMED
5248  */
5249 extern
5251  SCIP* scip, /**< SCIP data structure */
5252  unsigned int randseed, /**< seed value for random generator */
5253  SCIP_Bool permuteconss, /**< should the list of constraints in each constraint handler be permuted? */
5254  SCIP_Bool permutebinvars, /**< should the list of binary variables be permuted? */
5255  SCIP_Bool permuteintvars, /**< should the list of integer variables be permuted? */
5256  SCIP_Bool permuteimplvars, /**< should the list of implicit integer variables be permuted? */
5257  SCIP_Bool permutecontvars /**< should the list of continuous integer variables be permuted? */
5258  );
5259 
5260 /** gets user problem data
5261  *
5262  * @return a SCIP_PROBDATA pointer, or NULL if no problem data was allocated
5263  *
5264  * @pre This method can be called if @p scip is in one of the following stages:
5265  * - \ref SCIP_STAGE_PROBLEM
5266  * - \ref SCIP_STAGE_TRANSFORMING
5267  * - \ref SCIP_STAGE_TRANSFORMED
5268  * - \ref SCIP_STAGE_INITPRESOLVE
5269  * - \ref SCIP_STAGE_PRESOLVING
5270  * - \ref SCIP_STAGE_EXITPRESOLVE
5271  * - \ref SCIP_STAGE_PRESOLVED
5272  * - \ref SCIP_STAGE_INITSOLVE
5273  * - \ref SCIP_STAGE_SOLVING
5274  * - \ref SCIP_STAGE_SOLVED
5275  * - \ref SCIP_STAGE_EXITSOLVE
5276  * - \ref SCIP_STAGE_FREETRANS
5277  */
5278 extern
5280  SCIP* scip /**< SCIP data structure */
5281  );
5282 
5283 /** sets user problem data
5284  *
5285  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5286  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5287  *
5288  * @pre This method can be called if @p scip is in one of the following stages:
5289  * - \ref SCIP_STAGE_PROBLEM
5290  * - \ref SCIP_STAGE_TRANSFORMING
5291  * - \ref SCIP_STAGE_TRANSFORMED
5292  * - \ref SCIP_STAGE_INITPRESOLVE
5293  * - \ref SCIP_STAGE_PRESOLVING
5294  * - \ref SCIP_STAGE_EXITPRESOLVE
5295  * - \ref SCIP_STAGE_PRESOLVED
5296  * - \ref SCIP_STAGE_INITSOLVE
5297  * - \ref SCIP_STAGE_SOLVING
5298  * - \ref SCIP_STAGE_SOLVED
5299  * - \ref SCIP_STAGE_EXITSOLVE
5300  * - \ref SCIP_STAGE_FREETRANS
5301  */
5302 extern
5304  SCIP* scip, /**< SCIP data structure */
5305  SCIP_PROBDATA* probdata /**< user problem data to use */
5306  );
5307 
5308 /** returns name of the current problem instance
5309  *
5310  * @return name of the current problem instance
5311  *
5312  * @pre This method can be called if @p scip is in one of the following stages:
5313  * - \ref SCIP_STAGE_PROBLEM
5314  * - \ref SCIP_STAGE_TRANSFORMING
5315  * - \ref SCIP_STAGE_TRANSFORMED
5316  * - \ref SCIP_STAGE_INITPRESOLVE
5317  * - \ref SCIP_STAGE_PRESOLVING
5318  * - \ref SCIP_STAGE_EXITPRESOLVE
5319  * - \ref SCIP_STAGE_PRESOLVED
5320  * - \ref SCIP_STAGE_INITSOLVE
5321  * - \ref SCIP_STAGE_SOLVING
5322  * - \ref SCIP_STAGE_SOLVED
5323  * - \ref SCIP_STAGE_EXITSOLVE
5324  * - \ref SCIP_STAGE_FREETRANS
5325  */
5326 extern
5327 const char* SCIPgetProbName(
5328  SCIP* scip /**< SCIP data structure */
5329  );
5330 
5331 /** sets name of the current problem instance
5332  *
5333  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5334  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5335  *
5336  * @pre This method can be called if @p scip is in one of the following stages:
5337  * - \ref SCIP_STAGE_PROBLEM
5338  * - \ref SCIP_STAGE_TRANSFORMING
5339  * - \ref SCIP_STAGE_TRANSFORMED
5340  * - \ref SCIP_STAGE_INITPRESOLVE
5341  * - \ref SCIP_STAGE_PRESOLVING
5342  * - \ref SCIP_STAGE_EXITPRESOLVE
5343  * - \ref SCIP_STAGE_PRESOLVED
5344  * - \ref SCIP_STAGE_INITSOLVE
5345  * - \ref SCIP_STAGE_SOLVING
5346  * - \ref SCIP_STAGE_SOLVED
5347  * - \ref SCIP_STAGE_EXITSOLVE
5348  * - \ref SCIP_STAGE_FREETRANS
5349  */
5350 extern
5352  SCIP* scip, /**< SCIP data structure */
5353  const char* name /**< name to be set */
5354  );
5355 
5356 /** changes the objective function
5357  *
5358  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5359  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5360  *
5361  * @pre This method can be called if @p scip is in one of the following stages:
5362  * - \ref SCIP_STAGE_PROBLEM
5363  * - \ref SCIP_STAGE_PRESOLVED
5364  *
5365  * @note This method should be only used to change the objective function during two reoptimization runs and is only
5366  * recommended to an experienced user.
5367  *
5368  * @note All variables not given in \p vars array are assumed to have an objective coefficient of zero.
5369  */
5370 extern
5372  SCIP* scip, /**< SCIP data structure */
5373  SCIP_OBJSENSE objsense, /**< new objective function */
5374  SCIP_VAR** vars, /**< problem variables */
5375  SCIP_Real* coefs, /**< objective coefficients */
5376  int nvars /**< variables in vars array */
5377  );
5378 
5379 /** returns objective sense of original problem
5380  *
5381  * @return objective sense of original problem
5382  *
5383  * @pre This method can be called if @p scip is in one of the following stages:
5384  * - \ref SCIP_STAGE_PROBLEM
5385  * - \ref SCIP_STAGE_TRANSFORMING
5386  * - \ref SCIP_STAGE_TRANSFORMED
5387  * - \ref SCIP_STAGE_INITPRESOLVE
5388  * - \ref SCIP_STAGE_PRESOLVING
5389  * - \ref SCIP_STAGE_EXITPRESOLVE
5390  * - \ref SCIP_STAGE_PRESOLVED
5391  * - \ref SCIP_STAGE_INITSOLVE
5392  * - \ref SCIP_STAGE_SOLVING
5393  * - \ref SCIP_STAGE_SOLVED
5394  * - \ref SCIP_STAGE_EXITSOLVE
5395  * - \ref SCIP_STAGE_FREETRANS
5396  */
5397 extern
5399  SCIP* scip /**< SCIP data structure */
5400  );
5401 
5402 /** sets objective sense of problem
5403  *
5404  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5405  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5406  *
5407  * @pre This method can be called if @p scip is in one of the following stages:
5408  * - \ref SCIP_STAGE_PROBLEM
5409  */
5410 extern
5412  SCIP* scip, /**< SCIP data structure */
5413  SCIP_OBJSENSE objsense /**< new objective sense */
5414  );
5415 
5416 /** adds offset of objective function
5417  *
5418  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5419  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5420  *
5421  * @pre This method can be called if @p scip is in one of the following stages:
5422  * - \ref SCIP_STAGE_PRESOLVING
5423  */
5424 extern
5426  SCIP* scip, /**< SCIP data structure */
5427  SCIP_Real addval /**< value to add to objective offset */
5428  );
5429 
5430 /** adds offset of objective function to original problem and to all existing solution in original space
5431  *
5432  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5433  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5434  *
5435  * @pre This method can be called if @p scip is in one of the following stages:
5436  * - \ref SCIP_STAGE_PROBLEM
5437  */
5438 extern
5440  SCIP* scip, /**< SCIP data structure */
5441  SCIP_Real addval /**< value to add to objective offset */
5442  );
5443 
5444 /** returns the objective offset of the original problem
5445  *
5446  * @return the objective offset of the original problem
5447  *
5448  * @pre This method can be called if @p scip is in one of the following stages:
5449  * - \ref SCIP_STAGE_PROBLEM
5450  * - \ref SCIP_STAGE_TRANSFORMING
5451  * - \ref SCIP_STAGE_TRANSFORMED
5452  * - \ref SCIP_STAGE_INITPRESOLVE
5453  * - \ref SCIP_STAGE_PRESOLVING
5454  * - \ref SCIP_STAGE_EXITPRESOLVE
5455  * - \ref SCIP_STAGE_PRESOLVED
5456  * - \ref SCIP_STAGE_INITSOLVE
5457  * - \ref SCIP_STAGE_SOLVING
5458  * - \ref SCIP_STAGE_SOLVED
5459  */
5460 extern
5462  SCIP* scip /**< SCIP data structure */
5463  );
5464 
5465 /** returns the objective scale of the original problem
5466  *
5467  * @return the objective scale of the original problem
5468  *
5469  * @pre This method can be called if @p scip is in one of the following stages:
5470  * - \ref SCIP_STAGE_PROBLEM
5471  * - \ref SCIP_STAGE_TRANSFORMING
5472  * - \ref SCIP_STAGE_TRANSFORMED
5473  * - \ref SCIP_STAGE_INITPRESOLVE
5474  * - \ref SCIP_STAGE_PRESOLVING
5475  * - \ref SCIP_STAGE_EXITPRESOLVE
5476  * - \ref SCIP_STAGE_PRESOLVED
5477  * - \ref SCIP_STAGE_INITSOLVE
5478  * - \ref SCIP_STAGE_SOLVING
5479  * - \ref SCIP_STAGE_SOLVED
5480  */
5481 extern
5483  SCIP* scip /**< SCIP data structure */
5484  );
5485 
5486 /** returns the objective offset of the transformed problem
5487  *
5488  * @return the objective offset of the transformed problem
5489  *
5490  * @pre This method can be called if @p scip is in one of the following stages:
5491  * - \ref SCIP_STAGE_TRANSFORMED
5492  * - \ref SCIP_STAGE_INITPRESOLVE
5493  * - \ref SCIP_STAGE_PRESOLVING
5494  * - \ref SCIP_STAGE_EXITPRESOLVE
5495  * - \ref SCIP_STAGE_PRESOLVED
5496  * - \ref SCIP_STAGE_INITSOLVE
5497  * - \ref SCIP_STAGE_SOLVING
5498  * - \ref SCIP_STAGE_SOLVED
5499  */
5500 extern
5502  SCIP* scip /**< SCIP data structure */
5503  );
5504 
5505 /** returns the objective scale of the transformed problem
5506  *
5507  * @return the objective scale of the transformed problem
5508  *
5509  * @pre This method can be called if @p scip is in one of the following stages:
5510  * - \ref SCIP_STAGE_TRANSFORMED
5511  * - \ref SCIP_STAGE_INITPRESOLVE
5512  * - \ref SCIP_STAGE_PRESOLVING
5513  * - \ref SCIP_STAGE_EXITPRESOLVE
5514  * - \ref SCIP_STAGE_PRESOLVED
5515  * - \ref SCIP_STAGE_INITSOLVE
5516  * - \ref SCIP_STAGE_SOLVING
5517  * - \ref SCIP_STAGE_SOLVED
5518  */
5519 extern
5521  SCIP* scip /**< SCIP data structure */
5522  );
5523 
5524 /** sets limit on objective function, such that only solutions better than this limit are accepted
5525  *
5526  * @note SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune
5527  * all branch-and-bound nodes with dual bound equal or worse to the objective limit.
5528  * However, SCIP will also collect solutions with objective value worse than the objective limit and
5529  * use them to run improvement heuristics on them.
5530  * @note If SCIP can prove that there exists no solution with a strictly better objective value, the solving status
5531  * will normally be infeasible (the objective limit is interpreted as part of the problem).
5532  * The only exception is that by chance, SCIP found a solution with the same objective value and thus
5533  * proved the optimality of this solution, resulting in solution status optimal.
5534  *
5535  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5537  *
5538  * @pre This method can be called if @p scip is in one of the following stages:
5539  * - \ref SCIP_STAGE_PROBLEM
5540  * - \ref SCIP_STAGE_TRANSFORMED
5541  * - \ref SCIP_STAGE_INITPRESOLVE
5542  * - \ref SCIP_STAGE_PRESOLVING
5543  * - \ref SCIP_STAGE_EXITPRESOLVE
5544  * - \ref SCIP_STAGE_PRESOLVED
5545  * - \ref SCIP_STAGE_SOLVING
5546  */
5547 extern
5549  SCIP* scip, /**< SCIP data structure */
5550  SCIP_Real objlimit /**< new primal objective limit */
5551  );
5552 
5553 /** returns current limit on objective function
5554  *
5555  * @return the current objective limit of the original problem
5556  *
5557  * @pre This method can be called if @p scip is in one of the following stages:
5558  * - \ref SCIP_STAGE_PROBLEM
5559  * - \ref SCIP_STAGE_TRANSFORMING
5560  * - \ref SCIP_STAGE_TRANSFORMED
5561  * - \ref SCIP_STAGE_INITPRESOLVE
5562  * - \ref SCIP_STAGE_PRESOLVING
5563  * - \ref SCIP_STAGE_EXITPRESOLVE
5564  * - \ref SCIP_STAGE_PRESOLVED
5565  * - \ref SCIP_STAGE_INITSOLVE
5566  * - \ref SCIP_STAGE_SOLVING
5567  * - \ref SCIP_STAGE_SOLVED
5568  */
5569 extern
5571  SCIP* scip /**< SCIP data structure */
5572  );
5573 
5574 /** informs SCIP, that the objective value is always integral in every feasible solution
5575  *
5576  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
5577  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5578  *
5579  * @pre This method can be called if @p scip is in one of the following stages:
5580  * - \ref SCIP_STAGE_PROBLEM
5581  * - \ref SCIP_STAGE_TRANSFORMING
5582  * - \ref SCIP_STAGE_INITPRESOLVE
5583  * - \ref SCIP_STAGE_EXITPRESOLVE
5584  * - \ref SCIP_STAGE_SOLVING
5585  *
5586  * @note This function should be used to inform SCIP that the objective function is integral, helping to improve the
5587  * performance. This is useful when using column generation. If no column generation (pricing) is used, SCIP
5588  * automatically detects whether the objective function is integral or can be scaled to be integral. However, in
5589  * any case, the user has to make sure that no variable is added during the solving process that destroys this
5590  * property.
5591  */
5592 extern
5594  SCIP* scip /**< SCIP data structure */
5595  );
5596 
5597 /** returns whether the objective value is known to be integral in every feasible solution
5598  *
5599  * @return TRUE, if objective value is known to be always integral, otherwise FALSE
5600  *
5601  * @pre This method can be called if @p scip is in one of the following stages:
5602  * - \ref SCIP_STAGE_PROBLEM
5603  * - \ref SCIP_STAGE_TRANSFORMING
5604  * - \ref SCIP_STAGE_INITPRESOLVE
5605  * - \ref SCIP_STAGE_PRESOLVING
5606  * - \ref SCIP_STAGE_EXITPRESOLVE
5607  * - \ref SCIP_STAGE_PRESOLVED
5608  * - \ref SCIP_STAGE_SOLVING
5609  *
5610  * @note If no pricing is performed, SCIP automatically detects whether the objective function is integral or can be
5611  * scaled to be integral, helping to improve performance. This function returns the result. Otherwise
5612  * SCIPsetObjIntegral() can be used to inform SCIP. However, in any case, the user has to make sure that no
5613  * variable is added during the solving process that destroys this property.
5614  */
5615 extern
5617  SCIP* scip /**< SCIP data structure */
5618  );
5619 
5620 /** returns the Euclidean norm of the objective function vector (available only for transformed problem)
5621  *
5622  * @return the Euclidean norm of the transformed objective function vector
5623  *
5624  * @pre This method can be called if @p scip is in one of the following stages:
5625  * - \ref SCIP_STAGE_TRANSFORMED
5626  * - \ref SCIP_STAGE_INITPRESOLVE
5627  * - \ref SCIP_STAGE_PRESOLVING
5628  * - \ref SCIP_STAGE_EXITPRESOLVE
5629  * - \ref SCIP_STAGE_PRESOLVED
5630  * - \ref SCIP_STAGE_INITSOLVE
5631  * - \ref SCIP_STAGE_SOLVING
5632  * - \ref SCIP_STAGE_SOLVED
5633  * - \ref SCIP_STAGE_EXITSOLVE
5634  */
5635 extern
5637  SCIP* scip /**< SCIP data structure */
5638  );
5639 
5640 /** adds variable to the problem
5641  *
5642  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5643  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5644  *
5645  * @pre This method can be called if @p scip is in one of the following stages:
5646  * - \ref SCIP_STAGE_PROBLEM
5647  * - \ref SCIP_STAGE_TRANSFORMING
5648  * - \ref SCIP_STAGE_INITPRESOLVE
5649  * - \ref SCIP_STAGE_PRESOLVING
5650  * - \ref SCIP_STAGE_EXITPRESOLVE
5651  * - \ref SCIP_STAGE_PRESOLVED
5652  * - \ref SCIP_STAGE_SOLVING
5653  */
5654 extern
5656  SCIP* scip, /**< SCIP data structure */
5657  SCIP_VAR* var /**< variable to add */
5658  );
5659 
5660 /** adds variable to the problem and uses it as pricing candidate to enter the LP
5661  *
5662  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5663  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5664  *
5665  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
5666  */
5667 extern
5669  SCIP* scip, /**< SCIP data structure */
5670  SCIP_VAR* var, /**< variable to add */
5671  SCIP_Real score /**< pricing score of variable (the larger, the better the variable) */
5672  );
5673 
5674 /** removes variable from the problem
5675  *
5676  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5677  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5678  *
5679  * @pre This method can be called if @p scip is in one of the following stages:
5680  * - \ref SCIP_STAGE_PROBLEM
5681  * - \ref SCIP_STAGE_TRANSFORMING
5682  * - \ref SCIP_STAGE_TRANSFORMED
5683  * - \ref SCIP_STAGE_PRESOLVING
5684  * - \ref SCIP_STAGE_FREETRANS
5685  */
5686 extern
5688  SCIP* scip, /**< SCIP data structure */
5689  SCIP_VAR* var, /**< variable to delete */
5690  SCIP_Bool* deleted /**< pointer to store whether variable was successfully marked to be deleted */
5691  );
5692 
5693 /** gets variables of the problem along with the numbers of different variable types; data may become invalid after
5694  * calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5695  *
5696  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5697  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5698  *
5699  * @pre This method can be called if @p scip is in one of the following stages:
5700  * - \ref SCIP_STAGE_PROBLEM
5701  * - \ref SCIP_STAGE_TRANSFORMED
5702  * - \ref SCIP_STAGE_INITPRESOLVE
5703  * - \ref SCIP_STAGE_PRESOLVING
5704  * - \ref SCIP_STAGE_EXITPRESOLVE
5705  * - \ref SCIP_STAGE_PRESOLVED
5706  * - \ref SCIP_STAGE_INITSOLVE
5707  * - \ref SCIP_STAGE_SOLVING
5708  * - \ref SCIP_STAGE_SOLVED
5709  * - \ref SCIP_STAGE_EXITSOLVE
5710  *
5711  * @note Variables in the vars array are ordered: binaries first, then integers, implicit integers and continuous last.
5712  */
5713 extern
5715  SCIP* scip, /**< SCIP data structure */
5716  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5717  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5718  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5719  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5720  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5721  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5722  );
5723 
5724 /** gets array with active problem variables
5725  *
5726  * @return array with active problem variables
5727  *
5728  * @pre This method can be called if @p scip is in one of the following stages:
5729  * - \ref SCIP_STAGE_PROBLEM
5730  * - \ref SCIP_STAGE_TRANSFORMED
5731  * - \ref SCIP_STAGE_INITPRESOLVE
5732  * - \ref SCIP_STAGE_PRESOLVING
5733  * - \ref SCIP_STAGE_EXITPRESOLVE
5734  * - \ref SCIP_STAGE_PRESOLVED
5735  * - \ref SCIP_STAGE_INITSOLVE
5736  * - \ref SCIP_STAGE_SOLVING
5737  * - \ref SCIP_STAGE_SOLVED
5738  * - \ref SCIP_STAGE_EXITSOLVE
5739  *
5740  * @warning If your are using the methods which add or change bound of variables (e.g., SCIPchgVarType(), SCIPfixVar(),
5741  * SCIPaggregateVars(), and SCIPmultiaggregateVar()), it can happen that the internal variable array (which is
5742  * accessed via this method) gets resized and/or resorted. This can invalid the data pointer which is returned
5743  * by this method.
5744  *
5745  * @note Variables in the array are ordered: binaries first, then integers, implicit integers and continuous last.
5746  */
5747 extern
5749  SCIP* scip /**< SCIP data structure */
5750  );
5751 
5752 /** gets number of active problem variables
5753  *
5754  * @return the number of active problem variables
5755  *
5756  * @pre This method can be called if @p scip is in one of the following stages:
5757  * - \ref SCIP_STAGE_PROBLEM
5758  * - \ref SCIP_STAGE_TRANSFORMED
5759  * - \ref SCIP_STAGE_INITPRESOLVE
5760  * - \ref SCIP_STAGE_PRESOLVING
5761  * - \ref SCIP_STAGE_EXITPRESOLVE
5762  * - \ref SCIP_STAGE_PRESOLVED
5763  * - \ref SCIP_STAGE_INITSOLVE
5764  * - \ref SCIP_STAGE_SOLVING
5765  * - \ref SCIP_STAGE_SOLVED
5766  * - \ref SCIP_STAGE_EXITSOLVE
5767  */
5768 extern
5769 int SCIPgetNVars(
5770  SCIP* scip /**< SCIP data structure */
5771  );
5772 
5773 /** gets number of binary active problem variables
5774  *
5775  * @return the number of binary active problem variables
5776  *
5777  * @pre This method can be called if @p scip is in one of the following stages:
5778  * - \ref SCIP_STAGE_PROBLEM
5779  * - \ref SCIP_STAGE_TRANSFORMED
5780  * - \ref SCIP_STAGE_INITPRESOLVE
5781  * - \ref SCIP_STAGE_PRESOLVING
5782  * - \ref SCIP_STAGE_EXITPRESOLVE
5783  * - \ref SCIP_STAGE_PRESOLVED
5784  * - \ref SCIP_STAGE_INITSOLVE
5785  * - \ref SCIP_STAGE_SOLVING
5786  * - \ref SCIP_STAGE_SOLVED
5787  * - \ref SCIP_STAGE_EXITSOLVE
5788  */
5789 extern
5790 int SCIPgetNBinVars(
5791  SCIP* scip /**< SCIP data structure */
5792  );
5793 
5794 /** gets number of integer active problem variables
5795  *
5796  * @return the number of integer active problem variables
5797  *
5798  * @pre This method can be called if @p scip is in one of the following stages:
5799  * - \ref SCIP_STAGE_PROBLEM
5800  * - \ref SCIP_STAGE_TRANSFORMED
5801  * - \ref SCIP_STAGE_INITPRESOLVE
5802  * - \ref SCIP_STAGE_PRESOLVING
5803  * - \ref SCIP_STAGE_EXITPRESOLVE
5804  * - \ref SCIP_STAGE_PRESOLVED
5805  * - \ref SCIP_STAGE_INITSOLVE
5806  * - \ref SCIP_STAGE_SOLVING
5807  * - \ref SCIP_STAGE_SOLVED
5808  * - \ref SCIP_STAGE_EXITSOLVE
5809  */
5810 extern
5811 int SCIPgetNIntVars(
5812  SCIP* scip /**< SCIP data structure */
5813  );
5814 
5815 /** gets number of implicit integer active problem variables
5816  *
5817  * @return the number of implicit integer active problem variables
5818  *
5819  * @pre This method can be called if @p scip is in one of the following stages:
5820  * - \ref SCIP_STAGE_PROBLEM
5821  * - \ref SCIP_STAGE_TRANSFORMED
5822  * - \ref SCIP_STAGE_INITPRESOLVE
5823  * - \ref SCIP_STAGE_PRESOLVING
5824  * - \ref SCIP_STAGE_EXITPRESOLVE
5825  * - \ref SCIP_STAGE_PRESOLVED
5826  * - \ref SCIP_STAGE_INITSOLVE
5827  * - \ref SCIP_STAGE_SOLVING
5828  * - \ref SCIP_STAGE_SOLVED
5829  * - \ref SCIP_STAGE_EXITSOLVE
5830  */
5831 extern
5832 int SCIPgetNImplVars(
5833  SCIP* scip /**< SCIP data structure */
5834  );
5835 
5836 /** gets number of continuous active problem variables
5837  *
5838  * @return the number of continuous active problem variables
5839  *
5840  * @pre This method can be called if @p scip is in one of the following stages:
5841  * - \ref SCIP_STAGE_PROBLEM
5842  * - \ref SCIP_STAGE_TRANSFORMED
5843  * - \ref SCIP_STAGE_INITPRESOLVE
5844  * - \ref SCIP_STAGE_PRESOLVING
5845  * - \ref SCIP_STAGE_EXITPRESOLVE
5846  * - \ref SCIP_STAGE_PRESOLVED
5847  * - \ref SCIP_STAGE_INITSOLVE
5848  * - \ref SCIP_STAGE_SOLVING
5849  * - \ref SCIP_STAGE_SOLVED
5850  * - \ref SCIP_STAGE_EXITSOLVE
5851  */
5852 extern
5853 int SCIPgetNContVars(
5854  SCIP* scip /**< SCIP data structure */
5855  );
5856 
5857 /** gets number of active problem variables with a non-zero objective coefficient
5858  *
5859  * @note In case of the original problem the number of variables is counted. In case of the transformed problem the
5860  * number of variables is just returned since it is stored internally
5861  *
5862  * @return the number of active problem variables with a non-zero objective coefficient
5863  *
5864  * @pre This method can be called if @p scip is in one of the following stages:
5865  * - \ref SCIP_STAGE_PROBLEM
5866  * - \ref SCIP_STAGE_TRANSFORMED
5867  * - \ref SCIP_STAGE_INITPRESOLVE
5868  * - \ref SCIP_STAGE_PRESOLVING
5869  * - \ref SCIP_STAGE_EXITPRESOLVE
5870  * - \ref SCIP_STAGE_PRESOLVED
5871  * - \ref SCIP_STAGE_INITSOLVE
5872  * - \ref SCIP_STAGE_SOLVING
5873  * - \ref SCIP_STAGE_SOLVED
5874  */
5875 extern
5876 int SCIPgetNObjVars(
5877  SCIP* scip /**< SCIP data structure */
5878  );
5879 
5880 /** gets array with fixed and aggregated problem variables; data may become invalid after
5881  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5882  *
5883  * @return an array with fixed and aggregated problem variables; data may become invalid after
5884  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5885  *
5886  * @pre This method can be called if @p scip is in one of the following stages:
5887  * - \ref SCIP_STAGE_PROBLEM
5888  * - \ref SCIP_STAGE_TRANSFORMED
5889  * - \ref SCIP_STAGE_INITPRESOLVE
5890  * - \ref SCIP_STAGE_PRESOLVING
5891  * - \ref SCIP_STAGE_EXITPRESOLVE
5892  * - \ref SCIP_STAGE_PRESOLVED
5893  * - \ref SCIP_STAGE_INITSOLVE
5894  * - \ref SCIP_STAGE_SOLVING
5895  * - \ref SCIP_STAGE_SOLVED
5896  */
5897 extern
5899  SCIP* scip /**< SCIP data structure */
5900  );
5901 
5902 /** gets number of fixed or aggregated problem variables
5903  *
5904  * @return the number of fixed or aggregated problem variables
5905  *
5906  * @pre This method can be called if @p scip is in one of the following stages:
5907  * - \ref SCIP_STAGE_PROBLEM
5908  * - \ref SCIP_STAGE_TRANSFORMED
5909  * - \ref SCIP_STAGE_INITPRESOLVE
5910  * - \ref SCIP_STAGE_PRESOLVING
5911  * - \ref SCIP_STAGE_EXITPRESOLVE
5912  * - \ref SCIP_STAGE_PRESOLVED
5913  * - \ref SCIP_STAGE_INITSOLVE
5914  * - \ref SCIP_STAGE_SOLVING
5915  * - \ref SCIP_STAGE_SOLVED
5916  */
5917 extern
5918 int SCIPgetNFixedVars(
5919  SCIP* scip /**< SCIP data structure */
5920  );
5921 
5922 /** gets variables of the original problem along with the numbers of different variable types; data may become invalid
5923  * after a call to SCIPchgVarType()
5924  *
5925  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5926  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5927  *
5928  * @pre This method can be called if @p scip is in one of the following stages:
5929  * - \ref SCIP_STAGE_PROBLEM
5930  * - \ref SCIP_STAGE_TRANSFORMING
5931  * - \ref SCIP_STAGE_TRANSFORMED
5932  * - \ref SCIP_STAGE_INITPRESOLVE
5933  * - \ref SCIP_STAGE_PRESOLVING
5934  * - \ref SCIP_STAGE_EXITPRESOLVE
5935  * - \ref SCIP_STAGE_PRESOLVED
5936  * - \ref SCIP_STAGE_INITSOLVE
5937  * - \ref SCIP_STAGE_SOLVING
5938  * - \ref SCIP_STAGE_SOLVED
5939  * - \ref SCIP_STAGE_EXITSOLVE
5940  * - \ref SCIP_STAGE_FREETRANS
5941  */
5942 extern
5944  SCIP* scip, /**< SCIP data structure */
5945  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5946  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5947  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5948  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5949  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5950  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5951  );
5952 
5953 /** gets array with original problem variables; data may become invalid after
5954  * a call to SCIPchgVarType()
5955  *
5956  * @return an array with original problem variables; data may become invalid after
5957  * a call to SCIPchgVarType()
5958  *
5959  * @pre This method can be called if @p scip is in one of the following stages:
5960  * - \ref SCIP_STAGE_PROBLEM
5961  * - \ref SCIP_STAGE_TRANSFORMING
5962  * - \ref SCIP_STAGE_TRANSFORMED
5963  * - \ref SCIP_STAGE_INITPRESOLVE
5964  * - \ref SCIP_STAGE_PRESOLVING
5965  * - \ref SCIP_STAGE_EXITPRESOLVE
5966  * - \ref SCIP_STAGE_PRESOLVED
5967  * - \ref SCIP_STAGE_INITSOLVE
5968  * - \ref SCIP_STAGE_SOLVING
5969  * - \ref SCIP_STAGE_SOLVED
5970  * - \ref SCIP_STAGE_EXITSOLVE
5971  * - \ref SCIP_STAGE_FREETRANS
5972  */
5973 extern
5975  SCIP* scip /**< SCIP data structure */
5976  );
5977 
5978 /** gets number of original problem variables
5979  *
5980  * @return the number of original problem variables
5981  *
5982  * @pre This method can be called if @p scip is in one of the following stages:
5983  * - \ref SCIP_STAGE_PROBLEM
5984  * - \ref SCIP_STAGE_TRANSFORMING
5985  * - \ref SCIP_STAGE_TRANSFORMED
5986  * - \ref SCIP_STAGE_INITPRESOLVE
5987  * - \ref SCIP_STAGE_PRESOLVING
5988  * - \ref SCIP_STAGE_EXITPRESOLVE
5989  * - \ref SCIP_STAGE_PRESOLVED
5990  * - \ref SCIP_STAGE_INITSOLVE
5991  * - \ref SCIP_STAGE_SOLVING
5992  * - \ref SCIP_STAGE_SOLVED
5993  * - \ref SCIP_STAGE_EXITSOLVE
5994  * - \ref SCIP_STAGE_FREETRANS
5995  */
5996 extern
5997 int SCIPgetNOrigVars(
5998  SCIP* scip /**< SCIP data structure */
5999  );
6000 
6001 /** gets number of binary variables in the original problem
6002  *
6003  * @return the number of binary variables in the original problem
6004  *
6005  * @pre This method can be called if @p scip is in one of the following stages:
6006  * - \ref SCIP_STAGE_PROBLEM
6007  * - \ref SCIP_STAGE_TRANSFORMING
6008  * - \ref SCIP_STAGE_TRANSFORMED
6009  * - \ref SCIP_STAGE_INITPRESOLVE
6010  * - \ref SCIP_STAGE_PRESOLVING
6011  * - \ref SCIP_STAGE_EXITPRESOLVE
6012  * - \ref SCIP_STAGE_PRESOLVED
6013  * - \ref SCIP_STAGE_INITSOLVE
6014  * - \ref SCIP_STAGE_SOLVING
6015  * - \ref SCIP_STAGE_SOLVED
6016  * - \ref SCIP_STAGE_EXITSOLVE
6017  * - \ref SCIP_STAGE_FREETRANS
6018  */
6019 extern
6021  SCIP* scip /**< SCIP data structure */
6022  );
6023 
6024 /** gets the number of integer variables in the original problem
6025  *
6026  * @return the number of integer variables in the original problem
6027  *
6028  * @pre This method can be called if @p scip is in one of the following stages:
6029  * - \ref SCIP_STAGE_PROBLEM
6030  * - \ref SCIP_STAGE_TRANSFORMING
6031  * - \ref SCIP_STAGE_TRANSFORMED
6032  * - \ref SCIP_STAGE_INITPRESOLVE
6033  * - \ref SCIP_STAGE_PRESOLVING
6034  * - \ref SCIP_STAGE_EXITPRESOLVE
6035  * - \ref SCIP_STAGE_PRESOLVED
6036  * - \ref SCIP_STAGE_INITSOLVE
6037  * - \ref SCIP_STAGE_SOLVING
6038  * - \ref SCIP_STAGE_SOLVED
6039  * - \ref SCIP_STAGE_EXITSOLVE
6040  * - \ref SCIP_STAGE_FREETRANS
6041  */
6042 extern
6044  SCIP* scip /**< SCIP data structure */
6045  );
6046 
6047 /** gets number of implicit integer variables in the original problem
6048  *
6049  * @return the number of implicit integer variables in the original problem
6050  *
6051  * @pre This method can be called if @p scip is in one of the following stages:
6052  * - \ref SCIP_STAGE_PROBLEM
6053  * - \ref SCIP_STAGE_TRANSFORMING
6054  * - \ref SCIP_STAGE_TRANSFORMED
6055  * - \ref SCIP_STAGE_INITPRESOLVE
6056  * - \ref SCIP_STAGE_PRESOLVING
6057  * - \ref SCIP_STAGE_EXITPRESOLVE
6058  * - \ref SCIP_STAGE_PRESOLVED
6059  * - \ref SCIP_STAGE_INITSOLVE
6060  * - \ref SCIP_STAGE_SOLVING
6061  * - \ref SCIP_STAGE_SOLVED
6062  * - \ref SCIP_STAGE_EXITSOLVE
6063  * - \ref SCIP_STAGE_FREETRANS
6064  */
6065 extern
6067  SCIP* scip /**< SCIP data structure */
6068  );
6069 
6070 /** gets number of continuous variables in the original problem
6071  *
6072  * @return the number of continuous variables in the original problem
6073  *
6074  * @pre This method can be called if @p scip is in one of the following stages:
6075  * - \ref SCIP_STAGE_PROBLEM
6076  * - \ref SCIP_STAGE_TRANSFORMING
6077  * - \ref SCIP_STAGE_TRANSFORMED
6078  * - \ref SCIP_STAGE_INITPRESOLVE
6079  * - \ref SCIP_STAGE_PRESOLVING
6080  * - \ref SCIP_STAGE_EXITPRESOLVE
6081  * - \ref SCIP_STAGE_PRESOLVED
6082  * - \ref SCIP_STAGE_INITSOLVE
6083  * - \ref SCIP_STAGE_SOLVING
6084  * - \ref SCIP_STAGE_SOLVED
6085  * - \ref SCIP_STAGE_EXITSOLVE
6086  * - \ref SCIP_STAGE_FREETRANS
6087  */
6088 extern
6090  SCIP* scip /**< SCIP data structure */
6091  );
6092 
6093 /** gets number of all problem variables created during creation and solving of problem;
6094  * this includes also variables that were deleted in the meantime
6095  *
6096  * @return the number of all problem variables created during creation and solving of problem;
6097  * this includes also variables that were deleted in the meantime
6098  *
6099  * @pre This method can be called if @p scip is in one of the following stages:
6100  * - \ref SCIP_STAGE_PROBLEM
6101  * - \ref SCIP_STAGE_TRANSFORMING
6102  * - \ref SCIP_STAGE_TRANSFORMED
6103  * - \ref SCIP_STAGE_INITPRESOLVE
6104  * - \ref SCIP_STAGE_PRESOLVING
6105  * - \ref SCIP_STAGE_EXITPRESOLVE
6106  * - \ref SCIP_STAGE_PRESOLVED
6107  * - \ref SCIP_STAGE_INITSOLVE
6108  * - \ref SCIP_STAGE_SOLVING
6109  * - \ref SCIP_STAGE_SOLVED
6110  * - \ref SCIP_STAGE_EXITSOLVE
6111  * - \ref SCIP_STAGE_FREETRANS
6112  */
6113 extern
6114 int SCIPgetNTotalVars(
6115  SCIP* scip /**< SCIP data structure */
6116  );
6117 
6118 /** gets variables of the original or transformed problem along with the numbers of different variable types;
6119  * the returned problem space (original or transformed) corresponds to the given solution;
6120  * data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and
6121  * SCIPmultiaggregateVar()
6122  *
6123  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6124  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6125  *
6126  * @pre This method can be called if @p scip is in one of the following stages:
6127  * - \ref SCIP_STAGE_PROBLEM
6128  * - \ref SCIP_STAGE_TRANSFORMED
6129  * - \ref SCIP_STAGE_INITPRESOLVE
6130  * - \ref SCIP_STAGE_PRESOLVING
6131  * - \ref SCIP_STAGE_EXITPRESOLVE
6132  * - \ref SCIP_STAGE_PRESOLVED
6133  * - \ref SCIP_STAGE_INITSOLVE
6134  * - \ref SCIP_STAGE_SOLVING
6135  * - \ref SCIP_STAGE_SOLVED
6136  */
6137 extern
6139  SCIP* scip, /**< SCIP data structure */
6140  SCIP_SOL* sol, /**< primal solution that selects the problem space, NULL for current solution */
6141  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
6142  int* nvars, /**< pointer to store number of variables or NULL if not needed */
6143  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
6144  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
6145  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
6146  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
6147  );
6148 
6149 /** returns variable of given name in the problem, or NULL if not existing
6150  *
6151  * @return variable of given name in the problem, or NULL if not existing
6152  *
6153  * @pre This method can be called if @p scip is in one of the following stages:
6154  * - \ref SCIP_STAGE_PROBLEM
6155  * - \ref SCIP_STAGE_TRANSFORMING
6156  * - \ref SCIP_STAGE_TRANSFORMED
6157  * - \ref SCIP_STAGE_INITPRESOLVE
6158  * - \ref SCIP_STAGE_PRESOLVING
6159  * - \ref SCIP_STAGE_EXITPRESOLVE
6160  * - \ref SCIP_STAGE_PRESOLVED
6161  * - \ref SCIP_STAGE_INITSOLVE
6162  * - \ref SCIP_STAGE_SOLVING
6163  * - \ref SCIP_STAGE_SOLVED
6164  * - \ref SCIP_STAGE_EXITSOLVE
6165  * - \ref SCIP_STAGE_FREETRANS
6166  */
6167 extern
6169  SCIP* scip, /**< SCIP data structure */
6170  const char* name /**< name of variable to find */
6171  );
6172 
6173 /** returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables,
6174  * that will be added in pricing and improve the objective value
6175  *
6176  * @return TRUE, if all potential variables exist in the problem; FALSE, otherwise
6177  *
6178  * @pre This method can be called if @p scip is in one of the following stages:
6179  * - \ref SCIP_STAGE_TRANSFORMING
6180  * - \ref SCIP_STAGE_TRANSFORMED
6181  * - \ref SCIP_STAGE_INITPRESOLVE
6182  * - \ref SCIP_STAGE_PRESOLVING
6183  * - \ref SCIP_STAGE_EXITPRESOLVE
6184  * - \ref SCIP_STAGE_PRESOLVED
6185  * - \ref SCIP_STAGE_INITSOLVE
6186  * - \ref SCIP_STAGE_SOLVING
6187  * - \ref SCIP_STAGE_SOLVED
6188  * - \ref SCIP_STAGE_EXITSOLVE
6189  * - \ref SCIP_STAGE_FREETRANS
6190  */
6191 extern
6193  SCIP* scip /**< SCIP data structure */
6194  );
6195 
6196 /** adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the
6197  * current node (and all of its subnodes); otherwise it is added to the global problem;
6198  * if a local constraint is added at the root node, it is automatically upgraded into a global constraint
6199  *
6200  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6201  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6202  *
6203  * @pre This method can be called if @p scip is in one of the following stages:
6204  * - \ref SCIP_STAGE_PROBLEM
6205  * - \ref SCIP_STAGE_INITPRESOLVE
6206  * - \ref SCIP_STAGE_PRESOLVING
6207  * - \ref SCIP_STAGE_EXITPRESOLVE
6208  * - \ref SCIP_STAGE_PRESOLVED
6209  * - \ref SCIP_STAGE_INITSOLVE
6210  * - \ref SCIP_STAGE_SOLVING
6211  * - \ref SCIP_STAGE_EXITSOLVE
6212  */
6213 extern
6215  SCIP* scip, /**< SCIP data structure */
6216  SCIP_CONS* cons /**< constraint to add */
6217  );
6218 
6219 /** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
6220  * node, where it was added, or from the problem, if it was a problem constraint
6221  *
6222  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6223  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6224  *
6225  * @pre This method can be called if @p scip is in one of the following stages:
6226  * - \ref SCIP_STAGE_PROBLEM
6227  * - \ref SCIP_STAGE_INITPRESOLVE
6228  * - \ref SCIP_STAGE_PRESOLVING
6229  * - \ref SCIP_STAGE_EXITPRESOLVE
6230  * - \ref SCIP_STAGE_INITSOLVE
6231  * - \ref SCIP_STAGE_SOLVING
6232  * - \ref SCIP_STAGE_EXITSOLVE
6233  */
6234 extern
6236  SCIP* scip, /**< SCIP data structure */
6237  SCIP_CONS* cons /**< constraint to delete */
6238  );
6239 
6240 /** returns original constraint of given name in the problem, or NULL if not existing
6241  *
6242  * @return original constraint of given name in the problem, or NULL if not existing
6243  *
6244  * @pre This method can be called if @p scip is in one of the following stages:
6245  * - \ref SCIP_STAGE_PROBLEM
6246  * - \ref SCIP_STAGE_TRANSFORMING
6247  * - \ref SCIP_STAGE_TRANSFORMED
6248  * - \ref SCIP_STAGE_INITPRESOLVE
6249  * - \ref SCIP_STAGE_PRESOLVING
6250  * - \ref SCIP_STAGE_EXITPRESOLVE
6251  * - \ref SCIP_STAGE_INITSOLVE
6252  * - \ref SCIP_STAGE_SOLVING
6253  * - \ref SCIP_STAGE_SOLVED
6254  * - \ref SCIP_STAGE_EXITSOLVE
6255  * - \ref SCIP_STAGE_FREETRANS */
6256 extern
6258  SCIP* scip, /**< SCIP data structure */
6259  const char* name /**< name of constraint to find */
6260  );
6261 
6262 /** returns constraint of given name in the problem, or NULL if not existing
6263  *
6264  * @return constraint of given name in the problem, or NULL if not existing
6265  *
6266  * @pre This method can be called if @p scip is in one of the following stages:
6267  * - \ref SCIP_STAGE_PROBLEM
6268  * - \ref SCIP_STAGE_TRANSFORMING
6269  * - \ref SCIP_STAGE_TRANSFORMED
6270  * - \ref SCIP_STAGE_INITPRESOLVE
6271  * - \ref SCIP_STAGE_PRESOLVING
6272  * - \ref SCIP_STAGE_EXITPRESOLVE
6273  * - \ref SCIP_STAGE_PRESOLVED
6274  * - \ref SCIP_STAGE_INITSOLVE
6275  * - \ref SCIP_STAGE_SOLVING
6276  * - \ref SCIP_STAGE_SOLVED
6277  * - \ref SCIP_STAGE_EXITSOLVE
6278  * - \ref SCIP_STAGE_FREETRANS
6279  */
6280 extern
6282  SCIP* scip, /**< SCIP data structure */
6283  const char* name /**< name of constraint to find */
6284  );
6285 
6286 /** gets number of upgraded constraints
6287  *
6288  * @return number of upgraded constraints
6289  *
6290  * @pre This method can be called if @p scip is in one of the following stages:
6291  * - \ref SCIP_STAGE_PROBLEM
6292  * - \ref SCIP_STAGE_TRANSFORMED
6293  * - \ref SCIP_STAGE_INITPRESOLVE
6294  * - \ref SCIP_STAGE_PRESOLVING
6295  * - \ref SCIP_STAGE_PRESOLVED
6296  * - \ref SCIP_STAGE_EXITPRESOLVE
6297  * - \ref SCIP_STAGE_SOLVING
6298  * - \ref SCIP_STAGE_SOLVED
6299  */
6300 extern
6301 int SCIPgetNUpgrConss(
6302  SCIP* scip /**< SCIP data structure */
6303  );
6304 
6305 /** gets total number of globally valid constraints currently in the problem
6306  *
6307  * @return total number of globally valid constraints currently in the problem
6308  *
6309  * @pre This method can be called if @p scip is in one of the following stages:
6310  * - \ref SCIP_STAGE_PROBLEM
6311  * - \ref SCIP_STAGE_TRANSFORMED
6312  * - \ref SCIP_STAGE_INITPRESOLVE
6313  * - \ref SCIP_STAGE_PRESOLVING
6314  * - \ref SCIP_STAGE_EXITPRESOLVE
6315  * - \ref SCIP_STAGE_PRESOLVED
6316  * - \ref SCIP_STAGE_INITSOLVE
6317  * - \ref SCIP_STAGE_SOLVING
6318  * - \ref SCIP_STAGE_SOLVED
6319  */
6320 extern
6321 int SCIPgetNConss(
6322  SCIP* scip /**< SCIP data structure */
6323  );
6324 
6325 /** gets array of globally valid constraints currently in the problem
6326  *
6327  * @return array of globally valid constraints currently in the problem
6328  *
6329  * @pre This method can be called if @p scip is in one of the following stages:
6330  * - \ref SCIP_STAGE_PROBLEM
6331  * - \ref SCIP_STAGE_TRANSFORMED
6332  * - \ref SCIP_STAGE_INITPRESOLVE
6333  * - \ref SCIP_STAGE_PRESOLVING
6334  * - \ref SCIP_STAGE_EXITPRESOLVE
6335  * - \ref SCIP_STAGE_PRESOLVED
6336  * - \ref SCIP_STAGE_SOLVING
6337  * - \ref SCIP_STAGE_SOLVED
6338  *
6339  * @warning If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is
6340  * accessed via this method) gets resized. This can invalid the pointer which is returned by this method.
6341  */
6342 extern
6344  SCIP* scip /**< SCIP data structure */
6345  );
6346 
6347 /** gets total number of constraints in the original problem
6348  *
6349  * @return total number of constraints in the original problem
6350  *
6351  * @pre This method can be called if @p scip is in one of the following stages:
6352  * - \ref SCIP_STAGE_PROBLEM
6353  * - \ref SCIP_STAGE_TRANSFORMING
6354  * - \ref SCIP_STAGE_TRANSFORMED
6355  * - \ref SCIP_STAGE_INITPRESOLVE
6356  * - \ref SCIP_STAGE_PRESOLVING
6357  * - \ref SCIP_STAGE_EXITPRESOLVE
6358  * - \ref SCIP_STAGE_PRESOLVED
6359  * - \ref SCIP_STAGE_INITSOLVE
6360  * - \ref SCIP_STAGE_SOLVING
6361  * - \ref SCIP_STAGE_SOLVED
6362  * - \ref SCIP_STAGE_EXITSOLVE
6363  * - \ref SCIP_STAGE_FREETRANS
6364  */
6365 extern
6366 int SCIPgetNOrigConss(
6367  SCIP* scip /**< SCIP data structure */
6368  );
6369 
6370 /** gets array of constraints in the original problem
6371  *
6372  * @return array of constraints in the original problem
6373  *
6374  * @pre This method can be called if @p scip is in one of the following stages:
6375  * - \ref SCIP_STAGE_PROBLEM
6376  * - \ref SCIP_STAGE_TRANSFORMING
6377  * - \ref SCIP_STAGE_TRANSFORMED
6378  * - \ref SCIP_STAGE_INITPRESOLVE
6379  * - \ref SCIP_STAGE_PRESOLVING
6380  * - \ref SCIP_STAGE_EXITPRESOLVE
6381  * - \ref SCIP_STAGE_PRESOLVED
6382  * - \ref SCIP_STAGE_INITSOLVE
6383  * - \ref SCIP_STAGE_SOLVING
6384  * - \ref SCIP_STAGE_SOLVED
6385  * - \ref SCIP_STAGE_EXITSOLVE
6386  * - \ref SCIP_STAGE_FREETRANS
6387  */
6388 extern
6390  SCIP* scip /**< SCIP data structure */
6391  );
6392 
6393 /** computes the number of check constraint in the current node (loop over all constraint handler and cumulates the
6394  * number of check constraints)
6395  *
6396  * @return returns the number of check constraints
6397  *
6398  * @pre This method can be called if @p scip is in one of the following stages:
6399  * - \ref SCIP_STAGE_TRANSFORMED
6400  * - \ref SCIP_STAGE_INITPRESOLVE
6401  * - \ref SCIP_STAGE_PRESOLVING
6402  * - \ref SCIP_STAGE_EXITPRESOLVE
6403  * - \ref SCIP_STAGE_PRESOLVED
6404  * - \ref SCIP_STAGE_INITSOLVE
6405  * - \ref SCIP_STAGE_SOLVING
6406  */
6407 extern
6408 int SCIPgetNCheckConss(
6409  SCIP* scip /**< SCIP data structure */
6410  );
6411 
6412 /**@} */
6413 
6414 
6415 
6416 
6417 /*
6418  * local subproblem methods
6419  */
6420 
6421 /**@addtogroup LocalSubproblemMethods
6422  *
6423  * @{
6424  */
6425 
6426 /** adds a conflict to a given node or globally to the problem if @p node == NULL.
6427  *
6428  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6429  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6430  *
6431  * @pre this method can be called in one of the following stages of the SCIP solving process:
6432  * - \ref SCIP_STAGE_INITPRESOLVE
6433  * - \ref SCIP_STAGE_PRESOLVING
6434  * - \ref SCIP_STAGE_EXITPRESOLVE
6435  * - \ref SCIP_STAGE_SOLVING
6436  *
6437  * @note this method will release the constraint
6438  */
6439 extern
6441  SCIP* scip, /**< SCIP data structure */
6442  SCIP_NODE* node, /**< node to add conflict (or NULL if global) */
6443  SCIP_CONS* cons, /**< constraint representing the conflict */
6444  SCIP_NODE* validnode, /**< node at which the constraint is valid (or NULL) */
6445  SCIP_CONFTYPE conftype, /**< type of the conflict */
6446  SCIP_Bool iscutoffinvolved /**< is a cutoff bound involved in this conflict */
6447  );
6448 
6449 /** removes all conflicts depending on an old cutoff bound if the improvement of the incumbent is good enough
6450  *
6451  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6452  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6453  *
6454  * @pre this method can be called in one of the following stages of the SCIP solving process:
6455  * - \ref SCIP_STAGE_PRESOLVING
6456  * - \ref SCIP_STAGE_SOLVING
6457  */
6458 extern
6460  SCIP* scip, /**< SCIP data structure */
6461  SCIP_EVENT* event /**< event data */
6462  );
6463 
6464 /** adds constraint to the given node (and all of its subnodes), even if it is a global constraint;
6465  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
6466  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
6467  * only active in a small part of the tree although it is valid in a larger part.
6468  * In this case, one should pass the more global node where the constraint is valid as "validnode".
6469  * Note that the same constraint cannot be added twice to the branching tree with different "validnode" parameters.
6470  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
6471  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
6472  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
6473  *
6474  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6475  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6476  *
6477  * @pre this method can be called in one of the following stages of the SCIP solving process:
6478  * - \ref SCIP_STAGE_INITPRESOLVE
6479  * - \ref SCIP_STAGE_PRESOLVING
6480  * - \ref SCIP_STAGE_EXITPRESOLVE
6481  * - \ref SCIP_STAGE_SOLVING
6482  */
6483 extern
6485  SCIP* scip, /**< SCIP data structure */
6486  SCIP_NODE* node, /**< node to add constraint to */
6487  SCIP_CONS* cons, /**< constraint to add */
6488  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
6489  );
6490 
6491 /** adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint;
6492  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
6493  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
6494  * only active in a small part of the tree although it is valid in a larger part.
6495  *
6496  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
6497  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
6498  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
6499  *
6500  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6501  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6502  *
6503  * @pre this method can be called in one of the following stages of the SCIP solving process:
6504  * - \ref SCIP_STAGE_INITPRESOLVE
6505  * - \ref SCIP_STAGE_PRESOLVING
6506  * - \ref SCIP_STAGE_EXITPRESOLVE
6507  * - \ref SCIP_STAGE_SOLVING
6508  *
6509  * @note The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is
6510  * the case due internal data structures and performance issues. In such a case you should try to realize your
6511  * issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.
6512  */
6513 extern
6515  SCIP* scip, /**< SCIP data structure */
6516  SCIP_CONS* cons, /**< constraint to add */
6517  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
6518  );
6519 
6520 /** disables constraint's separation, enforcing, and propagation capabilities at the given node (and all subnodes);
6521  * if the method is called at the root node, the constraint is globally deleted from the problem;
6522  * the constraint deletion is being remembered at the given node, s.t. after leaving the node's subtree, the constraint
6523  * is automatically enabled again, and after entering the node's subtree, it is automatically disabled;
6524  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
6525  * alternatively, use SCIPdisableCons()
6526  *
6527  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6528  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6529  *
6530  * @pre this method can be called in one of the following stages of the SCIP solving process:
6531  * - \ref SCIP_STAGE_INITPRESOLVE
6532  * - \ref SCIP_STAGE_PRESOLVING
6533  * - \ref SCIP_STAGE_EXITPRESOLVE
6534  * - \ref SCIP_STAGE_SOLVING
6535  */
6536 extern
6538  SCIP* scip, /**< SCIP data structure */
6539  SCIP_NODE* node, /**< node to disable constraint in */
6540  SCIP_CONS* cons /**< constraint to locally delete */
6541  );
6542 
6543 /** disables constraint's separation, enforcing, and propagation capabilities at the current node (and all subnodes);
6544  * if the method is called during problem modification or at the root node, the constraint is globally deleted from
6545  * the problem;
6546  * the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the
6547  * constraint is automatically enabled again, and after reentering the current node's subtree, it is automatically
6548  * disabled again;
6549  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
6550  * alternatively, use SCIPdisableCons()
6551  *
6552  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6553  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6554  *
6555  * @pre this method can be called in one of the following stages of the SCIP solving process:
6556  * - \ref SCIP_STAGE_PROBLEM
6557  * - \ref SCIP_STAGE_INITPRESOLVE
6558  * - \ref SCIP_STAGE_PRESOLVING
6559  * - \ref SCIP_STAGE_EXITPRESOLVE
6560  * - \ref SCIP_STAGE_SOLVING
6561  */
6562 extern
6564  SCIP* scip, /**< SCIP data structure */
6565  SCIP_CONS* cons /**< constraint to locally delete */
6566  );
6567 
6568 /** gets estimate of best primal solution w.r.t. original problem contained in current subtree
6569  *
6570  * @return estimate of best primal solution w.r.t. original problem contained in current subtree
6571  *
6572  * @pre this method can be called in one of the following stages of the SCIP solving process:
6573  * - \ref SCIP_STAGE_SOLVING
6574  */
6575 extern
6577  SCIP* scip /**< SCIP data structure */
6578  );
6579 
6580 /** gets estimate of best primal solution w.r.t. transformed problem contained in current subtree
6581  *
6582  * @return estimate of best primal solution w.r.t. transformed problem contained in current subtree
6583  *
6584  * @pre this method can be called in one of the following stages of the SCIP solving process:
6585  * - \ref SCIP_STAGE_SOLVING
6586  */
6587 extern
6589  SCIP* scip /**< SCIP data structure */
6590  );
6591 
6592 /** gets dual bound of current node
6593  *
6594  * @return dual bound of current node
6595  *
6596  * @pre this method can be called in one of the following stages of the SCIP solving process:
6597  * - \ref SCIP_STAGE_SOLVING
6598  */
6599 extern
6601  SCIP* scip /**< SCIP data structure */
6602  );
6603 
6604 /** gets lower bound of current node in transformed problem
6605  *
6606  * @return lower bound of current node in transformed problem
6607  *
6608  * @pre this method can be called in one of the following stages of the SCIP solving process:
6609  * - \ref SCIP_STAGE_SOLVING
6610  */
6611 extern
6613  SCIP* scip /**< SCIP data structure */
6614  );
6615 
6616 /** gets dual bound of given node
6617  *
6618  * @return dual bound of a given node
6619  *
6620  * @pre this method can be called in one of the following stages of the SCIP solving process:
6621  * - \ref SCIP_STAGE_SOLVING
6622  */
6623 extern
6625  SCIP* scip, /**< SCIP data structure */
6626  SCIP_NODE* node /**< node to get dual bound for */
6627  );
6628 
6629 /** gets lower bound of given node in transformed problem
6630  *
6631  * @return lower bound of given node in transformed problem
6632  *
6633  * @pre this method can be called in one of the following stages of the SCIP solving process:
6634  * - \ref SCIP_STAGE_SOLVING
6635  */
6636 extern
6638  SCIP* scip, /**< SCIP data structure */
6639  SCIP_NODE* node /**< node to get dual bound for */
6640  );
6641 
6642 /** if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in
6643  * original problem space), sets the current node's dual bound to the new value
6644  *
6645  * @note the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.
6646  *
6647  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6648  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6649  *
6650  * @pre this method can be called in one of the following stages of the SCIP solving process:
6651  * - \ref SCIP_STAGE_PROBLEM
6652  * - \ref SCIP_STAGE_PRESOLVING
6653  * - \ref SCIP_STAGE_PRESOLVED
6654  * - \ref SCIP_STAGE_SOLVING
6655  */
6656 extern
6658  SCIP* scip, /**< SCIP data structure */
6659  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
6660  );
6661 
6662 /** if given value is larger than the current node's lower bound (in transformed problem), sets the current node's
6663  * lower bound to the new value
6664  *
6665  * @note the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.
6666  *
6667  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6668  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6669  *
6670  * @pre this method can be called in one of the following stages of the SCIP solving process:
6671  * - \ref SCIP_STAGE_PRESOLVING
6672  * - \ref SCIP_STAGE_PRESOLVED
6673  * - \ref SCIP_STAGE_SOLVING
6674  */
6675 extern
6677  SCIP* scip, /**< SCIP data structure */
6678  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
6679  );
6680 
6681 /** if given value is tighter (larger for minimization, smaller for maximization) than the node's dual bound,
6682  * sets the node's dual bound to the new value
6683  *
6684  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6685  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6686  *
6687  * @pre this method can be called in one of the following stages of the SCIP solving process:
6688  * - \ref SCIP_STAGE_SOLVING
6689  */
6690 extern
6692  SCIP* scip, /**< SCIP data structure */
6693  SCIP_NODE* node, /**< node to update dual bound for */
6694  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
6695  );
6696 
6697 /** if given value is larger than the node's lower bound (in transformed problem), sets the node's lower bound
6698  * to the new value
6699  *
6700  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6701  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6702  *
6703  * @pre this method can be called in one of the following stages of the SCIP solving process:
6704  * - \ref SCIP_STAGE_SOLVING
6705  */
6706 extern
6708  SCIP* scip, /**< SCIP data structure */
6709  SCIP_NODE* node, /**< node to update lower bound for */
6710  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
6711  );
6712 
6713 /** change the node selection priority of the given child
6714  *
6715  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6716  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6717  *
6718  * @pre this method can be called in one of the following stages of the SCIP solving process:
6719  * - \ref SCIP_STAGE_SOLVING
6720  */
6721 extern
6723  SCIP* scip, /**< SCIP data structure */
6724  SCIP_NODE* child, /**< child to update the node selection priority */
6725  SCIP_Real priority /**< node selection priority value */
6726  );
6727 
6728 /**@} */
6729 
6730 
6731 
6732 
6733 /*
6734  * solve methods
6735  */
6736 
6737 /**@addtogroup PublicSolveMethods
6738  *
6739  * @{
6740  */
6741 
6742 /** initializes solving data structures and transforms problem
6743  *
6744  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6745  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6746  *
6747  * @pre This method can be called if @p scip is in one of the following stages:
6748  * - \ref SCIP_STAGE_PROBLEM
6749  * - \ref SCIP_STAGE_TRANSFORMED
6750  * - \ref SCIP_STAGE_INITPRESOLVE
6751  * - \ref SCIP_STAGE_PRESOLVING
6752  * - \ref SCIP_STAGE_EXITPRESOLVE
6753  * - \ref SCIP_STAGE_PRESOLVED
6754  * - \ref SCIP_STAGE_INITSOLVE
6755  * - \ref SCIP_STAGE_SOLVING
6756  * - \ref SCIP_STAGE_SOLVED
6757  * - \ref SCIP_STAGE_EXITSOLVE
6758  * - \ref SCIP_STAGE_FREETRANS
6759  * - \ref SCIP_STAGE_FREE
6760  *
6761  * @post When calling this method in the \ref SCIP_STAGE_PROBLEM stage, the \SCIP stage is changed to \ref
6762  * SCIP_STAGE_TRANSFORMED; otherwise, the stage is not changed
6763  *
6764  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6765  */
6766 extern
6768  SCIP* scip /**< SCIP data structure */
6769  );
6770 
6771 /** transforms and presolves problem
6772  *
6773  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6774  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6775  *
6776  * @pre This method can be called if @p scip is in one of the following stages:
6777  * - \ref SCIP_STAGE_PROBLEM
6778  * - \ref SCIP_STAGE_TRANSFORMED
6779  * - \ref SCIP_STAGE_PRESOLVING
6780  * - \ref SCIP_STAGE_PRESOLVED
6781  *
6782  * @post After calling this method \SCIP reaches one of the following stages:
6783  * - \ref SCIP_STAGE_PRESOLVING if the presolving process was interrupted
6784  * - \ref SCIP_STAGE_PRESOLVED if the presolving process was finished and did not solve the problem
6785  * - \ref SCIP_STAGE_SOLVED if the problem was solved during presolving
6786  *
6787  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6788  */
6789 extern
6791  SCIP* scip /**< SCIP data structure */
6792  );
6793 
6794 /** transforms, presolves, and solves problem
6795  *
6796  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6797  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6798  *
6799  * @pre This method can be called if @p scip is in one of the following stages:
6800  * - \ref SCIP_STAGE_PROBLEM
6801  * - \ref SCIP_STAGE_TRANSFORMED
6802  * - \ref SCIP_STAGE_PRESOLVING
6803  * - \ref SCIP_STAGE_PRESOLVED
6804  * - \ref SCIP_STAGE_SOLVING
6805  * - \ref SCIP_STAGE_SOLVED
6806  *
6807  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
6808  * process was interrupted:
6809 
6810  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
6811  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
6812  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
6813  *
6814  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6815  */
6816 extern
6818  SCIP* scip /**< SCIP data structure */
6819  );
6820 
6821 /** transforms, presolves, and solves problem using additional solvers which emphasize on
6822  * finding solutions.
6823  *
6824  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6825  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6826  *
6827  * @pre This method can be called if @p scip is in one of the following stages:
6828  * - \ref SCIP_STAGE_PROBLEM
6829  * - \ref SCIP_STAGE_TRANSFORMED
6830  * - \ref SCIP_STAGE_PRESOLVING
6831  * - \ref SCIP_STAGE_PRESOLVED
6832  * - \ref SCIP_STAGE_SOLVING
6833  * - \ref SCIP_STAGE_SOLVED
6834  *
6835  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
6836  * process was interrupted:
6837  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
6838  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
6839  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
6840  *
6841  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6842  */
6843 extern
6845  SCIP* scip /**< SCIP data structure */
6846  );
6847 
6848 /** frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is
6849  * preserved
6850  *
6851  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6852  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6853  *
6854  * @pre This method can be called if @p scip is in one of the following stages:
6855  * - \ref SCIP_STAGE_INIT
6856  * - \ref SCIP_STAGE_PROBLEM
6857  * - \ref SCIP_STAGE_TRANSFORMED
6858  * - \ref SCIP_STAGE_PRESOLVING
6859  * - \ref SCIP_STAGE_PRESOLVED
6860  * - \ref SCIP_STAGE_SOLVING
6861  * - \ref SCIP_STAGE_SOLVED
6862  *
6863  * @post If this method is called in \SCIP stage \ref SCIP_STAGE_INIT or \ref SCIP_STAGE_PROBLEM, the stage of
6864  * \SCIP is not changed; otherwise, the \SCIP stage is changed to \ref SCIP_STAGE_TRANSFORMED
6865  *
6866  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6867  */
6868 extern
6870  SCIP* scip, /**< SCIP data structure */
6871  SCIP_Bool restart /**< should certain data be preserved for improved restarting? */
6872  );
6873 
6874 /** frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is
6875  * preserved
6876  *
6877  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6878  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6879  *
6880  * @pre This method can be called if @p scip is in one of the following stages:
6881  * - \ref SCIP_STAGE_INIT
6882  * - \ref SCIP_STAGE_PROBLEM
6883  * - \ref SCIP_STAGE_TRANSFORMED
6884  * - \ref SCIP_STAGE_PRESOLVING
6885  * - \ref SCIP_STAGE_PRESOLVED
6886  * - \ref SCIP_STAGE_SOLVING
6887  * - \ref SCIP_STAGE_SOLVED
6888  *
6889  * @post If this method is called in \SCIP stage \ref SCIP_STAGE_INIT or \ref SCIP_STAGE_PROBLEM, the stage of
6890  * \SCIP is not changed; otherwise, the \SCIP stage is changed to \ref SCIP_STAGE_PRESOLVED.
6891  *
6892  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6893  */
6894 extern
6896  SCIP* scip /**< SCIP data structure */
6897  );
6898 
6899 /** frees all solution process data including presolving and transformed problem, only original problem is kept
6900  *
6901  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6902  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6903  *
6904  * @pre This method can be called if @p scip is in one of the following stages:
6905  * - \ref SCIP_STAGE_INIT
6906  * - \ref SCIP_STAGE_PROBLEM
6907  * - \ref SCIP_STAGE_TRANSFORMED
6908  * - \ref SCIP_STAGE_PRESOLVING
6909  * - \ref SCIP_STAGE_PRESOLVED
6910  * - \ref SCIP_STAGE_SOLVING
6911  * - \ref SCIP_STAGE_SOLVED
6912  *
6913  * @post After calling this method \SCIP reaches one of the following stages:
6914  * - \ref SCIP_STAGE_INIT if the method was called from \SCIP stage \ref SCIP_STAGE_INIT
6915  * - \ref SCIP_STAGE_PROBLEM if the method was called from any other of the allowed stages
6916  *
6917  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6918  */
6919 extern
6921  SCIP* scip /**< SCIP data structure */
6922  );
6923 
6924 /** informs \SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has
6925  * been solved)
6926  *
6927  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6928  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6929  *
6930  * @pre This method can be called if @p scip is in one of the following stages:
6931  * - \ref SCIP_STAGE_PROBLEM
6932  * - \ref SCIP_STAGE_TRANSFORMING
6933  * - \ref SCIP_STAGE_TRANSFORMED
6934  * - \ref SCIP_STAGE_INITPRESOLVE
6935  * - \ref SCIP_STAGE_PRESOLVING
6936  * - \ref SCIP_STAGE_EXITPRESOLVE
6937  * - \ref SCIP_STAGE_PRESOLVED
6938  * - \ref SCIP_STAGE_SOLVING
6939  * - \ref SCIP_STAGE_SOLVED
6940  * - \ref SCIP_STAGE_EXITSOLVE
6941  * - \ref SCIP_STAGE_FREETRANS
6942  *
6943  * @note the \SCIP stage does not get changed
6944  */
6945 extern
6947  SCIP* scip /**< SCIP data structure */
6948  );
6949 
6950 /** informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has
6951  * been solved)
6952  *
6953  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6954  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6955  *
6956  * @pre This method can be called if @p scip is in one of the following stages:
6957  * - \ref SCIP_STAGE_INITPRESOLVE
6958  * - \ref SCIP_STAGE_PRESOLVING
6959  * - \ref SCIP_STAGE_EXITPRESOLVE
6960  * - \ref SCIP_STAGE_SOLVING
6961  *
6962  * @note the \SCIP stage does not get changed
6963  */
6964 extern
6966  SCIP* scip /**< SCIP data structure */
6967  );
6968 
6969 /** include specific heuristics and branching rules for reoptimization
6970  *
6971  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6972  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6973  *
6974  * @pre This method can be called if @p scip is in one of the following stages:
6975  * - \ref SCIP_STAGE_PROBLEM
6976  */
6977 extern
6979  SCIP* scip, /**< SCIP data structure */
6980  SCIP_Bool enable /**< enable reoptimization (TRUE) or disable it (FALSE) */
6981  );
6982 
6983 /** returns whether reoptimization is enabled or not */
6984 extern
6986  SCIP* scip /**< SCIP data structure */
6987  );
6988 
6989 /** returns the stored solutions corresponding to a given run */
6990 extern
6992  SCIP* scip, /**< SCIP data structue */
6993  int run, /**< number of the run */
6994  SCIP_SOL** sols, /**< array to store solutions */
6995  int allocmem, /**< allocated size of the array */
6996  int* nsols /**< number of solutions */
6997  );
6998 
6999 /** mark all stored solutions as not updated */
7000 extern
7002  SCIP* scip /**< SCIP data structure */
7003  );
7004 
7005 /** check if the reoptimization process should be restarted
7006  *
7007  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7008  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7009  *
7010  * @pre This method can be called if @p scip is in one of the following stages:
7011  * - \ref SCIP_STAGE_TRANSFORMED
7012  * - \ref SCIP_STAGE_SOLVING
7013  */
7014 extern
7016  SCIP* scip, /**< SCIP data structure */
7017  SCIP_NODE* node, /**< current node of the branch and bound tree (or NULL) */
7018  SCIP_Bool* restart /**< pointer to store of the reoptimitation process should be restarted */
7019  );
7020 
7021 /** save bound change based on dual information in the reoptimization tree
7022  *
7023  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7024  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7025  *
7026  * @pre This method can be called if @p scip is in one of the following stages:
7027  * - \ref SCIP_STAGE_SOLVING
7028  * - \ref SCIP_STAGE_SOLVED
7029  */
7030 extern
7032  SCIP* scip, /**< SCIP data structure */
7033  SCIP_NODE* node, /**< node of the search tree */
7034  SCIP_VAR* var, /**< variable whose bound changed */
7035  SCIP_Real newbound, /**< new bound of the variable */
7036  SCIP_Real oldbound /**< old bound of the variable */
7037  );
7038 
7039 /** returns the optimal solution of the last iteration or NULL of none exists */
7040 extern
7042  SCIP* scip /**< SCIP data structure */
7043  );
7044 
7045 /** returns the objective coefficent of a given variable in a previous iteration
7046  *
7047  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7048  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7049  *
7050  * @pre This method can be called if @p scip is in one of the following stages:
7051  * - \ref SCIP_STAGE_PRESOLVING
7052  * - \ref SCIP_STAGE_SOLVING
7053  */
7054 extern
7056  SCIP* scip, /**< SCIP data structure */
7057  SCIP_VAR* var, /**< variable */
7058  int run, /**< number of the run */
7059  SCIP_Real* objcoef /**< pointer to store the objective coefficient */
7060  );
7061 
7062 /** returns whether we are in the restarting phase
7063  *
7064  * @return TRUE, if we are in the restarting phase; FALSE, otherwise
7065  *
7066  * @pre This method can be called if @p scip is in one of the following stages:
7067  * - \ref SCIP_STAGE_INITPRESOLVE
7068  * - \ref SCIP_STAGE_PRESOLVING
7069  * - \ref SCIP_STAGE_EXITPRESOLVE
7070  * - \ref SCIP_STAGE_PRESOLVED
7071  * - \ref SCIP_STAGE_INITSOLVE
7072  * - \ref SCIP_STAGE_SOLVING
7073  * - \ref SCIP_STAGE_SOLVED
7074  * - \ref SCIP_STAGE_EXITSOLVE
7075  * - \ref SCIP_STAGE_FREETRANS
7076  */
7077 extern
7079  SCIP* scip /**< SCIP data structure */
7080  );
7081 
7082 /**@} */
7083 
7084 
7085 
7086 
7087 /*
7088  * variable methods
7089  */
7090 
7091 /**@addtogroup PublicVariableMethods
7092  *
7093  *@{
7094  */
7095 
7096 /** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded;
7097  * an integer variable with bounds zero and one is automatically converted into a binary variable;
7098  *
7099  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
7100  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
7101  * original objective function value of variables created during the solving process has to be multiplied by
7102  * -1, too.
7103  *
7104  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7105  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7106  *
7107  * @pre This method can be called if @p scip is in one of the following stages:
7108  * - \ref SCIP_STAGE_PROBLEM
7109  * - \ref SCIP_STAGE_TRANSFORMING
7110  * - \ref SCIP_STAGE_INITPRESOLVE
7111  * - \ref SCIP_STAGE_PRESOLVING
7112  * - \ref SCIP_STAGE_EXITPRESOLVE
7113  * - \ref SCIP_STAGE_PRESOLVED
7114  * - \ref SCIP_STAGE_SOLVING
7115  *
7116  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
7117  */
7118 extern
7120  SCIP* scip, /**< SCIP data structure */
7121  SCIP_VAR** var, /**< pointer to variable object */
7122  const char* name, /**< name of variable, or NULL for automatic name creation */
7123  SCIP_Real lb, /**< lower bound of variable */
7124  SCIP_Real ub, /**< upper bound of variable */
7125  SCIP_Real obj, /**< objective function value */
7126  SCIP_VARTYPE vartype, /**< type of variable */
7127  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
7128  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
7129  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
7130  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
7131  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
7132  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
7133  SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */
7134  );
7135 
7136 /** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set
7137  * afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(),
7138  * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE
7139  * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.;
7140  * if variable is of integral type, fractional bounds are automatically rounded;
7141  * an integer variable with bounds zero and one is automatically converted into a binary variable;
7142  *
7143  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
7144  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
7145  * original objective function value of variables created during the solving process has to be multiplied by
7146  * -1, too.
7147  *
7148  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7149  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7150  *
7151  * @pre This method can be called if @p scip is in one of the following stages:
7152  * - \ref SCIP_STAGE_PROBLEM
7153  * - \ref SCIP_STAGE_TRANSFORMING
7154  * - \ref SCIP_STAGE_INITPRESOLVE
7155  * - \ref SCIP_STAGE_PRESOLVING
7156  * - \ref SCIP_STAGE_EXITPRESOLVE
7157  * - \ref SCIP_STAGE_PRESOLVED
7158  * - \ref SCIP_STAGE_SOLVING
7159  *
7160  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
7161  */
7162 extern
7164  SCIP* scip, /**< SCIP data structure */
7165  SCIP_VAR** var, /**< pointer to variable object */
7166  const char* name, /**< name of variable, or NULL for automatic name creation */
7167  SCIP_Real lb, /**< lower bound of variable */
7168  SCIP_Real ub, /**< upper bound of variable */
7169  SCIP_Real obj, /**< objective function value */
7170  SCIP_VARTYPE vartype /**< type of variable */
7171  );
7172 
7173 /** outputs the variable name to the file stream
7174  *
7175  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7176  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7177  *
7178  * @pre This method can be called if @p scip is in one of the following stages:
7179  * - \ref SCIP_STAGE_PROBLEM
7180  * - \ref SCIP_STAGE_TRANSFORMING
7181  * - \ref SCIP_STAGE_TRANSFORMED
7182  * - \ref SCIP_STAGE_INITPRESOLVE
7183  * - \ref SCIP_STAGE_PRESOLVING
7184  * - \ref SCIP_STAGE_EXITPRESOLVE
7185  * - \ref SCIP_STAGE_PRESOLVED
7186  * - \ref SCIP_STAGE_INITSOLVE
7187  * - \ref SCIP_STAGE_SOLVING
7188  * - \ref SCIP_STAGE_SOLVED
7189  * - \ref SCIP_STAGE_EXITSOLVE
7190  * - \ref SCIP_STAGE_FREETRANS
7191  */
7192 extern
7194  SCIP* scip, /**< SCIP data structure */
7195  FILE* file, /**< output file, or NULL for stdout */
7196  SCIP_VAR* var, /**< variable to output */
7197  SCIP_Bool type /**< should the variable type be also posted */
7198  );
7199 
7200 /** print the given list of variables to output stream separated by the given delimiter character;
7201  *
7202  * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
7203  *
7204  * the method SCIPparseVarsList() can parse such a string
7205  *
7206  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7207  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7208  *
7209  * @pre This method can be called if @p scip is in one of the following stages:
7210  * - \ref SCIP_STAGE_PROBLEM
7211  * - \ref SCIP_STAGE_TRANSFORMING
7212  * - \ref SCIP_STAGE_TRANSFORMED
7213  * - \ref SCIP_STAGE_INITPRESOLVE
7214  * - \ref SCIP_STAGE_PRESOLVING
7215  * - \ref SCIP_STAGE_EXITPRESOLVE
7216  * - \ref SCIP_STAGE_PRESOLVED
7217  * - \ref SCIP_STAGE_INITSOLVE
7218  * - \ref SCIP_STAGE_SOLVING
7219  * - \ref SCIP_STAGE_SOLVED
7220  * - \ref SCIP_STAGE_EXITSOLVE
7221  * - \ref SCIP_STAGE_FREETRANS
7222  *
7223  * @note The printing process is done via the message handler system.
7224  */
7225 extern
7227  SCIP* scip, /**< SCIP data structure */
7228  FILE* file, /**< output file, or NULL for stdout */
7229  SCIP_VAR** vars, /**< variable array to output */
7230  int nvars, /**< number of variables */
7231  SCIP_Bool type, /**< should the variable type be also posted */
7232  char delimiter /**< character which is used for delimitation */
7233  );
7234 
7235 /** print the given variables and coefficients as linear sum in the following form
7236  * c1 <x1> + c2 <x2> ... + cn <xn>
7237  *
7238  * This string can be parsed by the method SCIPparseVarsLinearsum().
7239  *
7240  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7241  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7242  *
7243  * @pre This method can be called if @p scip is in one of the following stages:
7244  * - \ref SCIP_STAGE_PROBLEM
7245  * - \ref SCIP_STAGE_TRANSFORMING
7246  * - \ref SCIP_STAGE_TRANSFORMED
7247  * - \ref SCIP_STAGE_INITPRESOLVE
7248  * - \ref SCIP_STAGE_PRESOLVING
7249  * - \ref SCIP_STAGE_EXITPRESOLVE
7250  * - \ref SCIP_STAGE_PRESOLVED
7251  * - \ref SCIP_STAGE_INITSOLVE
7252  * - \ref SCIP_STAGE_SOLVING
7253  * - \ref SCIP_STAGE_SOLVED
7254  * - \ref SCIP_STAGE_EXITSOLVE
7255  * - \ref SCIP_STAGE_FREETRANS
7256  *
7257  * @note The printing process is done via the message handler system.
7258  */
7259 extern
7261  SCIP* scip, /**< SCIP data structure */
7262  FILE* file, /**< output file, or NULL for stdout */
7263  SCIP_VAR** vars, /**< variable array to output */
7264  SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
7265  int nvars, /**< number of variables */
7266  SCIP_Bool type /**< should the variable type be also posted */
7267  );
7268 
7269 /** print the given monomials as polynomial in the following form
7270  * c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...
7271  *
7272  * This string can be parsed by the method SCIPparseVarsPolynomial().
7273  *
7274  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7275  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7276  *
7277  * @pre This method can be called if @p scip is in one of the following stages:
7278  * - \ref SCIP_STAGE_PROBLEM
7279  * - \ref SCIP_STAGE_TRANSFORMING
7280  * - \ref SCIP_STAGE_TRANSFORMED
7281  * - \ref SCIP_STAGE_INITPRESOLVE
7282  * - \ref SCIP_STAGE_PRESOLVING
7283  * - \ref SCIP_STAGE_EXITPRESOLVE
7284  * - \ref SCIP_STAGE_PRESOLVED
7285  * - \ref SCIP_STAGE_INITSOLVE
7286  * - \ref SCIP_STAGE_SOLVING
7287  * - \ref SCIP_STAGE_SOLVED
7288  * - \ref SCIP_STAGE_EXITSOLVE
7289  * - \ref SCIP_STAGE_FREETRANS
7290  *
7291  * @note The printing process is done via the message handler system.
7292  */
7293 extern
7295  SCIP* scip, /**< SCIP data structure */
7296  FILE* file, /**< output file, or NULL for stdout */
7297  SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */
7298  SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */
7299  SCIP_Real* monomialcoefs, /**< array with monomial coefficients */
7300  int* monomialnvars, /**< array with number of variables for each monomial */
7301  int nmonomials, /**< number of monomials */
7302  SCIP_Bool type /**< should the variable type be also posted */
7303  );
7304 
7305 /** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
7306  * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
7307  * variable with bounds zero and one is automatically converted into a binary variable
7308  *
7309  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7310  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7311  *
7312  * @pre This method can be called if @p scip is in one of the following stages:
7313  * - \ref SCIP_STAGE_PROBLEM
7314  * - \ref SCIP_STAGE_TRANSFORMING
7315  * - \ref SCIP_STAGE_INITPRESOLVE
7316  * - \ref SCIP_STAGE_PRESOLVING
7317  * - \ref SCIP_STAGE_EXITPRESOLVE
7318  * - \ref SCIP_STAGE_PRESOLVED
7319  * - \ref SCIP_STAGE_SOLVING
7320  */
7321 extern
7323  SCIP* scip, /**< SCIP data structure */
7324  SCIP_VAR** var, /**< pointer to store the problem variable */
7325  const char* str, /**< string to parse */
7326  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
7327  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
7328  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
7329  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
7330  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
7331  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
7332  SCIP_VARDATA* vardata, /**< user data for this specific variable */
7333  char** endptr, /**< pointer to store the final string position if successful */
7334  SCIP_Bool* success /**< pointer store if the paring process was successful */
7335  );
7336 
7337 /** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
7338  * exits and returns the position where the parsing stopped
7339  *
7340  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7341  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7342  *
7343  * @pre This method can be called if @p scip is in one of the following stages:
7344  * - \ref SCIP_STAGE_PROBLEM
7345  * - \ref SCIP_STAGE_TRANSFORMING
7346  * - \ref SCIP_STAGE_INITPRESOLVE
7347  * - \ref SCIP_STAGE_PRESOLVING
7348  * - \ref SCIP_STAGE_EXITPRESOLVE
7349  * - \ref SCIP_STAGE_PRESOLVED
7350  * - \ref SCIP_STAGE_SOLVING
7351  */
7352 extern
7354  SCIP* scip, /**< SCIP data structure */
7355  const char* str, /**< string to parse */
7356  SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */
7357  char** endptr /**< pointer to store the final string position if successful */
7358  );
7359 
7360 /** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
7361  * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
7362  *
7363  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7364  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7365  *
7366  * @pre This method can be called if @p scip is in one of the following stages:
7367  * - \ref SCIP_STAGE_PROBLEM
7368  * - \ref SCIP_STAGE_TRANSFORMING
7369  * - \ref SCIP_STAGE_INITPRESOLVE
7370  * - \ref SCIP_STAGE_PRESOLVING
7371  * - \ref SCIP_STAGE_EXITPRESOLVE
7372  * - \ref SCIP_STAGE_PRESOLVED
7373  * - \ref SCIP_STAGE_SOLVING
7374  *
7375  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
7376  *
7377  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
7378  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
7379  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
7380  * memory functions).
7381  */
7382 extern
7384  SCIP* scip, /**< SCIP data structure */
7385  const char* str, /**< string to parse */
7386  SCIP_VAR** vars, /**< array to store the parsed variable */
7387  int* nvars, /**< pointer to store number of parsed variables */
7388  int varssize, /**< size of the variable array */
7389  int* requiredsize, /**< pointer to store the required array size for the active variables */
7390  char** endptr, /**< pointer to store the final string position if successful */
7391  char delimiter, /**< character which is used for delimitation */
7392  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7393  );
7394 
7395 /** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
7396  * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
7397  *
7398  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7399  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7400  *
7401  * @pre This method can be called if @p scip is in one of the following stages:
7402  * - \ref SCIP_STAGE_PROBLEM
7403  * - \ref SCIP_STAGE_TRANSFORMING
7404  * - \ref SCIP_STAGE_INITPRESOLVE
7405  * - \ref SCIP_STAGE_PRESOLVING
7406  * - \ref SCIP_STAGE_EXITPRESOLVE
7407  * - \ref SCIP_STAGE_PRESOLVED
7408  * - \ref SCIP_STAGE_SOLVING
7409  *
7410  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
7411  *
7412  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
7413  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
7414  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
7415  * memory functions).
7416  */
7417 extern
7419  SCIP* scip, /**< SCIP data structure */
7420  const char* str, /**< string to parse */
7421  SCIP_VAR** vars, /**< array to store the parsed variables */
7422  SCIP_Real* vals, /**< array to store the parsed coefficients */
7423  int* nvars, /**< pointer to store number of parsed variables */
7424  int varssize, /**< size of the variable array */
7425  int* requiredsize, /**< pointer to store the required array size for the active variables */
7426  char** endptr, /**< pointer to store the final string position if successful */
7427  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7428  );
7429 
7430 /** parse the given string as polynomial of variables and coefficients
7431  * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
7432  * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
7433  *
7434  * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
7435  * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
7436  * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
7437  * they use buffer memory that is intended for short term use only.
7438  *
7439  * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
7440  * are recognized.
7441  *
7442  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7443  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7444  *
7445  * @pre This method can be called if @p scip is in one of the following stages:
7446  * - \ref SCIP_STAGE_PROBLEM
7447  * - \ref SCIP_STAGE_TRANSFORMING
7448  * - \ref SCIP_STAGE_INITPRESOLVE
7449  * - \ref SCIP_STAGE_PRESOLVING
7450  * - \ref SCIP_STAGE_EXITPRESOLVE
7451  * - \ref SCIP_STAGE_PRESOLVED
7452  * - \ref SCIP_STAGE_SOLVING
7453  */
7454 extern
7456  SCIP* scip, /**< SCIP data structure */
7457  const char* str, /**< string to parse */
7458  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
7459  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
7460  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
7461  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
7462  int* nmonomials, /**< pointer to store number of parsed monomials */
7463  char** endptr, /**< pointer to store the final string position if successful */
7464  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
7465  );
7466 
7467 /** frees memory allocated when parsing a polynomial from a string
7468  *
7469  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7470  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7471  *
7472  * @pre This method can be called if @p scip is in one of the following stages:
7473  * - \ref SCIP_STAGE_PROBLEM
7474  * - \ref SCIP_STAGE_TRANSFORMING
7475  * - \ref SCIP_STAGE_INITPRESOLVE
7476  * - \ref SCIP_STAGE_PRESOLVING
7477  * - \ref SCIP_STAGE_EXITPRESOLVE
7478  * - \ref SCIP_STAGE_PRESOLVED
7479  * - \ref SCIP_STAGE_SOLVING
7480  */
7481 extern
7483  SCIP* scip, /**< SCIP data structure */
7484  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
7485  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
7486  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
7487  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
7488  int nmonomials /**< pointer to store number of parsed monomials */
7489  );
7490 
7491 /** increases usage counter of variable
7492  *
7493  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7494  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7495  *
7496  * @pre This method can be called if @p scip is in one of the following stages:
7497  * - \ref SCIP_STAGE_PROBLEM
7498  * - \ref SCIP_STAGE_TRANSFORMING
7499  * - \ref SCIP_STAGE_TRANSFORMED
7500  * - \ref SCIP_STAGE_INITPRESOLVE
7501  * - \ref SCIP_STAGE_PRESOLVING
7502  * - \ref SCIP_STAGE_EXITPRESOLVE
7503  * - \ref SCIP_STAGE_PRESOLVED
7504  * - \ref SCIP_STAGE_INITSOLVE
7505  * - \ref SCIP_STAGE_SOLVING
7506  * - \ref SCIP_STAGE_SOLVED
7507  * - \ref SCIP_STAGE_EXITSOLVE
7508  */
7509 extern
7511  SCIP* scip, /**< SCIP data structure */
7512  SCIP_VAR* var /**< variable to capture */
7513  );
7514 
7515 /** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
7516  *
7517  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7518  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7519  *
7520  * @pre This method can be called if @p scip is in one of the following stages:
7521  * - \ref SCIP_STAGE_PROBLEM
7522  * - \ref SCIP_STAGE_TRANSFORMING
7523  * - \ref SCIP_STAGE_TRANSFORMED
7524  * - \ref SCIP_STAGE_INITPRESOLVE
7525  * - \ref SCIP_STAGE_PRESOLVING
7526  * - \ref SCIP_STAGE_EXITPRESOLVE
7527  * - \ref SCIP_STAGE_PRESOLVED
7528  * - \ref SCIP_STAGE_INITSOLVE
7529  * - \ref SCIP_STAGE_SOLVING
7530  * - \ref SCIP_STAGE_SOLVED
7531  * - \ref SCIP_STAGE_EXITSOLVE
7532  * - \ref SCIP_STAGE_FREETRANS
7533  *
7534  * @note the pointer of the variable will be NULLed
7535  */
7536 extern
7538  SCIP* scip, /**< SCIP data structure */
7539  SCIP_VAR** var /**< pointer to variable */
7540  );
7541 
7542 /** changes the name of a variable
7543  *
7544  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7545  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7546  *
7547  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM
7548  *
7549  * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h
7550  */
7551 extern
7553  SCIP* scip, /**< SCIP data structure */
7554  SCIP_VAR* var, /**< variable */
7555  const char* name /**< new name of constraint */
7556  );
7557 
7558 /** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
7559  * a new transformed variable for this variable is created
7560  *
7561  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7562  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7563  *
7564  * @pre This method can be called if @p scip is in one of the following stages:
7565  * - \ref SCIP_STAGE_TRANSFORMING
7566  * - \ref SCIP_STAGE_TRANSFORMED
7567  * - \ref SCIP_STAGE_INITPRESOLVE
7568  * - \ref SCIP_STAGE_PRESOLVING
7569  * - \ref SCIP_STAGE_EXITPRESOLVE
7570  * - \ref SCIP_STAGE_PRESOLVED
7571  * - \ref SCIP_STAGE_INITSOLVE
7572  * - \ref SCIP_STAGE_SOLVING
7573  */
7574 extern
7576  SCIP* scip, /**< SCIP data structure */
7577  SCIP_VAR* var, /**< variable to get/create transformed variable for */
7578  SCIP_VAR** transvar /**< pointer to store the transformed variable */
7579  );
7580 
7581 /** gets and captures transformed variables for an array of variables;
7582  * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
7583  * it is possible to call this method with vars == transvars
7584  *
7585  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7586  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7587  *
7588  * @pre This method can be called if @p scip is in one of the following stages:
7589  * - \ref SCIP_STAGE_TRANSFORMING
7590  * - \ref SCIP_STAGE_TRANSFORMED
7591  * - \ref SCIP_STAGE_INITPRESOLVE
7592  * - \ref SCIP_STAGE_PRESOLVING
7593  * - \ref SCIP_STAGE_EXITPRESOLVE
7594  * - \ref SCIP_STAGE_PRESOLVED
7595  * - \ref SCIP_STAGE_INITSOLVE
7596  * - \ref SCIP_STAGE_SOLVING
7597  */
7598 extern
7600  SCIP* scip, /**< SCIP data structure */
7601  int nvars, /**< number of variables to get/create transformed variables for */
7602  SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */
7603  SCIP_VAR** transvars /**< array to store the transformed variables */
7604  );
7605 
7606 /** gets corresponding transformed variable of a given variable;
7607  * returns NULL as transvar, if transformed variable is not yet existing
7608  *
7609  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7610  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7611  *
7612  * @pre This method can be called if @p scip is in one of the following stages:
7613  * - \ref SCIP_STAGE_TRANSFORMING
7614  * - \ref SCIP_STAGE_TRANSFORMED
7615  * - \ref SCIP_STAGE_INITPRESOLVE
7616  * - \ref SCIP_STAGE_PRESOLVING
7617  * - \ref SCIP_STAGE_EXITPRESOLVE
7618  * - \ref SCIP_STAGE_PRESOLVED
7619  * - \ref SCIP_STAGE_INITSOLVE
7620  * - \ref SCIP_STAGE_SOLVING
7621  * - \ref SCIP_STAGE_SOLVED
7622  * - \ref SCIP_STAGE_EXITSOLVE
7623  * - \ref SCIP_STAGE_FREETRANS
7624  */
7625 extern
7627  SCIP* scip, /**< SCIP data structure */
7628  SCIP_VAR* var, /**< variable to get transformed variable for */
7629  SCIP_VAR** transvar /**< pointer to store the transformed variable */
7630  );
7631 
7632 /** gets corresponding transformed variables for an array of variables;
7633  * stores NULL in a transvars slot, if the transformed variable is not yet existing;
7634  * it is possible to call this method with vars == transvars, but remember that variables that are not
7635  * yet transformed will be replaced with NULL
7636  *
7637  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7638  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7639  *
7640  * @pre This method can be called if @p scip is in one of the following stages:
7641  * - \ref SCIP_STAGE_TRANSFORMING
7642  * - \ref SCIP_STAGE_TRANSFORMED
7643  * - \ref SCIP_STAGE_INITPRESOLVE
7644  * - \ref SCIP_STAGE_PRESOLVING
7645  * - \ref SCIP_STAGE_EXITPRESOLVE
7646  * - \ref SCIP_STAGE_PRESOLVED
7647  * - \ref SCIP_STAGE_INITSOLVE
7648  * - \ref SCIP_STAGE_SOLVING
7649  * - \ref SCIP_STAGE_SOLVED
7650  * - \ref SCIP_STAGE_EXITSOLVE
7651  * - \ref SCIP_STAGE_FREETRANS
7652  */
7653 extern
7655  SCIP* scip, /**< SCIP data structure */
7656  int nvars, /**< number of variables to get transformed variables for */
7657  SCIP_VAR** vars, /**< array with variables to get transformed variables for */
7658  SCIP_VAR** transvars /**< array to store the transformed variables */
7659  );
7660 
7661 /** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing
7662  *
7663  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7664  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7665  *
7666  * @pre This method can be called if @p scip is in one of the following stages:
7667  * - \ref SCIP_STAGE_PROBLEM
7668  * - \ref SCIP_STAGE_TRANSFORMING
7669  * - \ref SCIP_STAGE_TRANSFORMED
7670  * - \ref SCIP_STAGE_INITPRESOLVE
7671  * - \ref SCIP_STAGE_PRESOLVING
7672  * - \ref SCIP_STAGE_EXITPRESOLVE
7673  * - \ref SCIP_STAGE_PRESOLVED
7674  * - \ref SCIP_STAGE_INITSOLVE
7675  * - \ref SCIP_STAGE_SOLVING
7676  * - \ref SCIP_STAGE_SOLVED
7677  * - \ref SCIP_STAGE_EXITSOLVE
7678  * - \ref SCIP_STAGE_FREETRANS
7679  */
7680 extern
7682  SCIP* scip, /**< SCIP data structure */
7683  SCIP_VAR* var, /**< variable to get negated variable for */
7684  SCIP_VAR** negvar /**< pointer to store the negated variable */
7685  );
7686 
7687 /** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing;
7688  * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
7689  *
7690  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7691  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7692  *
7693  * @pre This method can be called if @p scip is in one of the following stages:
7694  * - \ref SCIP_STAGE_PROBLEM
7695  * - \ref SCIP_STAGE_TRANSFORMING
7696  * - \ref SCIP_STAGE_TRANSFORMED
7697  * - \ref SCIP_STAGE_INITPRESOLVE
7698  * - \ref SCIP_STAGE_PRESOLVING
7699  * - \ref SCIP_STAGE_EXITPRESOLVE
7700  * - \ref SCIP_STAGE_PRESOLVED
7701  * - \ref SCIP_STAGE_INITSOLVE
7702  * - \ref SCIP_STAGE_SOLVING
7703  * - \ref SCIP_STAGE_SOLVED
7704  * - \ref SCIP_STAGE_EXITSOLVE
7705  * - \ref SCIP_STAGE_FREETRANS
7706  */
7707 extern
7709  SCIP* scip, /**< SCIP data structure */
7710  int nvars, /**< number of variables to get negated variables for */
7711  SCIP_VAR** vars, /**< array of variables to get negated variables for */
7712  SCIP_VAR** negvars /**< array to store the negated variables */
7713  );
7714 
7715 /** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
7716  * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
7717  *
7718  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7719  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7720  *
7721  * @pre This method can be called if @p scip is in one of the following stages:
7722  * - \ref SCIP_STAGE_PROBLEM
7723  * - \ref SCIP_STAGE_TRANSFORMED
7724  * - \ref SCIP_STAGE_INITPRESOLVE
7725  * - \ref SCIP_STAGE_PRESOLVING
7726  * - \ref SCIP_STAGE_EXITPRESOLVE
7727  * - \ref SCIP_STAGE_PRESOLVED
7728  * - \ref SCIP_STAGE_INITSOLVE
7729  * - \ref SCIP_STAGE_SOLVING
7730  * - \ref SCIP_STAGE_SOLVED
7731  * - \ref SCIP_STAGE_EXITSOLVE
7732  */
7733 extern
7735  SCIP* scip, /**< SCIP data structure */
7736  SCIP_VAR* var, /**< binary variable to get binary representative for */
7737  SCIP_VAR** repvar, /**< pointer to store the binary representative */
7738  SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
7739  );
7740 
7741 /** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
7742  * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
7743  *
7744  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7745  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7746  *
7747  * @pre This method can be called if @p scip is in one of the following stages:
7748  * - \ref SCIP_STAGE_PROBLEM
7749  * - \ref SCIP_STAGE_TRANSFORMED
7750  * - \ref SCIP_STAGE_INITPRESOLVE
7751  * - \ref SCIP_STAGE_PRESOLVING
7752  * - \ref SCIP_STAGE_EXITPRESOLVE
7753  * - \ref SCIP_STAGE_PRESOLVED
7754  * - \ref SCIP_STAGE_INITSOLVE
7755  * - \ref SCIP_STAGE_SOLVING
7756  * - \ref SCIP_STAGE_SOLVED
7757  * - \ref SCIP_STAGE_EXITSOLVE
7758  */
7759 extern
7761  SCIP* scip, /**< SCIP data structure */
7762  int nvars, /**< number of binary variables to get representatives for */
7763  SCIP_VAR** vars, /**< binary variables to get binary representatives for */
7764  SCIP_VAR** repvars, /**< array to store the binary representatives */
7765  SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
7766  );
7767 
7768 /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
7769  *
7770  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7771  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7772  *
7773  * @pre This method can be called if @p scip is in one of the following stages:
7774  * - \ref SCIP_STAGE_INITPRESOLVE
7775  * - \ref SCIP_STAGE_PRESOLVING
7776  * - \ref SCIP_STAGE_EXITPRESOLVE
7777  * - \ref SCIP_STAGE_PRESOLVED
7778  * - \ref SCIP_STAGE_INITSOLVE
7779  * - \ref SCIP_STAGE_SOLVING
7780  * - \ref SCIP_STAGE_SOLVED
7781  */
7782 extern
7784  SCIP* scip, /**< SCIP data structure */
7785  SCIP_VAR* var /**< problem variable */
7786  );
7787 
7788 /** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
7789  * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
7790  *
7791  * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
7792  * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
7793  * representation is stored in the variable array, scalar array and constant.
7794  *
7795  * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
7796  * allocated (e.g., by a C++ 'new' or SCIP functions).
7797  *
7798  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7799  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7800  *
7801  * @pre This method can be called if @p scip is in one of the following stages:
7802  * - \ref SCIP_STAGE_TRANSFORMED
7803  * - \ref SCIP_STAGE_INITPRESOLVE
7804  * - \ref SCIP_STAGE_PRESOLVING
7805  * - \ref SCIP_STAGE_EXITPRESOLVE
7806  * - \ref SCIP_STAGE_PRESOLVED
7807  * - \ref SCIP_STAGE_INITSOLVE
7808  * - \ref SCIP_STAGE_SOLVING
7809  * - \ref SCIP_STAGE_SOLVED
7810  * - \ref SCIP_STAGE_EXITSOLVE
7811  * - \ref SCIP_STAGE_FREETRANS
7812  *
7813  * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
7814  * given entries are overwritten.
7815  *
7816  * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
7817  * the method with the linear sum 1.0*x + 0.0.
7818  */
7819 extern
7821  SCIP* scip, /**< SCIP data structure */
7822  SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
7823  * overwritten by the variable array y_1, ..., y_m in the linear sum
7824  * w.r.t. active variables */
7825  SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
7826  * scalars b_1, ..., b_m in the linear sum of the active variables */
7827  int* nvars, /**< pointer to number of variables in the linear sum which will be
7828  * overwritten by the number of variables in the linear sum corresponding
7829  * to the active variables */
7830  int varssize, /**< available slots in vars and scalars array which is needed to check if
7831  * the array are large enough for the linear sum w.r.t. active
7832  * variables */
7833  SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
7834  * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
7835  * d w.r.t. the active variables */
7836  int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
7837  * active variables */
7838  SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
7839  );
7840 
7841 /** transforms given variable, scalar and constant to the corresponding active, fixed, or
7842  * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
7843  * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
7844  * with only one active variable (this can happen due to fixings after the multi-aggregation),
7845  * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
7846  *
7847  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7848  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7849  *
7850  * @pre This method can be called if @p scip is in one of the following stages:
7851  * - \ref SCIP_STAGE_TRANSFORMED
7852  * - \ref SCIP_STAGE_INITPRESOLVE
7853  * - \ref SCIP_STAGE_PRESOLVING
7854  * - \ref SCIP_STAGE_EXITPRESOLVE
7855  * - \ref SCIP_STAGE_PRESOLVED
7856  * - \ref SCIP_STAGE_INITSOLVE
7857  * - \ref SCIP_STAGE_SOLVING
7858  * - \ref SCIP_STAGE_SOLVED
7859  * - \ref SCIP_STAGE_EXITSOLVE
7860  * - \ref SCIP_STAGE_FREETRANS
7861  */
7862 extern
7864  SCIP* scip, /**< SCIP data structure */
7865  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
7866  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
7867  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
7868  );
7869 
7870 /** return for given variables all their active counterparts; all active variables will be pairwise different
7871  * @note It does not hold that the first output variable is the active variable for the first input variable.
7872  *
7873  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7874  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7875  *
7876  * @pre This method can be called if @p scip is in one of the following stages:
7877  * - \ref SCIP_STAGE_TRANSFORMED
7878  * - \ref SCIP_STAGE_INITPRESOLVE
7879  * - \ref SCIP_STAGE_PRESOLVING
7880  * - \ref SCIP_STAGE_EXITPRESOLVE
7881  * - \ref SCIP_STAGE_PRESOLVED
7882  * - \ref SCIP_STAGE_INITSOLVE
7883  * - \ref SCIP_STAGE_SOLVING
7884  * - \ref SCIP_STAGE_SOLVED
7885  * - \ref SCIP_STAGE_EXITSOLVE
7886  * - \ref SCIP_STAGE_FREETRANS
7887  */
7888 extern
7890  SCIP* scip, /**< SCIP data structure */
7891  SCIP_VAR** vars, /**< variable array with given variables and as output all active
7892  * variables, if enough slots exist */
7893  int* nvars, /**< number of given variables, and as output number of active variables,
7894  * if enough slots exist */
7895  int varssize, /**< available slots in vars array */
7896  int* requiredsize /**< pointer to store the required array size for the active variables */
7897  );
7898 
7899 /** returns the reduced costs of the variable in the current node's LP relaxation;
7900  * the current node has to have a feasible LP.
7901  *
7902  * returns SCIP_INVALID if the variable is active but not in the current LP;
7903  * returns 0 if the variable has been aggregated out or fixed in presolving.
7904  *
7905  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7906  */
7907 extern
7909  SCIP* scip, /**< SCIP data structure */
7910  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
7911  );
7912 
7913 /** returns the implied reduced costs of the variable in the current node's LP relaxation;
7914  * the current node has to have a feasible LP.
7915  *
7916  * returns SCIP_INVALID if the variable is active but not in the current LP;
7917  * returns 0 if the variable has been aggregated out or fixed in presolving.
7918  *
7919  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7920  */
7921 extern
7923  SCIP* scip, /**< SCIP data structure */
7924  SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */
7925  SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */
7926  );
7927 
7928 /** returns the Farkas coefficient of the variable in the current node's LP relaxation;
7929  * the current node has to have an infeasible LP.
7930  *
7931  * returns SCIP_INVALID if the variable is active but not in the current LP;
7932  * returns 0 if the variable has been aggregated out or fixed in presolving.
7933  *
7934  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7935  */
7936 extern
7938  SCIP* scip, /**< SCIP data structure */
7939  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
7940  );
7941 
7942 /** returns lower bound of variable directly before or after the bound change given by the bound change index
7943  * was applied
7944  */
7945 extern
7947  SCIP* scip, /**< SCIP data structure */
7948  SCIP_VAR* var, /**< problem variable */
7949  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
7950  SCIP_Bool after /**< should the bound change with given index be included? */
7951  );
7952 
7953 /** returns upper bound of variable directly before or after the bound change given by the bound change index
7954  * was applied
7955  */
7956 extern
7958  SCIP* scip, /**< SCIP data structure */
7959  SCIP_VAR* var, /**< problem variable */
7960  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
7961  SCIP_Bool after /**< should the bound change with given index be included? */
7962  );
7963 
7964 /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
7965  * was applied
7966  */
7967 extern
7969  SCIP* scip, /**< SCIP data structure */
7970  SCIP_VAR* var, /**< problem variable */
7971  SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
7972  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
7973  SCIP_Bool after /**< should the bound change with given index be included? */
7974  );
7975 
7976 /** returns whether the binary variable was fixed at the time given by the bound change index */
7977 extern
7979  SCIP* scip, /**< SCIP data structure */
7980  SCIP_VAR* var, /**< problem variable */
7981  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
7982  SCIP_Bool after /**< should the bound change with given index be included? */
7983  );
7984 
7985 /** gets solution value for variable in current node
7986  *
7987  * @return solution value for variable in current node
7988  *
7989  * @pre This method can be called if @p scip is in one of the following stages:
7990  * - \ref SCIP_STAGE_PRESOLVED
7991  * - \ref SCIP_STAGE_SOLVING
7992  */
7993 extern
7995  SCIP* scip, /**< SCIP data structure */
7996  SCIP_VAR* var /**< variable to get solution value for */
7997  );
7998 
7999 /** gets solution values of multiple variables in current node
8000  *
8001  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8002  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8003  *
8004  * @pre This method can be called if @p scip is in one of the following stages:
8005  * - \ref SCIP_STAGE_PRESOLVED
8006  * - \ref SCIP_STAGE_SOLVING
8007  */
8008 extern
8010  SCIP* scip, /**< SCIP data structure */
8011  int nvars, /**< number of variables to get solution value for */
8012  SCIP_VAR** vars, /**< array with variables to get value for */
8013  SCIP_Real* vals /**< array to store solution values of variables */
8014  );
8015 
8016 /** sets the solution value of all variables in the global relaxation solution to zero
8017  *
8018  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8019  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8020  *
8021  * @pre This method can be called if @p scip is in one of the following stages:
8022  * - \ref SCIP_STAGE_PRESOLVED
8023  * - \ref SCIP_STAGE_SOLVING
8024  */
8025 extern
8027  SCIP* scip /**< SCIP data structure */
8028  );
8029 
8030 /** sets the value of the given variable in the global relaxation solution;
8031  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
8032  * You can use SCIPclearRelaxSolVals() to set all values to zero, initially;
8033  * after setting all solution values, you have to call SCIPmarkRelaxSolValid()
8034  * to inform SCIP that the stored solution is valid
8035  *
8036  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8037  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8038  *
8039  * @pre This method can be called if @p scip is in one of the following stages:
8040  * - \ref SCIP_STAGE_PRESOLVED
8041  * - \ref SCIP_STAGE_SOLVING
8042  */
8043 extern
8045  SCIP* scip, /**< SCIP data structure */
8046  SCIP_VAR* var, /**< variable to set value for */
8047  SCIP_Real val /**< solution value of variable */
8048  );
8049 
8050 /** sets the values of the given variables in the global relaxation solution;
8051  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
8052  * the solution is automatically cleared, s.t. all other variables get value 0.0
8053  *
8054  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8055  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8056  *
8057  * @pre This method can be called if @p scip is in one of the following stages:
8058  * - \ref SCIP_STAGE_PRESOLVED
8059  * - \ref SCIP_STAGE_SOLVING
8060  */
8061 extern
8063  SCIP* scip, /**< SCIP data structure */
8064  int nvars, /**< number of variables to set relaxation solution value for */
8065  SCIP_VAR** vars, /**< array with variables to set value for */
8066  SCIP_Real* vals /**< array with solution values of variables */
8067  );
8068 
8069 /** sets the values of the variables in the global relaxation solution to the values
8070  * in the given primal solution; the relaxation solution can be filled by the relaxation hanlders
8071  * and might be used by heuristics and for separation
8072  *
8073  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8074  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8075  *
8076  * @pre This method can be called if @p scip is in one of the following stages:
8077  * - \ref SCIP_STAGE_PRESOLVED
8078  * - \ref SCIP_STAGE_SOLVING
8079  */
8080 extern
8082  SCIP* scip, /**< SCIP data structure */
8083  SCIP_SOL* sol /**< primal relaxation solution */
8084  );
8085 
8086 /** returns whether the relaxation solution is valid
8087  *
8088  * @return TRUE, if the relaxation solution is valid; FALSE, otherwise
8089  *
8090  * @pre This method can be called if @p scip is in one of the following stages:
8091  * - \ref SCIP_STAGE_PRESOLVED
8092  * - \ref SCIP_STAGE_SOLVING
8093  */
8094 extern
8096  SCIP* scip /**< SCIP data structure */
8097  );
8098 
8099 /** informs SCIP, that the relaxation solution is valid
8100  *
8101  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8102  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8103  *
8104  * @pre This method can be called if @p scip is in one of the following stages:
8105  * - \ref SCIP_STAGE_PRESOLVED
8106  * - \ref SCIP_STAGE_SOLVING
8107  */
8108 extern
8110  SCIP* scip /**< SCIP data structure */
8111  );
8112 
8113 /** informs SCIP, that the relaxation solution is invalid
8114  *
8115  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8116  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8117  *
8118  * @pre This method can be called if @p scip is in one of the following stages:
8119  * - \ref SCIP_STAGE_PRESOLVED
8120  * - \ref SCIP_STAGE_SOLVING
8121  */
8122 extern
8124  SCIP* scip /**< SCIP data structure */
8125  );
8126 
8127 /** gets the relaxation solution value of the given variable
8128  *
8129  * @return the relaxation solution value of the given variable
8130  *
8131  * @pre This method can be called if @p scip is in one of the following stages:
8132  * - \ref SCIP_STAGE_PRESOLVED
8133  * - \ref SCIP_STAGE_SOLVING
8134  */
8135 extern
8137  SCIP* scip, /**< SCIP data structure */
8138  SCIP_VAR* var /**< variable to get value for */
8139  );
8140 
8141 /** gets the relaxation solution objective value
8142  *
8143  * @return the objective value of the relaxation solution
8144  *
8145  * @pre This method can be called if @p scip is in one of the following stages:
8146  * - \ref SCIP_STAGE_PRESOLVED
8147  * - \ref SCIP_STAGE_SOLVING
8148  */
8149 extern
8151  SCIP* scip /**< SCIP data structure */
8152  );
8153 
8154 /** start strong branching - call before any strong branching
8155  *
8156  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8157  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8158  *
8159  * @pre This method can be called if @p scip is in one of the following stages:
8160  * - \ref SCIP_STAGE_PRESOLVED
8161  * - \ref SCIP_STAGE_SOLVING
8162  *
8163  * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
8164  * which allow to perform propagation but also creates some overhead
8165  */
8166 extern
8168  SCIP* scip, /**< SCIP data structure */
8169  SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
8170  );
8171 
8172 /** end strong branching - call after any strong branching
8173  *
8174  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8175  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8176  *
8177  * @pre This method can be called if @p scip is in one of the following stages:
8178  * - \ref SCIP_STAGE_PRESOLVED
8179  * - \ref SCIP_STAGE_SOLVING
8180  */
8181 extern
8183  SCIP* scip /**< SCIP data structure */
8184  );
8185 
8186 /** gets strong branching information on column variable with fractional value
8187  *
8188  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8189  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8190  *
8191  * @pre This method can be called if @p scip is in one of the following stages:
8192  * - \ref SCIP_STAGE_PRESOLVED
8193  * - \ref SCIP_STAGE_SOLVING
8194  */
8195 extern
8197  SCIP* scip, /**< SCIP data structure */
8198  SCIP_VAR* var, /**< variable to get strong branching values for */
8199  int itlim, /**< iteration limit for strong branchings */
8200  SCIP_Real* down, /**< stores dual bound after branching column down */
8201  SCIP_Real* up, /**< stores dual bound after branching column up */
8202  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8203  * otherwise, it can only be used as an estimate value */
8204  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8205  * otherwise, it can only be used as an estimate value */
8206  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8207  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8208  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8209  * infeasible downwards branch, or NULL */
8210  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8211  * infeasible upwards branch, or NULL */
8212  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8213  * solving process should be stopped (e.g., due to a time limit) */
8214  );
8215 
8216 /** gets strong branching information with previous domain propagation on column variable
8217  *
8218  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
8219  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
8220  * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
8221  * enabled in the SCIPstartStrongbranch() call.
8222  *
8223  * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
8224  * can be specified by the parameter @p maxproprounds.
8225  *
8226  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8227  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8228  *
8229  * @pre This method can be called if @p scip is in one of the following stages:
8230  * - \ref SCIP_STAGE_PRESOLVED
8231  * - \ref SCIP_STAGE_SOLVING
8232  *
8233  * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
8234  * they are updated w.r.t. the strong branching LP solution.
8235  */
8236 extern
8238  SCIP* scip, /**< SCIP data structure */
8239  SCIP_VAR* var, /**< variable to get strong branching values for */
8240  SCIP_Real solval, /**< value of the variable in the current LP solution */
8241  SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
8242  int itlim, /**< iteration limit for strong branchings */
8243  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
8244  * settings) */
8245  SCIP_Real* down, /**< stores dual bound after branching column down */
8246  SCIP_Real* up, /**< stores dual bound after branching column up */
8247  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8248  * otherwise, it can only be used as an estimate value */
8249  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8250  * otherwise, it can only be used as an estimate value */
8251  SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
8252  SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */
8253  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8254  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8255  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8256  * infeasible downwards branch, or NULL */
8257  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8258  * infeasible upwards branch, or NULL */
8259  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
8260  * solving process should be stopped (e.g., due to a time limit) */
8261  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
8262  SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
8263  );
8264 
8265 /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
8266  * is (val -1.0) and the up brach ins (val +1.0)
8267  *
8268  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8269  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8270  *
8271  * @pre This method can be called if @p scip is in one of the following stages:
8272  * - \ref SCIP_STAGE_PRESOLVED
8273  * - \ref SCIP_STAGE_SOLVING
8274  *
8275  * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
8276  * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
8277  */
8278 extern
8280  SCIP* scip, /**< SCIP data structure */
8281  SCIP_VAR* var, /**< variable to get strong branching values for */
8282  int itlim, /**< iteration limit for strong branchings */
8283  SCIP_Real* down, /**< stores dual bound after branching column down */
8284  SCIP_Real* up, /**< stores dual bound after branching column up */
8285  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8286  * otherwise, it can only be used as an estimate value */
8287  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8288  * otherwise, it can only be used as an estimate value */
8289  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
8290  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
8291  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
8292  * infeasible downwards branch, or NULL */
8293  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
8294  * infeasible upwards branch, or NULL */
8295  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8296  * solving process should be stopped (e.g., due to a time limit) */
8297  );
8298 
8299 /** gets strong branching information on column variables with fractional values
8300  *
8301  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8302  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8303  *
8304  * @pre This method can be called if @p scip is in one of the following stages:
8305  * - \ref SCIP_STAGE_PRESOLVED
8306  * - \ref SCIP_STAGE_SOLVING
8307  */
8308 extern
8310  SCIP* scip, /**< SCIP data structure */
8311  SCIP_VAR** vars, /**< variables to get strong branching values for */
8312  int nvars, /**< number of variables */
8313  int itlim, /**< iteration limit for strong branchings */
8314  SCIP_Real* down, /**< stores dual bounds after branching variables down */
8315  SCIP_Real* up, /**< stores dual bounds after branching variables up */
8316  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
8317  * otherwise, they can only be used as an estimate value */
8318  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
8319  * otherwise, they can only be used as an estimate value */
8320  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
8321  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
8322  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
8323  * infeasible downward branches, or NULL */
8324  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
8325  * infeasible upward branches, or NULL */
8326  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8327  * solving process should be stopped (e.g., due to a time limit) */
8328  );
8329 
8330 /** gets strong branching information on column variables with integral values
8331  *
8332  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8333  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8334  *
8335  * @pre This method can be called if @p scip is in one of the following stages:
8336  * - \ref SCIP_STAGE_PRESOLVED
8337  * - \ref SCIP_STAGE_SOLVING
8338  */
8339 extern
8341  SCIP* scip, /**< SCIP data structure */
8342  SCIP_VAR** vars, /**< variables to get strong branching values for */
8343  int nvars, /**< number of variables */
8344  int itlim, /**< iteration limit for strong branchings */
8345  SCIP_Real* down, /**< stores dual bounds after branching variables down */
8346  SCIP_Real* up, /**< stores dual bounds after branching variables up */
8347  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
8348  * otherwise, they can only be used as an estimate value */
8349  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
8350  * otherwise, they can only be used as an estimate value */
8351  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
8352  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
8353  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
8354  * infeasible downward branches, or NULL */
8355  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
8356  * infeasible upward branches, or NULL */
8357  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
8358  * solving process should be stopped (e.g., due to a time limit) */
8359  );
8360 
8361 /** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */
8362 extern
8364  SCIP* scip, /**< SCIP data structure */
8365  SCIP_BRANCHDIR branchdir /**< branching direction for which LP solution status is requested */
8366  );
8367 
8368 /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
8369  * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
8370  * keep in mind, that the returned old values may have nothing to do with the current LP solution
8371  *
8372  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8373  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8374  *
8375  * @pre This method can be called if @p scip is in one of the following stages:
8376  * - \ref SCIP_STAGE_SOLVING
8377  * - \ref SCIP_STAGE_SOLVED
8378  */
8379 extern
8381  SCIP* scip, /**< SCIP data structure */
8382  SCIP_VAR* var, /**< variable to get last strong branching values for */
8383  SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
8384  SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
8385  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
8386  * otherwise, it can only be used as an estimate value */
8387  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
8388  * otherwise, it can only be used as an estimate value */
8389  SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */
8390  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
8391  );
8392 
8393 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
8394  * given variable, or -1 if strong branching was never applied to the variable in current run
8395  *
8396  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8397  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8398  *
8399  * @pre This method can be called if @p scip is in one of the following stages:
8400  * - \ref SCIP_STAGE_TRANSFORMING
8401  * - \ref SCIP_STAGE_TRANSFORMED
8402  * - \ref SCIP_STAGE_INITPRESOLVE
8403  * - \ref SCIP_STAGE_PRESOLVING
8404  * - \ref SCIP_STAGE_EXITPRESOLVE
8405  * - \ref SCIP_STAGE_PRESOLVED
8406  * - \ref SCIP_STAGE_INITSOLVE
8407  * - \ref SCIP_STAGE_SOLVING
8408  * - \ref SCIP_STAGE_SOLVED
8409  * - \ref SCIP_STAGE_EXITSOLVE
8410  */
8411 extern
8413  SCIP* scip, /**< SCIP data structure */
8414  SCIP_VAR* var /**< variable to get last strong branching node for */
8415  );
8416 
8417 /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
8418  * the LP where the strong branching on this variable was applied;
8419  * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
8420  *
8421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8423  *
8424  * @pre This method can be called if @p scip is in one of the following stages:
8425  * - \ref SCIP_STAGE_TRANSFORMING
8426  * - \ref SCIP_STAGE_TRANSFORMED
8427  * - \ref SCIP_STAGE_INITPRESOLVE
8428  * - \ref SCIP_STAGE_PRESOLVING
8429  * - \ref SCIP_STAGE_EXITPRESOLVE
8430  * - \ref SCIP_STAGE_PRESOLVED
8431  * - \ref SCIP_STAGE_INITSOLVE
8432  * - \ref SCIP_STAGE_SOLVING
8433  * - \ref SCIP_STAGE_SOLVED
8434  * - \ref SCIP_STAGE_EXITSOLVE
8435  */
8436 extern
8438  SCIP* scip, /**< SCIP data structure */
8439  SCIP_VAR* var /**< variable to get strong branching LP age for */
8440  );
8441 
8442 /** gets number of times, strong branching was applied in current run on the given variable
8443  *
8444  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8445  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8446  *
8447  * @pre This method can be called if @p scip is in one of the following stages:
8448  * - \ref SCIP_STAGE_TRANSFORMING
8449  * - \ref SCIP_STAGE_TRANSFORMED
8450  * - \ref SCIP_STAGE_INITPRESOLVE
8451  * - \ref SCIP_STAGE_PRESOLVING
8452  * - \ref SCIP_STAGE_EXITPRESOLVE
8453  * - \ref SCIP_STAGE_PRESOLVED
8454  * - \ref SCIP_STAGE_INITSOLVE
8455  * - \ref SCIP_STAGE_SOLVING
8456  * - \ref SCIP_STAGE_SOLVED
8457  * - \ref SCIP_STAGE_EXITSOLVE
8458  */
8459 extern
8461  SCIP* scip, /**< SCIP data structure */
8462  SCIP_VAR* var /**< variable to get last strong branching node for */
8463  );
8464 
8465 /** adds given values to lock numbers of variable for rounding
8466  *
8467  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8468  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8469  *
8470  * @pre This method can be called if @p scip is in one of the following stages:
8471  * - \ref SCIP_STAGE_PROBLEM
8472  * - \ref SCIP_STAGE_TRANSFORMING
8473  * - \ref SCIP_STAGE_TRANSFORMED
8474  * - \ref SCIP_STAGE_INITPRESOLVE
8475  * - \ref SCIP_STAGE_PRESOLVING
8476  * - \ref SCIP_STAGE_EXITPRESOLVE
8477  * - \ref SCIP_STAGE_PRESOLVED
8478  * - \ref SCIP_STAGE_INITSOLVE
8479  * - \ref SCIP_STAGE_SOLVING
8480  * - \ref SCIP_STAGE_EXITSOLVE
8481  * - \ref SCIP_STAGE_FREETRANS
8482  */
8483 extern
8485  SCIP* scip, /**< SCIP data structure */
8486  SCIP_VAR* var, /**< problem variable */
8487  int nlocksdown, /**< modification in number of rounding down locks */
8488  int nlocksup /**< modification in number of rounding up locks */
8489  );
8490 
8491 /** locks rounding of variable with respect to the lock status of the constraint and its negation;
8492  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
8493  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
8494  * added or removed
8495  *
8496  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8497  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8498  *
8499  * @pre This method can be called if @p scip is in one of the following stages:
8500  * - \ref SCIP_STAGE_PROBLEM
8501  * - \ref SCIP_STAGE_TRANSFORMING
8502  * - \ref SCIP_STAGE_INITPRESOLVE
8503  * - \ref SCIP_STAGE_PRESOLVING
8504  * - \ref SCIP_STAGE_EXITPRESOLVE
8505  * - \ref SCIP_STAGE_INITSOLVE
8506  * - \ref SCIP_STAGE_SOLVING
8507  * - \ref SCIP_STAGE_EXITSOLVE
8508  * - \ref SCIP_STAGE_FREETRANS
8509  */
8510 extern
8512  SCIP* scip, /**< SCIP data structure */
8513  SCIP_VAR* var, /**< problem variable */
8514  SCIP_CONS* cons, /**< constraint */
8515  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
8516  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
8517  );
8518 
8519 /** unlocks rounding of variable with respect to the lock status of the constraint and its negation;
8520  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
8521  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
8522  * added or removed
8523  *
8524  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8525  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8526  *
8527  * @pre This method can be called if @p scip is in one of the following stages:
8528  * - \ref SCIP_STAGE_PROBLEM
8529  * - \ref SCIP_STAGE_TRANSFORMING
8530  * - \ref SCIP_STAGE_INITPRESOLVE
8531  * - \ref SCIP_STAGE_PRESOLVING
8532  * - \ref SCIP_STAGE_EXITPRESOLVE
8533  * - \ref SCIP_STAGE_INITSOLVE
8534  * - \ref SCIP_STAGE_SOLVING
8535  * - \ref SCIP_STAGE_EXITSOLVE
8536  * - \ref SCIP_STAGE_FREETRANS
8537  */
8538 extern
8540  SCIP* scip, /**< SCIP data structure */
8541  SCIP_VAR* var, /**< problem variable */
8542  SCIP_CONS* cons, /**< constraint */
8543  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
8544  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
8545  );
8546 
8547 /** changes variable's objective value
8548  *
8549  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8550  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8551  *
8552  * @pre This method can be called if @p scip is in one of the following stages:
8553  * - \ref SCIP_STAGE_PROBLEM
8554  * - \ref SCIP_STAGE_TRANSFORMING
8555  * - \ref SCIP_STAGE_PRESOLVING
8556  */
8557 extern
8559  SCIP* scip, /**< SCIP data structure */
8560  SCIP_VAR* var, /**< variable to change the objective value for */
8561  SCIP_Real newobj /**< new objective value */
8562  );
8563 
8564 /** adds value to variable's objective value
8565  *
8566  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8567  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8568  *
8569  * @pre This method can be called if @p scip is in one of the following stages:
8570  * - \ref SCIP_STAGE_PROBLEM
8571  * - \ref SCIP_STAGE_TRANSFORMING
8572  * - \ref SCIP_STAGE_PRESOLVING
8573  * - \ref SCIP_STAGE_EXITPRESOLVE
8574  * - \ref SCIP_STAGE_PRESOLVED
8575  */
8576 extern
8578  SCIP* scip, /**< SCIP data structure */
8579  SCIP_VAR* var, /**< variable to change the objective value for */
8580  SCIP_Real addobj /**< additional objective value */
8581  );
8582 
8583 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
8584  * does not change the bounds of the variable
8585  *
8586  * @return adjusted lower bound for the given variable; the bound of the variable is not changed
8587  *
8588  * @pre This method can be called if @p scip is in one of the following stages:
8589  * - \ref SCIP_STAGE_PROBLEM
8590  * - \ref SCIP_STAGE_TRANSFORMING
8591  * - \ref SCIP_STAGE_TRANSFORMED
8592  * - \ref SCIP_STAGE_INITPRESOLVE
8593  * - \ref SCIP_STAGE_PRESOLVING
8594  * - \ref SCIP_STAGE_EXITPRESOLVE
8595  * - \ref SCIP_STAGE_PRESOLVED
8596  * - \ref SCIP_STAGE_INITSOLVE
8597  * - \ref SCIP_STAGE_SOLVING
8598  * - \ref SCIP_STAGE_SOLVED
8599  * - \ref SCIP_STAGE_EXITSOLVE
8600  * - \ref SCIP_STAGE_FREETRANS
8601  */
8602 extern
8604  SCIP* scip, /**< SCIP data structure */
8605  SCIP_VAR* var, /**< variable to adjust the bound for */
8606  SCIP_Real lb /**< lower bound value to adjust */
8607  );
8608 
8609 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
8610  * does not change the bounds of the variable
8611  *
8612  * @return adjusted upper bound for the given variable; the bound of the variable is not changed
8613  *
8614  * @pre This method can be called if @p scip is in one of the following stages:
8615  * - \ref SCIP_STAGE_PROBLEM
8616  * - \ref SCIP_STAGE_TRANSFORMING
8617  * - \ref SCIP_STAGE_TRANSFORMED
8618  * - \ref SCIP_STAGE_INITPRESOLVE
8619  * - \ref SCIP_STAGE_PRESOLVING
8620  * - \ref SCIP_STAGE_EXITPRESOLVE
8621  * - \ref SCIP_STAGE_PRESOLVED
8622  * - \ref SCIP_STAGE_INITSOLVE
8623  * - \ref SCIP_STAGE_SOLVING
8624  * - \ref SCIP_STAGE_SOLVED
8625  * - \ref SCIP_STAGE_EXITSOLVE
8626  * - \ref SCIP_STAGE_FREETRANS
8627  */
8628 extern
8630  SCIP* scip, /**< SCIP data structure */
8631  SCIP_VAR* var, /**< variable to adjust the bound for */
8632  SCIP_Real ub /**< upper bound value to adjust */
8633  );
8634 
8635 /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
8636  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
8637  * that in conflict analysis, this change is treated like a branching decision
8638  *
8639  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8640  * SCIPgetVars()) gets resorted.
8641  *
8642  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8643  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8644  *
8645  * @pre This method can be called if @p scip is in one of the following stages:
8646  * - \ref SCIP_STAGE_PROBLEM
8647  * - \ref SCIP_STAGE_TRANSFORMING
8648  * - \ref SCIP_STAGE_PRESOLVING
8649  * - \ref SCIP_STAGE_SOLVING
8650  *
8651  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8652  */
8653 extern
8655  SCIP* scip, /**< SCIP data structure */
8656  SCIP_VAR* var, /**< variable to change the bound for */
8657  SCIP_Real newbound /**< new value for bound */
8658  );
8659 
8660 /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
8661  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
8662  * that in conflict analysis, this change is treated like a branching decision
8663  *
8664  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8665  * SCIPgetVars()) gets resorted.
8666  *
8667  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8668  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8669  *
8670  * @pre This method can be called if @p scip is in one of the following stages:
8671  * - \ref SCIP_STAGE_PROBLEM
8672  * - \ref SCIP_STAGE_TRANSFORMING
8673  * - \ref SCIP_STAGE_PRESOLVING
8674  * - \ref SCIP_STAGE_SOLVING
8675  *
8676  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8677  */
8678 extern
8680  SCIP* scip, /**< SCIP data structure */
8681  SCIP_VAR* var, /**< variable to change the bound for */
8682  SCIP_Real newbound /**< new value for bound */
8683  );
8684 
8685 /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
8686  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
8687  * decision
8688  *
8689  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8690  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8691  *
8692  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8693  */
8694 extern
8696  SCIP* scip, /**< SCIP data structure */
8697  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
8698  SCIP_VAR* var, /**< variable to change the bound for */
8699  SCIP_Real newbound /**< new value for bound */
8700  );
8701 
8702 /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
8703  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
8704  * decision
8705  *
8706  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8707  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8708  *
8709  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8710  */
8711 extern
8713  SCIP* scip, /**< SCIP data structure */
8714  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
8715  SCIP_VAR* var, /**< variable to change the bound for */
8716  SCIP_Real newbound /**< new value for bound */
8717  );
8718 
8719 /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
8720  * if the global bound is better than the local bound
8721  *
8722  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8723  * SCIPgetVars()) gets resorted.
8724  *
8725  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8726  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8727  *
8728  * @pre This method can be called if @p scip is in one of the following stages:
8729  * - \ref SCIP_STAGE_PROBLEM
8730  * - \ref SCIP_STAGE_TRANSFORMING
8731  * - \ref SCIP_STAGE_PRESOLVING
8732  * - \ref SCIP_STAGE_SOLVING
8733  *
8734  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8735  */
8736 extern
8738  SCIP* scip, /**< SCIP data structure */
8739  SCIP_VAR* var, /**< variable to change the bound for */
8740  SCIP_Real newbound /**< new value for bound */
8741  );
8742 
8743 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
8744  * if the global bound is better than the local bound
8745  *
8746  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8747  * SCIPgetVars()) gets resorted.
8748  *
8749  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8750  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8751  *
8752  * @pre This method can be called if @p scip is in one of the following stages:
8753  * - \ref SCIP_STAGE_PROBLEM
8754  * - \ref SCIP_STAGE_TRANSFORMING
8755  * - \ref SCIP_STAGE_PRESOLVING
8756  * - \ref SCIP_STAGE_SOLVING
8757  *
8758  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8759  */
8760 extern
8762  SCIP* scip, /**< SCIP data structure */
8763  SCIP_VAR* var, /**< variable to change the bound for */
8764  SCIP_Real newbound /**< new value for bound */
8765  );
8766 
8767 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
8768  *
8769  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
8770  * to be put into the LP explicitly.
8771  *
8772  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8773  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8774  *
8775  * @pre This method can be called if @p scip is in one of the following stages:
8776  * - \ref SCIP_STAGE_PROBLEM
8777  * - \ref SCIP_STAGE_TRANSFORMING
8778  * - \ref SCIP_STAGE_TRANSFORMED
8779  * - \ref SCIP_STAGE_PRESOLVING
8780  * - \ref SCIP_STAGE_SOLVING
8781  *
8782  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
8783  */
8784 extern
8786  SCIP* scip, /**< SCIP data structure */
8787  SCIP_VAR* var, /**< problem variable */
8788  SCIP_Real lazylb /**< the lazy lower bound to be set */
8789  );
8790 
8791 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
8792  *
8793  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
8794  * to be put into the LP explicitly.
8795  *
8796  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8797  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8798  *
8799  * @pre This method can be called if @p scip is in one of the following stages:
8800  * - \ref SCIP_STAGE_PROBLEM
8801  * - \ref SCIP_STAGE_TRANSFORMING
8802  * - \ref SCIP_STAGE_TRANSFORMED
8803  * - \ref SCIP_STAGE_PRESOLVING
8804  * - \ref SCIP_STAGE_SOLVING
8805  *
8806  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
8807  */
8808 extern
8810  SCIP* scip, /**< SCIP data structure */
8811  SCIP_VAR* var, /**< problem variable */
8812  SCIP_Real lazyub /**< the lazy lower bound to be set */
8813  );
8814 
8815 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8816  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8817  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
8818  * is treated like a branching decision
8819  *
8820  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8821  * SCIPgetVars()) gets resorted.
8822  *
8823  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8824  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8825  *
8826  * @pre This method can be called if @p scip is in one of the following stages:
8827  * - \ref SCIP_STAGE_PROBLEM
8828  * - \ref SCIP_STAGE_PRESOLVING
8829  * - \ref SCIP_STAGE_SOLVING
8830  *
8831  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8832  */
8833 extern
8835  SCIP* scip, /**< SCIP data structure */
8836  SCIP_VAR* var, /**< variable to change the bound for */
8837  SCIP_Real newbound, /**< new value for bound */
8838  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8839  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
8840  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8841  );
8842 
8843 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
8844  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8845  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
8846  * is treated like a branching decision
8847  *
8848  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8849  * SCIPgetVars()) gets resorted.
8850  *
8851  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8852  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8853  *
8854  * @pre This method can be called if @p scip is in one of the following stages:
8855  * - \ref SCIP_STAGE_PROBLEM
8856  * - \ref SCIP_STAGE_PRESOLVING
8857  * - \ref SCIP_STAGE_SOLVING
8858  *
8859  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8860  */
8861 extern
8863  SCIP* scip, /**< SCIP data structure */
8864  SCIP_VAR* var, /**< variable to change the bound for */
8865  SCIP_Real newbound, /**< new value for bound */
8866  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8867  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
8868  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8869  );
8870 
8871 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
8872  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
8873  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
8874  *
8875  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
8876  * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
8877  * SCIPinferVarUbCons
8878  *
8879  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
8880  * SCIPgetVars()) gets resorted.
8881  *
8882  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
8883  */
8884 extern
8886  SCIP* scip, /**< SCIP data structure */
8887  SCIP_VAR* var, /**< variable to change the bound for */
8888  SCIP_Real fixedval, /**< new value for fixation */
8889  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
8890  int inferinfo, /**< user information for inference to help resolving the conflict */
8891  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8892  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8893  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8894  );
8895 
8896 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8897  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8898  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
8899  * for the deduction of the bound change
8900  *
8901  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8902  * SCIPgetVars()) gets resorted.
8903  *
8904  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8905  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8906  *
8907  * @pre This method can be called if @p scip is in one of the following stages:
8908  * - \ref SCIP_STAGE_PROBLEM
8909  * - \ref SCIP_STAGE_PRESOLVING
8910  * - \ref SCIP_STAGE_SOLVING
8911  *
8912  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8913  */
8914 extern
8916  SCIP* scip, /**< SCIP data structure */
8917  SCIP_VAR* var, /**< variable to change the bound for */
8918  SCIP_Real newbound, /**< new value for bound */
8919  SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
8920  int inferinfo, /**< user information for inference to help resolving the conflict */
8921  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8922  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8923  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8924  );
8925 
8926 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
8927  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8928  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
8929  * for the deduction of the bound change
8930  *
8931  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8932  * SCIPgetVars()) gets resorted.
8933  *
8934  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8935  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8936  *
8937  * @pre This method can be called if @p scip is in one of the following stages:
8938  * - \ref SCIP_STAGE_PROBLEM
8939  * - \ref SCIP_STAGE_PRESOLVING
8940  * - \ref SCIP_STAGE_SOLVING
8941  *
8942  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8943  */
8944 extern
8946  SCIP* scip, /**< SCIP data structure */
8947  SCIP_VAR* var, /**< variable to change the bound for */
8948  SCIP_Real newbound, /**< new value for bound */
8949  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
8950  int inferinfo, /**< user information for inference to help resolving the conflict */
8951  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8952  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8953  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8954  );
8955 
8956 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
8957  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
8958  * deduction of the fixing
8959  *
8960  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8961  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8962  *
8963  * @pre This method can be called if @p scip is in one of the following stages:
8964  * - \ref SCIP_STAGE_PROBLEM
8965  * - \ref SCIP_STAGE_PRESOLVING
8966  * - \ref SCIP_STAGE_SOLVING
8967  */
8968 extern
8970  SCIP* scip, /**< SCIP data structure */
8971  SCIP_VAR* var, /**< binary variable to fix */
8972  SCIP_Bool fixedval, /**< value to fix binary variable to */
8973  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
8974  int inferinfo, /**< user information for inference to help resolving the conflict */
8975  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
8976  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
8977  );
8978 
8979 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
8980  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
8981  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
8982  *
8983  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
8984  * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
8985  * SCIPinferVarUbProp
8986  *
8987  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
8988  * SCIPgetVars()) gets resorted.
8989  *
8990  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
8991  */
8992 extern
8994  SCIP* scip, /**< SCIP data structure */
8995  SCIP_VAR* var, /**< variable to change the bound for */
8996  SCIP_Real fixedval, /**< new value for fixation */
8997  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
8998  int inferinfo, /**< user information for inference to help resolving the conflict */
8999  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9000  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9001  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9002  );
9003 
9004 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
9005  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9006  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
9007  * for the deduction of the bound change
9008  *
9009  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9010  * SCIPgetVars()) gets resorted.
9011  *
9012  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9013  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9014  *
9015  * @pre This method can be called if @p scip is in one of the following stages:
9016  * - \ref SCIP_STAGE_PROBLEM
9017  * - \ref SCIP_STAGE_PRESOLVING
9018  * - \ref SCIP_STAGE_SOLVING
9019  *
9020  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9021  */
9022 extern
9024  SCIP* scip, /**< SCIP data structure */
9025  SCIP_VAR* var, /**< variable to change the bound for */
9026  SCIP_Real newbound, /**< new value for bound */
9027  SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
9028  int inferinfo, /**< user information for inference to help resolving the conflict */
9029  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9030  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9031  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9032  );
9033 
9034 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
9035  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
9036  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
9037  * for the deduction of the bound change
9038  *
9039  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9040  * SCIPgetVars()) gets resorted.
9041  *
9042  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9043  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9044  *
9045  * @pre This method can be called if @p scip is in one of the following stages:
9046  * - \ref SCIP_STAGE_PROBLEM
9047  * - \ref SCIP_STAGE_PRESOLVING
9048  * - \ref SCIP_STAGE_SOLVING
9049  *
9050  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9051  */
9052 extern
9054  SCIP* scip, /**< SCIP data structure */
9055  SCIP_VAR* var, /**< variable to change the bound for */
9056  SCIP_Real newbound, /**< new value for bound */
9057  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
9058  int inferinfo, /**< user information for inference to help resolving the conflict */
9059  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9060  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
9061  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9062  );
9063 
9064 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
9065  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
9066  * deduction of the fixing
9067  *
9068  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9069  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9070  *
9071  * @pre This method can be called if @p scip is in one of the following stages:
9072  * - \ref SCIP_STAGE_PROBLEM
9073  * - \ref SCIP_STAGE_PRESOLVING
9074  * - \ref SCIP_STAGE_PRESOLVED
9075  * - \ref SCIP_STAGE_SOLVING
9076  */
9077 extern
9079  SCIP* scip, /**< SCIP data structure */
9080  SCIP_VAR* var, /**< binary variable to fix */
9081  SCIP_Bool fixedval, /**< value to fix binary variable to */
9082  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
9083  int inferinfo, /**< user information for inference to help resolving the conflict */
9084  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
9085  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
9086  );
9087 
9088 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
9089  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
9090  * also tightens the local bound, if the global bound is better than the local bound
9091  *
9092  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9093  * SCIPgetVars()) gets resorted.
9094  *
9095  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9096  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9097  *
9098  * @pre This method can be called if @p scip is in one of the following stages:
9099  * - \ref SCIP_STAGE_PROBLEM
9100  * - \ref SCIP_STAGE_TRANSFORMING
9101  * - \ref SCIP_STAGE_PRESOLVING
9102  * - \ref SCIP_STAGE_SOLVING
9103  *
9104  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9105  */
9106 extern
9108  SCIP* scip, /**< SCIP data structure */
9109  SCIP_VAR* var, /**< variable to change the bound for */
9110  SCIP_Real newbound, /**< new value for bound */
9111  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9112  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
9113  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9114  );
9115 
9116 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
9117  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
9118  * also tightens the local bound, if the global bound is better than the local bound
9119  *
9120  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
9121  * SCIPgetVars()) gets resorted.
9122  *
9123  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9124  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9125  *
9126  * @pre This method can be called if @p scip is in one of the following stages:
9127  * - \ref SCIP_STAGE_PROBLEM
9128  * - \ref SCIP_STAGE_TRANSFORMING
9129  * - \ref SCIP_STAGE_PRESOLVING
9130  * - \ref SCIP_STAGE_SOLVING
9131  *
9132  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
9133  */
9134 extern
9136  SCIP* scip, /**< SCIP data structure */
9137  SCIP_VAR* var, /**< variable to change the bound for */
9138  SCIP_Real newbound, /**< new value for bound */
9139  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
9140  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
9141  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
9142  );
9143 
9144 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
9145  *
9146  * 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
9147  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
9148  *
9149  * @return the global lower bound computed by adding the global bounds from all aggregation variables
9150  */
9151 extern
9153  SCIP* scip, /**< SCIP data structure */
9154  SCIP_VAR* var /**< variable to compute the bound for */
9155  );
9156 
9157 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
9158  *
9159  * 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
9160  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
9161  *
9162  * @return the global upper bound computed by adding the global bounds from all aggregation variables
9163  */
9164 extern
9166  SCIP* scip, /**< SCIP data structure */
9167  SCIP_VAR* var /**< variable to compute the bound for */
9168  );
9169 
9170 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
9171  *
9172  * 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
9173  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
9174  *
9175  * @return the local lower bound computed by adding the global bounds from all aggregation variables
9176  */
9177 extern
9179  SCIP* scip, /**< SCIP data structure */
9180  SCIP_VAR* var /**< variable to compute the bound for */
9181  );
9182 
9183 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
9184  *
9185  * 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
9186  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
9187  *
9188  * @return the local upper bound computed by adding the global bounds from all aggregation variables
9189  */
9190 extern
9192  SCIP* scip, /**< SCIP data structure */
9193  SCIP_VAR* var /**< variable to compute the bound for */
9194  );
9195 
9196 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
9197  * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
9198  * not updated if bounds of aggregation variables are changing
9199  *
9200  * calling this function for a non-multi-aggregated variable is not allowed
9201  */
9202 extern
9204  SCIP* scip, /**< SCIP data structure */
9205  SCIP_VAR* var /**< variable to compute the bound for */
9206  );
9207 
9208 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
9209  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
9210  * not updated if bounds of aggregation variables are changing
9211  *
9212  * calling this function for a non-multi-aggregated variable is not allowed
9213  */
9214 extern
9216  SCIP* scip, /**< SCIP data structure */
9217  SCIP_VAR* var /**< variable to compute the bound for */
9218  );
9219 
9220 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
9221  * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
9222  * not updated if bounds of aggregation variables are changing
9223  *
9224  * calling this function for a non-multi-aggregated variable is not allowed
9225  */
9226 extern
9228  SCIP* scip, /**< SCIP data structure */
9229  SCIP_VAR* var /**< variable to compute the bound for */
9230  );
9231 
9232 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
9233  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
9234  * not updated if bounds of aggregation variables are changing
9235  *
9236  * calling this function for a non-multi-aggregated variable is not allowed
9237  */
9238 extern
9240  SCIP* scip, /**< SCIP data structure */
9241  SCIP_VAR* var /**< variable to compute the bound for */
9242  );
9243 
9244 #ifdef NDEBUG
9245 
9246 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
9247  * speed up the algorithms.
9248  */
9249 
9250 #define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
9251 #define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
9252 #define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
9253 #define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
9254 
9255 #endif
9256 
9257 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
9258  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
9259  * available
9260  *
9261  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9262  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9263  *
9264  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
9265  */
9266 extern
9268  SCIP* scip, /**< SCIP data structure */
9269  SCIP_VAR* var, /**< active problem variable */
9270  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
9271  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
9272  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
9273  );
9274 
9275 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
9276  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
9277  *
9278  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9279  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9280  *
9281  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
9282  */
9283 extern
9285  SCIP* scip, /**< SCIP data structure */
9286  SCIP_VAR* var, /**< active problem variable */
9287  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
9288  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
9289  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
9290  );
9291 
9292 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
9293  * if z is binary, the corresponding valid implication for z is also added;
9294  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
9295  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
9296  * improves the global bounds of the variable and the vlb variable if possible
9297  *
9298  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9299  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9300  *
9301  * @pre This method can be called if @p scip is in one of the following stages:
9302  * - \ref SCIP_STAGE_PRESOLVING
9303  * - \ref SCIP_STAGE_PRESOLVED
9304  * - \ref SCIP_STAGE_SOLVING
9305  */
9306 extern
9308  SCIP* scip, /**< SCIP data structure */
9309  SCIP_VAR* var, /**< problem variable */
9310  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
9311  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
9312  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
9313  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9314  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9315  );
9316 
9317 
9318 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
9319  * if z is binary, the corresponding valid implication for z is also added;
9320  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
9321  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
9322  * improves the global bounds of the variable and the vlb variable if possible
9323  *
9324  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9325  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9326  *
9327  * @pre This method can be called if @p scip is in one of the following stages:
9328  * - \ref SCIP_STAGE_PRESOLVING
9329  * - \ref SCIP_STAGE_PRESOLVED
9330  * - \ref SCIP_STAGE_SOLVING
9331  */
9332 extern
9334  SCIP* scip, /**< SCIP data structure */
9335  SCIP_VAR* var, /**< problem variable */
9336  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
9337  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
9338  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
9339  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9340  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9341  );
9342 
9343 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
9344  * also adds the corresponding implication or variable bound to the implied variable;
9345  * if the implication is conflicting, the variable is fixed to the opposite value;
9346  * if the variable is already fixed to the given value, the implication is performed immediately;
9347  * if the implication is redundant with respect to the variables' global bounds, it is ignored
9348  *
9349  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9350  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9351  *
9352  * @pre This method can be called if @p scip is in one of the following stages:
9353  * - \ref SCIP_STAGE_TRANSFORMED
9354  * - \ref SCIP_STAGE_PRESOLVING
9355  * - \ref SCIP_STAGE_PRESOLVED
9356  * - \ref SCIP_STAGE_SOLVING
9357  */
9358 extern
9360  SCIP* scip, /**< SCIP data structure */
9361  SCIP_VAR* var, /**< problem variable */
9362  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
9363  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
9364  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
9365  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
9366  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
9367  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9368  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9369  );
9370 
9371 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
9372  * if a variable appears twice in the same clique, the corresponding implications are performed
9373  *
9374  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9375  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9376  *
9377  * @pre This method can be called if @p scip is in one of the following stages:
9378  * - \ref SCIP_STAGE_TRANSFORMED
9379  * - \ref SCIP_STAGE_PRESOLVING
9380  * - \ref SCIP_STAGE_PRESOLVED
9381  * - \ref SCIP_STAGE_SOLVING
9382  */
9383 extern
9385  SCIP* scip, /**< SCIP data structure */
9386  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
9387  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
9388  int nvars, /**< number of variables in the clique */
9389  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
9390  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
9391  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
9392  );
9393 
9394 /** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
9395  *
9396  * The algorithm performs the following steps:
9397  * - recomputes connected components of the clique table, if necessary
9398  * - computes a clique partition for every connected component greedily.
9399  * - relabels the resulting clique partition such that it satisfies the description below
9400  *
9401  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
9402  * were assigned to the same clique;
9403  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
9404  * the preceding variables was assigned to clique i-1;
9405  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
9406  *
9407  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9408  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9409  *
9410  * @pre This method can be called if @p scip is in one of the following stages:
9411  * - \ref SCIP_STAGE_INITPRESOLVE
9412  * - \ref SCIP_STAGE_PRESOLVING
9413  * - \ref SCIP_STAGE_EXITPRESOLVE
9414  * - \ref SCIP_STAGE_PRESOLVED
9415  * - \ref SCIP_STAGE_SOLVING
9416  */
9417 extern
9419  SCIP*const scip, /**< SCIP data structure */
9420  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
9421  int const nvars, /**< number of variables in the clique */
9422  int*const cliquepartition, /**< array of length nvars to store the clique partition */
9423  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
9424  );
9425 
9426 /** calculates a partition of the given set of binary variables into negated cliques;
9427  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
9428  * were assigned to the same negated clique;
9429  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
9430  * the preceding variables was assigned to clique i-1;
9431  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
9432  *
9433  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9434  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9435  *
9436  * @pre This method can be called if @p scip is in one of the following stages:
9437  * - \ref SCIP_STAGE_INITPRESOLVE
9438  * - \ref SCIP_STAGE_PRESOLVING
9439  * - \ref SCIP_STAGE_EXITPRESOLVE
9440  * - \ref SCIP_STAGE_PRESOLVED
9441  * - \ref SCIP_STAGE_SOLVING
9442  */
9443 extern
9445  SCIP*const scip, /**< SCIP data structure */
9446  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
9447  int const nvars, /**< number of variables in the clique */
9448  int*const cliquepartition, /**< array of length nvars to store the clique partition */
9449  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
9450  );
9451 
9452 /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
9453  * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
9454  *
9455  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
9456  *
9457  * @pre This method can be called if @p scip is in one of the following stages:
9458  * - \ref SCIP_STAGE_TRANSFORMED
9459  * - \ref SCIP_STAGE_INITPRESOLVE
9460  * - \ref SCIP_STAGE_PRESOLVING
9461  * - \ref SCIP_STAGE_EXITPRESOLVE
9462  * - \ref SCIP_STAGE_PRESOLVED
9463  * - \ref SCIP_STAGE_INITSOLVE
9464  * - \ref SCIP_STAGE_SOLVING
9465  * - \ref SCIP_STAGE_SOLVED
9466  * - \ref SCIP_STAGE_EXITSOLVE
9467  */
9468 extern
9470  SCIP* scip, /**< SCIP data structure */
9471  SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
9472  );
9473 
9474 /** gets the number of cliques in the clique table
9475  *
9476  * @return number of cliques in the clique table
9477  *
9478  * @pre This method can be called if @p scip is in one of the following stages:
9479  * - \ref SCIP_STAGE_TRANSFORMED
9480  * - \ref SCIP_STAGE_INITPRESOLVE
9481  * - \ref SCIP_STAGE_PRESOLVING
9482  * - \ref SCIP_STAGE_EXITPRESOLVE
9483  * - \ref SCIP_STAGE_PRESOLVED
9484  * - \ref SCIP_STAGE_INITSOLVE
9485  * - \ref SCIP_STAGE_SOLVING
9486  * - \ref SCIP_STAGE_SOLVED
9487  * - \ref SCIP_STAGE_EXITSOLVE
9488  */
9489 extern
9490 int SCIPgetNCliques(
9491  SCIP* scip /**< SCIP data structure */
9492  );
9493 
9494 /** gets the array of cliques in the clique table
9495  *
9496  * @return array of cliques in the clique table
9497  *
9498  * @pre This method can be called if @p scip is in one of the following stages:
9499  * - \ref SCIP_STAGE_TRANSFORMED
9500  * - \ref SCIP_STAGE_INITPRESOLVE
9501  * - \ref SCIP_STAGE_PRESOLVING
9502  * - \ref SCIP_STAGE_EXITPRESOLVE
9503  * - \ref SCIP_STAGE_PRESOLVED
9504  * - \ref SCIP_STAGE_INITSOLVE
9505  * - \ref SCIP_STAGE_SOLVING
9506  * - \ref SCIP_STAGE_SOLVED
9507  * - \ref SCIP_STAGE_EXITSOLVE
9508  */
9509 extern
9511  SCIP* scip /**< SCIP data structure */
9512  );
9513 
9514 /** returns whether there is a clique that contains both given variable/value pairs;
9515  * the variables must be active binary variables;
9516  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
9517  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
9518  *
9519  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
9520  *
9521  * @pre This method can be called if @p scip is in one of the following stages:
9522  * - \ref SCIP_STAGE_TRANSFORMED
9523  * - \ref SCIP_STAGE_INITPRESOLVE
9524  * - \ref SCIP_STAGE_PRESOLVING
9525  * - \ref SCIP_STAGE_EXITPRESOLVE
9526  * - \ref SCIP_STAGE_PRESOLVED
9527  * - \ref SCIP_STAGE_INITSOLVE
9528  * - \ref SCIP_STAGE_SOLVING
9529  * - \ref SCIP_STAGE_SOLVED
9530  * - \ref SCIP_STAGE_EXITSOLVE
9531  *
9532  * @note a variable with it's negated variable are NOT! in a clique
9533  * @note a variable with itself are in a clique
9534  */
9535 extern
9537  SCIP* scip, /**< SCIP data structure */
9538  SCIP_VAR* var1, /**< first variable */
9539  SCIP_Bool value1, /**< value of first variable */
9540  SCIP_VAR* var2, /**< second variable */
9541  SCIP_Bool value2, /**< value of second variable */
9542  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
9543  );
9544 
9545 /** writes the clique graph to a gml file
9546  *
9547  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9548  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9549  *
9550  * @pre This method can be called if @p scip is in one of the following stages:
9551  * - \ref SCIP_STAGE_TRANSFORMED
9552  * - \ref SCIP_STAGE_INITPRESOLVE
9553  * - \ref SCIP_STAGE_PRESOLVING
9554  * - \ref SCIP_STAGE_EXITPRESOLVE
9555  * - \ref SCIP_STAGE_PRESOLVED
9556  * - \ref SCIP_STAGE_INITSOLVE
9557  * - \ref SCIP_STAGE_SOLVING
9558  * - \ref SCIP_STAGE_SOLVED
9559  * - \ref SCIP_STAGE_EXITSOLVE
9560  *
9561  * @note there can be duplicated arcs in the output file
9562  *
9563  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
9564  * between such nodes are written.
9565  */
9566 extern
9568  SCIP* scip, /**< SCIP data structure */
9569  const char* fname, /**< name of file */
9570  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
9571  );
9572 
9573 /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
9574  * This is an advanced method which should be used with care.
9575  *
9576  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
9577  *
9578  * @pre This method can be called if @p scip is in one of the following stages:
9579  * - \ref SCIP_STAGE_TRANSFORMED
9580  * - \ref SCIP_STAGE_INITPRESOLVE
9581  * - \ref SCIP_STAGE_PRESOLVING
9582  * - \ref SCIP_STAGE_EXITPRESOLVE
9583  * - \ref SCIP_STAGE_PRESOLVED
9584  * - \ref SCIP_STAGE_INITSOLVE
9585  * - \ref SCIP_STAGE_SOLVING
9586  * - \ref SCIP_STAGE_SOLVED
9587  * - \ref SCIP_STAGE_EXITSOLVE
9588  */
9589 extern
9591  SCIP* scip, /**< SCIP data structure */
9592  SCIP_VAR* var /**< variable to remove from global structures */
9593  );
9594 
9595 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
9596  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
9597  *
9598  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9599  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9600  *
9601  * @pre This method can be called if @p scip is in one of the following stages:
9602  * - \ref SCIP_STAGE_PROBLEM
9603  * - \ref SCIP_STAGE_TRANSFORMING
9604  * - \ref SCIP_STAGE_TRANSFORMED
9605  * - \ref SCIP_STAGE_INITPRESOLVE
9606  * - \ref SCIP_STAGE_PRESOLVING
9607  * - \ref SCIP_STAGE_EXITPRESOLVE
9608  * - \ref SCIP_STAGE_PRESOLVED
9609  * - \ref SCIP_STAGE_SOLVING
9610  */
9611 extern
9613  SCIP* scip, /**< SCIP data structure */
9614  SCIP_VAR* var, /**< problem variable */
9615  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
9616  );
9617 
9618 /** scales the branch factor of the variable with the given value
9619  *
9620  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9621  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9622  *
9623  * @pre This method can be called if @p scip is in one of the following stages:
9624  * - \ref SCIP_STAGE_PROBLEM
9625  * - \ref SCIP_STAGE_TRANSFORMING
9626  * - \ref SCIP_STAGE_TRANSFORMED
9627  * - \ref SCIP_STAGE_INITPRESOLVE
9628  * - \ref SCIP_STAGE_PRESOLVING
9629  * - \ref SCIP_STAGE_EXITPRESOLVE
9630  * - \ref SCIP_STAGE_PRESOLVED
9631  * - \ref SCIP_STAGE_SOLVING
9632  */
9633 extern
9635  SCIP* scip, /**< SCIP data structure */
9636  SCIP_VAR* var, /**< problem variable */
9637  SCIP_Real scale /**< factor to scale variable's branching factor with */
9638  );
9639 
9640 /** adds the given value to the branch factor of the variable
9641  *
9642  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9643  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9644  *
9645  * @pre This method can be called if @p scip is in one of the following stages:
9646  * - \ref SCIP_STAGE_PROBLEM
9647  * - \ref SCIP_STAGE_TRANSFORMING
9648  * - \ref SCIP_STAGE_TRANSFORMED
9649  * - \ref SCIP_STAGE_INITPRESOLVE
9650  * - \ref SCIP_STAGE_PRESOLVING
9651  * - \ref SCIP_STAGE_EXITPRESOLVE
9652  * - \ref SCIP_STAGE_PRESOLVED
9653  * - \ref SCIP_STAGE_SOLVING
9654  */
9655 extern
9657  SCIP* scip, /**< SCIP data structure */
9658  SCIP_VAR* var, /**< problem variable */
9659  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
9660  );
9661 
9662 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
9663  * with lower priority in selection of branching variable
9664  *
9665  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9666  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9667  *
9668  * @pre This method can be called if @p scip is in one of the following stages:
9669  * - \ref SCIP_STAGE_PROBLEM
9670  * - \ref SCIP_STAGE_TRANSFORMING
9671  * - \ref SCIP_STAGE_TRANSFORMED
9672  * - \ref SCIP_STAGE_INITPRESOLVE
9673  * - \ref SCIP_STAGE_PRESOLVING
9674  * - \ref SCIP_STAGE_EXITPRESOLVE
9675  * - \ref SCIP_STAGE_PRESOLVED
9676  * - \ref SCIP_STAGE_SOLVING
9677  *
9678  * @note the default branching priority is 0
9679  */
9680 extern
9682  SCIP* scip, /**< SCIP data structure */
9683  SCIP_VAR* var, /**< problem variable */
9684  int branchpriority /**< branch priority of the variable */
9685  );
9686 
9687 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
9688  *
9689  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9690  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9691  *
9692  * @pre This method can be called if @p scip is in one of the following stages:
9693  * - \ref SCIP_STAGE_PROBLEM
9694  * - \ref SCIP_STAGE_TRANSFORMING
9695  * - \ref SCIP_STAGE_TRANSFORMED
9696  * - \ref SCIP_STAGE_INITPRESOLVE
9697  * - \ref SCIP_STAGE_PRESOLVING
9698  * - \ref SCIP_STAGE_EXITPRESOLVE
9699  * - \ref SCIP_STAGE_PRESOLVED
9700  * - \ref SCIP_STAGE_SOLVING
9701  */
9702 extern
9704  SCIP* scip, /**< SCIP data structure */
9705  SCIP_VAR* var, /**< problem variable */
9706  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
9707  );
9708 
9709 /** adds the given value to the branch priority of the variable
9710  *
9711  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9712  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9713  *
9714  * @pre This method can be called if @p scip is in one of the following stages:
9715  * - \ref SCIP_STAGE_PROBLEM
9716  * - \ref SCIP_STAGE_TRANSFORMING
9717  * - \ref SCIP_STAGE_TRANSFORMED
9718  * - \ref SCIP_STAGE_INITPRESOLVE
9719  * - \ref SCIP_STAGE_PRESOLVING
9720  * - \ref SCIP_STAGE_EXITPRESOLVE
9721  * - \ref SCIP_STAGE_PRESOLVED
9722  * - \ref SCIP_STAGE_SOLVING
9723  */
9724 extern
9726  SCIP* scip, /**< SCIP data structure */
9727  SCIP_VAR* var, /**< problem variable */
9728  int addpriority /**< value to add to the branch priority of the variable */
9729  );
9730 
9731 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
9732  * branch)
9733  *
9734  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9735  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9736  *
9737  * @pre This method can be called if @p scip is in one of the following stages:
9738  * - \ref SCIP_STAGE_PROBLEM
9739  * - \ref SCIP_STAGE_TRANSFORMING
9740  * - \ref SCIP_STAGE_TRANSFORMED
9741  * - \ref SCIP_STAGE_INITPRESOLVE
9742  * - \ref SCIP_STAGE_PRESOLVING
9743  * - \ref SCIP_STAGE_EXITPRESOLVE
9744  * - \ref SCIP_STAGE_PRESOLVED
9745  * - \ref SCIP_STAGE_SOLVING
9746  */
9747 extern
9749  SCIP* scip, /**< SCIP data structure */
9750  SCIP_VAR* var, /**< problem variable */
9751  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
9752  );
9753 
9754 /** changes type of variable in the problem;
9755  *
9756  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
9757  *
9758  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9759  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9760  *
9761  * @pre This method can be called if @p scip is in one of the following stages:
9762  * - \ref SCIP_STAGE_PROBLEM
9763  * - \ref SCIP_STAGE_TRANSFORMING
9764  * - \ref SCIP_STAGE_PRESOLVING
9765  *
9766  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
9767  * corresponding transformed variable is changed; the type of the original variable does not change
9768  *
9769  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
9770  * adjusted w.r.t. to integrality information
9771  */
9772 extern
9774  SCIP* scip, /**< SCIP data structure */
9775  SCIP_VAR* var, /**< variable to change the bound for */
9776  SCIP_VARTYPE vartype, /**< new type of variable */
9777  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
9778  * integrality condition of the new variable type) */
9779  );
9780 
9781 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
9782  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
9783  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
9784  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
9785  *
9786  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9787  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9788  *
9789  * @pre This method can be called if @p scip is in one of the following stages:
9790  * - \ref SCIP_STAGE_PROBLEM
9791  * - \ref SCIP_STAGE_PRESOLVING
9792  * - \ref SCIP_STAGE_SOLVING
9793  */
9794 extern
9796  SCIP* scip, /**< SCIP data structure */
9797  SCIP_VAR* var, /**< variable to fix */
9798  SCIP_Real fixedval, /**< value to fix variable to */
9799  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
9800  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
9801  );
9802 
9803 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
9804  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
9805  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
9806  * In the first step, the equality is transformed into an equality with active problem variables
9807  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
9808  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
9809  * infeasibility) otherwise.
9810  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
9811  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
9812  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
9813  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
9814  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
9815  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
9816  *
9817  * The output flags have the following meaning:
9818  * - infeasible: the problem is infeasible
9819  * - redundant: the equality can be deleted from the constraint set
9820  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
9821  *
9822  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9823  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9824  *
9825  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
9826  */
9827 extern
9829  SCIP* scip, /**< SCIP data structure */
9830  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
9831  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
9832  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
9833  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
9834  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
9835  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
9836  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
9837  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
9838  );
9839 
9840 /** converts variable into multi-aggregated variable; this changes the variable array returned from
9841  * SCIPgetVars() and SCIPgetVarsData();
9842  *
9843  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
9844  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
9845  * implies integrality on the aggregated variable.
9846  *
9847  * The output flags have the following meaning:
9848  * - infeasible: the problem is infeasible
9849  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
9850  *
9851  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9852  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9853  *
9854  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
9855  */
9856 extern
9858  SCIP* scip, /**< SCIP data structure */
9859  SCIP_VAR* var, /**< variable x to aggregate */
9860  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9861  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9862  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9863  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9864  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
9865  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
9866  );
9867 
9868 /** returns whether aggregation of variables is not allowed */
9869 extern
9871  SCIP* scip /**< SCIP data structure */
9872  );
9873 
9874 /** returns whether multi-aggregation is disabled */
9875 extern
9877  SCIP* scip /**< SCIP data structure */
9878  );
9879 
9880 /** returns whether variable is not allowed to be multi-aggregated */
9881 extern
9883  SCIP* scip, /**< SCIP data structure */
9884  SCIP_VAR* var /**< variable x to aggregate */
9885  );
9886 
9887 /** returns whether dual reductions propagation methods and presolvers is allowed */
9888 extern
9890  SCIP* scip /**< SCIP data structure */
9891  );
9892 
9893 /** returns whether propagation w.r.t. current objective is allowed */
9894 extern
9896  SCIP* scip /**< SCIP data structure */
9897  );
9898 
9899 /** modifies an initial seed value with the global shift of random seeds */
9900 extern
9901 unsigned int SCIPinitializeRandomSeed(
9902  SCIP* scip, /**< SCIP data structure */
9903  int initialseedvalue /**< initial seed value to be modified */
9904  );
9905 
9906 /** marks the variable that it must not be multi-aggregated
9907  *
9908  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9909  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9910  *
9911  * @pre This method can be called if @p scip is in one of the following stages:
9912  * - \ref SCIP_STAGE_INIT
9913  * - \ref SCIP_STAGE_PROBLEM
9914  * - \ref SCIP_STAGE_TRANSFORMING
9915  * - \ref SCIP_STAGE_TRANSFORMED
9916  * - \ref SCIP_STAGE_INITPRESOLVE
9917  * - \ref SCIP_STAGE_PRESOLVING
9918  * - \ref SCIP_STAGE_EXITPRESOLVE
9919  *
9920  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
9921  * multi-aggregated that this is will be the case.
9922  */
9923 extern
9925  SCIP* scip, /**< SCIP data structure */
9926  SCIP_VAR* var /**< variable to delete */
9927  );
9928 
9929 /** enables the collection of statistics for a variable
9930  *
9931  * @pre This method can be called if @p scip is in one of the following stages:
9932  * - \ref SCIP_STAGE_PROBLEM
9933  * - \ref SCIP_STAGE_INITPRESOLVE
9934  * - \ref SCIP_STAGE_PRESOLVING
9935  * - \ref SCIP_STAGE_EXITPRESOLVE
9936  * - \ref SCIP_STAGE_SOLVING
9937  * - \ref SCIP_STAGE_SOLVED
9938  */
9939 extern
9941  SCIP* scip /**< SCIP data structure */
9942  );
9943 
9944 /** disables the collection of any statistic for a variable
9945  *
9946  * @pre This method can be called if @p scip is in one of the following stages:
9947  * - \ref SCIP_STAGE_PROBLEM
9948  * - \ref SCIP_STAGE_INITPRESOLVE
9949  * - \ref SCIP_STAGE_PRESOLVING
9950  * - \ref SCIP_STAGE_EXITPRESOLVE
9951  * - \ref SCIP_STAGE_SOLVING
9952  * - \ref SCIP_STAGE_SOLVED
9953  */
9954 extern
9956  SCIP* scip /**< SCIP data structure */
9957  );
9958 
9959 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
9960  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
9961  * the update is ignored, if the objective value difference is infinite
9962  *
9963  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9964  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9965  *
9966  * @pre This method can be called if @p scip is in one of the following stages:
9967  * - \ref SCIP_STAGE_SOLVING
9968  * - \ref SCIP_STAGE_SOLVED
9969  */
9970 extern
9972  SCIP* scip, /**< SCIP data structure */
9973  SCIP_VAR* var, /**< problem variable */
9974  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
9975  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
9976  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
9977  );
9978 
9979 /** gets the variable's pseudo cost value for the given change of the variable's LP value
9980  *
9981  * @return the variable's pseudo cost value for the given change of the variable's LP value
9982  *
9983  * @pre This method can be called if @p scip is in one of the following stages:
9984  * - \ref SCIP_STAGE_INITPRESOLVE
9985  * - \ref SCIP_STAGE_PRESOLVING
9986  * - \ref SCIP_STAGE_EXITPRESOLVE
9987  * - \ref SCIP_STAGE_PRESOLVED
9988  * - \ref SCIP_STAGE_INITSOLVE
9989  * - \ref SCIP_STAGE_SOLVING
9990  * - \ref SCIP_STAGE_SOLVED
9991  */
9992 extern
9994  SCIP* scip, /**< SCIP data structure */
9995  SCIP_VAR* var, /**< problem variable */
9996  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
9997  );
9998 
9999 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
10000  * only using the pseudo cost information of the current run
10001  *
10002  * @return the variable's pseudo cost value for the given change of the variable's LP value,
10003  * only using the pseudo cost information of the current run
10004  *
10005  * @pre This method can be called if @p scip is in one of the following stages:
10006  * - \ref SCIP_STAGE_INITPRESOLVE
10007  * - \ref SCIP_STAGE_PRESOLVING
10008  * - \ref SCIP_STAGE_EXITPRESOLVE
10009  * - \ref SCIP_STAGE_PRESOLVED
10010  * - \ref SCIP_STAGE_INITSOLVE
10011  * - \ref SCIP_STAGE_SOLVING
10012  * - \ref SCIP_STAGE_SOLVED
10013  */
10014 extern
10016  SCIP* scip, /**< SCIP data structure */
10017  SCIP_VAR* var, /**< problem variable */
10018  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
10019  );
10020 
10021 /** gets the variable's pseudo cost value for the given direction
10022  *
10023  * @return the variable's pseudo cost value for the given direction
10024  *
10025  * @pre This method can be called if @p scip is in one of the following stages:
10026  * - \ref SCIP_STAGE_INITPRESOLVE
10027  * - \ref SCIP_STAGE_PRESOLVING
10028  * - \ref SCIP_STAGE_EXITPRESOLVE
10029  * - \ref SCIP_STAGE_PRESOLVED
10030  * - \ref SCIP_STAGE_INITSOLVE
10031  * - \ref SCIP_STAGE_SOLVING
10032  * - \ref SCIP_STAGE_SOLVED
10033  */
10034 extern
10036  SCIP* scip, /**< SCIP data structure */
10037  SCIP_VAR* var, /**< problem variable */
10038  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10039  );
10040 
10041 /** gets the variable's pseudo cost value for the given direction,
10042  * only using the pseudo cost information of the current run
10043  *
10044  * @return the variable's pseudo cost value for the given direction,
10045  * only using the pseudo cost information of the current run
10046  *
10047  * @pre This method can be called if @p scip is in one of the following stages:
10048  * - \ref SCIP_STAGE_INITPRESOLVE
10049  * - \ref SCIP_STAGE_PRESOLVING
10050  * - \ref SCIP_STAGE_EXITPRESOLVE
10051  * - \ref SCIP_STAGE_PRESOLVED
10052  * - \ref SCIP_STAGE_INITSOLVE
10053  * - \ref SCIP_STAGE_SOLVING
10054  * - \ref SCIP_STAGE_SOLVED
10055  */
10056 extern
10058  SCIP* scip, /**< SCIP data structure */
10059  SCIP_VAR* var, /**< problem variable */
10060  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10061  );
10062 
10063 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
10064  *
10065  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
10066  *
10067  * @pre This method can be called if @p scip is in one of the following stages:
10068  * - \ref SCIP_STAGE_INITPRESOLVE
10069  * - \ref SCIP_STAGE_PRESOLVING
10070  * - \ref SCIP_STAGE_EXITPRESOLVE
10071  * - \ref SCIP_STAGE_PRESOLVED
10072  * - \ref SCIP_STAGE_INITSOLVE
10073  * - \ref SCIP_STAGE_SOLVING
10074  * - \ref SCIP_STAGE_SOLVED
10075  */
10076 extern
10078  SCIP* scip, /**< SCIP data structure */
10079  SCIP_VAR* var, /**< problem variable */
10080  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10081  );
10082 
10083 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
10084  * only using the pseudo cost information of the current run
10085  *
10086  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
10087  * only using the pseudo cost information of the current run
10088  *
10089  * @pre This method can be called if @p scip is in one of the following stages:
10090  * - \ref SCIP_STAGE_INITPRESOLVE
10091  * - \ref SCIP_STAGE_PRESOLVING
10092  * - \ref SCIP_STAGE_EXITPRESOLVE
10093  * - \ref SCIP_STAGE_PRESOLVED
10094  * - \ref SCIP_STAGE_INITSOLVE
10095  * - \ref SCIP_STAGE_SOLVING
10096  * - \ref SCIP_STAGE_SOLVED
10097  */
10098 extern
10100  SCIP* scip, /**< SCIP data structure */
10101  SCIP_VAR* var, /**< problem variable */
10102  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10103  );
10104 
10105 /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
10106  *
10107  * @return returns the (corrected) variance of pseudo code information collected so far.
10108  *
10109  * @pre This method can be called if @p scip is in one of the following stages:
10110  * - \ref SCIP_STAGE_INITPRESOLVE
10111  * - \ref SCIP_STAGE_PRESOLVING
10112  * - \ref SCIP_STAGE_EXITPRESOLVE
10113  * - \ref SCIP_STAGE_PRESOLVED
10114  * - \ref SCIP_STAGE_INITSOLVE
10115  * - \ref SCIP_STAGE_SOLVING
10116  * - \ref SCIP_STAGE_SOLVED
10117  */
10118 extern
10120  SCIP* scip, /**< SCIP data structure */
10121  SCIP_VAR* var, /**< problem variable */
10122  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
10123  SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
10124  );
10125 
10126 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
10127  *
10128  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
10129  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
10130  * of 2 * clevel - 1.
10131  *
10132  * @return value of confidence bound for this variable
10133  */
10134 extern
10136  SCIP* scip, /**< SCIP data structure */
10137  SCIP_VAR* var, /**< variable in question */
10138  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
10139  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
10140  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
10141  );
10142 
10143 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
10144  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
10145  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
10146  * unknown location means of the underlying pseudo-cost distributions of x and y.
10147  *
10148  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
10149  * better than x (despite the current information), meaning that y can be expected to yield branching
10150  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
10151  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
10152  * than y.
10153  *
10154  * @note The order of x and y matters for the one-sided hypothesis
10155  *
10156  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
10157  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
10158  *
10159  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
10160  */
10161 extern
10163  SCIP* scip, /**< SCIP data structure */
10164  SCIP_VAR* varx, /**< variable x */
10165  SCIP_Real fracx, /**< the fractionality of variable x */
10166  SCIP_VAR* vary, /**< variable y */
10167  SCIP_Real fracy, /**< the fractionality of variable y */
10168  SCIP_BRANCHDIR dir, /**< branching direction */
10169  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
10170  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
10171  );
10172 
10173 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
10174  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
10175  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
10176  * of at least \p threshold.
10177  *
10178  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
10179  * the estimated probability to exceed \p threshold is less than 25 %.
10180  *
10181  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
10182  * of confidence.
10183  *
10184  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
10185  * at the given confidence level \p clevel.
10186  */
10187 extern
10189  SCIP* scip, /**< SCIP data structure */
10190  SCIP_VAR* var, /**< variable x */
10191  SCIP_Real frac, /**< the fractionality of variable x */
10192  SCIP_Real threshold, /**< the threshold to test against */
10193  SCIP_BRANCHDIR dir, /**< branching direction */
10194  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
10195  );
10196 
10197 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
10198  * Error is calculated at a specific confidence level
10199  *
10200  * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
10201  */
10202 extern
10204  SCIP* scip, /**< SCIP data structure */
10205  SCIP_VAR* var, /**< variable in question */
10206  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
10207  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
10208  );
10209 
10210 /** gets the variable's pseudo cost score value for the given LP solution value
10211  *
10212  * @return the variable's pseudo cost score value for the given LP solution value
10213  *
10214  * @pre This method can be called if @p scip is in one of the following stages:
10215  * - \ref SCIP_STAGE_INITPRESOLVE
10216  * - \ref SCIP_STAGE_PRESOLVING
10217  * - \ref SCIP_STAGE_EXITPRESOLVE
10218  * - \ref SCIP_STAGE_PRESOLVED
10219  * - \ref SCIP_STAGE_INITSOLVE
10220  * - \ref SCIP_STAGE_SOLVING
10221  * - \ref SCIP_STAGE_SOLVED
10222  */
10223 extern
10225  SCIP* scip, /**< SCIP data structure */
10226  SCIP_VAR* var, /**< problem variable */
10227  SCIP_Real solval /**< variable's LP solution value */
10228  );
10229 
10230 /** gets the variable's pseudo cost score value for the given LP solution value,
10231  * only using the pseudo cost information of the current run
10232  *
10233  * @return the variable's pseudo cost score value for the given LP solution value,
10234  * only using the pseudo cost information of the current run
10235  *
10236  * @pre This method can be called if @p scip is in one of the following stages:
10237  * - \ref SCIP_STAGE_INITPRESOLVE
10238  * - \ref SCIP_STAGE_PRESOLVING
10239  * - \ref SCIP_STAGE_EXITPRESOLVE
10240  * - \ref SCIP_STAGE_PRESOLVED
10241  * - \ref SCIP_STAGE_INITSOLVE
10242  * - \ref SCIP_STAGE_SOLVING
10243  * - \ref SCIP_STAGE_SOLVED
10244  */
10245 extern
10247  SCIP* scip, /**< SCIP data structure */
10248  SCIP_VAR* var, /**< problem variable */
10249  SCIP_Real solval /**< variable's LP solution value */
10250  );
10251 
10252 /** returns the variable's VSIDS value
10253  *
10254  * @return the variable's VSIDS value
10255  *
10256  * @pre This method can be called if @p scip is in one of the following stages:
10257  * - \ref SCIP_STAGE_INITPRESOLVE
10258  * - \ref SCIP_STAGE_PRESOLVING
10259  * - \ref SCIP_STAGE_EXITPRESOLVE
10260  * - \ref SCIP_STAGE_PRESOLVED
10261  * - \ref SCIP_STAGE_INITSOLVE
10262  * - \ref SCIP_STAGE_SOLVING
10263  * - \ref SCIP_STAGE_SOLVED
10264  */
10265 extern
10267  SCIP* scip, /**< SCIP data structure */
10268  SCIP_VAR* var, /**< problem variable */
10269  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10270  );
10271 
10272 /** returns the variable's VSIDS value only using conflicts of the current run
10273  *
10274  * @return the variable's VSIDS value only using conflicts of the current run
10275  *
10276  * @pre This method can be called if @p scip is in one of the following stages:
10277  * - \ref SCIP_STAGE_INITPRESOLVE
10278  * - \ref SCIP_STAGE_PRESOLVING
10279  * - \ref SCIP_STAGE_EXITPRESOLVE
10280  * - \ref SCIP_STAGE_PRESOLVED
10281  * - \ref SCIP_STAGE_INITSOLVE
10282  * - \ref SCIP_STAGE_SOLVING
10283  * - \ref SCIP_STAGE_SOLVED
10284  */
10285 extern
10287  SCIP* scip, /**< SCIP data structure */
10288  SCIP_VAR* var, /**< problem variable */
10289  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10290  );
10291 
10292 /** returns the variable's conflict score value
10293  *
10294  * @return the variable's conflict score value
10295  *
10296  * @pre This method can be called if @p scip is in one of the following stages:
10297  * - \ref SCIP_STAGE_INITPRESOLVE
10298  * - \ref SCIP_STAGE_PRESOLVING
10299  * - \ref SCIP_STAGE_EXITPRESOLVE
10300  * - \ref SCIP_STAGE_PRESOLVED
10301  * - \ref SCIP_STAGE_INITSOLVE
10302  * - \ref SCIP_STAGE_SOLVING
10303  * - \ref SCIP_STAGE_SOLVED
10304  */
10305 extern
10307  SCIP* scip, /**< SCIP data structure */
10308  SCIP_VAR* var /**< problem variable */
10309  );
10310 
10311 /** returns the variable's conflict score value only using conflicts of the current run
10312  *
10313  * @return the variable's conflict score value only using conflicts of the current run
10314  *
10315  * @pre This method can be called if @p scip is in one of the following stages:
10316  * - \ref SCIP_STAGE_INITPRESOLVE
10317  * - \ref SCIP_STAGE_PRESOLVING
10318  * - \ref SCIP_STAGE_EXITPRESOLVE
10319  * - \ref SCIP_STAGE_PRESOLVED
10320  * - \ref SCIP_STAGE_INITSOLVE
10321  * - \ref SCIP_STAGE_SOLVING
10322  * - \ref SCIP_STAGE_SOLVED
10323  */
10324 extern
10326  SCIP* scip, /**< SCIP data structure */
10327  SCIP_VAR* var /**< problem variable */
10328  );
10329 
10330 /** returns the variable's conflict length score
10331  *
10332  * @return the variable's conflict length score
10333  *
10334  * @pre This method can be called if @p scip is in one of the following stages:
10335  * - \ref SCIP_STAGE_INITPRESOLVE
10336  * - \ref SCIP_STAGE_PRESOLVING
10337  * - \ref SCIP_STAGE_EXITPRESOLVE
10338  * - \ref SCIP_STAGE_PRESOLVED
10339  * - \ref SCIP_STAGE_INITSOLVE
10340  * - \ref SCIP_STAGE_SOLVING
10341  * - \ref SCIP_STAGE_SOLVED
10342  */
10343 extern
10345  SCIP* scip, /**< SCIP data structure */
10346  SCIP_VAR* var /**< problem variable */
10347  );
10348 
10349 /** returns the variable's conflict length score only using conflicts of the current run
10350  *
10351  * @return the variable's conflict length score only using conflicts of the current run
10352  *
10353  * @pre This method can be called if @p scip is in one of the following stages:
10354  * - \ref SCIP_STAGE_INITPRESOLVE
10355  * - \ref SCIP_STAGE_PRESOLVING
10356  * - \ref SCIP_STAGE_EXITPRESOLVE
10357  * - \ref SCIP_STAGE_PRESOLVED
10358  * - \ref SCIP_STAGE_INITSOLVE
10359  * - \ref SCIP_STAGE_SOLVING
10360  * - \ref SCIP_STAGE_SOLVED
10361  */
10362 extern
10364  SCIP* scip, /**< SCIP data structure */
10365  SCIP_VAR* var /**< problem variable */
10366  );
10367 
10368 /** returns the variable's average conflict length
10369  *
10370  * @return the variable's average conflict length
10371  *
10372  * @pre This method can be called if @p scip is in one of the following stages:
10373  * - \ref SCIP_STAGE_INITPRESOLVE
10374  * - \ref SCIP_STAGE_PRESOLVING
10375  * - \ref SCIP_STAGE_EXITPRESOLVE
10376  * - \ref SCIP_STAGE_PRESOLVED
10377  * - \ref SCIP_STAGE_INITSOLVE
10378  * - \ref SCIP_STAGE_SOLVING
10379  * - \ref SCIP_STAGE_SOLVED
10380  */
10381 extern
10383  SCIP* scip, /**< SCIP data structure */
10384  SCIP_VAR* var, /**< problem variable */
10385  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10386  );
10387 
10388 /** returns the variable's average conflict length only using conflicts of the current run
10389  *
10390  * @return the variable's average conflict length only using conflicts of the current run
10391  *
10392  * @pre This method can be called if @p scip is in one of the following stages:
10393  * - \ref SCIP_STAGE_INITPRESOLVE
10394  * - \ref SCIP_STAGE_PRESOLVING
10395  * - \ref SCIP_STAGE_EXITPRESOLVE
10396  * - \ref SCIP_STAGE_PRESOLVED
10397  * - \ref SCIP_STAGE_INITSOLVE
10398  * - \ref SCIP_STAGE_SOLVING
10399  * - \ref SCIP_STAGE_SOLVED
10400  */
10401 extern
10403  SCIP* scip, /**< SCIP data structure */
10404  SCIP_VAR* var, /**< problem variable */
10405  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10406  );
10407 
10408 /** returns the average number of inferences found after branching on the variable in given direction;
10409  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
10410  * over all variables for branching in the given direction is returned
10411  *
10412  * @return the average number of inferences found after branching on the variable in given direction
10413  *
10414  * @pre This method can be called if @p scip is in one of the following stages:
10415  * - \ref SCIP_STAGE_INITPRESOLVE
10416  * - \ref SCIP_STAGE_PRESOLVING
10417  * - \ref SCIP_STAGE_EXITPRESOLVE
10418  * - \ref SCIP_STAGE_PRESOLVED
10419  * - \ref SCIP_STAGE_INITSOLVE
10420  * - \ref SCIP_STAGE_SOLVING
10421  * - \ref SCIP_STAGE_SOLVED
10422  */
10423 extern
10425  SCIP* scip, /**< SCIP data structure */
10426  SCIP_VAR* var, /**< problem variable */
10427  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10428  );
10429 
10430 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
10431  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
10432  * over all variables for branching in the given direction is returned
10433  *
10434  * @return the average number of inferences found after branching on the variable in given direction in the current run
10435  *
10436  * @pre This method can be called if @p scip is in one of the following stages:
10437  * - \ref SCIP_STAGE_INITPRESOLVE
10438  * - \ref SCIP_STAGE_PRESOLVING
10439  * - \ref SCIP_STAGE_EXITPRESOLVE
10440  * - \ref SCIP_STAGE_PRESOLVED
10441  * - \ref SCIP_STAGE_INITSOLVE
10442  * - \ref SCIP_STAGE_SOLVING
10443  * - \ref SCIP_STAGE_SOLVED
10444  */
10445 extern
10447  SCIP* scip, /**< SCIP data structure */
10448  SCIP_VAR* var, /**< problem variable */
10449  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10450  );
10451 
10452 /** returns the variable's average inference score value
10453  *
10454  * @return the variable's average inference score value
10455  *
10456  * @pre This method can be called if @p scip is in one of the following stages:
10457  * - \ref SCIP_STAGE_INITPRESOLVE
10458  * - \ref SCIP_STAGE_PRESOLVING
10459  * - \ref SCIP_STAGE_EXITPRESOLVE
10460  * - \ref SCIP_STAGE_PRESOLVED
10461  * - \ref SCIP_STAGE_INITSOLVE
10462  * - \ref SCIP_STAGE_SOLVING
10463  * - \ref SCIP_STAGE_SOLVED
10464  */
10465 extern
10467  SCIP* scip, /**< SCIP data structure */
10468  SCIP_VAR* var /**< problem variable */
10469  );
10470 
10471 /** returns the variable's average inference score value only using inferences of the current run
10472  *
10473  * @return the variable's average inference score value only using inferences of the current run
10474  *
10475  * @pre This method can be called if @p scip is in one of the following stages:
10476  * - \ref SCIP_STAGE_INITPRESOLVE
10477  * - \ref SCIP_STAGE_PRESOLVING
10478  * - \ref SCIP_STAGE_EXITPRESOLVE
10479  * - \ref SCIP_STAGE_PRESOLVED
10480  * - \ref SCIP_STAGE_INITSOLVE
10481  * - \ref SCIP_STAGE_SOLVING
10482  * - \ref SCIP_STAGE_SOLVED
10483  */
10484 extern
10486  SCIP* scip, /**< SCIP data structure */
10487  SCIP_VAR* var /**< problem variable */
10488  );
10489 
10490 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
10491  * of a variable to the given values
10492  *
10493  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10494  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10495  *
10496  * @pre This method can be called if @p scip is in one of the following stages:
10497  * - \ref SCIP_STAGE_TRANSFORMED
10498  * - \ref SCIP_STAGE_INITPRESOLVE
10499  * - \ref SCIP_STAGE_PRESOLVING
10500  * - \ref SCIP_STAGE_EXITPRESOLVE
10501  * - \ref SCIP_STAGE_PRESOLVED
10502  * - \ref SCIP_STAGE_INITSOLVE
10503  * - \ref SCIP_STAGE_SOLVING
10504  */
10505 extern
10507  SCIP* scip, /**< SCIP data structure */
10508  SCIP_VAR* var, /**< variable which should be initialized */
10509  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
10510  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
10511  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
10512  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
10513  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
10514  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
10515  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
10516  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
10517  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
10518  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
10519  );
10520 
10521 /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
10522  * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
10523  *
10524  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10525  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10526  *
10527  * @pre This method can be called if @p scip is in one of the following stages:
10528  * - \ref SCIP_STAGE_TRANSFORMED
10529  * - \ref SCIP_STAGE_INITPRESOLVE
10530  * - \ref SCIP_STAGE_PRESOLVING
10531  * - \ref SCIP_STAGE_EXITPRESOLVE
10532  * - \ref SCIP_STAGE_PRESOLVED
10533  * - \ref SCIP_STAGE_INITSOLVE
10534  * - \ref SCIP_STAGE_SOLVING
10535  */
10536 extern
10538  SCIP* scip, /**< SCIP data structure */
10539  SCIP_VAR* var, /**< variable which should be initialized */
10540  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
10541  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
10542  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
10543  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
10544  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
10545  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
10546  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
10547  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
10548  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
10549  );
10550 
10551 /** returns the average number of cutoffs found after branching on the variable in given direction;
10552  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
10553  * over all variables for branching in the given direction is returned
10554  *
10555  * @return the average number of cutoffs found after branching on the variable in given direction
10556  *
10557  * @pre This method can be called if @p scip is in one of the following stages:
10558  * - \ref SCIP_STAGE_INITPRESOLVE
10559  * - \ref SCIP_STAGE_PRESOLVING
10560  * - \ref SCIP_STAGE_EXITPRESOLVE
10561  * - \ref SCIP_STAGE_PRESOLVED
10562  * - \ref SCIP_STAGE_INITSOLVE
10563  * - \ref SCIP_STAGE_SOLVING
10564  * - \ref SCIP_STAGE_SOLVED
10565  */
10566 extern
10568  SCIP* scip, /**< SCIP data structure */
10569  SCIP_VAR* var, /**< problem variable */
10570  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10571  );
10572 
10573 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
10574  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
10575  * over all variables for branching in the given direction is returned
10576  *
10577  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
10578  *
10579  * @pre This method can be called if @p scip is in one of the following stages:
10580  * - \ref SCIP_STAGE_INITPRESOLVE
10581  * - \ref SCIP_STAGE_PRESOLVING
10582  * - \ref SCIP_STAGE_EXITPRESOLVE
10583  * - \ref SCIP_STAGE_PRESOLVED
10584  * - \ref SCIP_STAGE_INITSOLVE
10585  * - \ref SCIP_STAGE_SOLVING
10586  * - \ref SCIP_STAGE_SOLVED
10587  */
10588 extern
10590  SCIP* scip, /**< SCIP data structure */
10591  SCIP_VAR* var, /**< problem variable */
10592  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
10593  );
10594 
10595 /** returns the variable's average cutoff score value
10596  *
10597  * @return the variable's average cutoff score value
10598  *
10599  * @pre This method can be called if @p scip is in one of the following stages:
10600  * - \ref SCIP_STAGE_INITPRESOLVE
10601  * - \ref SCIP_STAGE_PRESOLVING
10602  * - \ref SCIP_STAGE_EXITPRESOLVE
10603  * - \ref SCIP_STAGE_PRESOLVED
10604  * - \ref SCIP_STAGE_INITSOLVE
10605  * - \ref SCIP_STAGE_SOLVING
10606  * - \ref SCIP_STAGE_SOLVED
10607  */
10608 extern
10610  SCIP* scip, /**< SCIP data structure */
10611  SCIP_VAR* var /**< problem variable */
10612  );
10613 
10614 /** returns the variable's average cutoff score value, only using cutoffs of the current run
10615  *
10616  * @return the variable's average cutoff score value, only using cutoffs of the current run
10617  *
10618  * @pre This method can be called if @p scip is in one of the following stages:
10619  * - \ref SCIP_STAGE_INITPRESOLVE
10620  * - \ref SCIP_STAGE_PRESOLVING
10621  * - \ref SCIP_STAGE_EXITPRESOLVE
10622  * - \ref SCIP_STAGE_PRESOLVED
10623  * - \ref SCIP_STAGE_INITSOLVE
10624  * - \ref SCIP_STAGE_SOLVING
10625  * - \ref SCIP_STAGE_SOLVED
10626  */
10627 extern
10629  SCIP* scip, /**< SCIP data structure */
10630  SCIP_VAR* var /**< problem variable */
10631  );
10632 
10633 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
10634  * factor
10635  *
10636  * @return the variable's average inference/cutoff score value
10637  *
10638  * @pre This method can be called if @p scip is in one of the following stages:
10639  * - \ref SCIP_STAGE_INITPRESOLVE
10640  * - \ref SCIP_STAGE_PRESOLVING
10641  * - \ref SCIP_STAGE_EXITPRESOLVE
10642  * - \ref SCIP_STAGE_PRESOLVED
10643  * - \ref SCIP_STAGE_INITSOLVE
10644  * - \ref SCIP_STAGE_SOLVING
10645  * - \ref SCIP_STAGE_SOLVED
10646  */
10647 extern
10649  SCIP* scip, /**< SCIP data structure */
10650  SCIP_VAR* var, /**< problem variable */
10651  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
10652  );
10653 
10654 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
10655  * factor, only using inferences and cutoffs of the current run
10656  *
10657  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
10658  *
10659  * @pre This method can be called if @p scip is in one of the following stages:
10660  * - \ref SCIP_STAGE_INITPRESOLVE
10661  * - \ref SCIP_STAGE_PRESOLVING
10662  * - \ref SCIP_STAGE_EXITPRESOLVE
10663  * - \ref SCIP_STAGE_PRESOLVED
10664  * - \ref SCIP_STAGE_INITSOLVE
10665  * - \ref SCIP_STAGE_SOLVING
10666  * - \ref SCIP_STAGE_SOLVED
10667  */
10668 extern
10670  SCIP* scip, /**< SCIP data structure */
10671  SCIP_VAR* var, /**< problem variable */
10672  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
10673  );
10674 
10675 /** outputs variable information to file stream via the message system
10676  *
10677  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10678  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10679  *
10680  * @pre This method can be called if @p scip is in one of the following stages:
10681  * - \ref SCIP_STAGE_PROBLEM
10682  * - \ref SCIP_STAGE_TRANSFORMING
10683  * - \ref SCIP_STAGE_TRANSFORMED
10684  * - \ref SCIP_STAGE_INITPRESOLVE
10685  * - \ref SCIP_STAGE_PRESOLVING
10686  * - \ref SCIP_STAGE_EXITPRESOLVE
10687  * - \ref SCIP_STAGE_PRESOLVED
10688  * - \ref SCIP_STAGE_INITSOLVE
10689  * - \ref SCIP_STAGE_SOLVING
10690  * - \ref SCIP_STAGE_SOLVED
10691  * - \ref SCIP_STAGE_EXITSOLVE
10692  * - \ref SCIP_STAGE_FREETRANS
10693  *
10694  * @note If the message handler is set to a NULL pointer nothing will be printed
10695  */
10696 extern
10698  SCIP* scip, /**< SCIP data structure */
10699  SCIP_VAR* var, /**< problem variable */
10700  FILE* file /**< output file (or NULL for standard output) */
10701  );
10702 
10703 /**@} */
10704 
10705 
10706 
10707 
10708 /*
10709  * conflict analysis methods
10710  */
10711 
10712 /**@addtogroup PublicConflictMethods
10713  *
10714  * @{
10715  */
10716 
10717 /** return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
10718  * conflict analysis since it will not be applied
10719  *
10720  * @return return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
10721  * conflict analysis since it will not be applied
10722  *
10723  * @pre This method can be called if SCIP is in one of the following stages:
10724  * - \ref SCIP_STAGE_INITPRESOLVE
10725  * - \ref SCIP_STAGE_PRESOLVING
10726  * - \ref SCIP_STAGE_EXITPRESOLVE
10727  * - \ref SCIP_STAGE_SOLVING
10728  *
10729  * @note SCIP stage does not get changed
10730  */
10731 extern
10733  SCIP* scip /**< SCIP data structure */
10734  );
10735 
10736 /** initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you
10737  * enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
10738  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
10739  *
10740  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10741  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10742  *
10743  * @pre This method can be called if SCIP is in one of the following stages:
10744  * - \ref SCIP_STAGE_PRESOLVING
10745  * - \ref SCIP_STAGE_SOLVING
10746  *
10747  * @note SCIP stage does not get changed
10748  */
10749 extern
10751  SCIP* scip, /**< SCIP data structure */
10752  SCIP_CONFTYPE conftype, /**< type of conflict */
10753  SCIP_Bool iscutoffinvolved /**< is the current cutoff bound involved? */
10754  );
10755 
10756 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
10757  * this method should be called in one of the following two cases:
10758  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound
10759  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10760  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called
10761  * for each lower bound, whose current assignment led to the deduction of the given conflict bound.
10762  *
10763  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10764  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10765  *
10766  * @pre This method can be called if SCIP is in one of the following stages:
10767  * - \ref SCIP_STAGE_PRESOLVING
10768  * - \ref SCIP_STAGE_SOLVING
10769  *
10770  * @note SCIP stage does not get changed
10771  */
10772 extern
10774  SCIP* scip, /**< SCIP data structure */
10775  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
10776  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10777  * conflicting bound was valid, NULL for current local bound */
10778  );
10779 
10780 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
10781  * with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough
10782  * to explain a certain bound change;
10783  * this method should be called in one of the following two cases:
10784  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound
10785  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10786  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called
10787  * for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.
10788  *
10789  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10790  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10791  *
10792  * @pre This method can be called if SCIP is in one of the following stages:
10793  * - \ref SCIP_STAGE_PRESOLVING
10794  * - \ref SCIP_STAGE_SOLVING
10795  *
10796  * @note SCIP stage does not get changed
10797  */
10798 extern
10800  SCIP* scip, /**< SCIP data structure */
10801  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
10802  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10803  * conflicting bound was valid, NULL for current local bound */
10804  SCIP_Real relaxedlb /**< the relaxed lower bound */
10805  );
10806 
10807 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
10808  * this method should be called in one of the following two cases:
10809  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that
10810  * led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10811  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for
10812  * each upper bound, whose current assignment led to the deduction of the given conflict bound.
10813  *
10814  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10815  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10816  *
10817  * @pre This method can be called if SCIP is in one of the following stages:
10818  * - \ref SCIP_STAGE_PRESOLVING
10819  * - \ref SCIP_STAGE_SOLVING
10820  *
10821  * @note SCIP stage does not get changed
10822  */
10823 extern
10825  SCIP* scip, /**< SCIP data structure */
10826  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10827  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10828  * conflicting bound was valid, NULL for current local bound */
10829  );
10830 
10831 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
10832  * with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough
10833  * to explain a certain bound change;
10834  * this method should be called in one of the following two cases:
10835  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper
10836  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10837  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be
10838  * called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict
10839  * bound.
10840  *
10841  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10842  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10843  *
10844  * @pre This method can be called if SCIP is in one of the following stages:
10845  * - \ref SCIP_STAGE_PRESOLVING
10846  * - \ref SCIP_STAGE_SOLVING
10847  *
10848  * @note SCIP stage does not get changed
10849  */
10850 extern
10852  SCIP* scip, /**< SCIP data structure */
10853  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10854  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10855  * conflicting bound was valid, NULL for current local bound */
10856  SCIP_Real relaxedub /**< the relaxed upper bound */
10857  );
10858 
10859 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate
10860  * storage; this method should be called in one of the following two cases:
10861  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound
10862  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10863  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called
10864  * for each bound, whose current assignment led to the deduction of the given conflict bound.
10865  *
10866  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10867  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10868  *
10869  * @pre This method can be called if SCIP is in one of the following stages:
10870  * - \ref SCIP_STAGE_PRESOLVING
10871  * - \ref SCIP_STAGE_SOLVING
10872  *
10873  * @note SCIP stage does not get changed
10874  */
10875 extern
10877  SCIP* scip, /**< SCIP data structure */
10878  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10879  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10880  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10881  * conflicting bound was valid, NULL for current local bound */
10882  );
10883 
10884 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis'
10885  * candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one
10886  * which would be enough to explain a certain bound change;
10887  * this method should be called in one of the following two cases:
10888  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed)
10889  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10890  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be
10891  * called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.
10892  *
10893  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10894  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10895  *
10896  * @pre This method can be called if SCIP is in one of the following stages:
10897  * - \ref SCIP_STAGE_PRESOLVING
10898  * - \ref SCIP_STAGE_SOLVING
10899  *
10900  * @note SCIP stage does not get changed
10901  */
10902 extern
10904  SCIP* scip, /**< SCIP data structure */
10905  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10906  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10907  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10908  * conflicting bound was valid, NULL for current local bound */
10909  SCIP_Real relaxedbd /**< the relaxed bound */
10910  );
10911 
10912 /** adds changed bound of fixed binary variable to the conflict analysis' candidate storage;
10913  * this method should be called in one of the following two cases:
10914  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary
10915  * variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10916  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called
10917  * for each binary variable, whose current fixing led to the deduction of the given conflict bound.
10918  *
10919  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10920  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10921  *
10922  * @pre This method can be called if SCIP is in one of the following stages:
10923  * - \ref SCIP_STAGE_PRESOLVING
10924  * - \ref SCIP_STAGE_SOLVING
10925  *
10926  * @note SCIP stage does not get changed
10927  */
10928 extern
10930  SCIP* scip, /**< SCIP data structure */
10931  SCIP_VAR* var /**< binary variable whose changed bound should be added to conflict queue */
10932  );
10933 
10934 /** checks if the given variable is already part of the current conflict set or queued for resolving with the same or
10935  * even stronger bound
10936  *
10937  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10938  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10939  *
10940  * @pre This method can be called if SCIP is in one of the following stages:
10941  * - \ref SCIP_STAGE_PRESOLVING
10942  * - \ref SCIP_STAGE_SOLVING
10943  *
10944  * @note SCIP stage does not get changed
10945  */
10946 extern
10948  SCIP* scip, /**< SCIP data structure */
10949  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10950  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10951  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10952  * conflicting bound was valid, NULL for current local bound */
10953  SCIP_Bool* used /**< pointer to store if the variable is already used */
10954  );
10955 
10956 /** returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
10957  * bound
10958  *
10959  * @return returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
10960  * bound
10961  *
10962  * @pre This method can be called if SCIP is in one of the following stages:
10963  * - \ref SCIP_STAGE_PRESOLVING
10964  * - \ref SCIP_STAGE_SOLVING
10965  *
10966  * @note SCIP stage does not get changed
10967  */
10968 extern
10970  SCIP* scip, /**< SCIP data structure */
10971  SCIP_VAR* var /**< problem variable */
10972  );
10973 
10974 /** returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
10975  * upper bound
10976  *
10977  * @return returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
10978  * upper bound
10979  *
10980  * @pre This method can be called if SCIP is in one of the following stages:
10981  * - \ref SCIP_STAGE_PRESOLVING
10982  * - \ref SCIP_STAGE_SOLVING
10983  *
10984  * @note SCIP stage does not get changed
10985  */
10986 extern
10988  SCIP* scip, /**< SCIP data structure */
10989  SCIP_VAR* var /**< problem variable */
10990  );
10991 
10992 /** analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to
10993  * SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
10994  * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict
10995  * handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth
10996  * level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
10997  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is
10998  * valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons()
10999  * instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used
11000  *
11001  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11002  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11003  *
11004  * @pre This method can be called if SCIP is in one of the following stages:
11005  * - \ref SCIP_STAGE_PRESOLVING
11006  * - \ref SCIP_STAGE_SOLVING
11007  *
11008  * @note SCIP stage does not get changed
11009  */
11010 extern
11012  SCIP* scip, /**< SCIP data structure */
11013  int validdepth, /**< minimal depth level at which the initial conflict set is valid */
11014  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
11015  );
11016 
11017 /** analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(),
11018  * SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or
11019  * SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the
11020  * resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint
11021  * that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(),
11022  * SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(),
11023  * SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())
11024  *
11025  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11026  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11027  *
11028  * @pre This method can be called if SCIP is in one of the following stages:
11029  * - \ref SCIP_STAGE_PRESOLVING
11030  * - \ref SCIP_STAGE_SOLVING
11031  *
11032  * @note SCIP stage does not get changed
11033  */
11034 extern
11036  SCIP* scip, /**< SCIP data structure */
11037  SCIP_CONS* cons, /**< constraint that detected the conflict */
11038  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
11039  );
11040 
11041 /**@} */
11042 
11043 
11044 
11045 
11046 /*
11047  * constraint methods
11048  */
11049 
11050 /**@addtogroup PublicConstraintMethods
11051  *
11052  * @{
11053  */
11054 
11055 /** creates and captures a constraint of the given constraint handler
11056  *
11057  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
11058  * be declared feasible even if it violates this particular constraint. This constellation should only be
11059  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
11060  * to the variable's local bounds.
11061  *
11062  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11063  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11064  *
11065  * @pre This method can be called if @p scip is in one of the following stages:
11066  * - \ref SCIP_STAGE_PROBLEM
11067  * - \ref SCIP_STAGE_TRANSFORMING
11068  * - \ref SCIP_STAGE_INITPRESOLVE
11069  * - \ref SCIP_STAGE_PRESOLVING
11070  * - \ref SCIP_STAGE_EXITPRESOLVE
11071  * - \ref SCIP_STAGE_PRESOLVED
11072  * - \ref SCIP_STAGE_INITSOLVE
11073  * - \ref SCIP_STAGE_SOLVING
11074  * - \ref SCIP_STAGE_EXITSOLVE
11075  *
11076  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
11077  */
11078 extern
11080  SCIP* scip, /**< SCIP data structure */
11081  SCIP_CONS** cons, /**< pointer to constraint */
11082  const char* name, /**< name of constraint */
11083  SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
11084  SCIP_CONSDATA* consdata, /**< data for this specific constraint */
11085  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
11086  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
11087  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
11088  * Usually set to TRUE. */
11089  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
11090  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11091  SCIP_Bool check, /**< should the constraint be checked for feasibility?
11092  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11093  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
11094  * Usually set to TRUE. */
11095  SCIP_Bool local, /**< is constraint only valid locally?
11096  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
11097  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
11098  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
11099  * adds coefficients to this constraint. */
11100  SCIP_Bool dynamic, /**< is constraint subject to aging?
11101  * Usually set to FALSE. Set to TRUE for own cuts which
11102  * are separated as constraints. */
11103  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
11104  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
11105  SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
11106  * if it may be moved to a more global node?
11107  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
11108  );
11109 
11110 /** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
11111  * creates and captures;
11112  *
11113  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11114  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11115  *
11116  * @pre This method can be called if @p scip is in one of the following stages:
11117  * - \ref SCIP_STAGE_PROBLEM
11118  * - \ref SCIP_STAGE_TRANSFORMING
11119  * - \ref SCIP_STAGE_INITPRESOLVE
11120  * - \ref SCIP_STAGE_PRESOLVING
11121  * - \ref SCIP_STAGE_EXITPRESOLVE
11122  * - \ref SCIP_STAGE_PRESOLVED
11123  * - \ref SCIP_STAGE_SOLVING
11124  * - \ref SCIP_STAGE_EXITSOLVE
11125  *
11126  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
11127  * be declared feasible even if it violates this particular constraint. This constellation should only be
11128  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
11129  * to the variable's local bounds.
11130  */
11131 extern
11133  SCIP* scip, /**< SCIP data structure */
11134  SCIP_CONS** cons, /**< pointer to store constraint */
11135  const char* str, /**< string to parse for constraint */
11136  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
11137  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
11138  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
11139  * Usually set to TRUE. */
11140  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
11141  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11142  SCIP_Bool check, /**< should the constraint be checked for feasibility?
11143  * TRUE for model constraints, FALSE for additional, redundant constraints. */
11144  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
11145  * Usually set to TRUE. */
11146  SCIP_Bool local, /**< is constraint only valid locally?
11147  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
11148  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
11149  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
11150  * adds coefficients to this constraint. */
11151  SCIP_Bool dynamic, /**< is constraint subject to aging?
11152  * Usually set to FALSE. Set to TRUE for own cuts which
11153  * are separated as constraints. */
11154  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
11155  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
11156  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
11157  * if it may be moved to a more global node?
11158  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
11159  SCIP_Bool* success /**< pointer to store if the paring process was successful */
11160  );
11161 
11162 /** increases usage counter of constraint
11163  *
11164  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11165  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11166  *
11167  * @pre This method can be called if @p scip is in one of the following stages:
11168  * - \ref SCIP_STAGE_PROBLEM
11169  * - \ref SCIP_STAGE_TRANSFORMING
11170  * - \ref SCIP_STAGE_TRANSFORMED
11171  * - \ref SCIP_STAGE_INITPRESOLVE
11172  * - \ref SCIP_STAGE_PRESOLVING
11173  * - \ref SCIP_STAGE_EXITPRESOLVE
11174  * - \ref SCIP_STAGE_PRESOLVED
11175  * - \ref SCIP_STAGE_INITSOLVE
11176  * - \ref SCIP_STAGE_SOLVING
11177  * - \ref SCIP_STAGE_SOLVED
11178  */
11179 extern
11181  SCIP* scip, /**< SCIP data structure */
11182  SCIP_CONS* cons /**< constraint to capture */
11183  );
11184 
11185 /** decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
11186  *
11187  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11188  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11189  *
11190  * @pre This method can be called if @p scip is in one of the following stages:
11191  * - \ref SCIP_STAGE_PROBLEM
11192  * - \ref SCIP_STAGE_TRANSFORMING
11193  * - \ref SCIP_STAGE_TRANSFORMED
11194  * - \ref SCIP_STAGE_INITPRESOLVE
11195  * - \ref SCIP_STAGE_PRESOLVING
11196  * - \ref SCIP_STAGE_EXITPRESOLVE
11197  * - \ref SCIP_STAGE_PRESOLVED
11198  * - \ref SCIP_STAGE_INITSOLVE
11199  * - \ref SCIP_STAGE_SOLVING
11200  * - \ref SCIP_STAGE_SOLVED
11201  * - \ref SCIP_STAGE_EXITSOLVE
11202  * - \ref SCIP_STAGE_FREETRANS
11203  *
11204  * @note the pointer of the constraint will be NULLed
11205  */
11206 extern
11208  SCIP* scip, /**< SCIP data structure */
11209  SCIP_CONS** cons /**< pointer to constraint */
11210  );
11211 
11212 /** change constraint name
11213  *
11214  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11215  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11216  *
11217  * @pre This method can be called if @p scip is in one of the following stages:
11218  * - \ref SCIP_STAGE_PROBLEM
11219  *
11220  * @note to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h
11221  */
11222 extern
11224  SCIP* scip, /**< SCIP data structure */
11225  SCIP_CONS* cons, /**< constraint */
11226  const char* name /**< new name of constraint */
11227  );
11228 
11229 /** sets the initial flag of the given constraint
11230  *
11231  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11232  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11233  *
11234  * @pre This method can be called if @p scip is in one of the following stages:
11235  * - \ref SCIP_STAGE_PROBLEM
11236  * - \ref SCIP_STAGE_TRANSFORMING
11237  * - \ref SCIP_STAGE_PRESOLVING
11238  * - \ref SCIP_STAGE_PRESOLVED
11239  * - \ref SCIP_STAGE_SOLVING
11240  */
11241 extern
11243  SCIP* scip, /**< SCIP data structure */
11244  SCIP_CONS* cons, /**< constraint */
11245  SCIP_Bool initial /**< new value */
11246  );
11247 
11248 /** sets the separate flag of the given constraint
11249  *
11250  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11251  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11252  *
11253  * @pre This method can be called if @p scip is in one of the following stages:
11254  * - \ref SCIP_STAGE_PROBLEM
11255  * - \ref SCIP_STAGE_TRANSFORMING
11256  * - \ref SCIP_STAGE_PRESOLVING
11257  * - \ref SCIP_STAGE_PRESOLVED
11258  * - \ref SCIP_STAGE_SOLVING
11259  */
11260 extern
11262  SCIP* scip, /**< SCIP data structure */
11263  SCIP_CONS* cons, /**< constraint */
11264  SCIP_Bool separate /**< new value */
11265  );
11266 
11267 /** sets the enforce flag of the given constraint
11268  *
11269  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11270  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11271  *
11272  * @pre This method can be called if @p scip is in one of the following stages:
11273  * - \ref SCIP_STAGE_PROBLEM
11274  * - \ref SCIP_STAGE_TRANSFORMING
11275  * - \ref SCIP_STAGE_PRESOLVING
11276  * - \ref SCIP_STAGE_PRESOLVED
11277  * - \ref SCIP_STAGE_SOLVING
11278  */
11279 extern
11281  SCIP* scip, /**< SCIP data structure */
11282  SCIP_CONS* cons, /**< constraint */
11283  SCIP_Bool enforce /**< new value */
11284  );
11285 
11286 /** sets the check flag of the given constraint
11287  *
11288  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11289  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11290  *
11291  * @pre This method can be called if @p scip is in one of the following stages:
11292  * - \ref SCIP_STAGE_PROBLEM
11293  * - \ref SCIP_STAGE_TRANSFORMING
11294  * - \ref SCIP_STAGE_PRESOLVING
11295  * - \ref SCIP_STAGE_PRESOLVED
11296  * - \ref SCIP_STAGE_SOLVING
11297  */
11298 extern
11300  SCIP* scip, /**< SCIP data structure */
11301  SCIP_CONS* cons, /**< constraint */
11302  SCIP_Bool check /**< new value */
11303  );
11304 
11305 /** sets the propagate flag of the given constraint
11306  *
11307  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11308  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11309  *
11310  * @pre This method can be called if @p scip is in one of the following stages:
11311  * - \ref SCIP_STAGE_PROBLEM
11312  * - \ref SCIP_STAGE_TRANSFORMING
11313  * - \ref SCIP_STAGE_PRESOLVING
11314  * - \ref SCIP_STAGE_PRESOLVED
11315  * - \ref SCIP_STAGE_SOLVING
11316  */
11317 extern
11319  SCIP* scip, /**< SCIP data structure */
11320  SCIP_CONS* cons, /**< constraint */
11321  SCIP_Bool propagate /**< new value */
11322  );
11323 
11324 /** sets the local flag of the given constraint
11325  *
11326  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11327  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11328  *
11329  * @pre This method can be called if @p scip is in one of the following stages:
11330  * - \ref SCIP_STAGE_PROBLEM
11331  * - \ref SCIP_STAGE_TRANSFORMING
11332  * - \ref SCIP_STAGE_INITPRESOLVE
11333  * - \ref SCIP_STAGE_PRESOLVING
11334  * - \ref SCIP_STAGE_PRESOLVED
11335  * - \ref SCIP_STAGE_INITSOLVE
11336  * - \ref SCIP_STAGE_SOLVING
11337  */
11338 extern
11340  SCIP* scip, /**< SCIP data structure */
11341  SCIP_CONS* cons, /**< constraint */
11342  SCIP_Bool local /**< new value */
11343  );
11344 
11345 /** sets the modifiable flag of the given constraint
11346  *
11347  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11348  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11349  *
11350  * @pre This method can be called if @p scip is in one of the following stages:
11351  * - \ref SCIP_STAGE_PROBLEM
11352  * - \ref SCIP_STAGE_TRANSFORMING
11353  * - \ref SCIP_STAGE_PRESOLVING
11354  * - \ref SCIP_STAGE_PRESOLVED
11355  * - \ref SCIP_STAGE_SOLVING
11356  * - \ref SCIP_STAGE_EXITSOLVE
11357  */
11358 extern
11360  SCIP* scip, /**< SCIP data structure */
11361  SCIP_CONS* cons, /**< constraint */
11362  SCIP_Bool modifiable /**< new value */
11363  );
11364 
11365 /** sets the dynamic flag of the given constraint
11366  *
11367  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11368  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11369  *
11370  * @pre This method can be called if @p scip is in one of the following stages:
11371  * - \ref SCIP_STAGE_PROBLEM
11372  * - \ref SCIP_STAGE_TRANSFORMING
11373  * - \ref SCIP_STAGE_PRESOLVING
11374  * - \ref SCIP_STAGE_PRESOLVED
11375  * - \ref SCIP_STAGE_SOLVING
11376  */
11377 extern
11379  SCIP* scip, /**< SCIP data structure */
11380  SCIP_CONS* cons, /**< constraint */
11381  SCIP_Bool dynamic /**< new value */
11382  );
11383 
11384 /** sets the removable flag of the given constraint
11385  *
11386  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11387  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11388  *
11389  * @pre This method can be called if @p scip is in one of the following stages:
11390  * - \ref SCIP_STAGE_PROBLEM
11391  * - \ref SCIP_STAGE_TRANSFORMING
11392  * - \ref SCIP_STAGE_PRESOLVING
11393  * - \ref SCIP_STAGE_PRESOLVED
11394  * - \ref SCIP_STAGE_SOLVING
11395  */
11396 extern
11398  SCIP* scip, /**< SCIP data structure */
11399  SCIP_CONS* cons, /**< constraint */
11400  SCIP_Bool removable /**< new value */
11401  );
11402 
11403 /** sets the stickingatnode flag of the given constraint
11404  *
11405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11407  *
11408  * @pre This method can be called if @p scip is in one of the following stages:
11409  * - \ref SCIP_STAGE_PROBLEM
11410  * - \ref SCIP_STAGE_TRANSFORMING
11411  * - \ref SCIP_STAGE_PRESOLVING
11412  * - \ref SCIP_STAGE_PRESOLVED
11413  * - \ref SCIP_STAGE_SOLVING
11414  */
11415 extern
11417  SCIP* scip, /**< SCIP data structure */
11418  SCIP_CONS* cons, /**< constraint */
11419  SCIP_Bool stickingatnode /**< new value */
11420  );
11421 
11422 /** updates the flags of the first constraint according to the ones of the second constraint
11423  *
11424  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11425  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11426  *
11427  * @pre This method can be called if @p scip is in one of the following stages:
11428  * - \ref SCIP_STAGE_PROBLEM
11429  * - \ref SCIP_STAGE_TRANSFORMING
11430  * - \ref SCIP_STAGE_PRESOLVING
11431  * - \ref SCIP_STAGE_PRESOLVED
11432  * - \ref SCIP_STAGE_SOLVING
11433  */
11434 extern
11436  SCIP* scip, /**< SCIP data structure */
11437  SCIP_CONS* cons0, /**< constraint that should stay */
11438  SCIP_CONS* cons1 /**< constraint that should be deleted */
11439  );
11440 
11441 /** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
11442  * a new transformed constraint for this constraint is created
11443  *
11444  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11445  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11446  *
11447  * @pre This method can be called if @p scip is in one of the following stages:
11448  * - \ref SCIP_STAGE_TRANSFORMING
11449  * - \ref SCIP_STAGE_TRANSFORMED
11450  * - \ref SCIP_STAGE_INITPRESOLVE
11451  * - \ref SCIP_STAGE_PRESOLVING
11452  * - \ref SCIP_STAGE_EXITPRESOLVE
11453  * - \ref SCIP_STAGE_PRESOLVED
11454  * - \ref SCIP_STAGE_INITSOLVE
11455  * - \ref SCIP_STAGE_SOLVING
11456  */
11457 extern
11459  SCIP* scip, /**< SCIP data structure */
11460  SCIP_CONS* cons, /**< constraint to get/create transformed constraint for */
11461  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
11462  );
11463 
11464 /** gets and captures transformed constraints for an array of constraints;
11465  * if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created;
11466  * it is possible to call this method with conss == transconss
11467  *
11468  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11469  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11470  *
11471  * @pre This method can be called if @p scip is in one of the following stages:
11472  * - \ref SCIP_STAGE_TRANSFORMING
11473  * - \ref SCIP_STAGE_TRANSFORMED
11474  * - \ref SCIP_STAGE_INITPRESOLVE
11475  * - \ref SCIP_STAGE_PRESOLVING
11476  * - \ref SCIP_STAGE_EXITPRESOLVE
11477  * - \ref SCIP_STAGE_PRESOLVED
11478  * - \ref SCIP_STAGE_INITSOLVE
11479  * - \ref SCIP_STAGE_SOLVING
11480  */
11481 extern
11483  SCIP* scip, /**< SCIP data structure */
11484  int nconss, /**< number of constraints to get/create transformed constraints for */
11485  SCIP_CONS** conss, /**< array with constraints to get/create transformed constraints for */
11486  SCIP_CONS** transconss /**< array to store the transformed constraints */
11487  );
11488 
11489 /** gets corresponding transformed constraint of a given constraint;
11490  * returns NULL as transcons, if transformed constraint is not yet existing
11491  *
11492  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11493  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11494  *
11495  * @pre This method can be called if @p scip is in one of the following stages:
11496  * - \ref SCIP_STAGE_TRANSFORMING
11497  * - \ref SCIP_STAGE_TRANSFORMED
11498  * - \ref SCIP_STAGE_INITPRESOLVE
11499  * - \ref SCIP_STAGE_PRESOLVING
11500  * - \ref SCIP_STAGE_EXITPRESOLVE
11501  * - \ref SCIP_STAGE_PRESOLVED
11502  * - \ref SCIP_STAGE_INITSOLVE
11503  * - \ref SCIP_STAGE_SOLVING
11504  * - \ref SCIP_STAGE_SOLVED
11505  * - \ref SCIP_STAGE_EXITSOLVE
11506  * - \ref SCIP_STAGE_FREETRANS
11507  */
11508 extern
11510  SCIP* scip, /**< SCIP data structure */
11511  SCIP_CONS* cons, /**< constraint to get the transformed constraint for */
11512  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
11513  );
11514 
11515 /** gets corresponding transformed constraints for an array of constraints;
11516  * stores NULL in a transconss slot, if the transformed constraint is not yet existing;
11517  * it is possible to call this method with conss == transconss, but remember that constraints that are not
11518  * yet transformed will be replaced with NULL
11519  *
11520  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11521  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11522  *
11523  * @pre This method can be called if @p scip is in one of the following stages:
11524  * - \ref SCIP_STAGE_TRANSFORMING
11525  * - \ref SCIP_STAGE_TRANSFORMED
11526  * - \ref SCIP_STAGE_INITPRESOLVE
11527  * - \ref SCIP_STAGE_PRESOLVING
11528  * - \ref SCIP_STAGE_EXITPRESOLVE
11529  * - \ref SCIP_STAGE_PRESOLVED
11530  * - \ref SCIP_STAGE_INITSOLVE
11531  * - \ref SCIP_STAGE_SOLVING
11532  * - \ref SCIP_STAGE_SOLVED
11533  * - \ref SCIP_STAGE_EXITSOLVE
11534  * - \ref SCIP_STAGE_FREETRANS
11535  */
11536 extern
11538  SCIP* scip, /**< SCIP data structure */
11539  int nconss, /**< number of constraints to get the transformed constraints for */
11540  SCIP_CONS** conss, /**< constraints to get the transformed constraints for */
11541  SCIP_CONS** transconss /**< array to store the transformed constraints */
11542  );
11543 
11544 /** adds given value to age of constraint, but age can never become negative;
11545  * should be called
11546  * - in constraint separation, if no cut was found for this constraint,
11547  * - in constraint enforcing, if constraint was feasible, and
11548  * - in constraint propagation, if no domain reduction was deduced;
11549  *
11550  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11551  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11552  *
11553  * @pre This method can be called if @p scip is in one of the following stages:
11554  * - \ref SCIP_STAGE_TRANSFORMED
11555  * - \ref SCIP_STAGE_PRESOLVING
11556  * - \ref SCIP_STAGE_PRESOLVED
11557  * - \ref SCIP_STAGE_SOLVING
11558  * - \ref SCIP_STAGE_SOLVED
11559  */
11560 extern
11562  SCIP* scip, /**< SCIP data structure */
11563  SCIP_CONS* cons, /**< constraint */
11564  SCIP_Real deltaage /**< value to add to the constraint's age */
11565  );
11566 
11567 /** increases age of constraint by 1.0;
11568  * should be called
11569  * - in constraint separation, if no cut was found for this constraint,
11570  * - in constraint enforcing, if constraint was feasible, and
11571  * - in constraint propagation, if no domain reduction was deduced;
11572  *
11573  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11574  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11575  *
11576  * @pre This method can be called if @p scip is in one of the following stages:
11577  * - \ref SCIP_STAGE_TRANSFORMED
11578  * - \ref SCIP_STAGE_PRESOLVING
11579  * - \ref SCIP_STAGE_PRESOLVED
11580  * - \ref SCIP_STAGE_SOLVING
11581  * - \ref SCIP_STAGE_SOLVED
11582  */
11583 extern
11585  SCIP* scip, /**< SCIP data structure */
11586  SCIP_CONS* cons /**< constraint */
11587  );
11588 
11589 /** resets age of constraint to zero;
11590  * should be called
11591  * - in constraint separation, if a cut was found for this constraint,
11592  * - in constraint enforcing, if the constraint was violated, and
11593  * - in constraint propagation, if a domain reduction was deduced;
11594  *
11595  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11596  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11597  *
11598  * @pre This method can be called if @p scip is in one of the following stages:
11599  * - \ref SCIP_STAGE_TRANSFORMED
11600  * - \ref SCIP_STAGE_PRESOLVING
11601  * - \ref SCIP_STAGE_PRESOLVED
11602  * - \ref SCIP_STAGE_SOLVING
11603  * - \ref SCIP_STAGE_SOLVED
11604  */
11605 extern
11607  SCIP* scip, /**< SCIP data structure */
11608  SCIP_CONS* cons /**< constraint */
11609  );
11610 
11611 /** enables constraint's separation, propagation, and enforcing capabilities
11612  *
11613  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11614  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11615  *
11616  * @pre This method can be called if @p scip is in one of the following stages:
11617  * - \ref SCIP_STAGE_TRANSFORMED
11618  * - \ref SCIP_STAGE_PRESOLVING
11619  * - \ref SCIP_STAGE_PRESOLVED
11620  * - \ref SCIP_STAGE_INITSOLVE
11621  * - \ref SCIP_STAGE_SOLVING
11622  * - \ref SCIP_STAGE_SOLVED
11623  */
11624 extern
11626  SCIP* scip, /**< SCIP data structure */
11627  SCIP_CONS* cons /**< constraint */
11628  );
11629 
11630 /** disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated,
11631  * separated, and enforced anymore until it is enabled again with a call to SCIPenableCons();
11632  * in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and
11633  * does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor
11634  * automatically disabled again on entering the node again;
11635  * note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint
11636  * is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree,
11637  * and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using
11638  * an appropriate event handler that watches the corresponding variables' domain changes)
11639  *
11640  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11641  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11642  *
11643  * @pre This method can be called if @p scip is in one of the following stages:
11644  * - \ref SCIP_STAGE_TRANSFORMED
11645  * - \ref SCIP_STAGE_INITPRESOLVE
11646  * - \ref SCIP_STAGE_PRESOLVING
11647  * - \ref SCIP_STAGE_PRESOLVED
11648  * - \ref SCIP_STAGE_INITSOLVE
11649  * - \ref SCIP_STAGE_SOLVING
11650  * - \ref SCIP_STAGE_SOLVED
11651  */
11652 extern
11654  SCIP* scip, /**< SCIP data structure */
11655  SCIP_CONS* cons /**< constraint */
11656  );
11657 
11658 /** enables constraint's separation capabilities
11659  *
11660  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11661  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11662  *
11663  * @pre This method can be called if @p scip is in one of the following stages:
11664  * - \ref SCIP_STAGE_TRANSFORMED
11665  * - \ref SCIP_STAGE_PRESOLVING
11666  * - \ref SCIP_STAGE_PRESOLVED
11667  * - \ref SCIP_STAGE_INITSOLVE
11668  * - \ref SCIP_STAGE_SOLVING
11669  * - \ref SCIP_STAGE_SOLVED
11670  */
11671 extern
11673  SCIP* scip, /**< SCIP data structure */
11674  SCIP_CONS* cons /**< constraint */
11675  );
11676 
11677 /** disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation
11678  * is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
11679  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
11680  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
11681  *
11682  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11683  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11684  *
11685  * @pre This method can be called if @p scip is in one of the following stages:
11686  * - \ref SCIP_STAGE_TRANSFORMED
11687  * - \ref SCIP_STAGE_PRESOLVING
11688  * - \ref SCIP_STAGE_PRESOLVED
11689  * - \ref SCIP_STAGE_INITSOLVE
11690  * - \ref SCIP_STAGE_SOLVING
11691  * - \ref SCIP_STAGE_SOLVED
11692  */
11693 extern
11695  SCIP* scip, /**< SCIP data structure */
11696  SCIP_CONS* cons /**< constraint */
11697  );
11698 
11699 /** enables constraint's propagation capabilities
11700  *
11701  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11702  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11703  *
11704  * @pre This method can be called if @p scip is in one of the following stages:
11705  * - \ref SCIP_STAGE_TRANSFORMED
11706  * - \ref SCIP_STAGE_INITPRESOLVE
11707  * - \ref SCIP_STAGE_PRESOLVING
11708  * - \ref SCIP_STAGE_EXITPRESOLVE
11709  * - \ref SCIP_STAGE_PRESOLVED
11710  * - \ref SCIP_STAGE_INITSOLVE
11711  * - \ref SCIP_STAGE_SOLVING
11712  * - \ref SCIP_STAGE_SOLVED
11713  */
11714 extern
11716  SCIP* scip, /**< SCIP data structure */
11717  SCIP_CONS* cons /**< constraint */
11718  );
11719 
11720 /** disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation
11721  * is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
11722  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
11723  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
11724  *
11725  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11726  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11727  *
11728  * @pre This method can be called if @p scip is in one of the following stages:
11729  * - \ref SCIP_STAGE_TRANSFORMED
11730  * - \ref SCIP_STAGE_INITPRESOLVE
11731  * - \ref SCIP_STAGE_PRESOLVING
11732  * - \ref SCIP_STAGE_EXITPRESOLVE
11733  * - \ref SCIP_STAGE_PRESOLVED
11734  * - \ref SCIP_STAGE_INITSOLVE
11735  * - \ref SCIP_STAGE_SOLVING
11736  * - \ref SCIP_STAGE_SOLVED
11737  */
11738 extern
11740  SCIP* scip, /**< SCIP data structure */
11741  SCIP_CONS* cons /**< constraint */
11742  );
11743 
11744 
11745 /** marks constraint to be propagated
11746  *
11747  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11748  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11749  *
11750  * @pre This method can be called if @p scip is in one of the following stages:
11751  * - \ref SCIP_STAGE_TRANSFORMING
11752  * - \ref SCIP_STAGE_TRANSFORMED
11753  * - \ref SCIP_STAGE_PRESOLVING
11754  * - \ref SCIP_STAGE_EXITPRESOLVE
11755  * - \ref SCIP_STAGE_PRESOLVED
11756  * - \ref SCIP_STAGE_INITSOLVE
11757  * - \ref SCIP_STAGE_SOLVING
11758  * - \ref SCIP_STAGE_SOLVED
11759  *
11760  * @note if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation
11761  */
11762 extern
11764  SCIP* scip, /**< SCIP data structure */
11765  SCIP_CONS* cons /**< constraint */
11766  );
11767 
11768 /** unmarks the constraint to be propagated
11769  *
11770  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11771  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11772  *
11773  * @pre This method can be called if @p scip is in one of the following stages:
11774  * - \ref SCIP_STAGE_TRANSFORMED
11775  * - \ref SCIP_STAGE_PRESOLVING
11776  * - \ref SCIP_STAGE_EXITPRESOLVE
11777  * - \ref SCIP_STAGE_PRESOLVED
11778  * - \ref SCIP_STAGE_INITSOLVE
11779  * - \ref SCIP_STAGE_SOLVING
11780  * - \ref SCIP_STAGE_SOLVED
11781  */
11782 extern
11784  SCIP* scip, /**< SCIP data structure */
11785  SCIP_CONS* cons /**< constraint */
11786  );
11787 
11788 /** adds given values to lock status of the constraint and updates the rounding locks of the involved variables
11789  *
11790  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11791  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11792  *
11793  * @pre This method can be called if @p scip is in one of the following stages:
11794  * - \ref SCIP_STAGE_PROBLEM
11795  * - \ref SCIP_STAGE_TRANSFORMING
11796  * - \ref SCIP_STAGE_INITPRESOLVE
11797  * - \ref SCIP_STAGE_PRESOLVING
11798  * - \ref SCIP_STAGE_EXITPRESOLVE
11799  * - \ref SCIP_STAGE_INITSOLVE
11800  * - \ref SCIP_STAGE_SOLVING
11801  * - \ref SCIP_STAGE_EXITSOLVE
11802  * - \ref SCIP_STAGE_FREETRANS
11803  */
11804 extern
11806  SCIP* scip, /**< SCIP data structure */
11807  SCIP_CONS* cons, /**< constraint */
11808  int nlockspos, /**< increase in number of rounding locks for constraint */
11809  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
11810  );
11811 
11812 /** checks single constraint for feasibility of the given solution
11813  *
11814  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11815  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11816  *
11817  * @pre This method can be called if @p scip is in one of the following stages:
11818  * - \ref SCIP_STAGE_TRANSFORMED
11819  * - \ref SCIP_STAGE_INITPRESOLVE
11820  * - \ref SCIP_STAGE_PRESOLVING
11821  * - \ref SCIP_STAGE_EXITPRESOLVE
11822  * - \ref SCIP_STAGE_PRESOLVED
11823  * - \ref SCIP_STAGE_INITSOLVE
11824  * - \ref SCIP_STAGE_SOLVING
11825  * - \ref SCIP_STAGE_SOLVED
11826  */
11827 extern
11829  SCIP* scip, /**< SCIP data structure */
11830  SCIP_CONS* cons, /**< constraint to check */
11831  SCIP_SOL* sol, /**< primal CIP solution */
11832  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
11833  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
11834  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
11835  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11836  );
11837 
11838 /** enforces single constraint for a given pseudo solution
11839  *
11840  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11841  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11842  *
11843  * @pre This method can be called if @p scip is in one of the following stages:
11844  * - \ref SCIP_STAGE_SOLVING
11845  *
11846  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11847  * added to SCIP beforehand.
11848  */
11849 extern
11851  SCIP* scip, /**< SCIP data structure */
11852  SCIP_CONS* cons, /**< constraint to enforce */
11853  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
11854  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
11855  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11856  );
11857 
11858 /** enforces single constraint for a given LP solution
11859  *
11860  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11861  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11862  *
11863  * @pre This method can be called if @p scip is in one of the following stages:
11864  * - \ref SCIP_STAGE_SOLVING
11865  *
11866  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11867  * added to SCIP beforehand.
11868  */
11869 extern
11871  SCIP* scip, /**< SCIP data structure */
11872  SCIP_CONS* cons, /**< constraint to enforce */
11873  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
11874  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11875  );
11876 
11877 /** enforces single constraint for a given relaxation solution
11878  *
11879  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11880  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11881  *
11882  * @pre This method can be called if @p scip is in one of the following stages:
11883  * - \ref SCIP_STAGE_SOLVING
11884  *
11885  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11886  * added to SCIP beforehand.
11887  */
11889  SCIP* scip, /**< SCIP data structure */
11890  SCIP_CONS* cons, /**< constraint to enforce */
11891  SCIP_SOL* sol, /**< solution to enforce */
11892  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
11893  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11894  );
11895 
11896 /** calls LP initialization method for single constraint
11897  *
11898  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11899  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11900  *
11901  * @pre This method can be called if @p scip is in one of the following stages:
11902  * - \ref SCIP_STAGE_SOLVING
11903  *
11904  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11905  * added to SCIP beforehand.
11906  */
11907 extern
11909  SCIP* scip, /**< SCIP data structure */
11910  SCIP_CONS* cons, /**< constraint to initialize */
11911  SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
11912 
11913  );
11914 
11915 /** calls separation method of single constraint for LP solution
11916  *
11917  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11918  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11919  *
11920  * @pre This method can be called if @p scip is in one of the following stages:
11921  * - \ref SCIP_STAGE_SOLVING
11922  *
11923  * @note This is an advanced method and should be used with caution.
11924  */
11925 extern
11927  SCIP* scip, /**< SCIP data structure */
11928  SCIP_CONS* cons, /**< constraint to separate */
11929  SCIP_RESULT* result /**< pointer to store the result of the separation call */
11930  );
11931 
11932 /** calls separation method of single constraint for given primal solution
11933  *
11934  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11935  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11936  *
11937  * @pre This method can be called if @p scip is in one of the following stages:
11938  * - \ref SCIP_STAGE_SOLVING
11939  *
11940  * @note This is an advanced method and should be used with caution.
11941  */
11942 extern
11944  SCIP* scip, /**< SCIP data structure */
11945  SCIP_CONS* cons, /**< constraint to separate */
11946  SCIP_SOL* sol, /**< primal solution that should be separated*/
11947  SCIP_RESULT* result /**< pointer to store the result of the separation call */
11948  );
11949 
11950 /** calls domain propagation method of single constraint
11951  *
11952  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11953  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11954  *
11955  * @pre This method can be called if @p scip is in one of the following stages:
11956  * - \ref SCIP_STAGE_PRESOLVING
11957  * - \ref SCIP_STAGE_SOLVING
11958  *
11959  * @note This is an advanced method and should be used with caution.
11960  */
11961 extern
11963  SCIP* scip, /**< SCIP data structure */
11964  SCIP_CONS* cons, /**< constraint to propagate */
11965  SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
11966  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11967  );
11968 
11969 /** resolves propagation conflict of single constraint
11970  *
11971  *
11972  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11973  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11974  *
11975  * @pre This method can be called if @p scip is in one of the following stages:
11976  * - \ref SCIP_STAGE_PRESOLVING
11977  * - \ref SCIP_STAGE_SOLVING
11978  *
11979  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11980  * added to SCIP beforehand.
11981  */
11982 extern
11984  SCIP* scip, /**< SCIP data structure */
11985  SCIP_CONS* cons, /**< constraint to resolve conflict for */
11986  SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
11987  int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
11988  SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
11989  SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
11990  SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
11991  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11992  );
11993 
11994 /** presolves of single constraint
11995  *
11996  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11997  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11998  *
11999  * @pre This method can be called if @p scip is in one of the following stages:
12000  * - \ref SCIP_STAGE_PRESOLVING
12001  *
12002  * @note This is an advanced method and should be used with caution.
12003  */
12004 extern
12006  SCIP* scip, /**< SCIP data structure */
12007  SCIP_CONS* cons, /**< constraint to presolve */
12008  int nrounds, /**< number of presolving rounds already done */
12009  SCIP_PRESOLTIMING presoltiming, /**< presolving timing(s) to be performed */
12010  int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
12011  int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
12012  int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
12013  int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
12014  int nnewholes, /**< number of domain holes added since the last call to the presolving method */
12015  int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
12016  int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
12017  int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
12018  int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
12019  int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
12020  int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
12021  int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
12022  int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
12023  int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
12024  int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
12025  int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
12026  int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
12027  int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
12028  int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
12029  int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
12030  SCIP_RESULT* result /**< pointer to store the result of the callback method */
12031  );
12032 
12033 /** calls constraint activation notification method of single constraint
12034  *
12035  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12036  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12037  *
12038  * @pre This method can be called if @p scip is in one of the following stages:
12039  * - \ref SCIP_STAGE_TRANSFORMING
12040  *
12041  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12042  * added to SCIP beforehand.
12043  */
12044 extern
12046  SCIP* scip, /**< SCIP data structure */
12047  SCIP_CONS* cons /**< constraint to notify */
12048  );
12049 
12050 /** calls constraint deactivation notification method of single constraint
12051  *
12052  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12053  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12054  *
12055  * @pre This method can be called if @p scip is in one of the following stages:
12056  * - \ref SCIP_STAGE_PRESOLVING
12057  * - \ref SCIP_STAGE_SOLVING
12058  *
12059  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
12060  * added to SCIP beforehand.
12061  */
12062 extern
12064  SCIP* scip, /**< SCIP data structure */
12065  SCIP_CONS* cons /**< constraint to notify */
12066  );
12067 
12068 /** outputs constraint information to file stream via the message handler system
12069  *
12070  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12071  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12072  *
12073  * @pre This method can be called if @p scip is in one of the following stages:
12074  * - \ref SCIP_STAGE_PROBLEM
12075  * - \ref SCIP_STAGE_TRANSFORMING
12076  * - \ref SCIP_STAGE_TRANSFORMED
12077  * - \ref SCIP_STAGE_INITPRESOLVE
12078  * - \ref SCIP_STAGE_PRESOLVING
12079  * - \ref SCIP_STAGE_EXITPRESOLVE
12080  * - \ref SCIP_STAGE_PRESOLVED
12081  * - \ref SCIP_STAGE_INITSOLVE
12082  * - \ref SCIP_STAGE_SOLVING
12083  * - \ref SCIP_STAGE_SOLVED
12084  * - \ref SCIP_STAGE_EXITSOLVE
12085  * - \ref SCIP_STAGE_FREETRANS
12086  *
12087  * @note If the message handler is set to a NULL pointer nothing will be printed.
12088  * @note The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a
12089  * newline character.
12090  */
12091 extern
12093  SCIP* scip, /**< SCIP data structure */
12094  SCIP_CONS* cons, /**< constraint */
12095  FILE* file /**< output file (or NULL for standard output) */
12096  );
12097 
12098 /** method to collect the variables of a constraint
12099  *
12100  * If the number of variables is greater than the available slots in the variable array, nothing happens except that
12101  * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
12102  * a constraint has in its scope.
12103  *
12104  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12105  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12106  *
12107  * @pre This method can be called if @p scip is in one of the following stages:
12108  * - \ref SCIP_STAGE_PROBLEM
12109  * - \ref SCIP_STAGE_TRANSFORMING
12110  * - \ref SCIP_STAGE_TRANSFORMED
12111  * - \ref SCIP_STAGE_INITPRESOLVE
12112  * - \ref SCIP_STAGE_PRESOLVING
12113  * - \ref SCIP_STAGE_EXITPRESOLVE
12114  * - \ref SCIP_STAGE_PRESOLVED
12115  * - \ref SCIP_STAGE_INITSOLVE
12116  * - \ref SCIP_STAGE_SOLVING
12117  * - \ref SCIP_STAGE_SOLVED
12118  * - \ref SCIP_STAGE_EXITSOLVE
12119  * - \ref SCIP_STAGE_FREETRANS
12120  *
12121  * @note The success pointer indicates if all variables were copied into the vars arrray.
12122  *
12123  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
12124  * set to FALSE.
12125  */
12126 extern
12128  SCIP* scip, /**< SCIP data structure */
12129  SCIP_CONS* cons, /**< constraint for which the variables are wanted */
12130  SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
12131  int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
12132  SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
12133  );
12134 
12135 /** method to collect the number of variables of a constraint
12136  *
12137  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12138  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12139  *
12140  * @pre This method can be called if @p scip is in one of the following stages:
12141  * - \ref SCIP_STAGE_PROBLEM
12142  * - \ref SCIP_STAGE_TRANSFORMING
12143  * - \ref SCIP_STAGE_TRANSFORMED
12144  * - \ref SCIP_STAGE_INITPRESOLVE
12145  * - \ref SCIP_STAGE_PRESOLVING
12146  * - \ref SCIP_STAGE_EXITPRESOLVE
12147  * - \ref SCIP_STAGE_PRESOLVED
12148  * - \ref SCIP_STAGE_INITSOLVE
12149  * - \ref SCIP_STAGE_SOLVING
12150  * - \ref SCIP_STAGE_SOLVED
12151  * - \ref SCIP_STAGE_EXITSOLVE
12152  * - \ref SCIP_STAGE_FREETRANS
12153  *
12154  * @note The success pointer indicates if the contraint handler was able to return the number of variables
12155  *
12156  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
12157  * set to FALSE
12158  */
12159 extern
12161  SCIP* scip, /**< SCIP data structure */
12162  SCIP_CONS* cons, /**< constraint for which the number of variables is wanted */
12163  int* nvars, /**< pointer to store the number of variables */
12164  SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
12165  );
12166 
12167 /**@} */
12168 
12169 
12170 
12171 
12172 /*
12173  * LP methods
12174  */
12175 
12176 /**@addtogroup PublicLPMethods
12177  *
12178  * @{
12179  */
12180 
12181 /** returns, whether the LP was or is to be solved in the current node
12182  *
12183  * @return whether the LP was or is to be solved in the current node.
12184  *
12185  * @pre This method can be called if @p scip is in one of the following stages:
12186  * - \ref SCIP_STAGE_SOLVING
12187  *
12188  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12189  */
12190 extern
12192  SCIP* scip /**< SCIP data structure */
12193  );
12194 
12195 /** returns, whether the LP of the current node is already constructed
12196  *
12197  * @return whether the LP of the current node is already constructed.
12198  *
12199  * @pre This method can be called if @p scip is in one of the following stages:
12200  * - \ref SCIP_STAGE_SOLVING
12201  *
12202  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12203  */
12204 extern
12206  SCIP* scip /**< SCIP data structure */
12207  );
12208 
12209 /** makes sure that the LP of the current node is loaded and may be accessed through the LP information methods
12210  *
12211  * @warning Contructing the LP might change the amount of variables known in the transformed problem and therefore also
12212  * the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to
12213  * call one of the later method after this one
12214  *
12215  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12216  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12217  *
12218  * @pre This method can be called if @p scip is in one of the following stages:
12219  * - \ref SCIP_STAGE_SOLVING
12220  *
12221  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12222  */
12223 extern
12225  SCIP* scip, /**< SCIP data structure */
12226  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
12227  );
12228 
12229 /** makes sure that the LP of the current node is flushed
12230  *
12231  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12232  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12233  *
12234  * @pre This method can be called if @p scip is in one of the following stages:
12235  * - \ref SCIP_STAGE_SOLVING
12236  *
12237  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12238  */
12239 extern
12241  SCIP* scip /**< SCIP data structure */
12242  );
12243 
12244 /** gets solution status of current LP
12245  *
12246  * @return the solution status of current LP.
12247  *
12248  * @pre This method can be called if @p scip is in one of the following stages:
12249  * - \ref SCIP_STAGE_SOLVING
12250  *
12251  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12252  */
12253 extern
12255  SCIP* scip /**< SCIP data structure */
12256  );
12257 
12258 /** returns whether the current LP solution passed the primal feasibility check
12259  *
12260  * @returns whether the current LP solution passed the primal feasibility check.
12261  *
12262  * @pre This method can be called if @p scip is in one of the following stages:
12263  * - \ref SCIP_STAGE_SOLVING
12264  *
12265  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12266  */
12267 extern
12269  SCIP* scip /**< SCIP data structure */
12270  );
12271 
12272 /** returns whether the current LP solution passed the dual feasibility check
12273  *
12274  * @returns whether the current LP solution passed the dual feasibility check.
12275  *
12276  * @pre This method can be called if @p scip is in one of the following stages:
12277  * - \ref SCIP_STAGE_SOLVING
12278  *
12279  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12280  */
12281 extern
12283  SCIP* scip /**< SCIP data structure */
12284  );
12285 
12286 /** returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
12287  *
12288  * @return whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.
12289  *
12290  * @pre This method can be called if @p scip is in one of the following stages:
12291  * - \ref SCIP_STAGE_SOLVING
12292  *
12293  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12294  */
12295 extern
12297  SCIP* scip /**< SCIP data structure */
12298  );
12299 
12300 /** gets objective value of current LP (which is the sum of column and loose objective value)
12301  *
12302  * @return the objective value of current LP (which is the sum of column and loose objective value).
12303  *
12304  * @pre This method can be called if @p scip is in one of the following stages:
12305  * - \ref SCIP_STAGE_SOLVING
12306  *
12307  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
12308  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by
12309  * SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
12310  *
12311  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12312  */
12313 extern
12315  SCIP* scip /**< SCIP data structure */
12316  );
12317 
12318 /** gets part of objective value of current LP that results from COLUMN variables only
12319  *
12320  * @return the part of objective value of current LP that results from COLUMN variables only.
12321  *
12322  * @pre This method can be called if @p scip is in one of the following stages:
12323  * - \ref SCIP_STAGE_SOLVING
12324  *
12325  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12326  */
12327 extern
12329  SCIP* scip /**< SCIP data structure */
12330  );
12331 
12332 /** gets part of objective value of current LP that results from LOOSE variables only
12333  *
12334  * @return part of objective value of current LP that results from LOOSE variables only.
12335  *
12336  * @pre This method can be called if @p scip is in one of the following stages:
12337  * - \ref SCIP_STAGE_SOLVING
12338  *
12339  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12340  */
12341 extern
12343  SCIP* scip /**< SCIP data structure */
12344  );
12345 
12346 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
12347  * function) global bound
12348  *
12349  * @return the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
12350  * function) global bound.
12351  *
12352  * @pre This method can be called if @p scip is in one of the following stages:
12353  * - \ref SCIP_STAGE_INITPRESOLVE
12354  * - \ref SCIP_STAGE_PRESOLVING
12355  * - \ref SCIP_STAGE_EXITPRESOLVE
12356  * - \ref SCIP_STAGE_PRESOLVED
12357  * - \ref SCIP_STAGE_INITSOLVE
12358  * - \ref SCIP_STAGE_SOLVING
12359  *
12360  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12361  */
12362 extern
12364  SCIP* scip /**< SCIP data structure */
12365  );
12366 
12367 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
12368  * objective function) local bound
12369  *
12370  * @return the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
12371  * objective function) local bound.
12372  *
12373  * @pre This method can be called if @p scip is in one of the following stages:
12374  * - \ref SCIP_STAGE_INITPRESOLVE
12375  * - \ref SCIP_STAGE_PRESOLVING
12376  * - \ref SCIP_STAGE_EXITPRESOLVE
12377  * - \ref SCIP_STAGE_PRESOLVED
12378  * - \ref SCIP_STAGE_INITSOLVE
12379  * - \ref SCIP_STAGE_SOLVING
12380  *
12381  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12382  */
12383 extern
12385  SCIP* scip /**< SCIP data structure */
12386  );
12387 
12388 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
12389  *
12390  * @return whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.
12391  *
12392  * @pre This method can be called if @p scip is in one of the following stages:
12393  * - \ref SCIP_STAGE_SOLVING
12394  *
12395  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12396  */
12397 extern
12399  SCIP* scip /**< SCIP data structure */
12400  );
12401 
12402 /** gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved
12403  *
12404  * @return the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved.
12405  *
12406  * @pre This method can be called if @p scip is in one of the following stages:
12407  * - \ref SCIP_STAGE_INITPRESOLVE
12408  * - \ref SCIP_STAGE_PRESOLVING
12409  * - \ref SCIP_STAGE_EXITPRESOLVE
12410  * - \ref SCIP_STAGE_SOLVING
12411  *
12412  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12413  */
12414 extern
12416  SCIP* scip /**< SCIP data structure */
12417  );
12418 
12419 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
12420  * returns SCIP_INVALID if the root node LP was not (yet) solved
12421  *
12422  * @return the part of the objective value of the root node LP that results from COLUMN variables only;
12423  * or SCIP_INVALID if the root node LP was not (yet) solved.
12424  *
12425  * @pre This method can be called if @p scip is in one of the following stages:
12426  * - \ref SCIP_STAGE_INITPRESOLVE
12427  * - \ref SCIP_STAGE_PRESOLVING
12428  * - \ref SCIP_STAGE_EXITPRESOLVE
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  );
12437 
12438 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
12439  * returns SCIP_INVALID if the root node LP was not (yet) solved
12440  *
12441  * @return the part of the objective value of the root node LP that results from LOOSE variables only;
12442  * or SCIP_INVALID if the root node LP was not (yet) solved.
12443  *
12444  * @pre This method can be called if @p scip is in one of the following stages:
12445  * - \ref SCIP_STAGE_INITPRESOLVE
12446  * - \ref SCIP_STAGE_PRESOLVING
12447  * - \ref SCIP_STAGE_EXITPRESOLVE
12448  * - \ref SCIP_STAGE_SOLVING
12449  *
12450  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12451  */
12452 extern
12454  SCIP* scip /**< SCIP data structure */
12455  );
12456 
12457 /** gets current LP columns along with the current number of LP columns
12458  *
12459  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12460  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12461  *
12462  * @pre This method can be called if @p scip is in one of the following stages:
12463  * - \ref SCIP_STAGE_SOLVING
12464  *
12465  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12466  */
12467 extern
12469  SCIP* scip, /**< SCIP data structure */
12470  SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */
12471  int* ncols /**< pointer to store the number of LP columns, or NULL */
12472  );
12473 
12474 /** gets current LP columns
12475  *
12476  * @return the current LP columns.
12477  *
12478  * @pre This method can be called if @p scip is in one of the following stages:
12479  * - \ref SCIP_STAGE_SOLVING
12480  *
12481  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12482  */
12483 extern
12485  SCIP* scip /**< SCIP data structure */
12486  );
12487 
12488 /** gets current number of LP columns
12489  *
12490  * @return the current number of LP columns.
12491  *
12492  * @pre This method can be called if @p scip is in one of the following stages:
12493  * - \ref SCIP_STAGE_SOLVING
12494  *
12495  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12496  */
12497 extern
12498 int SCIPgetNLPCols(
12499  SCIP* scip /**< SCIP data structure */
12500  );
12501 
12502 /** gets current LP rows along with the current number of LP rows
12503  *
12504  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12505  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12506  *
12507  * @pre This method can be called if @p scip is in one of the following stages:
12508  * - \ref SCIP_STAGE_SOLVING
12509  *
12510  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12511  */
12512 extern
12514  SCIP* scip, /**< SCIP data structure */
12515  SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */
12516  int* nrows /**< pointer to store the number of LP rows, or NULL */
12517  );
12518 
12519 /** gets current LP rows
12520  *
12521  * @return the current LP rows.
12522  *
12523  * @pre This method can be called if @p scip is in one of the following stages:
12524  * - \ref SCIP_STAGE_SOLVING
12525  *
12526  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12527  */
12528 extern
12530  SCIP* scip /**< SCIP data structure */
12531  );
12532 
12533 /** gets current number of LP rows
12534  *
12535  * @return the current number of LP rows.
12536  *
12537  * @pre This method can be called if @p scip is in one of the following stages:
12538  * - \ref SCIP_STAGE_SOLVING
12539  *
12540  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12541  */
12542 extern
12543 int SCIPgetNLPRows(
12544  SCIP* scip /**< SCIP data structure */
12545  );
12546 
12547 /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
12548  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
12549  *
12550  * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
12551  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.
12552  *
12553  * @pre This method can be called if @p scip is in one of the following stages:
12554  * - \ref SCIP_STAGE_SOLVING
12555  *
12556  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12557  */
12558 extern
12560  SCIP* scip /**< SCIP data structure */
12561  );
12562 
12563 /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
12564  *
12565  * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis.
12566  *
12567  * @pre This method can be called if @p scip is in one of the following stages:
12568  * - \ref SCIP_STAGE_SOLVING
12569  *
12570  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12571  */
12572 extern
12574  SCIP* scip /**< SCIP data structure */
12575  );
12576 
12577 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
12578  *
12579  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12580  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12581  *
12582  * @pre This method can be called if @p scip is in one of the following stages:
12583  * - \ref SCIP_STAGE_SOLVING
12584  *
12585  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12586  */
12587 extern
12589  SCIP* scip, /**< SCIP data structure */
12590  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
12591  );
12592 
12593 /** gets a row from the inverse basis matrix B^-1
12594  *
12595  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12596  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12597  *
12598  * @pre This method can be called if @p scip is in one of the following stages:
12599  * - \ref SCIP_STAGE_SOLVING
12600  *
12601  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12602  */
12603 extern
12605  SCIP* scip, /**< SCIP data structure */
12606  int r, /**< row number */
12607  SCIP_Real* coefs, /**< array to store the coefficients of the row */
12608  int* inds, /**< array to store the non-zero indices, or NULL */
12609  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12610  * (-1: if we do not store sparsity informations) */
12611  );
12612 
12613 /** gets a column from the inverse basis matrix B^-1
12614  *
12615  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12616  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12617  *
12618  * @pre This method can be called if @p scip is in one of the following stages:
12619  * - \ref SCIP_STAGE_SOLVING
12620  *
12621  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12622  */
12623 extern
12625  SCIP* scip, /**< SCIP data structure */
12626  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
12627  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
12628  * to get the array which links the B^-1 column numbers to the row and
12629  * column numbers of the LP! c must be between 0 and nrows-1, since the
12630  * basis has the size nrows * nrows */
12631  SCIP_Real* coefs, /**< array to store the coefficients of the column */
12632  int* inds, /**< array to store the non-zero indices, or NULL */
12633  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12634  * (-1: if we do not store sparsity informations) */
12635  );
12636 
12637 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
12638  *
12639  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12640  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12641  *
12642  * @pre This method can be called if @p scip is in one of the following stages:
12643  * - \ref SCIP_STAGE_SOLVING
12644  *
12645  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12646  */
12647 extern
12649  SCIP* scip, /**< SCIP data structure */
12650  int r, /**< row number */
12651  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */
12652  SCIP_Real* coefs, /**< array to store the coefficients of the row */
12653  int* inds, /**< array to store the non-zero indices, or NULL */
12654  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12655  * (-1: if we do not store sparsity informations) */
12656  );
12657 
12658 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
12659  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
12660  *
12661  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12662  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12663  *
12664  * @pre This method can be called if @p scip is in one of the following stages:
12665  * - \ref SCIP_STAGE_SOLVING
12666  *
12667  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12668  */
12669 extern
12671  SCIP* scip, /**< SCIP data structure */
12672  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
12673  SCIP_Real* coefs, /**< array to store the coefficients of the column */
12674  int* inds, /**< array to store the non-zero indices, or NULL */
12675  int* ninds /**< pointer to store the number of non-zero indices, or NULL
12676  * (-1: if we do not store sparsity informations) */
12677  );
12678 
12679 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
12680  * LP row are swapped in the summation
12681  *
12682  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12683  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12684  *
12685  * @pre This method can be called if @p scip is in one of the following stages:
12686  * - \ref SCIP_STAGE_SOLVING
12687  *
12688  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12689  */
12690 extern
12692  SCIP* scip, /**< SCIP data structure */
12693  SCIP_Real* weights, /**< row weights in row summation */
12694  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
12695  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
12696  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
12697  );
12698 
12699 /** calculates a MIR cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these
12700  * rows cannot participate in a MIR cut.
12701  *
12702  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12703  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12704  *
12705  * @pre This method can be called if @p scip is in one of the following stages:
12706  * - \ref SCIP_STAGE_SOLVING
12707  *
12708  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12709  */
12710 extern
12712  SCIP* scip, /**< SCIP data structure */
12713  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
12714  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
12715  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
12716  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
12717  SCIP_Bool fixintegralrhs, /**< should complementation tried to be adjusted such that rhs gets fractional? */
12718  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
12719  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
12720  * NULL for using closest bound for all variables */
12721  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
12722  * NULL for using closest bound for all variables */
12723  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
12724  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
12725  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
12726  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
12727  SCIP_Real* weights, /**< row weights in row summation; some weights might be set to zero */
12728  SCIP_Real maxweight, /**< largest magnitude of weights; set to -1.0 if sparsity information is
12729  * unknown */
12730  int* weightinds, /**< sparsity pattern of weights; size nrowinds; NULL if sparsity info is
12731  * unknown */
12732  int nweightinds, /**< number of nonzeros in weights; -1 if rowinds is NULL */
12733  int rowlensum, /**< total number of non-zeros in used rows (row associated with nonzero weight coefficient); -1 if unknown */
12734  int* sidetypes, /**< specify row side type (-1 = lhs, 0 = unkown, 1 = rhs) or NULL for automatic choices */
12735  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
12736  SCIP_Real* mksetcoefs, /**< array to store mixed knapsack set coefficients: size nvars; or NULL */
12737  SCIP_Bool* mksetcoefsvalid, /**< pointer to store whether mixed knapsack set coefficients are valid; or NULL */
12738  SCIP_Real* mircoef, /**< array to store MIR coefficients: must be of size SCIPgetNVars() */
12739  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the MIR 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 MIR 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 /** 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
12747  * rows cannot participate in a MIR cut.
12748  *
12749  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12750  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12751  *
12752  * @pre This method can be called if @p scip is in one of the following stages:
12753  * - \ref SCIP_STAGE_SOLVING
12754  *
12755  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12756  */
12757 extern
12759  SCIP* scip, /**< SCIP data structure */
12760  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
12761  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
12762  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
12763  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
12764  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
12765  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce strong CG cut for */
12766  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce strong CG cut for */
12767  SCIP_Real* weights, /**< row weights in row summation; some weights might be set to zero */
12768  int* inds, /**< indices of non-zero entries in weights array, or NULL */
12769  int ninds, /**< number of indices of non-zero entries in weights array, -1 if inds is
12770  * NULL */
12771  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
12772  SCIP_Real* mircoef, /**< array to store strong CG coefficients: must be of size SCIPgetNVars() */
12773  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the strong CG row */
12774  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
12775  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid strong CG cut */
12776  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
12777  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
12778  );
12779 
12780 /** writes current LP to a file
12781  *
12782  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12783  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12784  *
12785  * @pre This method can be called if @p scip is in one of the following stages:
12786  * - \ref SCIP_STAGE_SOLVING
12787  *
12788  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12789  */
12790 extern
12792  SCIP* scip, /**< SCIP data structure */
12793  const char* filename /**< file name */
12794  );
12795 
12796 /** writes MIP relaxation of the current branch-and-bound node to a file
12797  *
12798  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12799  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12800  *
12801  * @pre This method can be called if @p scip is in one of the following stages:
12802  * - \ref SCIP_STAGE_SOLVING
12803  *
12804  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12805  */
12806 extern
12808  SCIP* scip, /**< SCIP data structure */
12809  const char* filename, /**< file name */
12810  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
12811  * troubles with reserved symbols? */
12812  SCIP_Bool origobj, /**< should the original objective function be used? */
12813  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
12814  );
12815 
12816 /** gets the LP interface of SCIP;
12817  * with the LPI you can use all of the methods defined in lpi/lpi.h;
12818  *
12819  * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely
12820  * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution
12821  * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in
12822  * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make
12823  * sure, the internal solution status is recovered completely at the end of your method. This can be achieved
12824  * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it
12825  * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the
12826  * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.
12827  *
12828  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
12829  *
12830  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12831  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12832  *
12833  * @pre This method can be called if @p scip is in one of the following stages:
12834  * - \ref SCIP_STAGE_TRANSFORMED
12835  * - \ref SCIP_STAGE_INITPRESOLVE
12836  * - \ref SCIP_STAGE_PRESOLVING
12837  * - \ref SCIP_STAGE_EXITPRESOLVE
12838  * - \ref SCIP_STAGE_PRESOLVED
12839  * - \ref SCIP_STAGE_INITSOLVE
12840  * - \ref SCIP_STAGE_SOLVING
12841  * - \ref SCIP_STAGE_SOLVED
12842  * - \ref SCIP_STAGE_EXITSOLVE
12843  *
12844  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12845  */
12846 extern
12848  SCIP* scip, /**< SCIP data structure */
12849  SCIP_LPI** lpi /**< pointer to store the LP interface */
12850  );
12851 
12852 /** Displays quality information about the current LP solution. An LP solution need to be available. Information printed
12853  * is subject to what the LP solver supports
12854  *
12855  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12856  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12857  *
12858  * @pre This method can be called if @p scip is in one of the following stages:
12859  * - \ref SCIP_STAGE_INIT
12860  * - \ref SCIP_STAGE_PROBLEM
12861  * - \ref SCIP_STAGE_TRANSFORMED
12862  * - \ref SCIP_STAGE_INITPRESOLVE
12863  * - \ref SCIP_STAGE_PRESOLVING
12864  * - \ref SCIP_STAGE_EXITPRESOLVE
12865  * - \ref SCIP_STAGE_PRESOLVED
12866  * - \ref SCIP_STAGE_SOLVING
12867  * - \ref SCIP_STAGE_SOLVED
12868  * - \ref SCIP_STAGE_FREE
12869  *
12870  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12871  *
12872  * @note The printing process is done via the message handler system.
12873  */
12874 extern
12876  SCIP* scip, /**< SCIP data structure */
12877  FILE* file /**< output file (or NULL for standard output) */
12878  );
12879 
12880 /** compute relative interior point to current LP
12881  * @see SCIPlpComputeRelIntPoint
12882  *
12883  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12884  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12885  *
12886  * @pre This method can be called if @p scip is in one of the following stages:
12887  * - \ref SCIP_STAGE_TRANSFORMED
12888  * - \ref SCIP_STAGE_INITPRESOLVE
12889  * - \ref SCIP_STAGE_PRESOLVING
12890  * - \ref SCIP_STAGE_EXITPRESOLVE
12891  * - \ref SCIP_STAGE_PRESOLVED
12892  * - \ref SCIP_STAGE_SOLVING
12893  * - \ref SCIP_STAGE_SOLVED
12894  *
12895  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12896  */
12897 extern
12899  SCIP* scip, /**< SCIP data structure */
12900  SCIP_Bool relaxrows, /**< should the rows be relaxed */
12901  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
12902  SCIP_Real timelimit, /**< time limit for LP solver */
12903  int iterlimit, /**< iteration limit for LP solver */
12904  SCIP_SOL** point /**< relative interior point on exit */
12905  );
12906 
12907 /**@} */
12908 
12909 
12910 
12911 /*
12912  * LP column methods
12913  */
12914 
12915 /**@addtogroup PublicColumnMethods
12916  *
12917  * @{
12918  */
12919 
12920 /** returns the reduced costs of a column in the last (feasible) LP
12921  *
12922  * @return the reduced costs of a column in the last (feasible) LP
12923  *
12924  * @pre this method can be called in one of the following stages of the SCIP solving process:
12925  * - \ref SCIP_STAGE_SOLVING
12926  * - \ref SCIP_STAGE_SOLVED
12927  *
12928  * @note calling this method in SCIP_STAGE_SOLVED is only recommended to experienced users and should only be called
12929  * for pure LP instances (without presolving)
12930  */
12931 extern
12933  SCIP* scip, /**< SCIP data structure */
12934  SCIP_COL* col /**< LP column */
12935  );
12936 
12937 /** returns the Farkas coefficient of a column in the last (infeasible) LP
12938  *
12939  * @return the Farkas coefficient of a column in the last (infeasible) LP
12940  *
12941  * @pre this method can be called in one of the following stages of the SCIP solving process:
12942  * - \ref SCIP_STAGE_SOLVING
12943  */
12944 extern
12946  SCIP* scip, /**< SCIP data structure */
12947  SCIP_COL* col /**< LP column */
12948  );
12949 
12950 /** marks a column to be not removable from the LP in the current node
12951  *
12952  * @pre this method can be called in the following stage of the SCIP solving process:
12953  * - \ref SCIP_STAGE_SOLVING
12954  */
12955 extern
12957  SCIP* scip, /**< SCIP data structure */
12958  SCIP_COL* col /**< LP column */
12959  );
12960 
12961 /**@} */
12962 
12963 
12964 
12965 
12966 /*
12967  * LP row methods
12968  */
12969 
12970 /**@addtogroup PublicRowMethods
12971  *
12972  * @{
12973  */
12974 
12975 /** creates and captures an LP row from a constraint handler
12976  *
12977  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12978  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12979  *
12980  * @pre this method can be called in one of the following stages of the SCIP solving process:
12981  * - \ref SCIP_STAGE_INITSOLVE
12982  * - \ref SCIP_STAGE_SOLVING
12983  */
12984 extern
12986  SCIP* scip, /**< SCIP data structure */
12987  SCIP_ROW** row, /**< pointer to row */
12988  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
12989  const char* name, /**< name of row */
12990  int len, /**< number of nonzeros in the row */
12991  SCIP_COL** cols, /**< array with columns of row entries */
12992  SCIP_Real* vals, /**< array with coefficients of row entries */
12993  SCIP_Real lhs, /**< left hand side of row */
12994  SCIP_Real rhs, /**< right hand side of row */
12995  SCIP_Bool local, /**< is row only valid locally? */
12996  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12997  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12998  );
12999 
13000 /** creates and captures an LP row from a separator
13001  *
13002  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13003  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13004  *
13005  * @pre this method can be called in one of the following stages of the SCIP solving process:
13006  * - \ref SCIP_STAGE_INITSOLVE
13007  * - \ref SCIP_STAGE_SOLVING
13008  */
13009 extern
13011  SCIP* scip, /**< SCIP data structure */
13012  SCIP_ROW** row, /**< pointer to row */
13013  SCIP_SEPA* sepa, /**< separator that creates the row */
13014  const char* name, /**< name of row */
13015  int len, /**< number of nonzeros in the row */
13016  SCIP_COL** cols, /**< array with columns of row entries */
13017  SCIP_Real* vals, /**< array with coefficients of row entries */
13018  SCIP_Real lhs, /**< left hand side of row */
13019  SCIP_Real rhs, /**< right hand side of row */
13020  SCIP_Bool local, /**< is row only valid locally? */
13021  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13022  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13023  );
13024 
13025 /** creates and captures an LP row from an unspecified source
13026  *
13027  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13028  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13029  *
13030  * @pre this method can be called in one of the following stages of the SCIP solving process:
13031  * - \ref SCIP_STAGE_INITSOLVE
13032  * - \ref SCIP_STAGE_SOLVING
13033  */
13034 extern
13036  SCIP* scip, /**< SCIP data structure */
13037  SCIP_ROW** row, /**< pointer to row */
13038  const char* name, /**< name of row */
13039  int len, /**< number of nonzeros in the row */
13040  SCIP_COL** cols, /**< array with columns of row entries */
13041  SCIP_Real* vals, /**< array with coefficients of row entries */
13042  SCIP_Real lhs, /**< left hand side of row */
13043  SCIP_Real rhs, /**< right hand side of row */
13044  SCIP_Bool local, /**< is row only valid locally? */
13045  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13046  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13047  );
13048 
13049 /** creates and captures an LP row
13050  *
13051  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13052  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13053  *
13054  * @pre this method can be called in one of the following stages of the SCIP solving process:
13055  * - \ref SCIP_STAGE_INITSOLVE
13056  * - \ref SCIP_STAGE_SOLVING
13057  *
13058  * @deprecated Please use SCIPcreateRowCons() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order
13059  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().
13060  */
13061 extern
13063  SCIP* scip, /**< SCIP data structure */
13064  SCIP_ROW** row, /**< pointer to row */
13065  const char* name, /**< name of row */
13066  int len, /**< number of nonzeros in the row */
13067  SCIP_COL** cols, /**< array with columns of row entries */
13068  SCIP_Real* vals, /**< array with coefficients of row entries */
13069  SCIP_Real lhs, /**< left hand side of row */
13070  SCIP_Real rhs, /**< right hand side of row */
13071  SCIP_Bool local, /**< is row only valid locally? */
13072  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13073  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13074  );
13075 
13076 /** creates and captures an LP row without any coefficients from a constraint handler
13077  *
13078  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13079  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13080  *
13081  * @pre this method can be called in one of the following stages of the SCIP solving process:
13082  * - \ref SCIP_STAGE_INITSOLVE
13083  * - \ref SCIP_STAGE_SOLVING
13084  */
13085 extern
13087  SCIP* scip, /**< SCIP data structure */
13088  SCIP_ROW** row, /**< pointer to row */
13089  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
13090  const char* name, /**< name of row */
13091  SCIP_Real lhs, /**< left hand side of row */
13092  SCIP_Real rhs, /**< right hand side of row */
13093  SCIP_Bool local, /**< is row only valid locally? */
13094  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13095  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13096  );
13097 
13098 /** creates and captures an LP row without any coefficients from a separator
13099  *
13100  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13101  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13102  *
13103  * @pre this method can be called in one of the following stages of the SCIP solving process:
13104  * - \ref SCIP_STAGE_INITSOLVE
13105  * - \ref SCIP_STAGE_SOLVING
13106  */
13107 extern
13109  SCIP* scip, /**< SCIP data structure */
13110  SCIP_ROW** row, /**< pointer to row */
13111  SCIP_SEPA* sepa, /**< separator that creates the row */
13112  const char* name, /**< name of row */
13113  SCIP_Real lhs, /**< left hand side of row */
13114  SCIP_Real rhs, /**< right hand side of row */
13115  SCIP_Bool local, /**< is row only valid locally? */
13116  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13117  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13118  );
13119 
13120 /** creates and captures an LP row without any coefficients from an unspecified source
13121  *
13122  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13123  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13124  *
13125  * @pre this method can be called in one of the following stages of the SCIP solving process:
13126  * - \ref SCIP_STAGE_INITSOLVE
13127  * - \ref SCIP_STAGE_SOLVING
13128  */
13129 extern
13131  SCIP* scip, /**< SCIP data structure */
13132  SCIP_ROW** row, /**< pointer to row */
13133  const char* name, /**< name of row */
13134  SCIP_Real lhs, /**< left hand side of row */
13135  SCIP_Real rhs, /**< right hand side of row */
13136  SCIP_Bool local, /**< is row only valid locally? */
13137  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13138  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13139  );
13140 
13141 /** creates and captures an LP row without any coefficients
13142  *
13143  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13144  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13145  *
13146  * @pre this method can be called in one of the following stages of the SCIP solving process:
13147  * - \ref SCIP_STAGE_INITSOLVE
13148  * - \ref SCIP_STAGE_SOLVING
13149  *
13150  * @deprecated Please use SCIPcreateEmptyRowCons() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order
13151  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().
13152  */
13153 extern
13155  SCIP* scip, /**< SCIP data structure */
13156  SCIP_ROW** row, /**< pointer to row */
13157  const char* name, /**< name of row */
13158  SCIP_Real lhs, /**< left hand side of row */
13159  SCIP_Real rhs, /**< right hand side of row */
13160  SCIP_Bool local, /**< is row only valid locally? */
13161  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
13162  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
13163  );
13164 
13165 /** increases usage counter of LP row
13166  *
13167  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13168  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13169  *
13170  * @pre this method can be called in one of the following stages of the SCIP solving process:
13171  * - \ref SCIP_STAGE_INITSOLVE
13172  * - \ref SCIP_STAGE_SOLVING
13173  */
13174 extern
13176  SCIP* scip, /**< SCIP data structure */
13177  SCIP_ROW* row /**< row to capture */
13178  );
13179 
13180 /** decreases usage counter of LP row, and frees memory if necessary
13181  *
13182  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13183  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13184  *
13185  * @pre this method can be called in one of the following stages of the SCIP solving process:
13186  * - \ref SCIP_STAGE_INITSOLVE
13187  * - \ref SCIP_STAGE_SOLVING
13188  * - \ref SCIP_STAGE_EXITSOLVE
13189  */
13190 extern
13192  SCIP* scip, /**< SCIP data structure */
13193  SCIP_ROW** row /**< pointer to LP row */
13194  );
13195 
13196 /** changes left hand side of LP row
13197  *
13198  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13199  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13200  *
13201  * @pre this method can be called in one of the following stages of the SCIP solving process:
13202  * - \ref SCIP_STAGE_INITSOLVE
13203  * - \ref SCIP_STAGE_SOLVING
13204  */
13205 extern
13207  SCIP* scip, /**< SCIP data structure */
13208  SCIP_ROW* row, /**< LP row */
13209  SCIP_Real lhs /**< new left hand side */
13210  );
13211 
13212 /** changes right hand side of LP row
13213  *
13214  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13215  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13216  *
13217  * @pre this method can be called in one of the following stages of the SCIP solving process:
13218  * - \ref SCIP_STAGE_INITSOLVE
13219  * - \ref SCIP_STAGE_SOLVING
13220  */
13221 extern
13223  SCIP* scip, /**< SCIP data structure */
13224  SCIP_ROW* row, /**< LP row */
13225  SCIP_Real rhs /**< new right hand side */
13226  );
13227 
13228 /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
13229  * after all additions were applied, SCIPflushRowExtensions() must be called;
13230  * while the caching of row extensions is activated, information methods of the row give invalid results;
13231  * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase
13232  * the performance
13233  *
13234  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13235  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13236  *
13237  * @pre this method can be called in one of the following stages of the SCIP solving process:
13238  * - \ref SCIP_STAGE_INITSOLVE
13239  * - \ref SCIP_STAGE_SOLVING
13240  */
13241 extern
13243  SCIP* scip, /**< SCIP data structure */
13244  SCIP_ROW* row /**< LP row */
13245  );
13246 
13247 /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with
13248  * equal columns into a single coefficient
13249  *
13250  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13251  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13252  *
13253  * @pre this method can be called in one of the following stages of the SCIP solving process:
13254  * - \ref SCIP_STAGE_INITSOLVE
13255  * - \ref SCIP_STAGE_SOLVING
13256  */
13257 extern
13259  SCIP* scip, /**< SCIP data structure */
13260  SCIP_ROW* row /**< LP row */
13261  );
13262 
13263 /** resolves variable to columns and adds them with the coefficient to the row
13264  *
13265  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13266  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13267  *
13268  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variable will not added.
13269  *
13270  * @pre this method can be called in one of the following stages of the SCIP solving process:
13271  * - \ref SCIP_STAGE_INITSOLVE
13272  * - \ref SCIP_STAGE_SOLVING
13273  *
13274  * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables,
13275  * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP.
13276  * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution
13277  * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but
13278  * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the
13279  * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was
13280  * violated, the linear relaxation might not be violated anymore.)
13281  */
13282 extern
13284  SCIP* scip, /**< SCIP data structure */
13285  SCIP_ROW* row, /**< LP row */
13286  SCIP_VAR* var, /**< problem variable */
13287  SCIP_Real val /**< value of coefficient */
13288  );
13289 
13290 /** resolves variables to columns and adds them with the coefficients to the row;
13291  * this method caches the row extensions and flushes them afterwards to gain better performance
13292  *
13293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13295  *
13296  * @attention If a coefficients absolute value is below the SCIP epsilon tolerance, the variable with its value is not added.
13297  *
13298  * @pre this method can be called in one of the following stages of the SCIP solving process:
13299  * - \ref SCIP_STAGE_INITSOLVE
13300  * - \ref SCIP_STAGE_SOLVING
13301  */
13302 extern
13304  SCIP* scip, /**< SCIP data structure */
13305  SCIP_ROW* row, /**< LP row */
13306  int nvars, /**< number of variables to add to the row */
13307  SCIP_VAR** vars, /**< problem variables to add */
13308  SCIP_Real* vals /**< values of coefficients */
13309  );
13310 
13311 /** resolves variables to columns and adds them with the same single coefficient to the row;
13312  * this method caches the row extensions and flushes them afterwards to gain better performance
13313  *
13314  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13315  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13316  *
13317  * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variables will not added.
13318  *
13319  * @pre this method can be called in one of the following stages of the SCIP solving process:
13320  * - \ref SCIP_STAGE_INITSOLVE
13321  * - \ref SCIP_STAGE_SOLVING
13322  */
13323 extern
13325  SCIP* scip, /**< SCIP data structure */
13326  SCIP_ROW* row, /**< LP row */
13327  int nvars, /**< number of variables to add to the row */
13328  SCIP_VAR** vars, /**< problem variables to add */
13329  SCIP_Real val /**< unique value of all coefficients */
13330  );
13331 
13332 /** tries to find a value, such that all row coefficients, if scaled with this value become integral
13333  *
13334  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13335  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13336  *
13337  * @pre this method can be called in one of the following stages of the SCIP solving process:
13338  * - \ref SCIP_STAGE_INITSOLVE
13339  * - \ref SCIP_STAGE_SOLVING
13340  */
13341 extern
13343  SCIP* scip, /**< SCIP data structure */
13344  SCIP_ROW* row, /**< LP row */
13345  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
13346  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
13347  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
13348  SCIP_Real maxscale, /**< maximal allowed scalar */
13349  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
13350  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
13351  SCIP_Bool* success /**< stores whether returned value is valid */
13352  );
13353 
13354 /** tries to scale row, s.t. all coefficients (of integer variables) become integral
13355  *
13356  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13357  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13358  *
13359  * @pre this method can be called in one of the following stages of the SCIP solving process:
13360  * - \ref SCIP_STAGE_INITSOLVE
13361  * - \ref SCIP_STAGE_SOLVING
13362  */
13363 extern
13365  SCIP* scip, /**< SCIP data structure */
13366  SCIP_ROW* row, /**< LP row */
13367  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
13368  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
13369  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
13370  SCIP_Real maxscale, /**< maximal value to scale row with */
13371  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
13372  SCIP_Bool* success /**< stores whether row could be made rational */
13373  );
13374 
13375 /** marks a row to be not removable from the LP in the current node
13376  *
13377  * @pre this method can be called in the following stage of the SCIP solving process:
13378  * - \ref SCIP_STAGE_SOLVING
13379  */
13380 extern
13382  SCIP* scip, /**< SCIP data structure */
13383  SCIP_ROW* row /**< LP row */
13384  );
13385 
13386 /** returns minimal absolute value of row vector's non-zero coefficients
13387  *
13388  * @return minimal absolute value of row vector's non-zero coefficients
13389  *
13390  * @pre this method can be called in one of the following stages of the SCIP solving process:
13391  * - \ref SCIP_STAGE_INITSOLVE
13392  * - \ref SCIP_STAGE_SOLVING
13393  */
13394 extern
13396  SCIP* scip, /**< SCIP data structure */
13397  SCIP_ROW* row /**< LP row */
13398  );
13399 
13400 /** returns maximal absolute value of row vector's non-zero coefficients
13401  *
13402  * @return maximal absolute value of row vector's non-zero coefficients
13403  *
13404  * @pre this method can be called in one of the following stages of the SCIP solving process:
13405  * - \ref SCIP_STAGE_INITSOLVE
13406  * - \ref SCIP_STAGE_SOLVING
13407  */
13408 extern
13410  SCIP* scip, /**< SCIP data structure */
13411  SCIP_ROW* row /**< LP row */
13412  );
13413 
13414 /** returns the minimal activity of a row w.r.t. the column's bounds
13415  *
13416  * @return the minimal activity of a row w.r.t. the column's bounds
13417  *
13418  * @pre this method can be called in one of the following stages of the SCIP solving process:
13419  * - \ref SCIP_STAGE_SOLVING
13420  */
13421 extern
13423  SCIP* scip, /**< SCIP data structure */
13424  SCIP_ROW* row /**< LP row */
13425  );
13426 
13427 /** returns the maximal activity of a row w.r.t. the column's bounds
13428  *
13429  * @return the maximal activity of a row w.r.t. the column's bounds
13430  *
13431  * @pre this method can be called in one of the following stages of the SCIP solving process:
13432  * - \ref SCIP_STAGE_SOLVING
13433  */
13434 extern
13436  SCIP* scip, /**< SCIP data structure */
13437  SCIP_ROW* row /**< LP row */
13438  );
13439 
13440 /** recalculates the activity of a row in the last LP solution
13441  *
13442  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13443  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13444  *
13445  * @pre this method can be called in one of the following stages of the SCIP solving process:
13446  * - \ref SCIP_STAGE_SOLVING
13447  */
13448 extern
13450  SCIP* scip, /**< SCIP data structure */
13451  SCIP_ROW* row /**< LP row */
13452  );
13453 
13454 /** returns the activity of a row in the last LP solution
13455  *
13456  * @return activity of a row in the last LP solution
13457  *
13458  * @pre this method can be called in one of the following stages of the SCIP solving process:
13459  * - \ref SCIP_STAGE_SOLVING
13460  */
13461 extern
13463  SCIP* scip, /**< SCIP data structure */
13464  SCIP_ROW* row /**< LP row */
13465  );
13466 
13467 /** returns the feasibility of a row in the last LP solution
13468  *
13469  * @return the feasibility of a row in the last LP solution: negative value means infeasibility
13470  *
13471  * @pre this method can be called in one of the following stages of the SCIP solving process:
13472  * - \ref SCIP_STAGE_SOLVING
13473  */
13474 extern
13476  SCIP* scip, /**< SCIP data structure */
13477  SCIP_ROW* row /**< LP row */
13478  );
13479 
13480 /** recalculates the activity of a row for the current pseudo solution
13481  *
13482  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13483  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13484  *
13485  * @pre this method can be called in one of the following stages of the SCIP solving process:
13486  * - \ref SCIP_STAGE_SOLVING
13487  */
13488 extern
13490  SCIP* scip, /**< SCIP data structure */
13491  SCIP_ROW* row /**< LP row */
13492  );
13493 
13494 /** returns the activity of a row for the current pseudo solution
13495  *
13496  * @return the activity of a row for the current pseudo solution
13497  *
13498  * @pre this method can be called in one of the following stages of the SCIP solving process:
13499  * - \ref SCIP_STAGE_SOLVING
13500  */
13501 extern
13503  SCIP* scip, /**< SCIP data structure */
13504  SCIP_ROW* row /**< LP row */
13505  );
13506 
13507 /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
13508  *
13509  * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility
13510  *
13511  * @pre this method can be called in one of the following stages of the SCIP solving process:
13512  * - \ref SCIP_STAGE_SOLVING
13513  */
13514 extern
13516  SCIP* scip, /**< SCIP data structure */
13517  SCIP_ROW* row /**< LP row */
13518  );
13519 
13520 /** recalculates the activity of a row in the last LP or pseudo solution
13521  *
13522  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13523  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13524  *
13525  * @pre this method can be called in one of the following stages of the SCIP solving process:
13526  * - \ref SCIP_STAGE_SOLVING
13527  */
13528 extern
13530  SCIP* scip, /**< SCIP data structure */
13531  SCIP_ROW* row /**< LP row */
13532  );
13533 
13534 /** returns the activity of a row in the last LP or pseudo solution
13535  *
13536  * @return the activity of a row in the last LP or pseudo solution
13537  *
13538  * @pre this method can be called in one of the following stages of the SCIP solving process:
13539  * - \ref SCIP_STAGE_SOLVING
13540  */
13541 extern
13543  SCIP* scip, /**< SCIP data structure */
13544  SCIP_ROW* row /**< LP row */
13545  );
13546 
13547 /** returns the feasibility of a row in the last LP or pseudo solution
13548  *
13549  * @return the feasibility of a row in the last LP or pseudo solution
13550  *
13551  * @pre this method can be called in one of the following stages of the SCIP solving process:
13552  * - \ref SCIP_STAGE_SOLVING
13553  */
13554 extern
13556  SCIP* scip, /**< SCIP data structure */
13557  SCIP_ROW* row /**< LP row */
13558  );
13559 
13560 /** returns the activity of a row for the given primal solution
13561  *
13562  * @return the activitiy of a row for the given primal solution
13563  *
13564  * @pre this method can be called in one of the following stages of the SCIP solving process:
13565  * - \ref SCIP_STAGE_SOLVING
13566  */
13567 extern
13569  SCIP* scip, /**< SCIP data structure */
13570  SCIP_ROW* row, /**< LP row */
13571  SCIP_SOL* sol /**< primal CIP solution */
13572  );
13573 
13574 /** returns the feasibility of a row for the given primal solution
13575  *
13576  * @return the feasibility of a row for the given primal solution
13577  *
13578  * @pre this method can be called in one of the following stages of the SCIP solving process:
13579  * - \ref SCIP_STAGE_SOLVING
13580  */
13581 extern
13583  SCIP* scip, /**< SCIP data structure */
13584  SCIP_ROW* row, /**< LP row */
13585  SCIP_SOL* sol /**< primal CIP solution */
13586  );
13587 
13588 /** output row to file stream via the message handler system
13589  *
13590  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13591  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13592  *
13593  * @pre this method can be called in one of the following stages of the SCIP solving process:
13594  * - \ref SCIP_STAGE_INITSOLVE
13595  * - \ref SCIP_STAGE_SOLVING
13596  * - \ref SCIP_STAGE_SOLVED
13597  * - \ref SCIP_STAGE_EXITSOLVE
13598  */
13599 extern
13601  SCIP* scip, /**< SCIP data structure */
13602  SCIP_ROW* row, /**< LP row */
13603  FILE* file /**< output file (or NULL for standard output) */
13604  );
13605 
13606 /**@} */
13607 
13608 
13609 /*
13610  * NLP methods
13611  */
13612 
13613 /**@addtogroup PublicNLPMethods
13614  *
13615  * @{
13616  */
13617 
13618 /** returns whether the NLP relaxation has been enabled
13619  *
13620  * If the NLP relaxation is enabled, then SCIP will construct the NLP relaxation when the solving process is about to begin.
13621  * To check whether an NLP is existing, use SCIPisNLPConstructed().
13622  *
13623  * @pre This method can be called if SCIP is in one of the following stages:
13624  * - \ref SCIP_STAGE_INITPRESOLVE
13625  * - \ref SCIP_STAGE_PRESOLVING
13626  * - \ref SCIP_STAGE_EXITPRESOLVE
13627  * - \ref SCIP_STAGE_PRESOLVED
13628  * - \ref SCIP_STAGE_INITSOLVE
13629  * - \ref SCIP_STAGE_SOLVING
13630  *
13631  * @see SCIPenableNLP
13632  */
13633 extern
13635  SCIP* scip /**< SCIP data structure */
13636  );
13637 
13638 /** marks that there are constraints that are representable by nonlinear rows
13639  *
13640  * This method should be called by a constraint handler if it has constraints that have a representation as nonlinear rows.
13641  *
13642  * The function should be called before the branch-and-bound process is initialized, e.g., when presolve is exiting.
13643  *
13644  * @pre This method can be called if SCIP is in one of the following stages:
13645  * - \ref SCIP_STAGE_INITPRESOLVE
13646  * - \ref SCIP_STAGE_PRESOLVING
13647  * - \ref SCIP_STAGE_EXITPRESOLVE
13648  * - \ref SCIP_STAGE_PRESOLVED
13649  * - \ref SCIP_STAGE_INITSOLVE
13650  * - \ref SCIP_STAGE_SOLVING
13651  */
13652 extern
13653 void SCIPenableNLP(
13654  SCIP* scip /**< SCIP data structure */
13655  );
13656 
13657 /** returns, whether an NLP has been constructed
13658  *
13659  * @pre This method can be called if SCIP is in one of the following stages:
13660  * - \ref SCIP_STAGE_INITSOLVE
13661  * - \ref SCIP_STAGE_SOLVING
13662  */
13663 extern
13665  SCIP* scip /**< SCIP data structure */
13666  );
13667 
13668 /** returns whether the NLP has a continuous variable in a nonlinear term
13669  *
13670  * @pre This method can be called if SCIP is in one of the following stages:
13671  * - \ref SCIP_STAGE_INITSOLVE
13672  * - \ref SCIP_STAGE_SOLVING
13673  */
13674 extern
13676  SCIP* scip /**< SCIP data structure */
13677  );
13678 
13679 /** gets current NLP variables along with the current number of NLP variables
13680  *
13681  * @pre This method can be called if SCIP is in one of the following stages:
13682  * - \ref SCIP_STAGE_INITSOLVE
13683  * - \ref SCIP_STAGE_SOLVING
13684  */
13685 extern
13687  SCIP* scip, /**< SCIP data structure */
13688  SCIP_VAR*** vars, /**< pointer to store the array of NLP variables, or NULL */
13689  int* nvars /**< pointer to store the number of NLP variables, or NULL */
13690  );
13691 
13692 /** gets array with variables of the NLP
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 /** gets current number of variables in NLP
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
13710 int SCIPgetNNLPVars(
13711  SCIP* scip /**< SCIP data structure */
13712  );
13713 
13714 /** computes for each variables the number of NLP rows in which the variable appears in a nonlinear var
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  int* nlcount /**< an array of length at least SCIPnlpGetNVars() to store nonlinearity counts of variables */
13724  );
13725 
13726 /** returns dual solution values associated with lower bounds of NLP variables
13727  *
13728  * @pre This method can be called if SCIP is in one of the following stages:
13729  * - \ref SCIP_STAGE_INITSOLVE
13730  * - \ref SCIP_STAGE_SOLVING
13731  */
13732 extern
13734  SCIP* scip /**< SCIP data structure */
13735  );
13736 
13737 /** returns dual solution values associated with upper bounds of NLP variables
13738  *
13739  * @pre This method can be called if SCIP is in one of the following stages:
13740  * - \ref SCIP_STAGE_INITSOLVE
13741  * - \ref SCIP_STAGE_SOLVING
13742  */
13743 extern
13745  SCIP* scip /**< SCIP data structure */
13746  );
13747 
13748 /** gets current NLP nonlinear rows along with the current number of NLP nonlinear rows
13749  *
13750  * @pre This method can be called if SCIP is in one of the following stages:
13751  * - \ref SCIP_STAGE_INITSOLVE
13752  * - \ref SCIP_STAGE_SOLVING
13753  */
13754 extern
13756  SCIP* scip, /**< SCIP data structure */
13757  SCIP_NLROW*** nlrows, /**< pointer to store the array of NLP nonlinear rows, or NULL */
13758  int* nnlrows /**< pointer to store the number of NLP nonlinear rows, or NULL */
13759  );
13760 
13761 /** gets array with nonlinear rows of the NLP
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 /** gets current number of nonlinear rows in NLP
13773  *
13774  * @pre This method can be called if SCIP is in one of the following stages:
13775  * - \ref SCIP_STAGE_INITSOLVE
13776  * - \ref SCIP_STAGE_SOLVING
13777  */
13778 extern
13779 int SCIPgetNNLPNlRows(
13780  SCIP* scip /**< SCIP data structure */
13781  );
13782 
13783 /** adds a nonlinear row to the NLP. This row is captured by the NLP.
13784  *
13785  * @pre This method can be called if SCIP is in one of the following stages:
13786  * - \ref SCIP_STAGE_INITSOLVE
13787  * - \ref SCIP_STAGE_SOLVING
13788  */
13789 extern
13791  SCIP* scip, /**< SCIP data structure */
13792  SCIP_NLROW* nlrow /**< nonlinear row to add to NLP */
13793  );
13794 
13795 /** makes sure that the NLP of the current node is flushed
13796  *
13797  * @pre This method can be called if SCIP is in one of the following stages:
13798  * - \ref SCIP_STAGE_INITSOLVE
13799  * - \ref SCIP_STAGE_SOLVING
13800  */
13801 extern
13803  SCIP* scip /**< SCIP data structure */
13804  );
13805 
13806 /** sets or clears initial primal guess for NLP solution (start point for NLP solver)
13807  *
13808  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13809  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13810  *
13811  * @pre This method can be called if SCIP is in one of the following stages:
13812  * - \ref SCIP_STAGE_INITSOLVE
13813  * - \ref SCIP_STAGE_SOLVING
13814  */
13815 extern
13817  SCIP* scip, /**< SCIP data structure */
13818  SCIP_Real* initialguess /**< values of initial guess (corresponding to variables from SCIPgetNLPVarsData), or NULL to use no start point */
13819  );
13820 
13821 /** sets initial primal guess for NLP solution (start point for NLP solver)
13822  *
13823  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13824  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13825  *
13826  * @pre This method can be called if SCIP is in one of the following stages:
13827  * - \ref SCIP_STAGE_INITSOLVE
13828  * - \ref SCIP_STAGE_SOLVING
13829  */
13830 extern
13832  SCIP* scip, /**< SCIP data structure */
13833  SCIP_SOL* sol /**< solution which values should be taken as initial guess, or NULL for LP solution */
13834  );
13835 
13836 /** solves the current NLP
13837  *
13838  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13839  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13840  *
13841  * @pre This method can be called if SCIP is in one of the following stages:
13842  * - \ref SCIP_STAGE_INITSOLVE
13843  * - \ref SCIP_STAGE_SOLVING
13844  */
13845 extern
13847  SCIP* scip /**< SCIP data structure */
13848  );
13849 
13850 /** gets solution status of current NLP
13851  *
13852  * @pre This method can be called if SCIP is in one of the following stages:
13853  * - \ref SCIP_STAGE_INITSOLVE
13854  * - \ref SCIP_STAGE_SOLVING
13855  */
13856 extern
13858  SCIP* scip /**< SCIP data structure */
13859  );
13860 
13861 /** gets termination status of last NLP solve
13862  *
13863  * @pre This method can be called if SCIP is in one of the following stages:
13864  * - \ref SCIP_STAGE_INITSOLVE
13865  * - \ref SCIP_STAGE_SOLVING
13866  */
13867 extern
13869  SCIP* scip /**< SCIP data structure */
13870  );
13871 
13872 /** gives statistics (number of iterations, solving time, ...) of last NLP solve
13873  *
13874  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13875  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13876  *
13877  * @pre This method can be called if SCIP is in one of the following stages:
13878  * - \ref SCIP_STAGE_INITSOLVE
13879  * - \ref SCIP_STAGE_SOLVING
13880  */
13881 extern
13883  SCIP* scip, /**< SCIP data structure */
13884  SCIP_NLPSTATISTICS* statistics /**< pointer to store statistics */
13885  );
13886 
13887 /** gets objective value of current NLP
13888  *
13889  * @pre This method can be called if SCIP is in one of the following stages:
13890  * - \ref SCIP_STAGE_INITSOLVE
13891  * - \ref SCIP_STAGE_SOLVING
13892  */
13893 extern
13895  SCIP* scip /**< SCIP data structure */
13896  );
13897 
13898 /** indicates whether a feasible solution for the current NLP is available
13899  * thus, returns whether the solution status <= feasible
13900  *
13901  * @pre This method can be called if SCIP is in one of the following stages:
13902  * - \ref SCIP_STAGE_INITSOLVE
13903  * - \ref SCIP_STAGE_SOLVING
13904  */
13905 extern
13907  SCIP* scip /**< SCIP data structure */
13908  );
13909 
13910 /** gets fractional variables of last NLP solution along with solution values and fractionalities
13911  *
13912  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13913  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13914  *
13915  * @pre This method can be called if SCIP is in one of the following stages:
13916  * - \ref SCIP_STAGE_INITSOLVE
13917  * - \ref SCIP_STAGE_SOLVING
13918  */
13919 extern
13921  SCIP* scip, /**< SCIP data structure */
13922  SCIP_VAR*** fracvars, /**< pointer to store the array of NLP fractional variables, or NULL */
13923  SCIP_Real** fracvarssol, /**< pointer to store the array of NLP fractional variables solution values, or NULL */
13924  SCIP_Real** fracvarsfrac, /**< pointer to store the array of NLP fractional variables fractionalities, or NULL */
13925  int* nfracvars, /**< pointer to store the number of NLP fractional variables , or NULL */
13926  int* npriofracvars /**< pointer to store the number of NLP fractional variables with maximal branching priority, or NULL */
13927  );
13928 
13929 /** gets integer parameter of NLP
13930  *
13931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13933  *
13934  * @pre This method can be called if SCIP is in one of the following stages:
13935  * - \ref SCIP_STAGE_INITSOLVE
13936  * - \ref SCIP_STAGE_SOLVING
13937  */
13938 extern
13940  SCIP* scip, /**< SCIP data structure */
13941  SCIP_NLPPARAM type, /**< parameter number */
13942  int* ival /**< pointer to store the parameter value */
13943  );
13944 
13945 /** sets integer parameter of NLP
13946  *
13947  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13948  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13949  *
13950  * @pre This method can be called if SCIP is in one of the following stages:
13951  * - \ref SCIP_STAGE_INITSOLVE
13952  * - \ref SCIP_STAGE_SOLVING
13953  */
13954 extern
13956  SCIP* scip, /**< SCIP data structure */
13957  SCIP_NLPPARAM type, /**< parameter number */
13958  int ival /**< parameter value */
13959  );
13960 
13961 /** gets floating point parameter of NLP
13962  *
13963  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13964  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13965  *
13966  * @pre This method can be called if SCIP is in one of the following stages:
13967  * - \ref SCIP_STAGE_INITSOLVE
13968  * - \ref SCIP_STAGE_SOLVING
13969  */
13970 extern
13972  SCIP* scip, /**< SCIP data structure */
13973  SCIP_NLPPARAM type, /**< parameter number */
13974  SCIP_Real* dval /**< pointer to store the parameter value */
13975  );
13976 
13977 /** sets floating point parameter of NLP
13978  *
13979  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13980  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13981  *
13982  * @pre This method can be called if SCIP is in one of the following stages:
13983  * - \ref SCIP_STAGE_INITSOLVE
13984  * - \ref SCIP_STAGE_SOLVING
13985  */
13986 extern
13988  SCIP* scip, /**< SCIP data structure */
13989  SCIP_NLPPARAM type, /**< parameter number */
13990  SCIP_Real dval /**< parameter value */
13991  );
13992 
13993 /** gets string parameter of NLP
13994  *
13995  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13996  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13997  *
13998  * @pre This method can be called if SCIP is in one of the following stages:
13999  * - \ref SCIP_STAGE_INITSOLVE
14000  * - \ref SCIP_STAGE_SOLVING
14001  */
14002 extern
14004  SCIP* scip, /**< SCIP data structure */
14005  SCIP_NLPPARAM type, /**< parameter number */
14006  const char** sval /**< pointer to store the parameter value */
14007  );
14008 
14009 /** sets string parameter of NLP
14010  *
14011  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14012  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14013  *
14014  * @pre This method can be called if SCIP is in one of the following stages:
14015  * - \ref SCIP_STAGE_INITSOLVE
14016  * - \ref SCIP_STAGE_SOLVING
14017  */
14018 extern
14020  SCIP* scip, /**< SCIP data structure */
14021  SCIP_NLPPARAM type, /**< parameter number */
14022  const char* sval /**< parameter value */
14023  );
14024 
14025 /** writes current NLP to a file
14026  *
14027  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14028  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14029  *
14030  * @pre This method can be called if SCIP is in one of the following stages:
14031  * - \ref SCIP_STAGE_INITSOLVE
14032  * - \ref SCIP_STAGE_SOLVING
14033  */
14034 extern
14036  SCIP* scip, /**< SCIP data structure */
14037  const char* filename /**< file name */
14038  );
14039 
14040 /** gets the NLP interface and problem used by the SCIP NLP;
14041  * with the NLPI and its problem you can use all of the methods defined in nlpi/nlpi.h;
14042  *
14043  * @warning You have to make sure, that the full internal state of the NLPI does not change or is recovered completely
14044  * after the end of the method that uses the NLPI. In particular, if you manipulate the NLP or its solution
14045  * (e.g. by calling one of the SCIPnlpiAdd...() or the SCIPnlpiSolve() method), you have to check in advance
14046  * whether the NLP is currently solved. If this is the case, you have to make sure, the internal solution
14047  * status is recovered completely at the end of your method. Additionally you have to resolve the NLP with
14048  * SCIPnlpiSolve() in order to reinstall the internal solution status.
14049  *
14050  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
14051  *
14052  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14053  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14054  *
14055  * @pre This method can be called if SCIP is in one of the following stages:
14056  * - \ref SCIP_STAGE_INITSOLVE
14057  * - \ref SCIP_STAGE_SOLVING
14058  */
14059 extern
14061  SCIP* scip, /**< SCIP data structure */
14062  SCIP_NLPI** nlpi, /**< pointer to store the NLP solver interface */
14063  SCIP_NLPIPROBLEM** nlpiproblem /**< pointer to store the NLP solver interface problem */
14064  );
14065 
14066 /**@} */
14067 
14068 
14069 /*
14070  * NLP diving methods
14071  */
14072 
14073 /**@addtogroup PublicNLPDiveMethods
14074  *
14075  * @{ */
14076 
14077 /** initiates NLP diving making methods SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), SCIPchgVarsBoundsDiveNLP(), and SCIPsolveDiveNLP() available
14078  *
14079  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14080  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14081  *
14082  * @pre This method can be called if SCIP is in one of the following stages:
14083  * - \ref SCIP_STAGE_INITSOLVE
14084  * - \ref SCIP_STAGE_SOLVING
14085  */
14086 extern
14088  SCIP* scip /**< SCIP data structure */
14089  );
14090 
14091 /** ends NLP diving
14092  *
14093  * Resets changes made by SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), and SCIPchgVarsBoundsDiveNLP().
14094  *
14095  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14096  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14097  *
14098  * @pre This method can be called if SCIP is in one of the following stages:
14099  * - \ref SCIP_STAGE_INITSOLVE
14100  * - \ref SCIP_STAGE_SOLVING
14101  */
14102 extern
14104  SCIP* scip /**< SCIP data structure */
14105  );
14106 
14107 /** changes linear objective coefficient of a variable in diving NLP
14108  *
14109  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14110  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14111  *
14112  * @pre This method can be called if SCIP is in one of the following stages:
14113  * - \ref SCIP_STAGE_INITSOLVE
14114  * - \ref SCIP_STAGE_SOLVING
14115  */
14116 extern
14118  SCIP* scip, /**< SCIP data structure */
14119  SCIP_VAR* var, /**< variable which coefficient to change */
14120  SCIP_Real coef /**< new value for coefficient */
14121  );
14122 
14123 /** changes bounds of a variable in diving NLP
14124  *
14125  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14126  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14127  *
14128  * @pre This method can be called if SCIP is in one of the following stages:
14129  * - \ref SCIP_STAGE_INITSOLVE
14130  * - \ref SCIP_STAGE_SOLVING
14131  */
14132 extern
14134  SCIP* scip, /**< SCIP data structure */
14135  SCIP_VAR* var, /**< variable which bounds to change */
14136  SCIP_Real lb, /**< new lower bound */
14137  SCIP_Real ub /**< new upper bound */
14138  );
14139 
14140 /** changes bounds of a set of variables in diving NLP
14141  *
14142  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14143  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14144  *
14145  * @pre This method can be called if SCIP is in one of the following stages:
14146  * - \ref SCIP_STAGE_INITSOLVE
14147  * - \ref SCIP_STAGE_SOLVING
14148  */
14149 extern
14151  SCIP* scip, /**< SCIP data structure */
14152  int nvars, /**< number of variables which bounds to changes */
14153  SCIP_VAR** vars, /**< variables which bounds to change */
14154  SCIP_Real* lbs, /**< new lower bounds */
14155  SCIP_Real* ubs /**< new upper bounds */
14156  );
14157 
14158 /** solves diving NLP
14159  *
14160  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14161  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14162  *
14163  * @pre This method can be called if SCIP is in one of the following stages:
14164  * - \ref SCIP_STAGE_INITSOLVE
14165  * - \ref SCIP_STAGE_SOLVING
14166  */
14167 extern
14169  SCIP* scip /**< SCIP data structure */
14170  );
14171 
14172 /**@} */
14173 
14174 
14175 /*
14176  * NLP nonlinear row methods
14177  */
14178 
14179 /**@addtogroup PublicNLRowMethods
14180  *
14181  * @{
14182  */
14183 
14184 /** creates and captures an NLP row
14185  *
14186  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14187  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14188  *
14189  * @pre This method can be called if SCIP is in one of the following stages:
14190  * - \ref SCIP_STAGE_PRESOLVED
14191  * - \ref SCIP_STAGE_INITSOLVE
14192  * - \ref SCIP_STAGE_SOLVING
14193  */
14194 extern
14196  SCIP* scip, /**< SCIP data structure */
14197  SCIP_NLROW** nlrow, /**< buffer to store pointer to nonlinear row */
14198  const char* name, /**< name of nonlinear row */
14199  SCIP_Real constant, /**< constant */
14200  int nlinvars, /**< number of linear variables */
14201  SCIP_VAR** linvars, /**< linear variables, or NULL if nlinvars == 0 */
14202  SCIP_Real* lincoefs, /**< linear coefficients, or NULL if nlinvars == 0 */
14203  int nquadvars, /**< number of variables in quadratic term */
14204  SCIP_VAR** quadvars, /**< variables in quadratic terms, or NULL if nquadvars == 0 */
14205  int nquadelems, /**< number of elements in quadratic term */
14206  SCIP_QUADELEM* quadelems, /**< elements (i.e., monomials) in quadratic term, or NULL if nquadelems == 0 */
14207  SCIP_EXPRTREE* expression, /**< nonlinear expression, or NULL */
14208  SCIP_Real lhs, /**< left hand side */
14209  SCIP_Real rhs, /**< right hand side */
14210  SCIP_EXPRCURV curvature /**< curvature of the nonlinear row */
14211  );
14212 
14213 /** creates and captures an NLP nonlinear row without any coefficients
14214  *
14215  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14216  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14217  *
14218  * @pre This method can be called if SCIP is in one of the following stages:
14219  * - \ref SCIP_STAGE_PRESOLVED
14220  * - \ref SCIP_STAGE_INITSOLVE
14221  * - \ref SCIP_STAGE_SOLVING
14222  */
14223 extern
14225  SCIP* scip, /**< SCIP data structure */
14226  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
14227  const char* name, /**< name of nonlinear row */
14228  SCIP_Real lhs, /**< left hand side */
14229  SCIP_Real rhs /**< right hand side */
14230  );
14231 
14232 /** creates and captures an NLP row from a linear row
14233  *
14234  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14235  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14236  *
14237  * @pre This method can be called if SCIP is in one of the following stages:
14238  * - \ref SCIP_STAGE_PRESOLVED
14239  * - \ref SCIP_STAGE_INITSOLVE
14240  * - \ref SCIP_STAGE_SOLVING
14241  */
14242 extern
14244  SCIP* scip, /**< SCIP data structure */
14245  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
14246  SCIP_ROW* row /**< the linear row to copy */
14247  );
14248 
14249 /** increases usage counter of NLP nonlinear row
14250  *
14251  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14252  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14253  *
14254  * @pre This method can be called if SCIP is in one of the following stages:
14255  * - \ref SCIP_STAGE_PRESOLVED
14256  * - \ref SCIP_STAGE_INITSOLVE
14257  * - \ref SCIP_STAGE_SOLVING
14258  */
14259 extern
14261  SCIP* scip, /**< SCIP data structure */
14262  SCIP_NLROW* nlrow /**< nonlinear row to capture */
14263  );
14264 
14265 /** decreases usage counter of NLP nonlinear row, and frees memory if necessary
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  * - \ref SCIP_STAGE_EXITSOLVE
14275  */
14276 extern
14278  SCIP* scip, /**< SCIP data structure */
14279  SCIP_NLROW** nlrow /**< pointer to nonlinear row */
14280  );
14281 
14282 /** changes left hand side 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 nonlinear row */
14296  SCIP_Real lhs /**< new left hand side */
14297  );
14298 
14299 /** changes right hand side of NLP 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 nonlinear row */
14313  SCIP_Real rhs /**< new right hand side */
14314  );
14315 
14316 /** changes constant of NLP nonlinear row
14317  *
14318  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14319  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14320  *
14321  * @pre This method can be called if SCIP is in one of the following stages:
14322  * - \ref SCIP_STAGE_PRESOLVED
14323  * - \ref SCIP_STAGE_INITSOLVE
14324  * - \ref SCIP_STAGE_SOLVING
14325  */
14326 extern
14328  SCIP* scip, /**< SCIP data structure */
14329  SCIP_NLROW* nlrow, /**< NLP row */
14330  SCIP_Real constant /**< new value for constant */
14331  );
14332 
14333 /** adds variable with a linear coefficient to the nonlinear row
14334  *
14335  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14336  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14337  *
14338  * @pre This method can be called if SCIP is in one of the following stages:
14339  * - \ref SCIP_STAGE_PRESOLVED
14340  * - \ref SCIP_STAGE_INITSOLVE
14341  * - \ref SCIP_STAGE_SOLVING
14342  */
14343 extern
14345  SCIP* scip, /**< SCIP data structure */
14346  SCIP_NLROW* nlrow, /**< NLP row */
14347  SCIP_VAR* var, /**< problem variable */
14348  SCIP_Real val /**< value of coefficient in linear part of row */
14349  );
14350 
14351 /** adds variables with linear coefficients to the row
14352  *
14353  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14354  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14355  *
14356  * @pre This method can be called if SCIP is in one of the following stages:
14357  * - \ref SCIP_STAGE_PRESOLVED
14358  * - \ref SCIP_STAGE_INITSOLVE
14359  * - \ref SCIP_STAGE_SOLVING
14360  */
14361 extern
14363  SCIP* scip, /**< SCIP data structure */
14364  SCIP_NLROW* nlrow, /**< NLP row */
14365  int nvars, /**< number of variables to add to the row */
14366  SCIP_VAR** vars, /**< problem variables to add */
14367  SCIP_Real* vals /**< values of coefficients in linear part of row */
14368  );
14369 
14370 /** changes linear coefficient of a variables in a row
14371  *
14372  * Setting the coefficient to 0.0 means that it is removed from the row
14373  * the variable does not need to exists before.
14374  *
14375  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14376  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14377  *
14378  * @pre This method can be called if SCIP is in one of the following stages:
14379  * - \ref SCIP_STAGE_PRESOLVED
14380  * - \ref SCIP_STAGE_INITSOLVE
14381  * - \ref SCIP_STAGE_SOLVING
14382  */
14383 extern
14385  SCIP* scip, /**< SCIP data structure */
14386  SCIP_NLROW* nlrow, /**< NLP row */
14387  SCIP_VAR* var, /**< variable */
14388  SCIP_Real coef /**< new value of coefficient */
14389  );
14390 
14391 /** adds quadratic variable to the nonlinear row
14392  *
14393  * After adding a quadratic variable, it can be used to add quadratic elements.
14394  *
14395  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14396  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14397  *
14398  * @pre This method can be called if SCIP is in one of the following stages:
14399  * - \ref SCIP_STAGE_PRESOLVED
14400  * - \ref SCIP_STAGE_INITSOLVE
14401  * - \ref SCIP_STAGE_SOLVING
14402  */
14403 extern
14405  SCIP* scip, /**< SCIP data structure */
14406  SCIP_NLROW* nlrow, /**< NLP row */
14407  SCIP_VAR* var /**< problem variable */
14408  );
14409 
14410 /** adds quadratic variables to the nonlinear row
14411  *
14412  * After adding quadratic variables, they can be used to add quadratic elements.
14413  *
14414  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14415  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14416  *
14417  * @pre This method can be called if SCIP is in one of the following stages:
14418  * - \ref SCIP_STAGE_PRESOLVED
14419  * - \ref SCIP_STAGE_INITSOLVE
14420  * - \ref SCIP_STAGE_SOLVING
14421  */
14422 extern
14424  SCIP* scip, /**< SCIP data structure */
14425  SCIP_NLROW* nlrow, /**< NLP row */
14426  int nvars, /**< number of problem variables */
14427  SCIP_VAR** vars /**< problem variables */
14428  );
14429 
14430 /** add a quadratic element to the nonlinear row
14431  *
14432  * Variable indices of the quadratic element need to be relative to quadratic variables array of row.
14433  *
14434  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14435  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14436  *
14437  * @pre This method can be called if SCIP is in one of the following stages:
14438  * - \ref SCIP_STAGE_PRESOLVED
14439  * - \ref SCIP_STAGE_INITSOLVE
14440  * - \ref SCIP_STAGE_SOLVING
14441  */
14442 extern
14444  SCIP* scip, /**< SCIP data structure */
14445  SCIP_NLROW* nlrow, /**< NLP row */
14446  SCIP_QUADELEM quadelem /**< quadratic element */
14447  );
14448 
14449 /** adds quadratic elements to the nonlinear row
14450  *
14451  * Variable indices of the quadratic elements need to be relative to quadratic variables array of row.
14452  *
14453  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14454  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14455  *
14456  * @pre This method can be called if SCIP is in one of the following stages:
14457  * - \ref SCIP_STAGE_PRESOLVED
14458  * - \ref SCIP_STAGE_INITSOLVE
14459  * - \ref SCIP_STAGE_SOLVING
14460  */
14461 extern
14463  SCIP* scip, /**< SCIP data structure */
14464  SCIP_NLROW* nlrow, /**< NLP row */
14465  int nquadelems, /**< number of quadratic elements */
14466  SCIP_QUADELEM* quadelems /**< quadratic elements */
14467  );
14468 
14469 /** changes coefficient in quadratic part of a row
14470  *
14471  * Setting the coefficient in the quadelement to 0.0 means that it is removed from the row
14472  * the element does not need to exists before.
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  SCIP_QUADELEM quadelement /**< new quadratic element, or update for existing one */
14487  );
14488 
14489 /** sets or deletes expression tree in the nonlinear row
14490  *
14491  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14492  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14493  *
14494  * @pre This method can be called if SCIP is in one of the following stages:
14495  * - \ref SCIP_STAGE_PRESOLVED
14496  * - \ref SCIP_STAGE_INITSOLVE
14497  * - \ref SCIP_STAGE_SOLVING
14498  */
14499 extern
14501  SCIP* scip, /**< SCIP data structure */
14502  SCIP_NLROW* nlrow, /**< NLP row */
14503  SCIP_EXPRTREE* exprtree /**< expression tree, or NULL */
14504  );
14505 
14506 /** sets a parameter of expression tree in the nonlinear row
14507  *
14508  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14509  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14510  *
14511  * @pre This method can be called if SCIP is in one of the following stages:
14512  * - \ref SCIP_STAGE_PRESOLVED
14513  * - \ref SCIP_STAGE_INITSOLVE
14514  * - \ref SCIP_STAGE_SOLVING
14515  */
14516 extern
14518  SCIP* scip, /**< SCIP data structure */
14519  SCIP_NLROW* nlrow, /**< NLP row */
14520  int paramidx, /**< index of parameter in expression tree */
14521  SCIP_Real paramval /**< new value of parameter in expression tree */
14522  );
14523 
14524 /** sets parameters of expression tree in the nonlinear row
14525  *
14526  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14527  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14528  *
14529  * @pre This method can be called if SCIP is in one of the following stages:
14530  * - \ref SCIP_STAGE_PRESOLVED
14531  * - \ref SCIP_STAGE_INITSOLVE
14532  * - \ref SCIP_STAGE_SOLVING
14533  */
14534 extern
14536  SCIP* scip, /**< SCIP data structure */
14537  SCIP_NLROW* nlrow, /**< NLP row */
14538  SCIP_Real* paramvals /**< new values of parameter in expression tree */
14539  );
14540 
14541 /** recalculates the activity of a nonlinear row in the last NLP solution
14542  *
14543  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14544  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14545  *
14546  * @pre This method can be called if SCIP is in one of the following stages:
14547  * - \ref SCIP_STAGE_PRESOLVED
14548  * - \ref SCIP_STAGE_INITSOLVE
14549  * - \ref SCIP_STAGE_SOLVING
14550  */
14551 extern
14553  SCIP* scip, /**< SCIP data structure */
14554  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14555  );
14556 
14557 /** returns the activity of a nonlinear row in the last NLP solution
14558  *
14559  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14560  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14561  *
14562  * @pre This method can be called if SCIP is in one of the following stages:
14563  * - \ref SCIP_STAGE_INITSOLVE
14564  * - \ref SCIP_STAGE_SOLVING
14565  */
14566 extern
14568  SCIP* scip, /**< SCIP data structure */
14569  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14570  SCIP_Real* activity /**< pointer to store activity value */
14571  );
14572 
14573 /** gives the feasibility of a nonlinear row in the last NLP solution: negative value means infeasibility
14574  *
14575  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14576  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14577  *
14578  * @pre This method can be called if SCIP is in one of the following stages:
14579  * - \ref SCIP_STAGE_INITSOLVE
14580  * - \ref SCIP_STAGE_SOLVING
14581  */
14582 extern
14584  SCIP* scip, /**< SCIP data structure */
14585  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14586  SCIP_Real* feasibility /**< pointer to store feasibility value */
14587  );
14588 
14589 /** recalculates the activity of a nonlinear row for the current pseudo solution
14590  *
14591  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14592  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14593  *
14594  * @pre This method can be called if SCIP is in one of the following stages:
14595  * - \ref SCIP_STAGE_INITSOLVE
14596  * - \ref SCIP_STAGE_SOLVING
14597  */
14598 extern
14600  SCIP* scip, /**< SCIP data structure */
14601  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14602  );
14603 
14604 /** gives the activity of a nonlinear row for the current pseudo solution
14605  *
14606  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14607  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14608  *
14609  * @pre This method can be called if SCIP is in one of the following stages:
14610  * - \ref SCIP_STAGE_INITSOLVE
14611  * - \ref SCIP_STAGE_SOLVING
14612  */
14613 extern
14615  SCIP* scip, /**< SCIP data structure */
14616  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14617  SCIP_Real* pseudoactivity /**< pointer to store pseudo activity value */
14618  );
14619 
14620 /** gives the feasibility of a nonlinear row for the current pseudo solution: negative value means infeasibility
14621  *
14622  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14623  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14624  *
14625  * @pre This method can be called if SCIP is in one of the following stages:
14626  * - \ref SCIP_STAGE_INITSOLVE
14627  * - \ref SCIP_STAGE_SOLVING
14628  */
14629 extern
14631  SCIP* scip, /**< SCIP data structure */
14632  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14633  SCIP_Real* pseudofeasibility /**< pointer to store pseudo feasibility value */
14634  );
14635 
14636 /** recalculates the activity of a nonlinear row in the last NLP or pseudo solution
14637  *
14638  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14639  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14640  *
14641  * @pre This method can be called if SCIP is in one of the following stages:
14642  * - \ref SCIP_STAGE_INITSOLVE
14643  * - \ref SCIP_STAGE_SOLVING
14644  */
14645 extern
14647  SCIP* scip, /**< SCIP data structure */
14648  SCIP_NLROW* nlrow /**< NLP nonlinear row */
14649  );
14650 
14651 /** gives the activity of a nonlinear row in the last NLP or pseudo solution
14652  *
14653  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14654  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14655  *
14656  * @pre This method can be called if SCIP is in one of the following stages:
14657  * - \ref SCIP_STAGE_INITSOLVE
14658  * - \ref SCIP_STAGE_SOLVING
14659  */
14660 extern
14662  SCIP* scip, /**< SCIP data structure */
14663  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14664  SCIP_Real* activity /**< pointer to store activity value */
14665  );
14666 
14667 /** gives the feasibility of a nonlinear row in the last NLP or pseudo solution
14668  *
14669  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14670  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14671  *
14672  * @pre This method can be called if SCIP is in one of the following stages:
14673  * - \ref SCIP_STAGE_INITSOLVE
14674  * - \ref SCIP_STAGE_SOLVING
14675  */
14676 extern
14678  SCIP* scip, /**< SCIP data structure */
14679  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14680  SCIP_Real* feasibility /**< pointer to store feasibility value */
14681  );
14682 
14683 /** gives the activity of a nonlinear row for the given primal solution or NLP solution or pseudo solution
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_INITSOLVE
14690  * - \ref SCIP_STAGE_SOLVING
14691  */
14692 extern
14694  SCIP* scip, /**< SCIP data structure */
14695  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14696  SCIP_SOL* sol, /**< primal CIP solution, or NULL for NLP solution of pseudo solution */
14697  SCIP_Real* activity /**< pointer to store activity value */
14698  );
14699 
14700 /** gives the feasibility of a nonlinear row for the given primal solution
14701  *
14702  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14703  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14704  *
14705  * @pre This method can be called if SCIP is in one of the following stages:
14706  * - \ref SCIP_STAGE_INITSOLVE
14707  * - \ref SCIP_STAGE_SOLVING
14708  */
14709 extern
14711  SCIP* scip, /**< SCIP data structure */
14712  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
14713  SCIP_SOL* sol, /**< primal CIP solution */
14714  SCIP_Real* feasibility /**< pointer to store feasibility value */
14715  );
14716 
14717 /** gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds
14718  *
14719  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14720  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14721  *
14722  * @pre This method can be called if SCIP is in one of the following stages:
14723  * - \ref SCIP_STAGE_PRESOLVED
14724  * - \ref SCIP_STAGE_INITSOLVE
14725  * - \ref SCIP_STAGE_SOLVING
14726  */
14727 extern
14729  SCIP* scip, /**< SCIP data structure */
14730  SCIP_NLROW* nlrow, /**< NLP row */
14731  SCIP_Real* minactivity, /**< buffer to store minimal activity, or NULL */
14732  SCIP_Real* maxactivity /**< buffer to store maximal activity, or NULL */
14733  );
14734 
14735 /** output nonlinear row to file stream
14736  *
14737  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14738  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14739  *
14740  * @pre This method can be called if SCIP is in one of the following stages:
14741  * - \ref SCIP_STAGE_PRESOLVED
14742  * - \ref SCIP_STAGE_INITSOLVE
14743  * - \ref SCIP_STAGE_SOLVING
14744  */
14745 extern
14747  SCIP* scip, /**< SCIP data structure */
14748  SCIP_NLROW* nlrow, /**< NLP row */
14749  FILE* file /**< output file (or NULL for standard output) */
14750  );
14751 
14752 /**@} */
14753 
14754 /**@addtogroup PublicExpressionTreeMethods
14755  *
14756  * @{
14757  */
14758 
14759 /** replaces array of variables in expression tree by corresponding transformed variables
14760  *
14761  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14762  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14763  *
14764  * @pre This method can be called if @p scip is in one of the following stages:
14765  * - \ref SCIP_STAGE_TRANSFORMING
14766  * - \ref SCIP_STAGE_TRANSFORMED
14767  * - \ref SCIP_STAGE_INITPRESOLVE
14768  * - \ref SCIP_STAGE_PRESOLVING
14769  * - \ref SCIP_STAGE_EXITPRESOLVE
14770  * - \ref SCIP_STAGE_PRESOLVED
14771  * - \ref SCIP_STAGE_INITSOLVE
14772  * - \ref SCIP_STAGE_SOLVING
14773  * - \ref SCIP_STAGE_SOLVED
14774  * - \ref SCIP_STAGE_EXITSOLVE
14775  * - \ref SCIP_STAGE_FREETRANS
14776  *
14777  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14778  */
14779 extern
14781  SCIP* scip, /**< SCIP data structure */
14782  SCIP_EXPRTREE* tree /**< expression tree */
14783  );
14784 
14785 /** evaluates an expression tree for a primal solution or LP solution
14786  *
14787  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14788  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14789  *
14790  * @pre This method can be called if @p scip is in one of the following stages:
14791  * - \ref SCIP_STAGE_PROBLEM
14792  * - \ref SCIP_STAGE_TRANSFORMING
14793  * - \ref SCIP_STAGE_TRANSFORMED
14794  * - \ref SCIP_STAGE_INITPRESOLVE
14795  * - \ref SCIP_STAGE_PRESOLVING
14796  * - \ref SCIP_STAGE_EXITPRESOLVE
14797  * - \ref SCIP_STAGE_PRESOLVED
14798  * - \ref SCIP_STAGE_INITSOLVE
14799  * - \ref SCIP_STAGE_SOLVING
14800  * - \ref SCIP_STAGE_SOLVED
14801  * - \ref SCIP_STAGE_EXITSOLVE
14802  * - \ref SCIP_STAGE_FREETRANS
14803  *
14804  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14805  */
14806 extern
14808  SCIP* scip, /**< SCIP data structure */
14809  SCIP_EXPRTREE* tree, /**< expression tree */
14810  SCIP_SOL* sol, /**< a solution, or NULL for current LP solution */
14811  SCIP_Real* val /**< buffer to store value */
14812  );
14813 
14814 /** evaluates an expression tree w.r.t. current global bounds
14815  *
14816  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14817  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14818  *
14819  * @pre This method can be called if @p scip is in one of the following stages:
14820  * - \ref SCIP_STAGE_PROBLEM
14821  * - \ref SCIP_STAGE_TRANSFORMING
14822  * - \ref SCIP_STAGE_TRANSFORMED
14823  * - \ref SCIP_STAGE_INITPRESOLVE
14824  * - \ref SCIP_STAGE_PRESOLVING
14825  * - \ref SCIP_STAGE_EXITPRESOLVE
14826  * - \ref SCIP_STAGE_PRESOLVED
14827  * - \ref SCIP_STAGE_INITSOLVE
14828  * - \ref SCIP_STAGE_SOLVING
14829  * - \ref SCIP_STAGE_SOLVED
14830  * - \ref SCIP_STAGE_EXITSOLVE
14831  * - \ref SCIP_STAGE_FREETRANS
14832  *
14833  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14834  */
14835 extern
14837  SCIP* scip, /**< SCIP data structure */
14838  SCIP_EXPRTREE* tree, /**< expression tree */
14839  SCIP_Real infinity, /**< value to use for infinity */
14840  SCIP_INTERVAL* val /**< buffer to store result */
14841  );
14842 
14843 /** evaluates an expression tree w.r.t. current local bounds
14844  *
14845  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14846  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14847  *
14848  * @pre This method can be called if @p scip is in one of the following stages:
14849  * - \ref SCIP_STAGE_PROBLEM
14850  * - \ref SCIP_STAGE_TRANSFORMING
14851  * - \ref SCIP_STAGE_TRANSFORMED
14852  * - \ref SCIP_STAGE_INITPRESOLVE
14853  * - \ref SCIP_STAGE_PRESOLVING
14854  * - \ref SCIP_STAGE_EXITPRESOLVE
14855  * - \ref SCIP_STAGE_PRESOLVED
14856  * - \ref SCIP_STAGE_INITSOLVE
14857  * - \ref SCIP_STAGE_SOLVING
14858  * - \ref SCIP_STAGE_SOLVED
14859  * - \ref SCIP_STAGE_EXITSOLVE
14860  * - \ref SCIP_STAGE_FREETRANS
14861  *
14862  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14863  */
14864 extern
14866  SCIP* scip, /**< SCIP data structure */
14867  SCIP_EXPRTREE* tree, /**< expression tree */
14868  SCIP_Real infinity, /**< value to use for infinity */
14869  SCIP_INTERVAL* val /**< buffer to store result */
14870  );
14871 
14872 /**@} */
14873 
14874 
14875 
14876 
14877 /*
14878  * nonlinear methods
14879  */
14880 
14881 /**@addtogroup PublicNonlinearMethods
14882  *
14883  * @{
14884  */
14885 
14886 /** computes coefficients of linearization of a square term in a reference point */
14887 extern
14889  SCIP* scip, /**< SCIP data structure */
14890  SCIP_Real sqrcoef, /**< coefficient of square term */
14891  SCIP_Real refpoint, /**< point where to linearize */
14892  SCIP_Bool isint, /**< whether corresponding variable is a discrete variable, and thus linearization could be moved */
14893  SCIP_Real* lincoef, /**< buffer to add coefficient of linearization */
14894  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14895  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14896  );
14897 
14898 /** computes coefficients of secant of a square term */
14899 extern
14900 void SCIPaddSquareSecant(
14901  SCIP* scip, /**< SCIP data structure */
14902  SCIP_Real sqrcoef, /**< coefficient of square term */
14903  SCIP_Real lb, /**< lower bound on variable */
14904  SCIP_Real ub, /**< upper bound on variable */
14905  SCIP_Real refpoint, /**< point for which to compute value of linearization */
14906  SCIP_Real* lincoef, /**< buffer to add coefficient of secant */
14907  SCIP_Real* linconstant, /**< buffer to add constant of secant */
14908  SCIP_Bool* success /**< buffer to set to FALSE if secant has failed due to large numbers or unboundedness */
14909  );
14910 
14911 /** computes coefficients of linearization of a bilinear term in a reference point */
14912 extern
14914  SCIP* scip, /**< SCIP data structure */
14915  SCIP_Real bilincoef, /**< coefficient of bilinear term */
14916  SCIP_Real refpointx, /**< point where to linearize first variable */
14917  SCIP_Real refpointy, /**< point where to linearize second variable */
14918  SCIP_Real* lincoefx, /**< buffer to add coefficient of first variable in linearization */
14919  SCIP_Real* lincoefy, /**< buffer to add coefficient of second variable in linearization */
14920  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14921  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14922  );
14923 
14924 /** computes coefficients of McCormick under- or overestimation of a bilinear term */
14925 extern
14927  SCIP* scip, /**< SCIP data structure */
14928  SCIP_Real bilincoef, /**< coefficient of bilinear term */
14929  SCIP_Real lbx, /**< lower bound on first variable */
14930  SCIP_Real ubx, /**< upper bound on first variable */
14931  SCIP_Real refpointx, /**< reference point for first variable */
14932  SCIP_Real lby, /**< lower bound on second variable */
14933  SCIP_Real uby, /**< upper bound on second variable */
14934  SCIP_Real refpointy, /**< reference point for second variable */
14935  SCIP_Bool overestimate, /**< whether to compute an overestimator instead of an underestimator */
14936  SCIP_Real* lincoefx, /**< buffer to add coefficient of first variable in linearization */
14937  SCIP_Real* lincoefy, /**< buffer to add coefficient of second variable in linearization */
14938  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14939  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14940  );
14941 
14942 /** creates an NLP relaxation and stores it in a given NLPI problem; the function computes for each variable which the
14943  * number of non-linearly occurrences and stores it in the nlscore array
14944  *
14945  * @note the first row corresponds always to the cutoff row (even if cutoffbound is SCIPinfinity(scip))
14946  **/
14947 extern
14949  SCIP* scip, /**< SCIP data structure */
14950  SCIP_NLPI* nlpi, /**< interface to NLP solver */
14951  SCIP_NLROW** nlrows, /**< nonlinear rows */
14952  int nnlrows, /**< total number of nonlinear rows */
14953  SCIP_NLPIPROBLEM* nlpiprob, /**< empty nlpi problem */
14954  SCIP_HASHMAP* var2idx, /**< empty hash map to store mapping between variables and indices in nlpi
14955  * problem */
14956  SCIP_Real* nlscore, /**< array to store the score of each nonlinear variable (NULL if not
14957  * needed) */
14958  SCIP_Real cutoffbound, /**< cutoff bound */
14959  SCIP_Bool setobj, /**< should the objective function be set? */
14960  SCIP_Bool onlyconvex /**< filter only for convex constraints */
14961  );
14962 
14963 /** updates bounds of each variable and the cutoff row in the nlpiproblem */
14964 extern
14966  SCIP* scip, /**< SCIP data structure */
14967  SCIP_NLPI* nlpi, /**< interface to NLP solver */
14968  SCIP_NLPIPROBLEM* nlpiprob, /**< nlpi problem representing the convex NLP relaxation */
14969  SCIP_HASHMAP* var2nlpiidx, /**< mapping between variables and nlpi indices */
14970  SCIP_VAR** nlpivars, /**< array containing all variables of the nlpi */
14971  int nlpinvars, /**< total number of nlpi variables */
14972  SCIP_Real cutoffbound /**< new cutoff bound */
14973  );
14974 
14975 /** adds linear rows to the NLP relaxation */
14977  SCIP* scip, /**< SCIP data structure */
14978  SCIP_NLPI* nlpi, /**< interface to NLP solver */
14979  SCIP_NLPIPROBLEM* nlpiprob, /**< nlpi problem */
14980  SCIP_HASHMAP* var2idx, /**< empty hash map to store mapping between variables and indices in nlpi
14981  * problem */
14982  SCIP_ROW** rows, /**< rows to add */
14983  int nrows /**< total number of rows to add */
14984  );
14985 
14986 /**@} */
14987 
14988 
14989 
14990 
14991 /*
14992  * cutting plane methods
14993  */
14994 
14995 /**@addtogroup PublicCutMethods
14996  *
14997  * @{
14998  */
14999 
15000 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
15001  * e = -feasibility/norm
15002  *
15003  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
15004  * e = -feasibility/norm
15005  *
15006  * @pre This method can be called if @p scip is in one of the following stages:
15007  * - \ref SCIP_STAGE_SOLVING
15008  */
15009 extern
15011  SCIP* scip, /**< SCIP data structure */
15012  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
15013  SCIP_ROW* cut /**< separated cut */
15014  );
15015 
15016 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
15017  * than the minimal cut efficacy
15018  *
15019  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
15020  * than the minimal cut efficacy, otherwise FALSE
15021  *
15022  * @pre This method can be called if @p scip is in one of the following stages:
15023  * - \ref SCIP_STAGE_SOLVING
15024  */
15025 extern
15027  SCIP* scip, /**< SCIP data structure */
15028  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
15029  SCIP_ROW* cut /**< separated cut */
15030  );
15031 
15032 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
15033  *
15034  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
15035  */
15036 extern
15038  SCIP* scip, /**< SCIP data structure */
15039  SCIP_Real efficacy /**< efficacy of the cut */
15040  );
15041 
15042 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
15043  *
15044  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
15045  */
15046 extern
15048  SCIP* scip, /**< SCIP data structure */
15049  SCIP_Real* vals, /**< array of values */
15050  int nvals /**< number of values */
15051  );
15052 
15053 /** indicates whether a cut is applicable
15054  *
15055  * If the cut has only one variable and this method returns FALSE, it may
15056  * still be possible that the cut can be added to the LP (as a row instead
15057  * of a boundchange), but it will be a very weak cut. The user is asked
15058  * to avoid such cuts.
15059  *
15060  * @pre This method can be called if @p scip is in one of the following stages:
15061  * - \ref SCIP_STAGE_SOLVING
15062  *
15063  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
15064  */
15065 extern
15067  SCIP* scip, /**< SCIP data structure */
15068  SCIP_ROW* cut /**< separated cut */
15069  );
15070 
15071 /** adds cut to separation storage
15072  *
15073  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15074  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15075  *
15076  * @pre This method can be called if @p scip is in one of the following stages:
15077  * - \ref SCIP_STAGE_SOLVING
15078  */
15079 extern
15081  SCIP* scip, /**< SCIP data structure */
15082  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
15083  SCIP_ROW* cut, /**< separated cut */
15084  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
15085  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
15086  );
15087 
15088 /** if not already existing, adds row to global cut pool
15089  *
15090  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15091  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15092  *
15093  * @pre This method can be called if @p scip is in one of the following stages:
15094  * - \ref SCIP_STAGE_SOLVING
15095  */
15096 extern
15098  SCIP* scip, /**< SCIP data structure */
15099  SCIP_ROW* row /**< cutting plane to add */
15100  );
15101 
15102 /** removes the row from the global cut pool
15103  *
15104  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15105  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15106  *
15107  * @pre This method can be called if @p scip is in one of the following stages:
15108  * - \ref SCIP_STAGE_SOLVING
15109  */
15110 extern
15112  SCIP* scip, /**< SCIP data structure */
15113  SCIP_ROW* row /**< row to remove */
15114  );
15115 
15116 /** gets current cuts in the global cut pool
15117  *
15118  * @return the current cuts in the global cut pool
15119  *
15120  * @pre This method can be called if @p scip is in one of the following stages:
15121  * - \ref SCIP_STAGE_SOLVING
15122  * - \ref SCIP_STAGE_SOLVED
15123  * - \ref SCIP_STAGE_EXITSOLVE
15124  */
15125 extern
15127  SCIP* scip /**< SCIP data structure */
15128  );
15129 
15130 /** gets current number of rows in the global cut pool
15131  *
15132  * @return the current number of rows in the global cut pool
15133  *
15134  * @pre This method can be called if @p scip is in one of the following stages:
15135  * - \ref SCIP_STAGE_SOLVING
15136  * - \ref SCIP_STAGE_SOLVED
15137  * - \ref SCIP_STAGE_EXITSOLVE
15138  */
15139 extern
15140 int SCIPgetNPoolCuts(
15141  SCIP* scip /**< SCIP data structure */
15142  );
15143 
15144 /** gets the global cut pool used by SCIP
15145  *
15146  * @return the global cut pool used by SCIP
15147  *
15148  * @pre This method can be called if @p scip is in one of the following stages:
15149  * - \ref SCIP_STAGE_SOLVING
15150  * - \ref SCIP_STAGE_SOLVED
15151  * - \ref SCIP_STAGE_EXITSOLVE
15152  */
15153 extern
15155  SCIP* scip /**< SCIP data structure */
15156  );
15157 
15158 /** creates a cut pool
15159  *
15160  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15161  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15162  *
15163  * @pre This method can be called if @p scip is in one of the following stages:
15164  * - \ref SCIP_STAGE_TRANSFORMING
15165  * - \ref SCIP_STAGE_TRANSFORMED
15166  * - \ref SCIP_STAGE_INITPRESOLVE
15167  * - \ref SCIP_STAGE_PRESOLVING
15168  * - \ref SCIP_STAGE_EXITPRESOLVE
15169  * - \ref SCIP_STAGE_PRESOLVED
15170  * - \ref SCIP_STAGE_INITSOLVE
15171  * - \ref SCIP_STAGE_SOLVING
15172  */
15173 extern
15175  SCIP* scip, /**< SCIP data structure */
15176  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
15177  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
15178  );
15179 
15180 /** frees a cut pool
15181  *
15182  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15183  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15184  *
15185  * @pre This method can be called if @p scip is in one of the following stages:
15186  * - \ref SCIP_STAGE_TRANSFORMING
15187  * - \ref SCIP_STAGE_TRANSFORMED
15188  * - \ref SCIP_STAGE_INITPRESOLVE
15189  * - \ref SCIP_STAGE_PRESOLVING
15190  * - \ref SCIP_STAGE_EXITPRESOLVE
15191  * - \ref SCIP_STAGE_PRESOLVED
15192  * - \ref SCIP_STAGE_INITSOLVE
15193  * - \ref SCIP_STAGE_SOLVING
15194  * - \ref SCIP_STAGE_SOLVED
15195  * - \ref SCIP_STAGE_EXITSOLVE
15196  * - \ref SCIP_STAGE_FREETRANS
15197  */
15198 extern
15200  SCIP* scip, /**< SCIP data structure */
15201  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
15202  );
15203 
15204 /** if not already existing, adds row to a cut pool and captures it
15205  *
15206  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15207  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15208  *
15209  * @pre This method can be called if @p scip is in one of the following stages:
15210  * - \ref SCIP_STAGE_INITSOLVE
15211  * - \ref SCIP_STAGE_SOLVING
15212  */
15213 extern
15215  SCIP* scip, /**< SCIP data structure */
15216  SCIP_CUTPOOL* cutpool, /**< cut pool */
15217  SCIP_ROW* row /**< cutting plane to add */
15218  );
15219 
15220 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
15221  *
15222  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15223  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15224  *
15225  * @pre This method can be called if @p scip is in one of the following stages:
15226  * - \ref SCIP_STAGE_INITSOLVE
15227  * - \ref SCIP_STAGE_SOLVING
15228  */
15229 extern
15231  SCIP* scip, /**< SCIP data structure */
15232  SCIP_CUTPOOL* cutpool, /**< cut pool */
15233  SCIP_ROW* row /**< cutting plane to add */
15234  );
15235 
15236 /** removes the LP row from a cut pool
15237  *
15238  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15239  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15240  *
15241  * @pre This method can be called if @p scip is in one of the following stages:
15242  * - \ref SCIP_STAGE_INITSOLVE
15243  * - \ref SCIP_STAGE_SOLVING
15244  * - \ref SCIP_STAGE_SOLVED
15245  */
15246 extern
15248  SCIP* scip, /**< SCIP data structure */
15249  SCIP_CUTPOOL* cutpool, /**< cut pool */
15250  SCIP_ROW* row /**< row to remove */
15251  );
15252 
15253 /** separates cuts from a cut pool
15254  *
15255  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15256  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15257  *
15258  * @pre This method can be called if @p scip is in one of the following stages:
15259  * - \ref SCIP_STAGE_SOLVING
15260  */
15261 extern
15263  SCIP* scip, /**< SCIP data structure */
15264  SCIP_CUTPOOL* cutpool, /**< cut pool */
15265  SCIP_RESULT* result /**< pointer to store the result of the separation call */
15266  );
15267 
15268 /** separates cuts w.r.t. given solution from a cut pool
15269  *
15270  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15271  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15272  *
15273  * @pre This method can be called if @p scip is in one of the following stages:
15274  * - \ref SCIP_STAGE_SOLVING
15275  */
15276 extern
15278  SCIP* scip, /**< SCIP data structure */
15279  SCIP_CUTPOOL* cutpool, /**< cut pool */
15280  SCIP_SOL* sol, /**< solution to be separated */
15281  SCIP_RESULT* result /**< pointer to store the result of the separation call */
15282  );
15283 
15284 /** if not already existing, adds row to the delayed global cut pool
15285  *
15286  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15287  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15288  *
15289  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15290  */
15291 extern
15293  SCIP* scip, /**< SCIP data structure */
15294  SCIP_ROW* row /**< cutting plane to add */
15295  );
15296 
15297 /** removes the row from the delayed global cut pool
15298  *
15299  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15300  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15301  *
15302  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15303  */
15304 extern
15306  SCIP* scip, /**< SCIP data structure */
15307  SCIP_ROW* row /**< cutting plane to add */
15308  );
15309 
15310 /** gets current cuts in the delayed global cut pool
15311  *
15312  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15313  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15314  *
15315  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15316  */
15317 extern
15319  SCIP* scip /**< SCIP data structure */
15320  );
15321 
15322 /** gets current number of rows in the delayed global cut pool
15323  *
15324  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15325  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15326  *
15327  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15328  */
15329 extern
15331  SCIP* scip /**< SCIP data structure */
15332  );
15333 
15334 /** gets the delayed global cut pool used by SCIP
15335  *
15336  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15337  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15338  *
15339  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
15340  */
15341 extern
15343  SCIP* scip /**< SCIP data structure */
15344  );
15345 
15346 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
15347  * separation methods;
15348  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
15349  * SCIPgetNCuts();
15350  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
15351  * separation storage;
15352  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
15353  * afterwards
15354  *
15355  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15356  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15357  *
15358  * @pre This method can be called if @p scip is in one of the following stages:
15359  * - \ref SCIP_STAGE_SOLVING
15360  */
15361 extern
15363  SCIP* scip, /**< SCIP data structure */
15364  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
15365  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
15366  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
15367  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
15368  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
15369  );
15370 
15371 /** gets the array of cuts currently stored in the separation storage
15372  *
15373  * @return the array of cuts currently stored in the separation storage
15374  *
15375  * @pre This method can be called if @p scip is in one of the following stages:
15376  * - \ref SCIP_STAGE_PRESOLVED
15377  * - \ref SCIP_STAGE_SOLVING
15378  * - \ref SCIP_STAGE_SOLVED
15379  */
15380 extern
15382  SCIP* scip /**< SCIP data structure */
15383  );
15384 
15385 /** get current number of cuts in the separation storage
15386  *
15387  * @return the current number of cuts in the separation storage
15388  *
15389  * @pre This method can be called if @p scip is in one of the following stages:
15390  * - \ref SCIP_STAGE_PRESOLVED
15391  * - \ref SCIP_STAGE_SOLVING
15392  * - \ref SCIP_STAGE_SOLVED
15393  */
15394 extern
15395 int SCIPgetNCuts(
15396  SCIP* scip /**< SCIP data structure */
15397  );
15398 
15399 /** clears the separation storage
15400  *
15401  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15402  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15403  *
15404  * @pre This method can be called if @p scip is in one of the following stages:
15405  * - \ref SCIP_STAGE_SOLVING
15406  */
15407 extern
15409  SCIP* scip /**< SCIP data structure */
15410  );
15411 
15412 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
15413  *
15414  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15415  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15416  *
15417  * @pre This method can be called if @p scip is in one of the following stages:
15418  * - \ref SCIP_STAGE_SOLVING
15419  */
15420 extern
15422  SCIP* scip /**< SCIP data structure */
15423  );
15424 
15425 /** returns current factor on cut infeasibility to limit feasibility tolerance for relaxation solver
15426  *
15427  * Gives value of separating/feastolfac parameter.
15428  *
15429  * @return factor on cut infeasibility to limit feasibility tolerance for relaxation solver
15430  *
15431  * @pre This method can be called if @p scip is in one of the following stages:
15432  * - \ref SCIP_STAGE_SOLVING
15433  */
15434 extern
15436  SCIP* scip /**< SCIP data structure */
15437  );
15438 
15439 /**@} */
15440 
15441 
15442 
15443 
15444 /*
15445  * LP diving methods
15446  */
15447 
15448 /**@addtogroup PublicLPDivingMethods
15449  *
15450  * @{
15451  */
15452 
15453 /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
15454  *
15455  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15456  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15457  *
15458  * @pre This method can be called if @p scip is in one of the following stages:
15459  * - \ref SCIP_STAGE_SOLVING
15460  *
15461  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15462  *
15463  * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware
15464  * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from
15465  * numerical troubles during the last LP solve; because of this, most users will want to call this method only if
15466  * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL
15467  */
15468 extern
15470  SCIP* scip /**< SCIP data structure */
15471  );
15472 
15473 /** quits LP diving and resets bounds and objective values of columns to the current node's values
15474  *
15475  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15476  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15477  *
15478  * @pre This method can be called if @p scip is in one of the following stages:
15479  * - \ref SCIP_STAGE_SOLVING
15480  *
15481  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15482  */
15483 extern
15485  SCIP* scip /**< SCIP data structure */
15486  );
15487 
15488 /** changes cutoffbound in current dive
15489  *
15490  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15491  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15492  *
15493  * @pre This method can be called if @p scip is in one of the following stages:
15494  * - \ref SCIP_STAGE_SOLVING
15495  *
15496  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15497  */
15498 extern
15500  SCIP* scip, /**< SCIP data structure */
15501  SCIP_Real newcutoffbound /**< new cutoffbound */
15502  );
15503 
15504 /** changes variable's objective value 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 objective value for */
15518  SCIP_Real newobj /**< new objective value */
15519  );
15520 
15521 /** changes variable's lower bound 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_VAR* var, /**< variable to change the bound for */
15535  SCIP_Real newbound /**< new value for bound */
15536  );
15537 
15538 /** changes variable's upper bound in current dive
15539  *
15540  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15541  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15542  *
15543  * @pre This method can be called if @p scip is in one of the following stages:
15544  * - \ref SCIP_STAGE_SOLVING
15545  *
15546  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15547  */
15548 extern
15550  SCIP* scip, /**< SCIP data structure */
15551  SCIP_VAR* var, /**< variable to change the bound for */
15552  SCIP_Real newbound /**< new value for bound */
15553  );
15554 
15555 /** adds a row to the LP in current dive
15556  *
15557  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15558  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15559  *
15560  * @pre This method can be called if @p scip is in one of the following stages:
15561  * - \ref SCIP_STAGE_SOLVING
15562  *
15563  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15564  */
15565 extern
15567  SCIP* scip, /**< SCIP data structure */
15568  SCIP_ROW* row /**< row to be added */
15569  );
15570 
15571 /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
15572  *
15573  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15574  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15575  *
15576  * @pre This method can be called if @p scip is in one of the following stages:
15577  * - \ref SCIP_STAGE_SOLVING
15578  *
15579  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15580  */
15581 extern
15583  SCIP* scip, /**< SCIP data structure */
15584  SCIP_ROW* row, /**< row to change the lhs for */
15585  SCIP_Real newlhs /**< new value for lhs */
15586  );
15587 
15588 /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
15589  *
15590  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15591  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15592  *
15593  * @pre This method can be called if @p scip is in one of the following stages:
15594  * - \ref SCIP_STAGE_SOLVING
15595  *
15596  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15597  */
15598 extern
15600  SCIP* scip, /**< SCIP data structure */
15601  SCIP_ROW* row, /**< row to change the lhs for */
15602  SCIP_Real newrhs /**< new value for rhs */
15603  );
15604 
15605 /** gets variable's objective value in current dive
15606  *
15607  * @return the variable's objective value in current dive.
15608  *
15609  * @pre This method can be called if @p scip is in one of the following stages:
15610  * - \ref SCIP_STAGE_SOLVING
15611  *
15612  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15613  */
15614 extern
15616  SCIP* scip, /**< SCIP data structure */
15617  SCIP_VAR* var /**< variable to get the bound for */
15618  );
15619 
15620 /** gets variable's lower bound in current dive
15621  *
15622  * @return the variable's lower bound in current dive.
15623  *
15624  * @pre This method can be called if @p scip is in one of the following stages:
15625  * - \ref SCIP_STAGE_SOLVING
15626  *
15627  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15628  */
15629 extern
15631  SCIP* scip, /**< SCIP data structure */
15632  SCIP_VAR* var /**< variable to get the bound for */
15633  );
15634 
15635 /** gets variable's upper bound in current dive
15636  *
15637  * @return the variable's upper bound in current dive.
15638  *
15639  * @pre This method can be called if @p scip is in one of the following stages:
15640  * - \ref SCIP_STAGE_SOLVING
15641  *
15642  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15643  */
15644 extern
15646  SCIP* scip, /**< SCIP data structure */
15647  SCIP_VAR* var /**< variable to get the bound for */
15648  );
15649 /** solves the LP of the current dive; no separation or pricing is applied
15650  *
15651  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15652  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15653  *
15654  * @pre This method can be called if @p scip is in one of the following stages:
15655  * - \ref SCIP_STAGE_SOLVING
15656  *
15657  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15658  *
15659  * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL,
15660  * compare the explanation of SCIPstartDive()
15661  */
15662 extern
15664  SCIP* scip, /**< SCIP data structure */
15665  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
15666  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
15667  SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective
15668  * limit was reached (or NULL, if not needed) */
15669  );
15670 
15671 /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving
15672  * or probing mode
15673  *
15674  * @return the number of the node in the current branch and bound run, where the last LP was solved in diving
15675  * or probing mode.
15676  *
15677  * @pre This method can be called if @p scip is in one of the following stages:
15678  * - \ref SCIP_STAGE_TRANSFORMING
15679  * - \ref SCIP_STAGE_TRANSFORMED
15680  * - \ref SCIP_STAGE_INITPRESOLVE
15681  * - \ref SCIP_STAGE_PRESOLVING
15682  * - \ref SCIP_STAGE_EXITPRESOLVE
15683  * - \ref SCIP_STAGE_PRESOLVED
15684  * - \ref SCIP_STAGE_INITSOLVE
15685  * - \ref SCIP_STAGE_SOLVING
15686  * - \ref SCIP_STAGE_SOLVED
15687  * - \ref SCIP_STAGE_EXITSOLVE
15688  * - \ref SCIP_STAGE_FREETRANS
15689  *
15690  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15691  */
15692 extern
15694  SCIP* scip /**< SCIP data structure */
15695  );
15696 
15697 /** returns whether we are in diving mode
15698  *
15699  * @return whether we are in diving mode.
15700  *
15701  * @pre This method can be called if @p scip is in one of the following stages:
15702  * - \ref SCIP_STAGE_TRANSFORMING
15703  * - \ref SCIP_STAGE_TRANSFORMED
15704  * - \ref SCIP_STAGE_INITPRESOLVE
15705  * - \ref SCIP_STAGE_PRESOLVING
15706  * - \ref SCIP_STAGE_EXITPRESOLVE
15707  * - \ref SCIP_STAGE_PRESOLVED
15708  * - \ref SCIP_STAGE_INITSOLVE
15709  * - \ref SCIP_STAGE_SOLVING
15710  * - \ref SCIP_STAGE_SOLVED
15711  * - \ref SCIP_STAGE_EXITSOLVE
15712  * - \ref SCIP_STAGE_FREETRANS
15713  *
15714  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15715  */
15716 extern
15718  SCIP* scip /**< SCIP data structure */
15719  );
15720 
15721 /**@} */
15722 
15723 
15724 
15725 
15726 /*
15727  * probing methods
15728  */
15729 
15730 /**@addtogroup PublicProbingMethods
15731  *
15732  * @{
15733  */
15734 
15735 /** returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped
15736  * via SCIPendProbing()
15737  *
15738  * @return TRUE, if SCIP is currently in probing mode, otherwise FALSE
15739  *
15740  * @pre This method can be called if @p scip is in one of the following stages:
15741  * - \ref SCIP_STAGE_TRANSFORMED
15742  * - \ref SCIP_STAGE_INITPRESOLVE
15743  * - \ref SCIP_STAGE_PRESOLVING
15744  * - \ref SCIP_STAGE_EXITPRESOLVE
15745  * - \ref SCIP_STAGE_PRESOLVED
15746  * - \ref SCIP_STAGE_INITSOLVE
15747  * - \ref SCIP_STAGE_SOLVING
15748  * - \ref SCIP_STAGE_SOLVED
15749  * - \ref SCIP_STAGE_EXITSOLVE
15750  */
15751 extern
15753  SCIP* scip /**< SCIP data structure */
15754  );
15755 
15756 /** initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),
15757  * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available
15758  *
15759  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15760  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15761  *
15762  * @pre This method can be called if @p scip is in one of the following stages:
15763  * - \ref SCIP_STAGE_PRESOLVING
15764  * - \ref SCIP_STAGE_SOLVING
15765  *
15766  * @note The collection of variable statistics is turned off during probing. If these statistics should be collected
15767  * during probing use the method SCIPenableVarHistory() to turn the collection explicitly on.
15768  */
15769 extern
15771  SCIP* scip /**< SCIP data structure */
15772  );
15773 
15774 /** creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path
15775  * with a call to SCIPbacktrackProbing();
15776  * using a sub node for each set of probing bound changes can improve conflict analysis
15777  *
15778  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15779  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15780  *
15781  * @pre This method can be called if @p scip is in one of the following stages:
15782  * - \ref SCIP_STAGE_PRESOLVING
15783  * - \ref SCIP_STAGE_SOLVING
15784  */
15785 extern
15787  SCIP* scip /**< SCIP data structure */
15788  );
15789 
15790 /** returns the current probing depth
15791  *
15792  * @return the probing depth, i.e. the number of probing sub nodes existing in the probing path
15793  *
15794  * @pre This method can be called if @p scip is in one of the following stages:
15795  * - \ref SCIP_STAGE_PRESOLVING
15796  * - \ref SCIP_STAGE_SOLVING
15797  */
15798 extern
15800  SCIP* scip /**< SCIP data structure */
15801  );
15802 
15803 /** undoes all changes to the problem applied in probing up to the given probing depth;
15804  * the changes of the probing node of the given probing depth are the last ones that remain active;
15805  * changes that were applied before calling SCIPnewProbingNode() cannot be undone
15806  *
15807  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15808  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15809  *
15810  * @pre This method can be called if @p scip is in one of the following stages:
15811  * - \ref SCIP_STAGE_PRESOLVING
15812  * - \ref SCIP_STAGE_SOLVING
15813  */
15814 extern
15816  SCIP* scip, /**< SCIP data structure */
15817  int probingdepth /**< probing depth of the node in the probing path that should be reactivated */
15818  );
15819 
15820 /** quits probing and resets bounds and constraints to the focus node's environment
15821  *
15822  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15823  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15824  *
15825  * @pre This method can be called if @p scip is in one of the following stages:
15826  * - \ref SCIP_STAGE_PRESOLVING
15827  * - \ref SCIP_STAGE_SOLVING
15828  */
15829 extern
15831  SCIP* scip /**< SCIP data structure */
15832  );
15833 
15834 /** injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to
15835  * SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
15836  *
15837  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15838  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15839  *
15840  * @pre This method can be called if @p scip is in one of the following stages:
15841  * - \ref SCIP_STAGE_PRESOLVING
15842  * - \ref SCIP_STAGE_SOLVING
15843  */
15844 extern
15846  SCIP* scip, /**< SCIP data structure */
15847  SCIP_VAR* var, /**< variable to change the bound for */
15848  SCIP_Real newbound /**< new value for bound */
15849  );
15850 
15851 /** injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to
15852  * SCIPchgVarUb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
15853  *
15854  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15855  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15856  *
15857  * @pre This method can be called if @p scip is in one of the following stages:
15858  * - \ref SCIP_STAGE_PRESOLVING
15859  * - \ref SCIP_STAGE_SOLVING
15860  */
15861 extern
15863  SCIP* scip, /**< SCIP data structure */
15864  SCIP_VAR* var, /**< variable to change the bound for */
15865  SCIP_Real newbound /**< new value for bound */
15866  );
15867 
15868 /** gets variable's objective value in current probing
15869  *
15870  * @return the variable's objective value in current probing.
15871  *
15872  * @pre This method can be called if @p scip is in one of the following stages:
15873  * - \ref SCIP_STAGE_SOLVING
15874  *
15875  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15876  */
15877 extern
15879  SCIP* scip, /**< SCIP data structure */
15880  SCIP_VAR* var /**< variable to get the bound for */
15881  );
15882 
15883 /** injects a change of variable's bounds into current probing node to fix the variable to the specified value;
15884  * the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated
15885  * like deductions instead of branching decisions
15886  *
15887  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15888  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15889  *
15890  * @pre This method can be called if @p scip is in one of the following stages:
15891  * - \ref SCIP_STAGE_PRESOLVING
15892  * - \ref SCIP_STAGE_SOLVING
15893  */
15894 extern
15896  SCIP* scip, /**< SCIP data structure */
15897  SCIP_VAR* var, /**< variable to change the bound for */
15898  SCIP_Real fixedval /**< value to fix variable to */
15899  );
15900 
15901 /** changes (column) variable's objective value during probing mode
15902  *
15903  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15904  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15905  *
15906  * @pre This method can be called if @p scip is in one of the following stages:
15907  * - \ref SCIP_STAGE_PRESOLVING
15908  * - \ref SCIP_STAGE_SOLVING
15909  *
15910  * @pre The variable needs to be a column variable.
15911  */
15912 extern
15914  SCIP* scip, /**< SCIP data structure */
15915  SCIP_VAR* var, /**< variable to change the objective for */
15916  SCIP_Real newobj /**< new objective function value */
15917  );
15918 
15919 /** returns whether the objective function has changed during probing mode
15920  *
15921  * @return \ref TRUE if objective has changed, \ref FALSE otherwise
15922  *
15923  * @note this function should not be used during probing mode when some objective coefficients have been changed via
15924  * SCIPchgVarObjProbing()
15925  *
15926  * @pre This method can be called if @p scip is in one of the following stages:
15927  * - \ref SCIP_STAGE_TRANSFORMED
15928  * - \ref SCIP_STAGE_INITPRESOLVE
15929  * - \ref SCIP_STAGE_PRESOLVING
15930  * - \ref SCIP_STAGE_EXITPRESOLVE
15931  * - \ref SCIP_STAGE_PRESOLVED
15932  * - \ref SCIP_STAGE_INITSOLVE
15933  * - \ref SCIP_STAGE_SOLVING
15934  * - \ref SCIP_STAGE_SOLVED
15935  * - \ref SCIP_STAGE_EXITSOLVE
15936  */
15937 extern
15939  SCIP* scip /**< SCIP data structure */
15940  );
15941 
15942 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
15943  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
15944  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
15945  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
15946  *
15947  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15948  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15949  *
15950  * @pre This method can be called if @p scip is in one of the following stages:
15951  * - \ref SCIP_STAGE_PRESOLVING
15952  * - \ref SCIP_STAGE_SOLVING
15953  */
15954 extern
15956  SCIP* scip, /**< SCIP data structure */
15957  int maxproprounds, /**< maximal number of propagation rounds (-1: no limit, 0: parameter settings) */
15958  SCIP_Bool* cutoff, /**< pointer to store whether the probing node can be cut off */
15959  SCIP_Longint* ndomredsfound /**< pointer to store the number of domain reductions found, or NULL */
15960  );
15961 
15962 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
15963  * only propagations of the binary variables fixed at the current probing node that are triggered by the implication
15964  * graph and the clique table are applied;
15965  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
15966  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
15967  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
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_PRESOLVING
15974  * - \ref SCIP_STAGE_SOLVING
15975  */
15976 extern
15978  SCIP* scip, /**< SCIP data structure */
15979  SCIP_Bool* cutoff /**< pointer to store whether the probing node can be cut off */
15980  );
15981 
15982 /** solves the LP at the current probing node (cannot be applied at preprocessing stage);
15983  * no separation or pricing is applied
15984  *
15985  * The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()).
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  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
15997  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
15998  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
15999  * limit was reached (or NULL, if not needed) */
16000  );
16001 
16002 /** solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing
16003  * until the LP is solved to optimality; no separation is applied
16004  *
16005  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See \ref
16006  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16007  *
16008  * @pre This method can be called if @p scip is in one of the following stages:
16009  * - \ref SCIP_STAGE_SOLVING
16010  */
16011 extern
16013  SCIP* scip, /**< SCIP data structure */
16014  SCIP_Bool pretendroot, /**< should the pricers be called as if we are at the root node? */
16015  SCIP_Bool displayinfo, /**< should info lines be displayed after each pricing round? */
16016  int maxpricerounds, /**< maximal number of pricing rounds (-1: no limit);
16017  * a finite limit means that the LP might not be solved to optimality! */
16018  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
16019  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
16020  * limit was reached (or NULL, if not needed) */
16021 
16022  );
16023 
16024 /** adds a row to the LP in the current probing node
16025  *
16026  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16027  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16028  *
16029  * @pre This method can be called if @p scip is in one of the following stages:
16030  * - \ref SCIP_STAGE_SOLVING
16031  *
16032  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16033  */
16034 extern
16036  SCIP* scip, /**< SCIP data structure */
16037  SCIP_ROW* row /**< row to be added */
16038  );
16039 
16040 /** applies the cuts in the separation storage to the LP and clears the storage afterwards;
16041  * this method can only be applied during probing; the user should resolve the probing LP afterwards
16042  * in order to get a new solution
16043  *
16044  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16045  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16046  *
16047  * @pre This method can be called if @p scip is in one of the following stages:
16048  * - \ref SCIP_STAGE_SOLVING
16049  */
16050 extern
16052  SCIP* scip, /**< SCIP data structure */
16053  SCIP_Bool* cutoff /**< pointer to store whether an empty domain was created */
16054  );
16055 
16056 /** solves relaxation(s) at the current probing node (cannot be applied at preprocessing stage);
16057  * no separation or pricing is applied
16058  *
16059  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16060  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16061  *
16062  * @pre This method can be called if @p scip is in one of the following stages:
16063  * - \ref SCIP_STAGE_SOLVING
16064  */
16065 extern
16067  SCIP* scip, /**< SCIP data structure */
16068  SCIP_Bool* cutoff /**< pointer to store whether a relaxation was infeasible or the objective
16069  * limit was reached (or NULL, if not needed) */
16070  );
16071 
16072 /** stores the candidate score and preferred rounding direction for a candidate variable */
16073 extern
16075  SCIP* scip, /**< SCIP data structure */
16076  SCIP_DIVESET* diveset, /**< general diving settings */
16077  SCIP_DIVETYPE divetype, /**< represents different methods for a dive set to explore the next children */
16078  SCIP_VAR* divecand, /**< the candidate for which the branching direction is requested */
16079  SCIP_Real divecandsol, /**< LP solution value of the candidate */
16080  SCIP_Real divecandfrac, /**< fractionality of the candidate */
16081  SCIP_Real* candscore, /**< pointer to store the candidate score */
16082  SCIP_Bool* roundup /**< pointer to store whether preferred direction for diving is upwards */
16083  );
16084 
16085 /** update diveset LP statistics, should be called after every LP solved by this diving heuristic */
16086 extern
16088  SCIP* scip, /**< SCIP data structure */
16089  SCIP_DIVESET* diveset, /**< diving settings */
16090  SCIP_Longint niterstoadd /**< additional number of LP iterations to be added */
16091  );
16092 
16093 /** update diveset statistics and global diveset statistics */
16094 extern
16096  SCIP* scip, /**< SCIP data structure */
16097  SCIP_DIVESET* diveset, /**< diveset to be reset */
16098  int nprobingnodes, /**< the number of probing nodes explored this time */
16099  int nbacktracks, /**< the number of backtracks during probing this time */
16100  SCIP_Longint nsolsfound, /**< the number of solutions found */
16101  SCIP_Longint nbestsolsfound, /**< the number of best solutions found */
16102  SCIP_Bool leavewassol /**< was a solution found at the leaf? */
16103  );
16104 
16105 /** enforces a probing/diving solution by suggesting bound changes that maximize the score w.r.t. the current diving settings
16106  *
16107  * the process is guided by the enforcement priorities of the constraint handlers and the scoring mechanism provided by
16108  * the dive set.
16109  * Constraint handlers may suggest diving bound changes in decreasing order of their enforcement priority, based on the
16110  * solution values in the solution @p sol and the current local bounds of the variables. A diving bound change
16111  * is a triple (variable,branching direction,value) and is used inside SCIPperformGenericDivingAlgorithm().
16112  *
16113  * After a successful call, SCIP holds two arrays of suggested dive bound changes, one for the preferred child
16114  * and one for the alternative.
16115  *
16116  * @see SCIPgetDiveBoundChangeData() for retrieving the dive bound change suggestions.
16117  *
16118  * The method stops after the first constraint handler was successful
16119  *
16120  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16121  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16122  *
16123  * @pre This method can be called if @p scip is in one of the following stages:
16124  * - \ref SCIP_STAGE_SOLVING
16125  *
16126  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16127  */
16128 extern
16130  SCIP* scip, /**< SCIP data structure */
16131  SCIP_DIVESET* diveset, /**< diving settings to control scoring */
16132  SCIP_SOL* sol, /**< current solution of diving mode */
16133  SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */
16134  SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */
16135  );
16136 
16137 /** adds a diving bound change to the diving bound change storage of SCIP together with the information if this is a
16138  * bound change for the preferred direction or not
16139  *
16140  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16141  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16142  *
16143  * @pre This method can be called if @p scip is in one of the following stages:
16144  * - \ref SCIP_STAGE_SOLVING
16145  *
16146  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16147  */
16148 extern
16150  SCIP* scip, /**< SCIP data structure */
16151  SCIP_VAR* var, /**< variable to apply the bound change to */
16152  SCIP_BRANCHDIR dir, /**< direction of the bound change */
16153  SCIP_Real value, /**< value to adjust this variable bound to */
16154  SCIP_Bool preferred /**< is this a bound change for the preferred child? */
16155  );
16156 
16157 /** get the dive bound change data for the preferred or the alternative direction
16158  *
16159  * @pre This method can be called if @p scip is in one of the following stages:
16160  * - \ref SCIP_STAGE_SOLVING
16161  *
16162  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16163  */
16164 extern
16166  SCIP* scip, /**< SCIP data structure */
16167  SCIP_VAR*** variables, /**< pointer to store variables for the specified direction */
16168  SCIP_BRANCHDIR** directions, /**< pointer to store the branching directions */
16169  SCIP_Real** values, /**< pointer to store bound change values */
16170  int* ndivebdchgs, /**< pointer to store the number of dive bound changes */
16171  SCIP_Bool preferred /**< should the dive bound changes for the preferred child be output? */
16172  );
16173 
16174 /** clear the dive bound change data structures
16175  *
16176  * @pre This method can be called if @p scip is in one of the following stages:
16177  * - \ref SCIP_STAGE_SOLVING
16178  *
16179  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16180  */
16181 extern
16183  SCIP* scip /**< SCIP data structure */
16184  );
16185 
16186 /**@} */
16187 
16188 /*
16189  * branching methods
16190  */
16191 
16192 /**@addtogroup PublicBranchingMethods
16193  *
16194  * @{
16195  */
16196 
16197 /** gets branching candidates for LP solution branching (fractional variables) along with solution values,
16198  * fractionalities, and number of branching candidates; The number of branching candidates does NOT
16199  * account for fractional implicit integer variables which should not be used for branching decisions.
16200  *
16201  * Fractional implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1
16202  *
16203  * branching rules should always select the branching candidate among the first npriolpcands of the candidate
16204  * list
16205  *
16206  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16207  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16208  *
16209  * @pre This method can be called if @p scip is in one of the following stages:
16210  * - \ref SCIP_STAGE_SOLVING
16211  *
16212  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16213  */
16214 extern
16216  SCIP* scip, /**< SCIP data structure */
16217  SCIP_VAR*** lpcands, /**< pointer to store the array of LP branching candidates, or NULL */
16218  SCIP_Real** lpcandssol, /**< pointer to store the array of LP candidate solution values, or NULL */
16219  SCIP_Real** lpcandsfrac, /**< pointer to store the array of LP candidate fractionalities, or NULL */
16220  int* nlpcands, /**< pointer to store the number of LP branching candidates, or NULL */
16221  int* npriolpcands, /**< pointer to store the number of candidates with maximal priority, or NULL */
16222  int* nfracimplvars /**< pointer to store the number of fractional implicit integer variables, or NULL */
16223  );
16224 
16225 /** gets number of branching candidates for LP solution branching (number of fractional variables)
16226  *
16227  * @return the number of branching candidates for LP solution branching (number of fractional variables).
16228  *
16229  * @pre This method can be called if @p scip is in one of the following stages:
16230  * - \ref SCIP_STAGE_SOLVING
16231  *
16232  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16233  */
16234 extern
16236  SCIP* scip /**< SCIP data structure */
16237  );
16238 
16239 /** gets number of branching candidates with maximal priority for LP solution branching
16240  *
16241  * @return the number of branching candidates with maximal priority for LP solution branching.
16242  *
16243  * @pre This method can be called if @p scip is in one of the following stages:
16244  * - \ref SCIP_STAGE_SOLVING
16245  *
16246  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16247  */
16248 extern
16250  SCIP* scip /**< SCIP data structure */
16251  );
16252 
16253 /** gets external branching candidates along with solution values, scores, and number of branching candidates;
16254  * these branching candidates can be used by relaxations or nonlinear constraint handlers;
16255  * branching rules should always select the branching candidate among the first nprioexterncands of the candidate
16256  * list
16257  *
16258  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16259  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16260  *
16261  * @pre This method can be called if @p scip is in one of the following stages:
16262  * - \ref SCIP_STAGE_SOLVING
16263  *
16264  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16265  *
16266  * @note Candidate variables with maximal priority are ordered: binaries first, then integers, implicit integers and
16267  * continuous last.
16268  */
16269 extern
16271  SCIP* scip, /**< SCIP data structure */
16272  SCIP_VAR*** externcands, /**< pointer to store the array of extern branching candidates, or NULL */
16273  SCIP_Real** externcandssol, /**< pointer to store the array of extern candidate solution values, or NULL */
16274  SCIP_Real** externcandsscore, /**< pointer to store the array of extern candidate scores, or NULL */
16275  int* nexterncands, /**< pointer to store the number of extern branching candidates, or NULL */
16276  int* nprioexterncands, /**< pointer to store the number of candidates with maximal priority, or NULL */
16277  int* nprioexternbins, /**< pointer to store the number of binary candidates with maximal priority, or NULL */
16278  int* nprioexternints, /**< pointer to store the number of integer candidates with maximal priority, or NULL */
16279  int* nprioexternimpls /**< pointer to store the number of implicit integer candidates with maximal priority,
16280  * or NULL */
16281  );
16282 
16283 /** gets number of external branching candidates
16284  *
16285  * @return the number of external branching candidates.
16286  *
16287  * @pre This method can be called if @p scip is in one of the following stages:
16288  * - \ref SCIP_STAGE_SOLVING
16289  *
16290  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16291  */
16292 extern
16294  SCIP* scip /**< SCIP data structure */
16295  );
16296 
16297 /** gets number of external branching candidates with maximal branch priority
16298  *
16299  * @return the number of external branching candidates with maximal branch priority.
16300  *
16301  * @pre This method can be called if @p scip is in one of the following stages:
16302  * - \ref SCIP_STAGE_SOLVING
16303  *
16304  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16305  */
16306 extern
16308  SCIP* scip /**< SCIP data structure */
16309  );
16310 
16311 /** gets number of binary external branching candidates with maximal branch priority
16312  *
16313  * @return the number of binary external branching candidates with maximal branch priority.
16314  *
16315  * @pre This method can be called if @p scip is in one of the following stages:
16316  * - \ref SCIP_STAGE_SOLVING
16317  *
16318  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16319  */
16320 extern
16322  SCIP* scip /**< SCIP data structure */
16323  );
16324 
16325 /** gets number of integer external branching candidates with maximal branch priority
16326  *
16327  * @return the number of integer external branching candidates with maximal branch priority.
16328  *
16329  * @pre This method can be called if @p scip is in one of the following stages:
16330  * - \ref SCIP_STAGE_SOLVING
16331  *
16332  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16333  */
16334 extern
16336  SCIP* scip /**< SCIP data structure */
16337  );
16338 
16339 /** gets number of implicit integer external branching candidates with maximal branch priority
16340  *
16341  * @return the number of implicit integer external branching candidates with maximal branch priority.
16342  *
16343  * @pre This method can be called if @p scip is in one of the following stages:
16344  * - \ref SCIP_STAGE_SOLVING
16345  *
16346  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16347  */
16348 extern
16350  SCIP* scip /**< SCIP data structure */
16351  );
16352 
16353 /** gets number of continuous external branching candidates with maximal branch priority
16354  *
16355  * @return the number of continuous external branching candidates with maximal branch priority.
16356  *
16357  * @pre This method can be called if @p scip is in one of the following stages:
16358  * - \ref SCIP_STAGE_SOLVING
16359  *
16360  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16361  */
16362 extern
16364  SCIP* scip /**< SCIP data structure */
16365  );
16366 
16367 /** insert variable, its score and its solution value into the external branching candidate storage
16368  * the relative difference of the current lower and upper bounds of a continuous variable must be at least epsilon
16369  *
16370  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16371  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16372  *
16373  * @pre This method can be called if @p scip is in one of the following stages:
16374  * - \ref SCIP_STAGE_SOLVING
16375  *
16376  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16377  */
16378 extern
16380  SCIP* scip, /**< SCIP data structure */
16381  SCIP_VAR* var, /**< variable to insert */
16382  SCIP_Real score, /**< score of external candidate, e.g. infeasibility */
16383  SCIP_Real solval /**< value of the variable in the current solution */
16384  );
16385 
16386 /** removes all external candidates from the storage for external branching
16387  *
16388  * @pre This method can be called if @p scip is in one of the following stages:
16389  * - \ref SCIP_STAGE_SOLVING
16390  *
16391  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16392  */
16393 extern
16395  SCIP* scip /**< SCIP data structure */
16396  );
16397 
16398 /** checks whether the given variable is contained in the candidate storage for external branching
16399  *
16400  * @return whether the given variable is contained in the candidate storage for external branching.
16401  *
16402  * @pre This method can be called if @p scip is in one of the following stages:
16403  * - \ref SCIP_STAGE_SOLVING
16404  *
16405  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16406  */
16407 extern
16409  SCIP* scip, /**< SCIP data structure */
16410  SCIP_VAR* var /**< variable to look for */
16411  );
16412 
16413 /** gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates
16414  *
16415  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16416  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16417  *
16418  * @pre This method can be called if @p scip is in one of the following stages:
16419  * - \ref SCIP_STAGE_PRESOLVING
16420  * - \ref SCIP_STAGE_SOLVING
16421  *
16422  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16423  */
16424 extern
16426  SCIP* scip, /**< SCIP data structure */
16427  SCIP_VAR*** pseudocands, /**< pointer to store the array of pseudo branching candidates, or NULL */
16428  int* npseudocands, /**< pointer to store the number of pseudo branching candidates, or NULL */
16429  int* npriopseudocands /**< pointer to store the number of candidates with maximal priority, or NULL */
16430  );
16431 
16432 /** gets number of branching candidates for pseudo solution branching (non-fixed variables)
16433  *
16434  * @return the number branching candidates for pseudo solution branching (non-fixed variables).
16435  *
16436  * @pre This method can be called if @p scip is in one of the following stages:
16437  * - \ref SCIP_STAGE_PRESOLVING
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 /** gets number of branching candidates with maximal branch priority for pseudo solution branching
16448  *
16449  * @return the number of branching candidates with maximal branch priority for pseudo solution branching.
16450  *
16451  * @pre This method can be called if @p scip is in one of the following stages:
16452  * - \ref SCIP_STAGE_PRESOLVING
16453  * - \ref SCIP_STAGE_SOLVING
16454  *
16455  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16456  */
16457 extern
16459  SCIP* scip /**< SCIP data structure */
16460  );
16461 
16462 /** gets number of binary branching candidates with maximal branch priority for pseudo solution branching
16463  *
16464  * @return the number of binary branching candidates with maximal branch priority for pseudo solution branching.
16465  *
16466  * @pre This method can be called if @p scip is in one of the following stages:
16467  * - \ref SCIP_STAGE_SOLVING
16468  *
16469  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16470  */
16471 extern
16473  SCIP* scip /**< SCIP data structure */
16474  );
16475 
16476 /** gets number of integer branching candidates with maximal branch priority for pseudo solution branching
16477  *
16478  * @return the number of integer branching candidates with maximal branch priority for pseudo solution branching.
16479  *
16480  * @pre This method can be called if @p scip is in one of the following stages:
16481  * - \ref SCIP_STAGE_SOLVING
16482  *
16483  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16484  */
16485 extern
16487  SCIP* scip /**< SCIP data structure */
16488  );
16489 
16490 /** gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching
16491  *
16492  * @return the number of implicit integer branching candidates with maximal branch priority for pseudo solution branching.
16493  *
16494  * @pre This method can be called if @p scip is in one of the following stages:
16495  * - \ref SCIP_STAGE_SOLVING
16496  *
16497  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16498  */
16499 extern
16501  SCIP* scip /**< SCIP data structure */
16502  );
16503 
16504 /** calculates the branching score out of the gain predictions for a binary branching
16505  *
16506  * @return the branching score out of the gain predictions for a binary branching.
16507  *
16508  * @pre This method can be called if @p scip is in one of the following stages:
16509  * - \ref SCIP_STAGE_SOLVING
16510  *
16511  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16512  */
16513 extern
16515  SCIP* scip, /**< SCIP data structure */
16516  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
16517  SCIP_Real downgain, /**< prediction of objective gain for rounding downwards */
16518  SCIP_Real upgain /**< prediction of objective gain for rounding upwards */
16519  );
16520 
16521 /** calculates the branching score out of the gain predictions for a branching with arbitrary many children
16522  *
16523  * @return the branching score out of the gain predictions for a branching with arbitrary many children.
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, of which the branching factor should be applied, or NULL */
16534  int nchildren, /**< number of children that the branching will create */
16535  SCIP_Real* gains /**< prediction of objective gain for each child */
16536  );
16537 
16538 /** computes a branching point for a continuous or discrete variable
16539  *
16540  * @see SCIPbranchGetBranchingPoint
16541  *
16542  * @return the branching point for a continuous or discrete variable.
16543  *
16544  * @pre This method can be called if @p scip is in one of the following stages:
16545  * - \ref SCIP_STAGE_SOLVING
16546  *
16547  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16548  */
16549 extern
16551  SCIP* scip, /**< SCIP data structure */
16552  SCIP_VAR* var, /**< variable, of which the branching point should be computed */
16553  SCIP_Real suggestion /**< suggestion for branching point, or SCIP_INVALID if no suggestion */
16554  );
16555 
16556 /** calculates the node selection priority for moving the given variable's LP value to the given target value;
16557  * this node selection priority can be given to the SCIPcreateChild() call
16558  *
16559  * @return the node selection priority for moving the given variable's LP value to the given target value.
16560  *
16561  * @pre This method can be called if @p scip is in one of the following stages:
16562  * - \ref SCIP_STAGE_SOLVING
16563  *
16564  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16565  */
16566 extern
16568  SCIP* scip, /**< SCIP data structure */
16569  SCIP_VAR* var, /**< variable on which the branching is applied */
16570  SCIP_BRANCHDIR branchdir, /**< type of branching that was performed: upwards, downwards, or fixed;
16571  * fixed should only be used, when both bounds changed
16572  */
16573  SCIP_Real targetvalue /**< new value of the variable in the child node */
16574  );
16575 
16576 /** calculates an estimate for the objective of the best feasible solution contained in the subtree after applying the given
16577  * branching; this estimate can be given to the SCIPcreateChild() call
16578  *
16579  * @return the estimate for the objective of the best feasible solution contained in the subtree after applying the given
16580  * branching.
16581  *
16582  * @pre This method can be called if @p scip is in one of the following stages:
16583  * - \ref SCIP_STAGE_SOLVING
16584  *
16585  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16586  */
16587 extern
16589  SCIP* scip, /**< SCIP data structure */
16590  SCIP_VAR* var, /**< variable on which the branching is applied */
16591  SCIP_Real targetvalue /**< new value of the variable in the child node */
16592  );
16593 
16594 /** creates a child node of the focus node
16595  *
16596  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16597  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16598  *
16599  * @pre This method can be called if @p scip is in one of the following stages:
16600  * - \ref SCIP_STAGE_SOLVING
16601  *
16602  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16603  */
16604 extern
16606  SCIP* scip, /**< SCIP data structure */
16607  SCIP_NODE** node, /**< pointer to node data structure */
16608  SCIP_Real nodeselprio, /**< node selection priority of new node */
16609  SCIP_Real estimate /**< estimate for (transformed) objective value of best feasible solution in subtree */
16610  );
16611 
16612 /** branches on a non-continuous variable v using the current LP or pseudo solution;
16613  * if solution value x' is fractional, two child nodes will be created
16614  * (x <= floor(x'), x >= ceil(x')),
16615  * if solution value is integral, the x' is equal to lower or upper bound of the branching
16616  * variable and the bounds of v are finite, then two child nodes will be created
16617  * (x <= x'', x >= x''+1 with x'' = floor((lb + ub)/2)),
16618  * otherwise (up to) three child nodes will be created
16619  * (x <= x'-1, x == x', x >= x'+1)
16620  *
16621  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16622  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16623  *
16624  * @pre This method can be called if @p scip is in one of the following stages:
16625  * - \ref SCIP_STAGE_SOLVING
16626  *
16627  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16628  */
16629 extern
16631  SCIP* scip, /**< SCIP data structure */
16632  SCIP_VAR* var, /**< variable to branch on */
16633  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
16634  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
16635  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
16636  );
16637 
16638 /** branches a variable x using a given domain hole; two child nodes (x <= left, x >= right) are created
16639  *
16640  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16641  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16642  *
16643  * @pre This method can be called if @p scip is in one of the following stages:
16644  * - \ref SCIP_STAGE_SOLVING
16645  *
16646  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16647  */
16648 extern
16650  SCIP* scip, /**< SCIP data structure */
16651  SCIP_VAR* var, /**< variable to branch on */
16652  SCIP_Real left, /**< left side of the domain hole */
16653  SCIP_Real right, /**< right side of the domain hole */
16654  SCIP_NODE** downchild, /**< pointer to return the left child (x <= left), or NULL */
16655  SCIP_NODE** upchild /**< pointer to return the right child (x >= right), or NULL */
16656  );
16657 
16658 /** branches on a variable x using a given value x';
16659  * for continuous variables with relative domain width larger epsilon, x' must not be one of the bounds;
16660  * two child nodes (x <= x', x >= x') are created;
16661  * for integer variables, if solution value x' is fractional, two child nodes are created
16662  * (x <= floor(x'), x >= ceil(x')),
16663  * if x' is integral, three child nodes are created
16664  * (x <= x'-1, x == x', x >= x'+1)
16665  *
16666  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16667  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16668  *
16669  * @pre This method can be called if @p scip is in one of the following stages:
16670  * - \ref SCIP_STAGE_SOLVING
16671  *
16672  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16673  */
16674 extern
16676  SCIP* scip, /**< SCIP data structure */
16677  SCIP_VAR* var, /**< variable to branch on */
16678  SCIP_Real val, /**< value to branch on */
16679  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
16680  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
16681  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
16682  );
16683 
16684 /** n-ary branching on a variable x using a given value
16685  *
16686  * Branches on variable x such that up to n/2 children are created on each side of the usual branching value.
16687  * The branching value is selected as in SCIPbranchVarVal().
16688  * The parameters minwidth and widthfactor determine the domain width of the branching variable in the child nodes.
16689  * If n is odd, one child with domain width 'width' and having the branching value in the middle is created.
16690  * Otherwise, two children with domain width 'width' and being left and right of the branching value are created.
16691  * Next further nodes to the left and right are created, where width is multiplied by widthfactor with increasing distance
16692  * from the first nodes.
16693  * The initial width is calculated such that n/2 nodes are created to the left and to the right of the branching value.
16694  * If this value is below minwidth, the initial width is set to minwidth, which may result in creating less than n nodes.
16695  *
16696  * Giving a large value for widthfactor results in creating children with small domain when close to the branching value
16697  * and large domain when closer to the current variable bounds. That is, setting widthfactor to a very large value and n to 3
16698  * results in a ternary branching where the branching variable is mostly fixed in the middle child.
16699  * Setting widthfactor to 1.0 results in children where the branching variable always has the same domain width
16700  * (except for one child if the branching value is not in the middle).
16701  *
16702  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16703  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16704  *
16705  * @pre This method can be called if @p scip is in one of the following stages:
16706  * - \ref SCIP_STAGE_SOLVING
16707  *
16708  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16709  */
16710 extern
16712  SCIP* scip, /**< SCIP data structure */
16713  SCIP_VAR* var, /**< variable to branch on */
16714  SCIP_Real val, /**< value to branch on */
16715  int n, /**< attempted number of children to be created, must be >= 2 */
16716  SCIP_Real minwidth, /**< minimal domain width in children */
16717  SCIP_Real widthfactor, /**< multiplier for children domain width with increasing distance from val, must be >= 1.0 */
16718  int* nchildren /**< pointer to store number of created children, or NULL */
16719  );
16720 
16721 /** calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN;
16722  * if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional
16723  * variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority
16724  *
16725  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16726  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16727  *
16728  * @pre This method can be called if @p scip is in one of the following stages:
16729  * - \ref SCIP_STAGE_SOLVING
16730  *
16731  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16732  */
16733 extern
16735  SCIP* scip, /**< SCIP data structure */
16736  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16737  );
16738 
16739 /** calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN
16740  *
16741  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16742  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16743  *
16744  * @pre This method can be called if @p scip is in one of the following stages:
16745  * - \ref SCIP_STAGE_SOLVING
16746  *
16747  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16748  */
16749 extern
16751  SCIP* scip, /**< SCIP data structure */
16752  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16753  );
16754 
16755 /** calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN
16756  *
16757  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16758  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16759  *
16760  * @pre This method can be called if @p scip is in one of the following stages:
16761  * - \ref SCIP_STAGE_SOLVING
16762  *
16763  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
16764  */
16765 extern
16767  SCIP* scip, /**< SCIP data structure */
16768  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
16769  );
16770 
16771 /**@} */
16772 
16773 
16774 
16775 
16776 /*
16777  * primal solutions
16778  */
16779 
16780 /**@addtogroup PublicSolutionMethods
16781  *
16782  * @{
16783  */
16784 
16785 /** creates a primal solution, initialized to zero
16786  *
16787  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16788  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16789  *
16790  * @pre This method can be called if SCIP is in one of the following stages:
16791  * - \ref SCIP_STAGE_PROBLEM
16792  * - \ref SCIP_STAGE_TRANSFORMING
16793  * - \ref SCIP_STAGE_TRANSFORMED
16794  * - \ref SCIP_STAGE_INITPRESOLVE
16795  * - \ref SCIP_STAGE_PRESOLVING
16796  * - \ref SCIP_STAGE_EXITPRESOLVE
16797  * - \ref SCIP_STAGE_PRESOLVED
16798  * - \ref SCIP_STAGE_INITSOLVE
16799  * - \ref SCIP_STAGE_SOLVING
16800  */
16801 extern
16803  SCIP* scip, /**< SCIP data structure */
16804  SCIP_SOL** sol, /**< pointer to store the solution */
16805  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16806  );
16807 
16808 /** creates a primal solution, initialized to the current LP solution
16809  *
16810  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16811  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16812  *
16813  * @pre This method can be called if SCIP is in one of the following stages:
16814  * - \ref SCIP_STAGE_SOLVING
16815  */
16816 extern
16818  SCIP* scip, /**< SCIP data structure */
16819  SCIP_SOL** sol, /**< pointer to store the solution */
16820  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16821  );
16822 
16823 /** creates a primal solution, initialized to the current NLP solution
16824  *
16825  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16826  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16827  *
16828  * @pre This method can be called if SCIP is in one of the following stages:
16829  * - \ref SCIP_STAGE_SOLVING
16830  */
16831 extern
16833  SCIP* scip, /**< SCIP data structure */
16834  SCIP_SOL** sol, /**< pointer to store the solution */
16835  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16836  );
16837 
16838 /** creates a primal solution, initialized to the current relaxation solution
16839  *
16840  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16841  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16842  *
16843  * @pre This method can be called if SCIP is in one of the following stages:
16844  * - \ref SCIP_STAGE_SOLVING
16845  */
16846 extern
16848  SCIP* scip, /**< SCIP data structure */
16849  SCIP_SOL** sol, /**< pointer to store the solution */
16850  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16851  );
16852 
16853 /** creates a primal solution, initialized to the current pseudo solution
16854  *
16855  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16856  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16857  *
16858  * @pre This method can be called if SCIP is in one of the following stages:
16859  * - \ref SCIP_STAGE_SOLVING
16860  */
16861 extern
16863  SCIP* scip, /**< SCIP data structure */
16864  SCIP_SOL** sol, /**< pointer to store the solution */
16865  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16866  );
16867 
16868 /** creates a primal solution, initialized to the current LP or pseudo solution, depending on whether the LP was solved
16869  * at the current node
16870  *
16871  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16872  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16873  *
16874  * @pre This method can be called if SCIP is in one of the following stages:
16875  * - \ref SCIP_STAGE_SOLVING
16876  */
16877 extern
16879  SCIP* scip, /**< SCIP data structure */
16880  SCIP_SOL** sol, /**< pointer to store the solution */
16881  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16882  );
16883 
16884 /** creates a partial primal solution, initialized to unknown values
16885  *
16886  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16887  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16888  *
16889  * @pre This method can be called if SCIP is in one of the following stages:
16890  * - \ref SCIP_STAGE_PROBLEM
16891  */
16892 extern
16894  SCIP* scip, /**< SCIP data structure */
16895  SCIP_SOL** sol, /**< pointer to store the solution */
16896  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16897  );
16898 
16899 /** creates a primal solution, initialized to unknown values
16900  *
16901  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16902  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16903  *
16904  * @pre This method can be called if SCIP is in one of the following stages:
16905  * - \ref SCIP_STAGE_TRANSFORMING
16906  * - \ref SCIP_STAGE_TRANSFORMED
16907  * - \ref SCIP_STAGE_INITPRESOLVE
16908  * - \ref SCIP_STAGE_PRESOLVING
16909  * - \ref SCIP_STAGE_EXITPRESOLVE
16910  * - \ref SCIP_STAGE_PRESOLVED
16911  * - \ref SCIP_STAGE_INITSOLVE
16912  * - \ref SCIP_STAGE_SOLVING
16913  */
16914 extern
16916  SCIP* scip, /**< SCIP data structure */
16917  SCIP_SOL** sol, /**< pointer to store the solution */
16918  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16919  );
16920 
16921 /** creates a primal solution living in the original problem space, initialized to zero;
16922  * a solution in original space allows to set original variables to values that would be invalid in the
16923  * transformed problem due to preprocessing fixings or aggregations
16924  *
16925  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16926  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16927  *
16928  * @pre This method can be called if SCIP is in one of the following stages:
16929  * - \ref SCIP_STAGE_PROBLEM
16930  * - \ref SCIP_STAGE_TRANSFORMING
16931  * - \ref SCIP_STAGE_TRANSFORMED
16932  * - \ref SCIP_STAGE_INITPRESOLVE
16933  * - \ref SCIP_STAGE_PRESOLVING
16934  * - \ref SCIP_STAGE_EXITPRESOLVE
16935  * - \ref SCIP_STAGE_PRESOLVED
16936  * - \ref SCIP_STAGE_INITSOLVE
16937  * - \ref SCIP_STAGE_SOLVING
16938  */
16939 extern
16941  SCIP* scip, /**< SCIP data structure */
16942  SCIP_SOL** sol, /**< pointer to store the solution */
16943  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
16944  );
16945 
16946 /** creates a copy of a primal solution; note that a copy of a linked solution is also linked and needs to be unlinked
16947  * if it should stay unaffected from changes in the LP or pseudo solution
16948  *
16949  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16950  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16951  *
16952  * @pre This method can be called if SCIP is in one of the following stages:
16953  * - \ref SCIP_STAGE_PROBLEM
16954  * - \ref SCIP_STAGE_TRANSFORMING
16955  * - \ref SCIP_STAGE_TRANSFORMED
16956  * - \ref SCIP_STAGE_INITPRESOLVE
16957  * - \ref SCIP_STAGE_PRESOLVING
16958  * - \ref SCIP_STAGE_EXITPRESOLVE
16959  * - \ref SCIP_STAGE_PRESOLVED
16960  * - \ref SCIP_STAGE_INITSOLVE
16961  * - \ref SCIP_STAGE_SOLVING
16962  */
16963 extern
16965  SCIP* scip, /**< SCIP data structure */
16966  SCIP_SOL** sol, /**< pointer to store the solution */
16967  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
16968  );
16969 
16970 /** creates a copy of a solution in the original primal solution space
16971  *
16972  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16973  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16974  *
16975  * @pre This method can be called if SCIP is in one of the following stages:
16976  * - \ref SCIP_STAGE_PROBLEM
16977  * - \ref SCIP_STAGE_TRANSFORMING
16978  * - \ref SCIP_STAGE_TRANSFORMED
16979  * - \ref SCIP_STAGE_INITPRESOLVE
16980  * - \ref SCIP_STAGE_PRESOLVING
16981  * - \ref SCIP_STAGE_EXITPRESOLVE
16982  * - \ref SCIP_STAGE_PRESOLVED
16983  * - \ref SCIP_STAGE_INITSOLVE
16984  * - \ref SCIP_STAGE_SOLVING
16985  * - \ref SCIP_STAGE_SOLVED
16986  * - \ref SCIP_STAGE_EXITSOLVE
16987  * - \ref SCIP_STAGE_FREETRANS
16988  */
16989 extern
16991  SCIP* scip, /**< SCIP data structure */
16992  SCIP_SOL** sol, /**< pointer to store the solution */
16993  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
16994  );
16995 
16996 /** creates a copy of a primal solution, thereby replacing infinite fixings of variables by finite values;
16997  * the copy is always defined in the original variable space;
16998  * success indicates whether the objective value of the solution was changed by removing infinite values
16999  *
17000  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17001  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17002  *
17003  * @pre This method can be called if SCIP is in one of the following stages:
17004  * - \ref SCIP_STAGE_PROBLEM
17005  * - \ref SCIP_STAGE_TRANSFORMING
17006  * - \ref SCIP_STAGE_TRANSFORMED
17007  * - \ref SCIP_STAGE_INITPRESOLVE
17008  * - \ref SCIP_STAGE_PRESOLVING
17009  * - \ref SCIP_STAGE_EXITPRESOLVE
17010  * - \ref SCIP_STAGE_PRESOLVED
17011  * - \ref SCIP_STAGE_INITSOLVE
17012  * - \ref SCIP_STAGE_SOLVING
17013  * - \ref SCIP_STAGE_SOLVED
17014  * - \ref SCIP_STAGE_EXITSOLVE
17015  */
17016 extern
17018  SCIP* scip, /**< SCIP data structure */
17019  SCIP_SOL** sol, /**< pointer to store the solution */
17020  SCIP_SOL* sourcesol, /**< primal CIP solution to copy */
17021  SCIP_Bool* success /**< does the finite solution have the same objective value? */
17022  );
17023 
17024 /** frees primal CIP solution
17025  *
17026  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17027  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17028  *
17029  * @pre This method can be called if SCIP is in one of the following stages:
17030  * - \ref SCIP_STAGE_PROBLEM
17031  * - \ref SCIP_STAGE_TRANSFORMING
17032  * - \ref SCIP_STAGE_TRANSFORMED
17033  * - \ref SCIP_STAGE_INITPRESOLVE
17034  * - \ref SCIP_STAGE_PRESOLVING
17035  * - \ref SCIP_STAGE_EXITPRESOLVE
17036  * - \ref SCIP_STAGE_PRESOLVED
17037  * - \ref SCIP_STAGE_INITSOLVE
17038  * - \ref SCIP_STAGE_SOLVING
17039  * - \ref SCIP_STAGE_SOLVED
17040  * - \ref SCIP_STAGE_EXITSOLVE
17041  * - \ref SCIP_STAGE_FREETRANS
17042  */
17043 extern
17045  SCIP* scip, /**< SCIP data structure */
17046  SCIP_SOL** sol /**< pointer to the solution */
17047  );
17048 
17049 /** links a primal solution to the current LP 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 /** links a primal solution to the current NLP 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_SOLVING
17070  */
17071 extern
17073  SCIP* scip, /**< SCIP data structure */
17074  SCIP_SOL* sol /**< primal solution */
17075  );
17076 
17077 /** links a primal solution to the current relaxation solution
17078  *
17079  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17080  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17081  *
17082  * @pre This method can be called if SCIP is in one of the following stages:
17083  * - \ref SCIP_STAGE_SOLVING
17084  */
17085 extern
17087  SCIP* scip, /**< SCIP data structure */
17088  SCIP_SOL* sol /**< primal solution */
17089  );
17090 
17091 /** links a primal solution to the current pseudo solution
17092  *
17093  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17094  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17095  *
17096  * @pre This method can be called if SCIP is in one of the following stages:
17097  * - \ref SCIP_STAGE_PRESOLVING
17098  * - \ref SCIP_STAGE_SOLVING
17099  */
17100 extern
17102  SCIP* scip, /**< SCIP data structure */
17103  SCIP_SOL* sol /**< primal solution */
17104  );
17105 
17106 /** links a primal solution to the current LP or pseudo solution
17107  *
17108  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17109  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17110  *
17111  * @pre This method can be called if SCIP is in one of the following stages:
17112  * - \ref SCIP_STAGE_SOLVING
17113  */
17114 extern
17116  SCIP* scip, /**< SCIP data structure */
17117  SCIP_SOL* sol /**< primal solution */
17118  );
17119 
17120 /** clears a primal solution
17121  *
17122  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17123  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17124  *
17125  * @pre This method can be called if SCIP is in one of the following stages:
17126  * - \ref SCIP_STAGE_PROBLEM
17127  * - \ref SCIP_STAGE_TRANSFORMING
17128  * - \ref SCIP_STAGE_TRANSFORMED
17129  * - \ref SCIP_STAGE_INITPRESOLVE
17130  * - \ref SCIP_STAGE_PRESOLVING
17131  * - \ref SCIP_STAGE_EXITPRESOLVE
17132  * - \ref SCIP_STAGE_PRESOLVED
17133  * - \ref SCIP_STAGE_INITSOLVE
17134  * - \ref SCIP_STAGE_SOLVING
17135  * - \ref SCIP_STAGE_SOLVED
17136  * - \ref SCIP_STAGE_EXITSOLVE
17137  * - \ref SCIP_STAGE_FREETRANS
17138  */
17139 extern
17141  SCIP* scip, /**< SCIP data structure */
17142  SCIP_SOL* sol /**< primal solution */
17143  );
17144 
17145 /** stores solution values of variables in solution's own array
17146  *
17147  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17148  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17149  *
17150  * @pre This method can be called if SCIP is in one of the following stages:
17151  * - \ref SCIP_STAGE_TRANSFORMING
17152  * - \ref SCIP_STAGE_TRANSFORMED
17153  * - \ref SCIP_STAGE_PRESOLVING
17154  * - \ref SCIP_STAGE_PRESOLVED
17155  * - \ref SCIP_STAGE_INITSOLVE
17156  * - \ref SCIP_STAGE_SOLVING
17157  * - \ref SCIP_STAGE_SOLVED
17158  * - \ref SCIP_STAGE_EXITSOLVE
17159  * - \ref SCIP_STAGE_FREETRANS
17160  */
17161 extern
17163  SCIP* scip, /**< SCIP data structure */
17164  SCIP_SOL* sol /**< primal solution */
17165  );
17166 
17167 /** sets value of variable in primal CIP solution
17168  *
17169  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17170  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17171  *
17172  * @pre This method can be called if SCIP is in one of the following stages:
17173  * - \ref SCIP_STAGE_PROBLEM
17174  * - \ref SCIP_STAGE_TRANSFORMING
17175  * - \ref SCIP_STAGE_TRANSFORMED
17176  * - \ref SCIP_STAGE_INITPRESOLVE
17177  * - \ref SCIP_STAGE_PRESOLVING
17178  * - \ref SCIP_STAGE_EXITPRESOLVE
17179  * - \ref SCIP_STAGE_PRESOLVED
17180  * - \ref SCIP_STAGE_INITSOLVE
17181  * - \ref SCIP_STAGE_SOLVING
17182  * - \ref SCIP_STAGE_SOLVED
17183  * - \ref SCIP_STAGE_EXITSOLVE
17184  * - \ref SCIP_STAGE_FREETRANS
17185  */
17186 extern
17188  SCIP* scip, /**< SCIP data structure */
17189  SCIP_SOL* sol, /**< primal solution */
17190  SCIP_VAR* var, /**< variable to add to solution */
17191  SCIP_Real val /**< solution value of variable */
17192  );
17193 
17194 /** sets values of multiple variables in primal CIP solution
17195  *
17196  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17197  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17198  *
17199  * @pre This method can be called if SCIP is in one of the following stages:
17200  * - \ref SCIP_STAGE_PROBLEM
17201  * - \ref SCIP_STAGE_TRANSFORMING
17202  * - \ref SCIP_STAGE_TRANSFORMED
17203  * - \ref SCIP_STAGE_INITPRESOLVE
17204  * - \ref SCIP_STAGE_PRESOLVING
17205  * - \ref SCIP_STAGE_EXITPRESOLVE
17206  * - \ref SCIP_STAGE_PRESOLVED
17207  * - \ref SCIP_STAGE_INITSOLVE
17208  * - \ref SCIP_STAGE_SOLVING
17209  * - \ref SCIP_STAGE_SOLVED
17210  * - \ref SCIP_STAGE_EXITSOLVE
17211  * - \ref SCIP_STAGE_FREETRANS
17212  */
17213 extern
17215  SCIP* scip, /**< SCIP data structure */
17216  SCIP_SOL* sol, /**< primal solution */
17217  int nvars, /**< number of variables to set solution value for */
17218  SCIP_VAR** vars, /**< array with variables to add to solution */
17219  SCIP_Real* vals /**< array with solution values of variables */
17220  );
17221 
17222 /** increases value of variable in primal CIP solution
17223  *
17224  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17225  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17226  *
17227  * @pre This method can be called if SCIP is in one of the following stages:
17228  * - \ref SCIP_STAGE_PROBLEM
17229  * - \ref SCIP_STAGE_TRANSFORMING
17230  * - \ref SCIP_STAGE_TRANSFORMED
17231  * - \ref SCIP_STAGE_INITPRESOLVE
17232  * - \ref SCIP_STAGE_PRESOLVING
17233  * - \ref SCIP_STAGE_EXITPRESOLVE
17234  * - \ref SCIP_STAGE_PRESOLVED
17235  * - \ref SCIP_STAGE_INITSOLVE
17236  * - \ref SCIP_STAGE_SOLVING
17237  * - \ref SCIP_STAGE_SOLVED
17238  * - \ref SCIP_STAGE_EXITSOLVE
17239  * - \ref SCIP_STAGE_FREETRANS
17240  */
17241 extern
17243  SCIP* scip, /**< SCIP data structure */
17244  SCIP_SOL* sol, /**< primal solution */
17245  SCIP_VAR* var, /**< variable to increase solution value for */
17246  SCIP_Real incval /**< increment for solution value of variable */
17247  );
17248 
17249 /** returns value of variable in primal CIP solution, or in current LP/pseudo solution
17250  *
17251  * @return value of variable in primal CIP solution, or in current LP/pseudo solution
17252  *
17253  * @pre In case the solution pointer @p sol is @b NULL, that means it is asked for the LP or pseudo solution, this method
17254  * can only be called if @p scip is in the solving stage \ref SCIP_STAGE_SOLVING. In any other case, this method
17255  * can be called if @p scip is in one of the following stages:
17256  * - \ref SCIP_STAGE_PROBLEM
17257  * - \ref SCIP_STAGE_TRANSFORMING
17258  * - \ref SCIP_STAGE_TRANSFORMED
17259  * - \ref SCIP_STAGE_INITPRESOLVE
17260  * - \ref SCIP_STAGE_PRESOLVING
17261  * - \ref SCIP_STAGE_EXITPRESOLVE
17262  * - \ref SCIP_STAGE_PRESOLVED
17263  * - \ref SCIP_STAGE_INITSOLVE
17264  * - \ref SCIP_STAGE_SOLVING
17265  * - \ref SCIP_STAGE_SOLVED
17266  * - \ref SCIP_STAGE_EXITSOLVE
17267  * - \ref SCIP_STAGE_FREETRANS
17268  */
17269 extern
17271  SCIP* scip, /**< SCIP data structure */
17272  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17273  SCIP_VAR* var /**< variable to get value for */
17274  );
17275 
17276 /** gets values of multiple variables in primal CIP solution
17277  *
17278  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17279  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17280  *
17281  * @pre This method can be called if SCIP is in one of the following stages:
17282  * - \ref SCIP_STAGE_PROBLEM
17283  * - \ref SCIP_STAGE_TRANSFORMING
17284  * - \ref SCIP_STAGE_TRANSFORMED
17285  * - \ref SCIP_STAGE_INITPRESOLVE
17286  * - \ref SCIP_STAGE_PRESOLVING
17287  * - \ref SCIP_STAGE_EXITPRESOLVE
17288  * - \ref SCIP_STAGE_PRESOLVED
17289  * - \ref SCIP_STAGE_INITSOLVE
17290  * - \ref SCIP_STAGE_SOLVING
17291  * - \ref SCIP_STAGE_SOLVED
17292  * - \ref SCIP_STAGE_EXITSOLVE
17293  * - \ref SCIP_STAGE_FREETRANS
17294  */
17295 extern
17297  SCIP* scip, /**< SCIP data structure */
17298  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17299  int nvars, /**< number of variables to get solution value for */
17300  SCIP_VAR** vars, /**< array with variables to get value for */
17301  SCIP_Real* vals /**< array to store solution values of variables */
17302  );
17303 
17304 /** returns objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
17305  *
17306  * @return objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
17307  *
17308  * @pre This method can be called if SCIP is in one of the following stages:
17309  * - \ref SCIP_STAGE_PROBLEM
17310  * - \ref SCIP_STAGE_TRANSFORMING
17311  * - \ref SCIP_STAGE_TRANSFORMED
17312  * - \ref SCIP_STAGE_INITPRESOLVE
17313  * - \ref SCIP_STAGE_PRESOLVING
17314  * - \ref SCIP_STAGE_EXITPRESOLVE
17315  * - \ref SCIP_STAGE_PRESOLVED
17316  * - \ref SCIP_STAGE_INITSOLVE
17317  * - \ref SCIP_STAGE_SOLVING
17318  * - \ref SCIP_STAGE_SOLVED
17319  * - \ref SCIP_STAGE_EXITSOLVE
17320  * - \ref SCIP_STAGE_FREETRANS
17321  */
17322 extern
17324  SCIP* scip, /**< SCIP data structure */
17325  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
17326  );
17327 
17328 /** returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
17329  *
17330  * @return transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
17331  *
17332  * @pre This method can be called if SCIP is in one of the following stages:
17333  * - \ref SCIP_STAGE_TRANSFORMING
17334  * - \ref SCIP_STAGE_TRANSFORMED
17335  * - \ref SCIP_STAGE_INITPRESOLVE
17336  * - \ref SCIP_STAGE_PRESOLVING
17337  * - \ref SCIP_STAGE_EXITPRESOLVE
17338  * - \ref SCIP_STAGE_PRESOLVED
17339  * - \ref SCIP_STAGE_INITSOLVE
17340  * - \ref SCIP_STAGE_SOLVING
17341  * - \ref SCIP_STAGE_SOLVED
17342  * - \ref SCIP_STAGE_EXITSOLVE
17343  * - \ref SCIP_STAGE_FREETRANS
17344  */
17345 extern
17347  SCIP* scip, /**< SCIP data structure */
17348  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
17349  );
17350 
17351 /** recomputes the objective value of an original solution, e.g., when transferring solutions
17352  * from the solution pool (objective coefficients might have changed in the meantime)
17353  *
17354  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17355  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17356  *
17357  * @pre This method can be called if SCIP is in one of the following stages:
17358  * - \ref SCIP_STAGE_PRESOLVING
17359  * - \ref SCIP_STAGE_SOLVING
17360  *
17361  */
17362 extern
17364  SCIP* scip,
17365  SCIP_SOL* sol
17366  );
17367 
17368 /** maps original space objective value into transformed objective value
17369  *
17370  * @return transformed objective value
17371  *
17372  * @pre This method can be called if SCIP is in one of the following stages:
17373  * - \ref SCIP_STAGE_TRANSFORMING
17374  * - \ref SCIP_STAGE_TRANSFORMED
17375  * - \ref SCIP_STAGE_INITPRESOLVE
17376  * - \ref SCIP_STAGE_PRESOLVING
17377  * - \ref SCIP_STAGE_EXITPRESOLVE
17378  * - \ref SCIP_STAGE_PRESOLVED
17379  * - \ref SCIP_STAGE_INITSOLVE
17380  * - \ref SCIP_STAGE_SOLVING
17381  * - \ref SCIP_STAGE_SOLVED
17382  */
17383 extern
17385  SCIP* scip, /**< SCIP data structure */
17386  SCIP_Real obj /**< original space objective value to transform */
17387  );
17388 
17389 /** maps transformed objective value into original space
17390  *
17391  * @return objective value into original space
17392  *
17393  * @pre This method can be called if SCIP is in one of the following stages:
17394  * - \ref SCIP_STAGE_TRANSFORMING
17395  * - \ref SCIP_STAGE_TRANSFORMED
17396  * - \ref SCIP_STAGE_INITPRESOLVE
17397  * - \ref SCIP_STAGE_PRESOLVING
17398  * - \ref SCIP_STAGE_EXITPRESOLVE
17399  * - \ref SCIP_STAGE_PRESOLVED
17400  * - \ref SCIP_STAGE_INITSOLVE
17401  * - \ref SCIP_STAGE_SOLVING
17402  * - \ref SCIP_STAGE_SOLVED
17403  */
17404 extern
17406  SCIP* scip, /**< SCIP data structure */
17407  SCIP_Real obj /**< transformed objective value to retransform in original space */
17408  );
17409 
17410 /** gets clock time, when this solution was found
17411  *
17412  * @return clock time, when this solution was found
17413  *
17414  * @pre This method can be called if SCIP is in one of the following stages:
17415  * - \ref SCIP_STAGE_TRANSFORMING
17416  * - \ref SCIP_STAGE_TRANSFORMED
17417  * - \ref SCIP_STAGE_INITPRESOLVE
17418  * - \ref SCIP_STAGE_PRESOLVING
17419  * - \ref SCIP_STAGE_EXITPRESOLVE
17420  * - \ref SCIP_STAGE_PRESOLVED
17421  * - \ref SCIP_STAGE_INITSOLVE
17422  * - \ref SCIP_STAGE_SOLVING
17423  * - \ref SCIP_STAGE_SOLVED
17424  * - \ref SCIP_STAGE_EXITSOLVE
17425  * - \ref SCIP_STAGE_FREETRANS
17426  */
17427 extern
17429  SCIP* scip, /**< SCIP data structure */
17430  SCIP_SOL* sol /**< primal solution */
17431  );
17432 
17433 /** gets branch and bound run number, where this solution was found
17434  *
17435  * @return branch and bound run number, where this solution was found
17436  *
17437  * @pre This method can be called if SCIP is in one of the following stages:
17438  * - \ref SCIP_STAGE_TRANSFORMING
17439  * - \ref SCIP_STAGE_TRANSFORMED
17440  * - \ref SCIP_STAGE_INITPRESOLVE
17441  * - \ref SCIP_STAGE_PRESOLVING
17442  * - \ref SCIP_STAGE_EXITPRESOLVE
17443  * - \ref SCIP_STAGE_PRESOLVED
17444  * - \ref SCIP_STAGE_INITSOLVE
17445  * - \ref SCIP_STAGE_SOLVING
17446  * - \ref SCIP_STAGE_SOLVED
17447  * - \ref SCIP_STAGE_EXITSOLVE
17448  * - \ref SCIP_STAGE_FREETRANS
17449  */
17450 extern
17451 int SCIPgetSolRunnum(
17452  SCIP* scip, /**< SCIP data structure */
17453  SCIP_SOL* sol /**< primal solution */
17454  );
17455 
17456 /** gets node number of the specific branch and bound run, where this solution was found
17457  *
17458  * @return node number of the specific branch and bound run, where this solution was found
17459  *
17460  * @pre This method can be called if SCIP is in one of the following stages:
17461  * - \ref SCIP_STAGE_TRANSFORMING
17462  * - \ref SCIP_STAGE_TRANSFORMED
17463  * - \ref SCIP_STAGE_INITPRESOLVE
17464  * - \ref SCIP_STAGE_PRESOLVING
17465  * - \ref SCIP_STAGE_EXITPRESOLVE
17466  * - \ref SCIP_STAGE_PRESOLVED
17467  * - \ref SCIP_STAGE_INITSOLVE
17468  * - \ref SCIP_STAGE_SOLVING
17469  * - \ref SCIP_STAGE_SOLVED
17470  * - \ref SCIP_STAGE_EXITSOLVE
17471  * - \ref SCIP_STAGE_FREETRANS
17472  */
17473 extern
17475  SCIP* scip, /**< SCIP data structure */
17476  SCIP_SOL* sol /**< primal solution */
17477  );
17478 
17479 /** gets heuristic, that found this solution (or NULL if it's from the tree)
17480  *
17481  * @return heuristic, that found this solution (or NULL if it's from the tree)
17482  *
17483  * @pre This method can be called if SCIP is in one of the following stages:
17484  * - \ref SCIP_STAGE_TRANSFORMING
17485  * - \ref SCIP_STAGE_TRANSFORMED
17486  * - \ref SCIP_STAGE_INITPRESOLVE
17487  * - \ref SCIP_STAGE_PRESOLVING
17488  * - \ref SCIP_STAGE_EXITPRESOLVE
17489  * - \ref SCIP_STAGE_PRESOLVED
17490  * - \ref SCIP_STAGE_INITSOLVE
17491  * - \ref SCIP_STAGE_SOLVING
17492  * - \ref SCIP_STAGE_SOLVED
17493  * - \ref SCIP_STAGE_EXITSOLVE
17494  * - \ref SCIP_STAGE_FREETRANS
17495  */
17496 extern
17498  SCIP* scip, /**< SCIP data structure */
17499  SCIP_SOL* sol /**< primal solution */
17500  );
17501 
17502 /** returns whether two given solutions are exactly equal
17503  *
17504  * @return returns whether two given solutions are exactly equal
17505  *
17506  * @pre This method can be called if SCIP is in one of the following stages:
17507  * - \ref SCIP_STAGE_PROBLEM
17508  * - \ref SCIP_STAGE_TRANSFORMING
17509  * - \ref SCIP_STAGE_TRANSFORMED
17510  * - \ref SCIP_STAGE_INITPRESOLVE
17511  * - \ref SCIP_STAGE_PRESOLVING
17512  * - \ref SCIP_STAGE_EXITPRESOLVE
17513  * - \ref SCIP_STAGE_PRESOLVED
17514  * - \ref SCIP_STAGE_INITSOLVE
17515  * - \ref SCIP_STAGE_SOLVING
17516  * - \ref SCIP_STAGE_SOLVED
17517  * - \ref SCIP_STAGE_EXITSOLVE
17518  * - \ref SCIP_STAGE_FREETRANS
17519  */
17520 extern
17522  SCIP* scip, /**< SCIP data structure */
17523  SCIP_SOL* sol1, /**< first primal CIP solution */
17524  SCIP_SOL* sol2 /**< second primal CIP solution */
17525  );
17526 
17527 /** adjusts solution values of implicit integer variables in handed solution. Solution objective value is not
17528  * deteriorated by this method.
17529  *
17530  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17531  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17532  *
17533  * @pre This method can be called if SCIP is in one of the following stages:
17534  * - \ref SCIP_STAGE_SOLVING
17535  */
17536 extern
17538  SCIP* scip, /**< SCIP data structure */
17539  SCIP_SOL* sol, /**< primal CIP solution */
17540  SCIP_Bool uselprows /**< should LP row information be considered for none-objective variables */
17541  );
17542 
17543 /** outputs non-zero variables of solution in original problem space to the given file stream
17544  *
17545  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17546  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17547  *
17548  * @pre In case the solution pointer @p sol is NULL (askinking for the current LP/pseudo solution), this method can be
17549  * called if @p scip is in one of the following stages:
17550  * - \ref SCIP_STAGE_PRESOLVING
17551  * - \ref SCIP_STAGE_EXITPRESOLVE
17552  * - \ref SCIP_STAGE_PRESOLVED
17553  * - \ref SCIP_STAGE_INITSOLVE
17554  * - \ref SCIP_STAGE_SOLVING
17555  * - \ref SCIP_STAGE_SOLVED
17556  * - \ref SCIP_STAGE_EXITSOLVE
17557  *
17558  * @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
17559  * following stages:
17560  * - \ref SCIP_STAGE_PROBLEM
17561  * - \ref SCIP_STAGE_TRANSFORMED
17562  * - \ref SCIP_STAGE_INITPRESOLVE
17563  * - \ref SCIP_STAGE_PRESOLVING
17564  * - \ref SCIP_STAGE_EXITPRESOLVE
17565  * - \ref SCIP_STAGE_PRESOLVED
17566  * - \ref SCIP_STAGE_INITSOLVE
17567  * - \ref SCIP_STAGE_SOLVING
17568  * - \ref SCIP_STAGE_SOLVED
17569  * - \ref SCIP_STAGE_EXITSOLVE
17570  */
17571 extern
17573  SCIP* scip, /**< SCIP data structure */
17574  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17575  FILE* file, /**< output file (or NULL for standard output) */
17576  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17577  );
17578 
17579 /** outputs non-zero variables of solution in transformed problem space to file stream
17580  *
17581  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17582  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17583  *
17584  * @pre This method can be called if SCIP is in one of the following stages:
17585  * - \ref SCIP_STAGE_TRANSFORMED
17586  * - \ref SCIP_STAGE_INITPRESOLVE
17587  * - \ref SCIP_STAGE_PRESOLVING
17588  * - \ref SCIP_STAGE_EXITPRESOLVE
17589  * - \ref SCIP_STAGE_PRESOLVED
17590  * - \ref SCIP_STAGE_INITSOLVE
17591  * - \ref SCIP_STAGE_SOLVING
17592  * - \ref SCIP_STAGE_SOLVED
17593  * - \ref SCIP_STAGE_EXITSOLVE
17594  */
17595 extern
17597  SCIP* scip, /**< SCIP data structure */
17598  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
17599  FILE* file, /**< output file (or NULL for standard output) */
17600  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17601  );
17602 
17603 /** outputs discrete variables of solution in original problem space to the given file stream
17604  *
17605  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17606  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17607  *
17608  * @pre This method can be called if @p scip is in one of the following stages:
17609  * - \ref SCIP_STAGE_PROBLEM
17610  * - \ref SCIP_STAGE_TRANSFORMED
17611  * - \ref SCIP_STAGE_INITPRESOLVE
17612  * - \ref SCIP_STAGE_PRESOLVING
17613  * - \ref SCIP_STAGE_EXITPRESOLVE
17614  * - \ref SCIP_STAGE_PRESOLVED
17615  * - \ref SCIP_STAGE_INITSOLVE
17616  * - \ref SCIP_STAGE_SOLVING
17617  * - \ref SCIP_STAGE_SOLVED
17618  * - \ref SCIP_STAGE_EXITSOLVE
17619  */
17620 extern
17622  SCIP* scip, /**< SCIP data structure */
17623  SCIP_SOL* sol, /**< primal solution */
17624  FILE* file /**< output file (or NULL for standard output) */
17625  );
17626 
17627 /** returns dual solution value of a constraint */
17628 extern
17630  SCIP* scip, /**< SCIP data structure */
17631  SCIP_CONS* cons, /**< constraint for which the dual solution should be returned */
17632  SCIP_Real* dualsolval, /**< pointer to store the dual solution value */
17633  SCIP_Bool* boundconstraint /**< pointer to store whether the constraint is a bound constraint (or NULL) */
17634  );
17635 
17636 /** check whether the dual solution is available
17637  *
17638  * @note This is used when calling \ref SCIPprintDualSol()
17639  *
17640  * @return is dual solution available?
17641  *
17642  * @pre This method can be called if SCIP is in one of the following stages:
17643  * - \ref SCIP_STAGE_SOLVED
17644  */
17645 extern
17647  SCIP* scip, /**< SCIP data structure */
17648  SCIP_Bool printreason /**< print warning message if dualsol is not available? */
17649  );
17650 
17651 /** outputs dual solution from LP solver to file stream
17652  *
17653  * @note This only works if no presolving has been performed, which can be checked by calling method \ref
17654  * SCIPhasPerformedPresolve().
17655  *
17656  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17657  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17658  *
17659  * @pre This method can be called if SCIP is in one of the following stages:
17660  * - \ref SCIP_STAGE_SOLVED
17661  */
17662 extern
17664  SCIP* scip, /**< SCIP data structure */
17665  FILE* file, /**< output file (or NULL for standard output) */
17666  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17667  );
17668 
17669 
17670 /** outputs non-zero variables of solution representing a ray in original problem space to file stream
17671  *
17672  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17673  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17674  *
17675  * @pre This method can be called if SCIP is in one of the following stages:
17676  * - \ref SCIP_STAGE_PROBLEM
17677  * - \ref SCIP_STAGE_TRANSFORMED
17678  * - \ref SCIP_STAGE_INITPRESOLVE
17679  * - \ref SCIP_STAGE_PRESOLVING
17680  * - \ref SCIP_STAGE_EXITPRESOLVE
17681  * - \ref SCIP_STAGE_PRESOLVED
17682  * - \ref SCIP_STAGE_INITSOLVE
17683  * - \ref SCIP_STAGE_SOLVING
17684  * - \ref SCIP_STAGE_SOLVED
17685  * - \ref SCIP_STAGE_EXITSOLVE
17686  */
17687 extern
17689  SCIP* scip, /**< SCIP data structure */
17690  SCIP_SOL* sol, /**< primal solution representing ray */
17691  FILE* file, /**< output file (or NULL for standard output) */
17692  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17693  );
17694 
17695 /** gets number of feasible primal solutions stored in the solution storage in case the problem is transformed;
17696  * in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate
17697  * storage is returned
17698  *
17699  * @return number of feasible primal solutions stored in the solution storage in case the problem is transformed; or
17700  * number of solution in the original solution candidate storage if the problem stage is SCIP_STAGE_PROBLEM
17701  *
17702  * @pre This method can be called if SCIP is in one of the following stages:
17703  * - \ref SCIP_STAGE_PROBLEM
17704  * - \ref SCIP_STAGE_TRANSFORMED
17705  * - \ref SCIP_STAGE_INITPRESOLVE
17706  * - \ref SCIP_STAGE_PRESOLVING
17707  * - \ref SCIP_STAGE_EXITPRESOLVE
17708  * - \ref SCIP_STAGE_PRESOLVED
17709  * - \ref SCIP_STAGE_INITSOLVE
17710  * - \ref SCIP_STAGE_SOLVING
17711  * - \ref SCIP_STAGE_SOLVED
17712  * - \ref SCIP_STAGE_EXITSOLVE
17713  */
17714 extern
17715 int SCIPgetNSols(
17716  SCIP* scip /**< SCIP data structure */
17717  );
17718 
17719 /** gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case
17720  * if the problem stage is in SCIP_STAGE_PROBLEM, it returns the number array of solution candidate stored
17721  *
17722  * @return array of feasible primal solutions
17723  *
17724  * @pre This method can be called if SCIP is in one of the following stages:
17725  * - \ref SCIP_STAGE_PROBLEM
17726  * - \ref SCIP_STAGE_TRANSFORMED
17727  * - \ref SCIP_STAGE_INITPRESOLVE
17728  * - \ref SCIP_STAGE_PRESOLVING
17729  * - \ref SCIP_STAGE_EXITPRESOLVE
17730  * - \ref SCIP_STAGE_PRESOLVED
17731  * - \ref SCIP_STAGE_INITSOLVE
17732  * - \ref SCIP_STAGE_SOLVING
17733  * - \ref SCIP_STAGE_SOLVED
17734  * - \ref SCIP_STAGE_EXITSOLVE
17735  */
17736 extern
17738  SCIP* scip /**< SCIP data structure */
17739  );
17740 
17741 /** gets best feasible primal solution found so far if the problem is transformed; in case the problem is in
17742  * SCIP_STAGE_PROBLEM it returns the best solution candidate, or NULL if no solution has been found or the candidate
17743  * store is empty;
17744  *
17745  * @return best feasible primal solution so far
17746  *
17747  * @pre This method can be called if SCIP is in one of the following stages:
17748  * - \ref SCIP_STAGE_PROBLEM
17749  * - \ref SCIP_STAGE_TRANSFORMED
17750  * - \ref SCIP_STAGE_INITPRESOLVE
17751  * - \ref SCIP_STAGE_PRESOLVING
17752  * - \ref SCIP_STAGE_EXITPRESOLVE
17753  * - \ref SCIP_STAGE_PRESOLVED
17754  * - \ref SCIP_STAGE_INITSOLVE
17755  * - \ref SCIP_STAGE_SOLVING
17756  * - \ref SCIP_STAGE_SOLVED
17757  * - \ref SCIP_STAGE_EXITSOLVE
17758  */
17759 extern
17761  SCIP* scip /**< SCIP data structure */
17762  );
17763 
17764 /** outputs best feasible primal solution found so far to file stream
17765  *
17766  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17767  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17768  *
17769  * @pre This method can be called if SCIP is in one of the following stages:
17770  * - \ref SCIP_STAGE_INIT
17771  * - \ref SCIP_STAGE_PROBLEM
17772  * - \ref SCIP_STAGE_TRANSFORMING
17773  * - \ref SCIP_STAGE_TRANSFORMED
17774  * - \ref SCIP_STAGE_INITPRESOLVE
17775  * - \ref SCIP_STAGE_PRESOLVING
17776  * - \ref SCIP_STAGE_EXITPRESOLVE
17777  * - \ref SCIP_STAGE_PRESOLVED
17778  * - \ref SCIP_STAGE_INITSOLVE
17779  * - \ref SCIP_STAGE_SOLVING
17780  * - \ref SCIP_STAGE_SOLVED
17781  * - \ref SCIP_STAGE_EXITSOLVE
17782  * - \ref SCIP_STAGE_FREE
17783  */
17784 extern
17786  SCIP* scip, /**< SCIP data structure */
17787  FILE* file, /**< output file (or NULL for standard output) */
17788  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17789  );
17790 
17791 /** outputs best feasible primal solution found so far in transformed variables to file stream
17792  *
17793  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17794  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17795  *
17796  * @pre This method can be called if SCIP is in one of the following stages:
17797  * - \ref SCIP_STAGE_INIT
17798  * - \ref SCIP_STAGE_PROBLEM
17799  * - \ref SCIP_STAGE_TRANSFORMING
17800  * - \ref SCIP_STAGE_TRANSFORMED
17801  * - \ref SCIP_STAGE_INITPRESOLVE
17802  * - \ref SCIP_STAGE_PRESOLVING
17803  * - \ref SCIP_STAGE_EXITPRESOLVE
17804  * - \ref SCIP_STAGE_PRESOLVED
17805  * - \ref SCIP_STAGE_INITSOLVE
17806  * - \ref SCIP_STAGE_SOLVING
17807  * - \ref SCIP_STAGE_SOLVED
17808  * - \ref SCIP_STAGE_EXITSOLVE
17809  * - \ref SCIP_STAGE_FREE
17810  */
17811 extern
17813  SCIP* scip, /**< SCIP data structure */
17814  FILE* file, /**< output file (or NULL for standard output) */
17815  SCIP_Bool printzeros /**< should variables set to zero be printed? */
17816  );
17817 
17818 /** try to round given solution
17819  *
17820  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17821  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17822  *
17823  * @pre This method can be called if SCIP is in one of the following stages:
17824  * - \ref SCIP_STAGE_SOLVING
17825  */
17826 extern
17828  SCIP* scip, /**< SCIP data structure */
17829  SCIP_SOL* sol, /**< primal solution */
17830  SCIP_Bool* success /**< pointer to store whether rounding was successful */
17831  );
17832 
17833 /** retransforms solution to original problem space
17834  *
17835  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17836  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17837  *
17838  * @pre This method can be called if SCIP is in one of the following stages:
17839  * - \ref SCIP_STAGE_PROBLEM
17840  * - \ref SCIP_STAGE_TRANSFORMING
17841  * - \ref SCIP_STAGE_TRANSFORMED
17842  * - \ref SCIP_STAGE_INITPRESOLVE
17843  * - \ref SCIP_STAGE_PRESOLVING
17844  * - \ref SCIP_STAGE_EXITPRESOLVE
17845  * - \ref SCIP_STAGE_PRESOLVED
17846  * - \ref SCIP_STAGE_INITSOLVE
17847  * - \ref SCIP_STAGE_SOLVING
17848  * - \ref SCIP_STAGE_SOLVED
17849  * - \ref SCIP_STAGE_EXITSOLVE
17850  * - \ref SCIP_STAGE_FREETRANS
17851  */
17852 extern
17854  SCIP* scip, /**< SCIP data structure */
17855  SCIP_SOL* sol /**< primal CIP solution */
17856  );
17857 
17858 /** reads a given solution file, problem has to be transformed in advance
17859  *
17860  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17861  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17862  *
17863  * @pre This method can be called if SCIP is in one of the following stages:
17864  * - \ref SCIP_STAGE_PROBLEM
17865  * - \ref SCIP_STAGE_TRANSFORMED
17866  * - \ref SCIP_STAGE_INITPRESOLVE
17867  * - \ref SCIP_STAGE_PRESOLVING
17868  * - \ref SCIP_STAGE_EXITPRESOLVE
17869  * - \ref SCIP_STAGE_PRESOLVED
17870  * - \ref SCIP_STAGE_INITSOLVE
17871  * - \ref SCIP_STAGE_SOLVING
17872  */
17873 extern
17875  SCIP* scip, /**< SCIP data structure */
17876  const char* filename /**< name of the input file */
17877  );
17878 
17879 /** reads a given solution file and store the solution values in the given solution pointer
17880  *
17881  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17882  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17883  *
17884  * @pre This method can be called if SCIP is in one of the following stages:
17885  * - \ref SCIP_STAGE_PROBLEM
17886  * - \ref SCIP_STAGE_TRANSFORMED
17887  * - \ref SCIP_STAGE_INITPRESOLVE
17888  * - \ref SCIP_STAGE_PRESOLVING
17889  * - \ref SCIP_STAGE_EXITPRESOLVE
17890  * - \ref SCIP_STAGE_PRESOLVED
17891  * - \ref SCIP_STAGE_INITSOLVE
17892  * - \ref SCIP_STAGE_SOLVING
17893  */
17894 extern
17896  SCIP* scip, /**< SCIP data structure */
17897  const char* filename, /**< name of the input file */
17898  SCIP_SOL* sol, /**< solution pointer */
17899  SCIP_Bool xml, /**< true, iff the given solution in written in XML */
17900  SCIP_Bool* partial, /**< pointer to store if the solution is partial */
17901  SCIP_Bool* error /**< pointer store if an error occured */
17902  );
17903 
17904 /** adds feasible primal solution to solution storage by copying it
17905  *
17906  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17907  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17908  *
17909  * @pre This method can be called if SCIP is in one of the following stages:
17910  * - \ref SCIP_STAGE_PROBLEM
17911  * - \ref SCIP_STAGE_TRANSFORMED
17912  * - \ref SCIP_STAGE_INITPRESOLVE
17913  * - \ref SCIP_STAGE_PRESOLVING
17914  * - \ref SCIP_STAGE_EXITPRESOLVE
17915  * - \ref SCIP_STAGE_PRESOLVED
17916  * - \ref SCIP_STAGE_SOLVING
17917  * - \ref SCIP_STAGE_FREETRANS
17918  *
17919  * @note Do not call during propagation, use heur_trysol instead.
17920  */
17921 extern
17923  SCIP* scip, /**< SCIP data structure */
17924  SCIP_SOL* sol, /**< primal CIP solution */
17925  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
17926  );
17927 
17928 /** adds primal solution to solution storage, frees the solution afterwards
17929  *
17930  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17931  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17932  *
17933  * @pre This method can be called if SCIP is in one of the following stages:
17934  * - \ref SCIP_STAGE_PROBLEM
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  * - \ref SCIP_STAGE_FREETRANS
17942  *
17943  * @note Do not call during propagation, use heur_trysol instead.
17944  */
17945 extern
17947  SCIP* scip, /**< SCIP data structure */
17948  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
17949  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
17950  );
17951 
17952 /** adds current LP/pseudo solution to solution storage
17953  *
17954  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17955  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17956  *
17957  * @pre This method can be called if SCIP is in one of the following stages:
17958  * - \ref SCIP_STAGE_PRESOLVED
17959  * - \ref SCIP_STAGE_SOLVING
17960  */
17961 extern
17963  SCIP* scip, /**< SCIP data structure */
17964  SCIP_HEUR* heur, /**< heuristic that found the solution */
17965  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
17966  );
17967 
17968 /** checks solution for feasibility; if possible, adds it to storage by copying
17969  *
17970  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17971  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17972  *
17973  * @pre This method can be called if SCIP is in one of the following stages:
17974  * - \ref SCIP_STAGE_TRANSFORMED
17975  * - \ref SCIP_STAGE_INITPRESOLVE
17976  * - \ref SCIP_STAGE_PRESOLVING
17977  * - \ref SCIP_STAGE_EXITPRESOLVE
17978  * - \ref SCIP_STAGE_PRESOLVED
17979  * - \ref SCIP_STAGE_SOLVING
17980  *
17981  * @note Do not call during propagation, use heur_trysol instead.
17982  */
17983 extern
17985  SCIP* scip, /**< SCIP data structure */
17986  SCIP_SOL* sol, /**< primal CIP solution */
17987  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
17988  SCIP_Bool completely, /**< Should all violations be checked? */
17989  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
17990  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
17991  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
17992  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
17993  );
17994 
17995 /** checks primal solution; if feasible, adds it to storage; solution is freed afterwards
17996  *
17997  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17998  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17999  *
18000  * @pre This method can be called if SCIP is in one of the following stages:
18001  * - \ref SCIP_STAGE_TRANSFORMED
18002  * - \ref SCIP_STAGE_INITPRESOLVE
18003  * - \ref SCIP_STAGE_PRESOLVING
18004  * - \ref SCIP_STAGE_EXITPRESOLVE
18005  * - \ref SCIP_STAGE_PRESOLVED
18006  * - \ref SCIP_STAGE_SOLVING
18007  *
18008  * @note Do not call during propagation, use heur_trysol instead.
18009  */
18010 extern
18012  SCIP* scip, /**< SCIP data structure */
18013  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
18014  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
18015  SCIP_Bool completely, /**< Should all violation be checked? */
18016  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
18017  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
18018  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
18019  SCIP_Bool* stored /**< stores whether solution was feasible and good enough to keep */
18020  );
18021 
18022 /** checks current LP/pseudo solution for feasibility; if possible, adds it to storage
18023  *
18024  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18025  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18026  *
18027  * @pre This method can be called if SCIP is in one of the following stages:
18028  * - \ref SCIP_STAGE_PRESOLVED
18029  * - \ref SCIP_STAGE_SOLVING
18030  */
18031 extern
18033  SCIP* scip, /**< SCIP data structure */
18034  SCIP_HEUR* heur, /**< heuristic that found the solution */
18035  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
18036  SCIP_Bool completely, /**< Should all violation be checked? */
18037  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
18038  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
18039  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
18040  );
18041 
18042 /** returns all partial solutions
18043  *
18044  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18045  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18046  *
18047  * @pre This method can be called if SCIP is in one of the following stages:
18048  * - \ref SCIP_STAGE_PROBLEM
18049  * - \ref SCIP_STAGE_PRESOLVING
18050  * - \ref SCIP_STAGE_SOLVING
18051  * - \ref SCIP_STAGE_SOLVED
18052  */
18053 extern
18055  SCIP* scip /**< SCIP data structure */
18056  );
18057 
18058 /** returns number of partial solutions
18059  *
18060  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18061  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18062  *
18063  * @pre This method can be called if SCIP is in one of the following stages:
18064  * - \ref SCIP_STAGE_PROBLEM
18065  * - \ref SCIP_STAGE_PRESOLVING
18066  * - \ref SCIP_STAGE_SOLVING
18067  * - \ref SCIP_STAGE_SOLVED
18068  */
18070  SCIP* scip /**< SCIP data structure */
18071  );
18072 
18073 /** checks solution for feasibility without adding it to the solution store
18074  *
18075  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18076  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18077  *
18078  * @pre This method can be called if SCIP is in one of the following stages:
18079  * - \ref SCIP_STAGE_PROBLEM
18080  * - \ref SCIP_STAGE_TRANSFORMED
18081  * - \ref SCIP_STAGE_INITPRESOLVE
18082  * - \ref SCIP_STAGE_PRESOLVING
18083  * - \ref SCIP_STAGE_EXITPRESOLVE
18084  * - \ref SCIP_STAGE_PRESOLVED
18085  * - \ref SCIP_STAGE_INITSOLVE
18086  * - \ref SCIP_STAGE_SOLVING
18087  * - \ref SCIP_STAGE_SOLVED
18088  */
18089 extern
18091  SCIP* scip, /**< SCIP data structure */
18092  SCIP_SOL* sol, /**< primal CIP solution */
18093  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
18094  SCIP_Bool completely, /**< Should all violation be checked? */
18095  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
18096  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
18097  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
18098  SCIP_Bool* feasible /**< stores whether given solution is feasible */
18099  );
18100 
18101 /** checks solution for feasibility in original problem without adding it to the solution store;
18102  * this method is used to double check a solution in order to validate the presolving process
18103  *
18104  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18105  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18106  *
18107  * @pre This method can be called if SCIP is in one of the following stages:
18108  * - \ref SCIP_STAGE_PROBLEM
18109  * - \ref SCIP_STAGE_TRANSFORMED
18110  * - \ref SCIP_STAGE_INITPRESOLVE
18111  * - \ref SCIP_STAGE_PRESOLVING
18112  * - \ref SCIP_STAGE_EXITPRESOLVE
18113  * - \ref SCIP_STAGE_PRESOLVED
18114  * - \ref SCIP_STAGE_INITSOLVE
18115  * - \ref SCIP_STAGE_SOLVING
18116  * - \ref SCIP_STAGE_SOLVED
18117  */
18118 extern
18120  SCIP* scip, /**< SCIP data structure */
18121  SCIP_SOL* sol, /**< primal CIP solution */
18122  SCIP_Bool* feasible, /**< stores whether given solution is feasible */
18123  SCIP_Bool printreason, /**< should the reason for the violation be printed? */
18124  SCIP_Bool completely /**< should all violations be checked? */
18125  );
18126 
18127 /** return whether a primal ray is stored that proves unboundedness of the LP relaxation
18128  *
18129  * @return return whether a primal ray is stored that proves unboundedness of the LP relaxation
18130  *
18131  * @pre This method can be called if SCIP is in one of the following stages:
18132  * - \ref SCIP_STAGE_SOLVING
18133  * - \ref SCIP_STAGE_SOLVED
18134  */
18135 extern
18137  SCIP* scip /**< SCIP data structure */
18138  );
18139 
18140 /** gets value of given variable in primal ray causing unboundedness of the LP relaxation;
18141  * should only be called if such a ray is stored (check with SCIPhasPrimalRay())
18142  *
18143  * @return value of given variable in primal ray causing unboundedness of the LP relaxation
18144  *
18145  * @pre This method can be called if SCIP is in one of the following stages:
18146  * - \ref SCIP_STAGE_SOLVING
18147  * - \ref SCIP_STAGE_SOLVED
18148  */
18149 extern
18151  SCIP* scip, /**< SCIP data structure */
18152  SCIP_VAR* var /**< variable to get value for */
18153  );
18154 
18155 /** updates the primal ray thats proves unboundedness
18156  *
18157  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18158  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18159  *
18160  * @pre This method can be called if @p scip is in one of the following stages:
18161  * - \ref SCIP_STAGE_PRESOLVING
18162  * - \ref SCIP_STAGE_PRESOLVED
18163  * - \ref SCIP_STAGE_SOLVING
18164  * - \ref SCIP_STAGE_SOLVED
18165  *
18166  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18167  */
18168 extern
18170  SCIP* scip, /**< SCIP data structure */
18171  SCIP_SOL* primalray /**< the new primal ray */
18172  );
18173 
18174 /**@} */
18175 
18176 
18177 
18178 
18179 /*
18180  * event methods
18181  */
18182 
18183 /**@addtogroup PublicEventMethods
18184  *
18185  * @{
18186  */
18187 
18188 /** catches a global (not variable or row dependent) event
18189  *
18190  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18191  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18192  *
18193  * @pre This method can be called if @p scip is in one of the following stages:
18194  * - \ref SCIP_STAGE_TRANSFORMING
18195  * - \ref SCIP_STAGE_TRANSFORMED
18196  * - \ref SCIP_STAGE_INITPRESOLVE
18197  * - \ref SCIP_STAGE_PRESOLVING
18198  * - \ref SCIP_STAGE_EXITPRESOLVE
18199  * - \ref SCIP_STAGE_PRESOLVED
18200  * - \ref SCIP_STAGE_INITSOLVE
18201  * - \ref SCIP_STAGE_SOLVING
18202  * - \ref SCIP_STAGE_SOLVED
18203  * - \ref SCIP_STAGE_EXITSOLVE
18204  * - \ref SCIP_STAGE_FREETRANS
18205  */
18206 extern
18208  SCIP* scip, /**< SCIP data structure */
18209  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18210  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18211  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18212  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18213  );
18214 
18215 /** drops a global event (stops to track event)
18216  *
18217  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18218  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18219  *
18220  * @pre This method can be called if @p scip is in one of the following stages:
18221  * - \ref SCIP_STAGE_TRANSFORMING
18222  * - \ref SCIP_STAGE_TRANSFORMED
18223  * - \ref SCIP_STAGE_INITPRESOLVE
18224  * - \ref SCIP_STAGE_PRESOLVING
18225  * - \ref SCIP_STAGE_EXITPRESOLVE
18226  * - \ref SCIP_STAGE_PRESOLVED
18227  * - \ref SCIP_STAGE_INITSOLVE
18228  * - \ref SCIP_STAGE_SOLVING
18229  * - \ref SCIP_STAGE_SOLVED
18230  * - \ref SCIP_STAGE_EXITSOLVE
18231  * - \ref SCIP_STAGE_FREETRANS
18232  */
18233 extern
18235  SCIP* scip, /**< SCIP data structure */
18236  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18237  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18238  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18239  int filterpos /**< position of event filter entry returned by SCIPcatchEvent(), or -1 */
18240  );
18241 
18242 /** catches an objective value or domain change event on the given transformed variable
18243  *
18244  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18245  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18246  *
18247  * @pre This method can be called if @p scip is in one of the following stages:
18248  * - \ref SCIP_STAGE_TRANSFORMING
18249  * - \ref SCIP_STAGE_TRANSFORMED
18250  * - \ref SCIP_STAGE_INITPRESOLVE
18251  * - \ref SCIP_STAGE_PRESOLVING
18252  * - \ref SCIP_STAGE_EXITPRESOLVE
18253  * - \ref SCIP_STAGE_PRESOLVED
18254  * - \ref SCIP_STAGE_INITSOLVE
18255  * - \ref SCIP_STAGE_SOLVING
18256  * - \ref SCIP_STAGE_SOLVED
18257  * - \ref SCIP_STAGE_EXITSOLVE
18258  * - \ref SCIP_STAGE_FREETRANS
18259  */
18260 extern
18262  SCIP* scip, /**< SCIP data structure */
18263  SCIP_VAR* var, /**< transformed variable to catch event for */
18264  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18265  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18266  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18267  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18268  );
18269 
18270 /** drops an objective value or domain change event (stops to track event) on the given transformed variable
18271  *
18272  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18273  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18274  *
18275  * @pre This method can be called if @p scip is in one of the following stages:
18276  * - \ref SCIP_STAGE_TRANSFORMING
18277  * - \ref SCIP_STAGE_TRANSFORMED
18278  * - \ref SCIP_STAGE_INITPRESOLVE
18279  * - \ref SCIP_STAGE_PRESOLVING
18280  * - \ref SCIP_STAGE_EXITPRESOLVE
18281  * - \ref SCIP_STAGE_PRESOLVED
18282  * - \ref SCIP_STAGE_INITSOLVE
18283  * - \ref SCIP_STAGE_SOLVING
18284  * - \ref SCIP_STAGE_SOLVED
18285  * - \ref SCIP_STAGE_EXITSOLVE
18286  * - \ref SCIP_STAGE_FREETRANS
18287  */
18288 extern
18290  SCIP* scip, /**< SCIP data structure */
18291  SCIP_VAR* var, /**< transformed variable to drop event for */
18292  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18293  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18294  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18295  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
18296  );
18297 
18298 /** catches a row coefficient, constant, or side change event on the given row
18299  *
18300  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18301  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18302  *
18303  * @pre This method can be called if @p scip is in one of the following stages:
18304  * - \ref SCIP_STAGE_TRANSFORMING
18305  * - \ref SCIP_STAGE_TRANSFORMED
18306  * - \ref SCIP_STAGE_INITPRESOLVE
18307  * - \ref SCIP_STAGE_PRESOLVING
18308  * - \ref SCIP_STAGE_EXITPRESOLVE
18309  * - \ref SCIP_STAGE_PRESOLVED
18310  * - \ref SCIP_STAGE_INITSOLVE
18311  * - \ref SCIP_STAGE_SOLVING
18312  * - \ref SCIP_STAGE_SOLVED
18313  * - \ref SCIP_STAGE_EXITSOLVE
18314  * - \ref SCIP_STAGE_FREETRANS
18315  */
18316 extern
18318  SCIP* scip, /**< SCIP data structure */
18319  SCIP_ROW* row, /**< linear row to catch event for */
18320  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
18321  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18322  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18323  int* filterpos /**< pointer to store position of event filter entry, or NULL */
18324  );
18325 
18326 /** drops a row coefficient, constant, or side change event (stops to track event) on the given row
18327  *
18328  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18329  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18330  *
18331  * @pre This method can be called if @p scip is in one of the following stages:
18332  * - \ref SCIP_STAGE_TRANSFORMING
18333  * - \ref SCIP_STAGE_TRANSFORMED
18334  * - \ref SCIP_STAGE_INITPRESOLVE
18335  * - \ref SCIP_STAGE_PRESOLVING
18336  * - \ref SCIP_STAGE_EXITPRESOLVE
18337  * - \ref SCIP_STAGE_PRESOLVED
18338  * - \ref SCIP_STAGE_INITSOLVE
18339  * - \ref SCIP_STAGE_SOLVING
18340  * - \ref SCIP_STAGE_SOLVED
18341  * - \ref SCIP_STAGE_EXITSOLVE
18342  * - \ref SCIP_STAGE_FREETRANS
18343  */
18344 extern
18346  SCIP* scip, /**< SCIP data structure */
18347  SCIP_ROW* row, /**< linear row to drop event for */
18348  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
18349  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
18350  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
18351  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
18352  );
18353 
18354 /**@} */
18355 
18356 
18357 
18358 
18359 /*
18360  * tree methods
18361  */
18362 
18363 /**@addtogroup PublicTreeMethods
18364  *
18365  * @{
18366  */
18367 
18368 /** gets focus node in the tree
18369  *
18370  * if we are in probing/diving mode this method returns the node in the tree where the probing/diving mode was started.
18371  *
18372  * @return the current node of the search tree
18373  *
18374  * @pre This method can be called if @p scip is in one of the following stages:
18375  * - \ref SCIP_STAGE_INITPRESOLVE
18376  * - \ref SCIP_STAGE_PRESOLVING
18377  * - \ref SCIP_STAGE_EXITPRESOLVE
18378  * - \ref SCIP_STAGE_SOLVING
18379  */
18380 extern
18382  SCIP* scip /**< SCIP data structure */
18383  );
18384 
18385 /** gets current node in the tree
18386  *
18387  * @return the current node of the search tree
18388  *
18389  * @pre This method can be called if @p scip is in one of the following stages:
18390  * - \ref SCIP_STAGE_INITPRESOLVE
18391  * - \ref SCIP_STAGE_PRESOLVING
18392  * - \ref SCIP_STAGE_EXITPRESOLVE
18393  * - \ref SCIP_STAGE_SOLVING
18394  */
18395 extern
18397  SCIP* scip /**< SCIP data structure */
18398  );
18399 
18400 /** gets depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
18401  * such that the depth includes the probing path
18402  *
18403  * @return the depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
18404  * such that the depth includes the probing path
18405  *
18406  * @pre This method can be called if SCIP is in one of the following stages:
18407  * - \ref SCIP_STAGE_TRANSFORMED
18408  * - \ref SCIP_STAGE_INITPRESOLVE
18409  * - \ref SCIP_STAGE_PRESOLVING
18410  * - \ref SCIP_STAGE_EXITPRESOLVE
18411  * - \ref SCIP_STAGE_PRESOLVED
18412  * - \ref SCIP_STAGE_INITSOLVE
18413  * - \ref SCIP_STAGE_SOLVING
18414  * - \ref SCIP_STAGE_SOLVED
18415  * - \ref SCIP_STAGE_EXITSOLVE
18416  */
18417 extern
18418 int SCIPgetDepth(
18419  SCIP* scip /**< SCIP data structure */
18420  );
18421 
18422 /** gets depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
18423  * branching tree, excluding the nodes of the probing path
18424  *
18425  * @return the depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
18426  * branching tree, excluding the nodes of the probing path
18427  *
18428  * @pre This method can be called if SCIP is in one of the following stages:
18429  * - \ref SCIP_STAGE_TRANSFORMED
18430  * - \ref SCIP_STAGE_INITPRESOLVE
18431  * - \ref SCIP_STAGE_PRESOLVING
18432  * - \ref SCIP_STAGE_EXITPRESOLVE
18433  * - \ref SCIP_STAGE_PRESOLVED
18434  * - \ref SCIP_STAGE_INITSOLVE
18435  * - \ref SCIP_STAGE_SOLVING
18436  * - \ref SCIP_STAGE_SOLVED
18437  * - \ref SCIP_STAGE_EXITSOLVE
18438  */
18439 extern
18440 int SCIPgetFocusDepth(
18441  SCIP* scip /**< SCIP data structure */
18442  );
18443 
18444 /** gets current plunging depth (successive times, a child was selected as next node)
18445  *
18446  * @return the current plunging depth (successive times, a child was selected as next node)
18447  *
18448  * @pre This method can be called if SCIP is in one of the following stages:
18449  * - \ref SCIP_STAGE_PRESOLVED
18450  * - \ref SCIP_STAGE_SOLVING
18451  */
18452 extern
18453 int SCIPgetPlungeDepth(
18454  SCIP* scip /**< SCIP data structure */
18455  );
18456 
18457 /** gets the root node of the tree
18458  *
18459  * @return the root node of the search tree
18460  *
18461  * @pre This method can be called if @p scip is in one of the following stages:
18462  * - \ref SCIP_STAGE_INITPRESOLVE
18463  * - \ref SCIP_STAGE_PRESOLVING
18464  * - \ref SCIP_STAGE_EXITPRESOLVE
18465  * - \ref SCIP_STAGE_SOLVING
18466  */
18467 extern
18469  SCIP* scip /**< SCIP data structure */
18470  );
18471 
18472 /** gets the effective root depth, i.e., the depth of the deepest node which is part of all paths from the root node
18473  * to the unprocessed nodes.
18474  *
18475  * @return effective root depth
18476  *
18477  * @pre This method can be called if @p scip is in one of the following stages:
18478  * - \ref SCIP_STAGE_SOLVING
18479  */
18480 extern
18482  SCIP* scip /**< SCIP data structure */
18483  );
18484 
18485 /** returns whether the current node is already solved and only propagated again
18486  *
18487  * @return TRUE is returned if \SCIP performance repropagation, otherwise FALSE.
18488  *
18489  * @pre This method can be called if @p scip is in one of the following stages:
18490  * - \ref SCIP_STAGE_INITPRESOLVE
18491  * - \ref SCIP_STAGE_PRESOLVING
18492  * - \ref SCIP_STAGE_EXITPRESOLVE
18493  * - \ref SCIP_STAGE_SOLVING
18494  */
18495 extern
18497  SCIP* scip /**< SCIP data structure */
18498  );
18499 
18500 /** gets children of focus node along with the number of children
18501  *
18502  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18503  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18504  *
18505  * @pre This method can be called if @p scip is in one of the following stages:
18506  * - \ref SCIP_STAGE_SOLVING
18507  */
18508 extern
18510  SCIP* scip, /**< SCIP data structure */
18511  SCIP_NODE*** children, /**< pointer to store children array, or NULL if not needed */
18512  int* nchildren /**< pointer to store number of children, or NULL if not needed */
18513  );
18514 
18515 /** gets number of children of focus node
18516  *
18517  * @return number of children of the focus node
18518  *
18519  * @pre This method can be called if @p scip is in one of the following stages:
18520  * - \ref SCIP_STAGE_SOLVING
18521  */
18522 extern
18523 int SCIPgetNChildren(
18524  SCIP* scip /**< SCIP data structure */
18525  );
18526 
18527 /** gets siblings of focus node along with the number of siblings
18528  *
18529  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18530  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18531  *
18532  * @pre This method can be called if @p scip is in one of the following stages:
18533  * - \ref SCIP_STAGE_SOLVING
18534  */
18535 extern
18537  SCIP* scip, /**< SCIP data structure */
18538  SCIP_NODE*** siblings, /**< pointer to store siblings array, or NULL if not needed */
18539  int* nsiblings /**< pointer to store number of siblings, or NULL if not needed */
18540  );
18541 
18542 /** gets number of siblings of focus node
18543  *
18544  * @return the number of siblings of focus node
18545  *
18546  * @pre This method can be called if @p scip is in one of the following stages:
18547  * - \ref SCIP_STAGE_SOLVING
18548  */
18549 extern
18550 int SCIPgetNSiblings(
18551  SCIP* scip /**< SCIP data structure */
18552  );
18553 
18554 /** gets leaves of the tree along with the number of leaves
18555  *
18556  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18557  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18558  *
18559  * @pre This method can be called if @p scip is in one of the following stages:
18560  * - \ref SCIP_STAGE_SOLVING
18561  */
18562 extern
18564  SCIP* scip, /**< SCIP data structure */
18565  SCIP_NODE*** leaves, /**< pointer to store leaves array, or NULL if not needed */
18566  int* nleaves /**< pointer to store number of leaves, or NULL if not needed */
18567  );
18568 
18569 /** gets number of leaves in the tree
18570  *
18571  * @return the number of leaves in the tree
18572  *
18573  * @pre This method can be called if @p scip is in one of the following stages:
18574  * - \ref SCIP_STAGE_SOLVING
18575  */
18576 extern
18577 int SCIPgetNLeaves(
18578  SCIP* scip /**< SCIP data structure */
18579  );
18580 
18581 /** gets number of nodes left in the tree (children + siblings + leaves)
18582  *
18583  * @return the number of nodes left in the tree (children + siblings + leaves)
18584  *
18585  * @pre This method can be called if SCIP is in one of the following stages:
18586  * - \ref SCIP_STAGE_PRESOLVED
18587  * - \ref SCIP_STAGE_SOLVING
18588  * - \ref SCIP_STAGE_SOLVED
18589  */
18590 extern
18591 int SCIPgetNNodesLeft(
18592  SCIP* scip /**< SCIP data structure */
18593  );
18594 
18595 /** gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
18596  *
18597  * @return the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
18598  *
18599  * @pre This method can be called if @p scip is in one of the following stages:
18600  * - \ref SCIP_STAGE_SOLVING
18601  */
18602 extern
18604  SCIP* scip /**< SCIP data structure */
18605  );
18606 
18607 /** gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
18608  *
18609  * @return the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
18610  *
18611  * @pre This method can be called if @p scip is in one of the following stages:
18612  * - \ref SCIP_STAGE_SOLVING
18613  */
18614 extern
18616  SCIP* scip /**< SCIP data structure */
18617  );
18618 
18619 /** gets the best child of the focus node w.r.t. the node selection strategy
18620  *
18621  * @return the best child of the focus node w.r.t. the node selection strategy
18622  *
18623  * @pre This method can be called if @p scip is in one of the following stages:
18624  * - \ref SCIP_STAGE_SOLVING
18625  */
18626 extern
18628  SCIP* scip /**< SCIP data structure */
18629  );
18630 
18631 /** gets the best sibling of the focus node w.r.t. the node selection strategy
18632  *
18633  * @return the best sibling of the focus node w.r.t. the node selection strategy
18634  *
18635  * @pre This method can be called if @p scip is in one of the following stages:
18636  * - \ref SCIP_STAGE_SOLVING
18637  */
18638 extern
18640  SCIP* scip /**< SCIP data structure */
18641  );
18642 
18643 /** gets the best leaf from the node queue w.r.t. the node selection strategy
18644  *
18645  * @return the best leaf from the node queue w.r.t. the node selection strategy
18646  *
18647  * @pre This method can be called if @p scip is in one of the following stages:
18648  * - \ref SCIP_STAGE_SOLVING
18649  */
18650 extern
18652  SCIP* scip /**< SCIP data structure */
18653  );
18654 
18655 /** gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
18656  *
18657  * @return the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
18658  *
18659  * @pre This method can be called if @p scip is in one of the following stages:
18660  * - \ref SCIP_STAGE_SOLVING
18661  */
18662 extern
18664  SCIP* scip /**< SCIP data structure */
18665  );
18666 
18667 /** gets the node with smallest lower bound from the tree (child, sibling, or leaf)
18668  *
18669  * @return the node with smallest lower bound from the tree (child, sibling, or leaf)
18670  *
18671  * @pre This method can be called if @p scip is in one of the following stages:
18672  * - \ref SCIP_STAGE_SOLVING
18673  */
18674 extern
18676  SCIP* scip /**< SCIP data structure */
18677  );
18678 
18679 /** access to all data of open nodes (leaves, children, and siblings)
18680  *
18681  * @pre This method can be called if @p scip is in one of the following stages:
18682  * - \ref SCIP_STAGE_SOLVING
18683  */
18684 extern
18686  SCIP* scip, /**< SCIP data structure */
18687  SCIP_NODE*** leaves, /**< pointer to store the leaves, or NULL if not needed */
18688  SCIP_NODE*** children, /**< pointer to store the children, or NULL if not needed */
18689  SCIP_NODE*** siblings, /**< pointer to store the siblings, or NULL if not needed */
18690  int* nleaves, /**< pointer to store the number of leaves, or NULL */
18691  int* nchildren, /**< pointer to store the number of children, or NULL */
18692  int* nsiblings /**< pointer to store the number of siblings, or NULL */
18693  );
18694 
18695 /** cuts off node and whole sub tree from branch and bound tree
18696  *
18697  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18698  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18699  *
18700  * @pre This method can be called if @p scip is in one of the following stages:
18701  * - \ref SCIP_STAGE_SOLVING
18702  */
18703 extern
18705  SCIP* scip, /**< SCIP data structure */
18706  SCIP_NODE* node /**< node that should be cut off */
18707  );
18708 
18709 /** marks the given node to be propagated again the next time a node of its subtree is processed
18710  *
18711  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18712  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18713  *
18714  * @pre This method can be called if @p scip is in one of the following stages:
18715  * - \ref SCIP_STAGE_SOLVING
18716  */
18717 extern
18719  SCIP* scip, /**< SCIP data structure */
18720  SCIP_NODE* node /**< node that should be propagated again */
18721  );
18722 
18723 /** returns depth of first node in active path that is marked being cutoff
18724  *
18725  * @return depth of first node in active path that is marked being cutoff
18726  *
18727  * @pre This method can be called if @p scip is in one of the following stages:
18728  * - \ref SCIP_STAGE_SOLVING
18729  */
18730 extern
18731 int SCIPgetCutoffdepth(
18732  SCIP* scip /**< SCIP data structure */
18733  );
18734 
18735 /** returns depth of first node in active path that has to be propagated again
18736  *
18737  * @return depth of first node in active path that has to be propagated again
18738  *
18739  * @pre This method can be called if @p scip is in one of the following stages:
18740  * - \ref SCIP_STAGE_SOLVING
18741  */
18742 extern
18743 int SCIPgetRepropdepth(
18744  SCIP* scip /**< SCIP data structure */
18745  );
18746 
18747 /** prints all branching decisions on variables from the root to the given node
18748  *
18749  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18750  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18751  *
18752  * @pre This method can be called if @p scip is in one of the following stages:
18753  * - \ref SCIP_STAGE_SOLVING
18754  */
18755 extern
18757  SCIP* scip, /**< SCIP data structure */
18758  SCIP_NODE* node, /**< node data */
18759  FILE* file /**< output file (or NULL for standard output) */
18760  );
18761 
18762 /** sets whether the LP should be solved at the focus node
18763  *
18764  * @note In order to have an effect, this method needs to be called after a node is focused but before the LP is
18765  * solved.
18766  *
18767  * @pre This method can be called if @p scip is in one of the following stages:
18768  * - \ref SCIP_STAGE_SOLVING
18769  */
18770 extern
18771 void SCIPsetFocusnodeLP(
18772  SCIP* scip, /**< SCIP data structure */
18773  SCIP_Bool solvelp /**< should the LP be solved? */
18774  );
18775 
18776 /**@} */
18777 
18778 
18779 /*
18780  * parallel interface methods
18781  */
18782 
18783 /**@addtogroup PublicParallelMethods
18784  *
18785  * @{
18786  */
18787 
18788 /** Constructs the parallel interface to execute processes concurrently.
18789  *
18790  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18791  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18792  *
18793  * @pre This method can be called if @p scip is in one of the following stages:
18794  * - \ref SCIP_STAGE_PROBLEM
18795  * - \ref SCIP_STAGE_TRANSFORMING
18796  * - \ref SCIP_STAGE_TRANSFORMED
18797  * - \ref SCIP_STAGE_INITPRESOLVE
18798  * - \ref SCIP_STAGE_PRESOLVING
18799  * - \ref SCIP_STAGE_EXITPRESOLVE
18800  * - \ref SCIP_STAGE_PRESOLVED
18801  * - \ref SCIP_STAGE_INITSOLVE
18802  * - \ref SCIP_STAGE_SOLVING
18803  * - \ref SCIP_STAGE_SOLVED
18804  * - \ref SCIP_STAGE_EXITSOLVE
18805  * - \ref SCIP_STAGE_FREETRANS
18806  *
18807  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18808  */
18809 extern
18811  SCIP* scip /**< SCIP data structure */
18812  );
18813 
18814 /** releases the current synchronization store
18815  *
18816  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18817  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18818  *
18819  * @pre This method can be called if @p scip is in one of the following stages:
18820  * - \ref SCIP_STAGE_PROBLEM
18821  * - \ref SCIP_STAGE_TRANSFORMING
18822  * - \ref SCIP_STAGE_TRANSFORMED
18823  * - \ref SCIP_STAGE_INITPRESOLVE
18824  * - \ref SCIP_STAGE_PRESOLVING
18825  * - \ref SCIP_STAGE_EXITPRESOLVE
18826  * - \ref SCIP_STAGE_PRESOLVED
18827  * - \ref SCIP_STAGE_INITSOLVE
18828  * - \ref SCIP_STAGE_SOLVING
18829  * - \ref SCIP_STAGE_SOLVED
18830  * - \ref SCIP_STAGE_EXITSOLVE
18831  * - \ref SCIP_STAGE_FREETRANS
18832  * - \ref SCIP_STAGE_FREE
18833  *
18834  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18835  */
18837  SCIP* scip /**< SCIP data structure */
18838  );
18839 
18840 /** Gets the synchronization store.
18841  *
18842  * @return the \ref SCIP_SYNCSTORE parallel interface pointer to submit jobs for concurrent processing.
18843  *
18844  * @pre This method can be called if @p scip is in one of the following stages:
18845  * - \ref SCIP_STAGE_INIT
18846  * - \ref SCIP_STAGE_PROBLEM
18847  * - \ref SCIP_STAGE_TRANSFORMING
18848  * - \ref SCIP_STAGE_TRANSFORMED
18849  * - \ref SCIP_STAGE_INITPRESOLVE
18850  * - \ref SCIP_STAGE_PRESOLVING
18851  * - \ref SCIP_STAGE_EXITPRESOLVE
18852  * - \ref SCIP_STAGE_PRESOLVED
18853  * - \ref SCIP_STAGE_INITSOLVE
18854  * - \ref SCIP_STAGE_SOLVING
18855  * - \ref SCIP_STAGE_SOLVED
18856  * - \ref SCIP_STAGE_EXITSOLVE
18857  * - \ref SCIP_STAGE_FREETRANS
18858  *
18859  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18860  */
18861 extern
18863  SCIP* scip /**< SCIP data structure */
18864  );
18865 
18866 /**@} */
18867 
18868 
18869 
18870 /*
18871  * reoptimization methods
18872  */
18873 
18874 /**@addtogroup PublicReoptimizationMethods
18875  *
18876  * @{
18877  */
18878 
18879 /** return the ids of child nodes stored in the reoptimization tree
18880  *
18881  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18882  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18883  *
18884  * @pre This method can be called if @p scip is in one of the following stages:
18885  * - \ref SCIP_STAGE_PRESOLVED
18886  * - \ref SCIP_STAGE_SOLVING
18887  * - \ref SCIP_STAGE_SOLVED
18888  */
18889 extern
18891  SCIP* scip, /**< SCIP data structure */
18892  SCIP_NODE* node, /**< node of the search tree */
18893  unsigned int* ids, /**< array to store the ids of child nodes */
18894  int mem, /**< allocated memory */
18895  int* nids /**< number of child nodes */
18896  );
18897 
18898 /** return the ids of all leave nodes store in the reoptimization tree induced by the given node
18899  *
18900  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18901  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18902  *
18903  * @pre This method can be called if @p scip is in one of the following stages:
18904  * - \ref SCIP_STAGE_PRESOLVED
18905  * - \ref SCIP_STAGE_SOLVING
18906  * - \ref SCIP_STAGE_SOLVED
18907  */
18908 extern
18910  SCIP* scip, /**< SCIP data strcuture */
18911  SCIP_NODE* node, /**< node of the search tree */
18912  unsigned int* ids, /**< array of ids */
18913  int mem, /**< allocated memory */
18914  int* nids /**< number of child nodes */
18915  );
18916 
18917 /** returns the number of nodes in the reoptimization tree induced by @p node; if @p node == NULL, the method
18918  * returns the number of nodes of the whole reoptimization tree.
18919  */
18920 extern
18921 int SCIPgetNReoptnodes(
18922  SCIP* scip, /**< SCIP data structure */
18923  SCIP_NODE* node /**< node of the search tree */
18924  );
18925 
18926 /** returns the number of leave nodes of the subtree induced by @p node; if @p node == NULL, the method
18927  * returns the number of leaf nodes of the whole reoptimization tree.
18928  */
18929 extern
18931  SCIP* scip, /**< SCIP data structure */
18932  SCIP_NODE* node /**< node of the search tree */
18933  );
18934 
18935 /** gets the node of the reoptimization tree corresponding to the unique @p id */
18937  SCIP* scip, /**< SCIP data structure */
18938  unsigned int id /**< unique id */
18939  );
18940 
18941 /** add a variable bound change to a given reoptnode
18942  *
18943  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18944  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18945  *
18946  * @pre This method can be called if @p scip is in one of the following stages:
18947  * - \ref SCIP_STAGE_PRESOLVED
18948  * - \ref SCIP_STAGE_SOLVING
18949  * - \ref SCIP_STAGE_SOLVED
18950  */
18951 extern
18953  SCIP* scip, /**< SCIP data structure */
18954  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
18955  SCIP_VAR* var, /**< variable pointer */
18956  SCIP_Real bound, /**< variable bound to add */
18957  SCIP_BOUNDTYPE boundtype /**< bound type of the variable value */
18958  );
18959 
18960 /** set the @p representation as the new search frontier
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  */
18968 extern
18970  SCIP* scip, /**< SCIP data structure */
18971  SCIP_REOPTNODE** representation, /**< array of representatives */
18972  int nrepresentatives, /**< number of representatives */
18973  SCIP_Bool* success /**< pointer to store the result */
18974  );
18975 
18976 /** add stored constraint to a reoptimization node
18977  *
18978  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18979  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18980  *
18981  * @pre This method can be called if @p scip is in one of the following stages:
18982  * - \ref SCIP_STAGE_PRESOLVED
18983  */
18984 extern
18986  SCIP* scip, /**< SCIP data structure */
18987  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
18988  SCIP_VAR** vars, /**< array of variables */
18989  SCIP_Real* vals, /**< array of variable bounds */
18990  SCIP_BOUNDTYPE* boundtypes, /**< array of variable boundtypes */
18991  SCIP_Real lhs, /**< lhs of the constraint */
18992  SCIP_Real rhs, /**< rhs of the constraint */
18993  int nvars, /**< number of variables */
18994  REOPT_CONSTYPE constype, /**< type of the constraint */
18995  SCIP_Bool linear /**< the given constraint has a linear representation */
18996  );
18997 
18998 /** return the branching path stored in the reoptree at ID id */
18999 extern
19001  SCIP* scip, /**< SCIP data structure */
19002  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
19003  SCIP_VAR** vars, /**< array of variables */
19004  SCIP_Real* vals, /**< array of variable bounds */
19005  SCIP_BOUNDTYPE* boundtypes, /**< array of bound types */
19006  int mem, /**< allocated memory */
19007  int* nvars, /**< number of variables */
19008  int* nafterdualvars /**< number of variables directly after the first based on dual information */
19009  );
19010 
19011 /** initialize a set of empty reoptimization nodes
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_PRESOLVED
19018  */
19019 extern
19021  SCIP* scip, /**< SCIP data structure */
19022  SCIP_REOPTNODE** representatives, /**< array of representatives */
19023  int nrepresentatives /**< number of representatives */
19024  );
19025 
19026 /** reset a set of initialized reoptimization 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_PRESOLVED
19033  */
19035  SCIP* scip, /**< SCIP data structure */
19036  SCIP_REOPTNODE** representatives, /**< array of representatives */
19037  int nrepresentatives /**< number of representatives */
19038  );
19039 
19040 /** free a set of initialized reoptimization nodes
19041  *
19042  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19043  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19044  *
19045  * @pre This method can be called if @p scip is in one of the following stages:
19046  * - \ref SCIP_STAGE_PRESOLVED
19047  */
19048 extern
19050  SCIP* scip, /**< SCIP data structure */
19051  SCIP_REOPTNODE** representatives, /**< array of representatives */
19052  int nrepresentatives /**< number of representatives */
19053  );
19054 
19055 /** reactivate the given @p reoptnode and split them into several nodes if necessary
19056  *
19057  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19058  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19059  *
19060  * @pre This method can be called if @p scip is in one of the following stages:
19061  * - \ref SCIP_STAGE_SOLVING
19062  * - \ref SCIP_STAGE_SOLVED
19063  */
19064 extern
19066  SCIP* scip, /**< SCIP data structure */
19067  SCIP_REOPTNODE* reoptnode, /**< node to reactivate */
19068  unsigned int id, /**< unique id of the reoptimization node */
19069  SCIP_Real estimate, /**< estimate of the child nodes that should be created */
19070  SCIP_NODE** childnodes, /**< array to store the created child nodes */
19071  int* ncreatedchilds, /**< pointer to store number of created child nodes */
19072  int* naddedconss, /**< pointer to store number of generated constraints */
19073  int childnodessize, /**< available size of childnodes array */
19074  SCIP_Bool* success /**< pointer store the result*/
19075  );
19076 
19077 /** remove the stored information about bound changes based in dual information
19078  *
19079  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19080  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19081  *
19082  * @pre This method can be called if @p scip is in one of the following stages:
19083  * - \ref SCIP_STAGE_SOLVING
19084  * - \ref SCIP_STAGE_SOLVED
19085  */
19086 extern
19088  SCIP* scip, /**< SCIP data structure */
19089  SCIP_NODE* node /**< node of the search tree */
19090  );
19091 
19092 /** splits the root into several nodes and moves the child nodes of the root to one of the created nodes
19093  *
19094  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19095  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19096  *
19097  * @pre This method can be called if @p scip is in one of the following stages:
19098  * - \ref SCIP_STAGE_TRANSFORMED
19099  * - \ref SCIP_STAGE_SOLVING
19100  */
19101 extern
19103  SCIP* scip, /**< SCIP data structure */
19104  int* ncreatedchilds, /**< pointer to store the number of created nodes */
19105  int* naddedconss /**< pointer to store the number added constraints */
19106  );
19107 
19108 /** returns if a node should be reoptimized */
19109 extern
19111  SCIP* scip, /**< SCIP data structure */
19112  SCIP_NODE* node /**< node of the search tree */
19113  );
19114 
19115 /** deletes the given reoptimization node
19116  *
19117  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19118  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19119  *
19120  * @pre This method can be called if @p scip is in one of the following stages:
19121  * - \ref SCIP_STAGE_SOLVING
19122  */
19123 extern
19125  SCIP* scip, /**< SCIP data structure */
19126  SCIP_REOPTNODE** reoptnode /**< node of the reoptimization tree */
19127  );
19128 
19129 /** return the similarity between two objective functions */
19130 extern
19132  SCIP* scip, /**< SCIP data structure */
19133  int run1, /**< number of run */
19134  int run2 /**< number of run */
19135  );
19136 
19137 /** check the changes of the variable coefficient in the objective function */
19138 extern
19139 void SCIPgetVarCoefChg(
19140  SCIP* scip, /**< SCIP data structure */
19141  int varidx, /**< index of variable */
19142  SCIP_Bool* negated, /**< coefficient changed the sign */
19143  SCIP_Bool* entering, /**< coefficient gets non-zero coefficient */
19144  SCIP_Bool* leaving /**< coefficient gets zero coefficient */
19145  );
19146 
19147 /* @} */
19148 
19149 /*
19150  * statistic methods
19151  */
19152 
19153 /**@addtogroup PublicSolvingStatsMethods
19154  *
19155  * @{
19156  */
19157 
19158 /** gets number of branch and bound runs performed, including the current run
19159  *
19160  * @return the number of branch and bound runs performed, including the current run
19161  *
19162  * @pre This method can be called if SCIP is in one of the following stages:
19163  * - \ref SCIP_STAGE_PROBLEM
19164  * - \ref SCIP_STAGE_TRANSFORMING
19165  * - \ref SCIP_STAGE_TRANSFORMED
19166  * - \ref SCIP_STAGE_INITPRESOLVE
19167  * - \ref SCIP_STAGE_PRESOLVING
19168  * - \ref SCIP_STAGE_EXITPRESOLVE
19169  * - \ref SCIP_STAGE_PRESOLVED
19170  * - \ref SCIP_STAGE_INITSOLVE
19171  * - \ref SCIP_STAGE_SOLVING
19172  * - \ref SCIP_STAGE_SOLVED
19173  * - \ref SCIP_STAGE_EXITSOLVE
19174  * - \ref SCIP_STAGE_FREETRANS
19175  */
19176 extern
19177 int SCIPgetNRuns(
19178  SCIP* scip /**< SCIP data structure */
19179  );
19180 
19181 /** gets number of reoptimization runs performed, including the current run
19182  *
19183  * @return the number of reoptimization runs performed, including the current run
19184  *
19185  * @pre This method can be called if SCIP is in one of the following stages:
19186  * - \ref SCIP_STAGE_PROBLEM
19187  * - \ref SCIP_STAGE_TRANSFORMING
19188  * - \ref SCIP_STAGE_TRANSFORMED
19189  * - \ref SCIP_STAGE_INITPRESOLVE
19190  * - \ref SCIP_STAGE_PRESOLVING
19191  * - \ref SCIP_STAGE_EXITPRESOLVE
19192  * - \ref SCIP_STAGE_PRESOLVED
19193  * - \ref SCIP_STAGE_INITSOLVE
19194  * - \ref SCIP_STAGE_SOLVING
19195  * - \ref SCIP_STAGE_SOLVED
19196  * - \ref SCIP_STAGE_EXITSOLVE
19197  * - \ref SCIP_STAGE_FREETRANS
19198  */
19199 extern
19200 int SCIPgetNReoptRuns(
19201  SCIP* scip /**< SCIP data structure */
19202  );
19203 
19204 /** add given number to the number of processed nodes in current run and in all runs, including the focus node
19205  *
19206  * @return the number of processed nodes in current run, including the focus node
19207  *
19208  * @pre This method can be called if SCIP is in one of the following stages:
19209  * - \ref SCIP_STAGE_PROBLEM
19210  * - \ref SCIP_STAGE_TRANSFORMING
19211  * - \ref SCIP_STAGE_TRANSFORMED
19212  * - \ref SCIP_STAGE_INITPRESOLVE
19213  * - \ref SCIP_STAGE_PRESOLVING
19214  * - \ref SCIP_STAGE_EXITPRESOLVE
19215  * - \ref SCIP_STAGE_PRESOLVED
19216  * - \ref SCIP_STAGE_INITSOLVE
19217  * - \ref SCIP_STAGE_SOLVING
19218  * - \ref SCIP_STAGE_SOLVED
19219  * - \ref SCIP_STAGE_EXITSOLVE
19220  * - \ref SCIP_STAGE_FREETRANS
19221  */
19222 extern
19223 void SCIPaddNNodes(
19224  SCIP* scip, /**< SCIP data structure */
19225  SCIP_Longint nnodes /**< number of processed nodes to add to the statistics */
19226  );
19227 
19228 /** gets number of processed nodes in current run, including the focus node
19229  *
19230  * @return the number of processed nodes in current run, including the focus node
19231  *
19232  * @pre This method can be called if SCIP is in one of the following stages:
19233  * - \ref SCIP_STAGE_PROBLEM
19234  * - \ref SCIP_STAGE_TRANSFORMING
19235  * - \ref SCIP_STAGE_TRANSFORMED
19236  * - \ref SCIP_STAGE_INITPRESOLVE
19237  * - \ref SCIP_STAGE_PRESOLVING
19238  * - \ref SCIP_STAGE_EXITPRESOLVE
19239  * - \ref SCIP_STAGE_PRESOLVED
19240  * - \ref SCIP_STAGE_INITSOLVE
19241  * - \ref SCIP_STAGE_SOLVING
19242  * - \ref SCIP_STAGE_SOLVED
19243  * - \ref SCIP_STAGE_EXITSOLVE
19244  * - \ref SCIP_STAGE_FREETRANS
19245  */
19246 extern
19248  SCIP* scip /**< SCIP data structure */
19249  );
19250 
19251 /** gets total number of processed nodes in all runs, including the focus node
19252  *
19253  * @return the total number of processed nodes in all runs, including the focus node
19254  *
19255  * @pre This method can be called if SCIP is in one of the following stages:
19256  * - \ref SCIP_STAGE_PROBLEM
19257  * - \ref SCIP_STAGE_TRANSFORMING
19258  * - \ref SCIP_STAGE_TRANSFORMED
19259  * - \ref SCIP_STAGE_INITPRESOLVE
19260  * - \ref SCIP_STAGE_PRESOLVING
19261  * - \ref SCIP_STAGE_EXITPRESOLVE
19262  * - \ref SCIP_STAGE_PRESOLVED
19263  * - \ref SCIP_STAGE_INITSOLVE
19264  * - \ref SCIP_STAGE_SOLVING
19265  * - \ref SCIP_STAGE_SOLVED
19266  * - \ref SCIP_STAGE_EXITSOLVE
19267  * - \ref SCIP_STAGE_FREETRANS
19268  */
19269 extern
19271  SCIP* scip /**< SCIP data structure */
19272  );
19273 
19274 /** gets number of leaf nodes processed with feasible relaxation solution
19275  *
19276  * @return number of leaf nodes processed with feasible relaxation solution
19277  *
19278  * @pre This method can be called if SCIP is in one of the following stages:
19279  * - \ref SCIP_STAGE_PROBLEM
19280  * - \ref SCIP_STAGE_TRANSFORMING
19281  * - \ref SCIP_STAGE_TRANSFORMED
19282  * - \ref SCIP_STAGE_INITPRESOLVE
19283  * - \ref SCIP_STAGE_PRESOLVING
19284  * - \ref SCIP_STAGE_EXITPRESOLVE
19285  * - \ref SCIP_STAGE_PRESOLVED
19286  * - \ref SCIP_STAGE_INITSOLVE
19287  * - \ref SCIP_STAGE_SOLVING
19288  * - \ref SCIP_STAGE_SOLVED
19289  * - \ref SCIP_STAGE_EXITSOLVE
19290  * - \ref SCIP_STAGE_FREETRANS
19291  */
19292 extern
19294  SCIP* scip /**< SCIP data structure */
19295  );
19296 
19297 /** gets number of infeasible leaf nodes processed
19298  *
19299  * @return number of infeasible leaf nodes processed
19300  *
19301  * @pre This method can be called if SCIP is in one of the following stages:
19302  * - \ref SCIP_STAGE_PROBLEM
19303  * - \ref SCIP_STAGE_TRANSFORMING
19304  * - \ref SCIP_STAGE_TRANSFORMED
19305  * - \ref SCIP_STAGE_INITPRESOLVE
19306  * - \ref SCIP_STAGE_PRESOLVING
19307  * - \ref SCIP_STAGE_EXITPRESOLVE
19308  * - \ref SCIP_STAGE_PRESOLVED
19309  * - \ref SCIP_STAGE_INITSOLVE
19310  * - \ref SCIP_STAGE_SOLVING
19311  * - \ref SCIP_STAGE_SOLVED
19312  * - \ref SCIP_STAGE_EXITSOLVE
19313  * - \ref SCIP_STAGE_FREETRANS
19314  */
19315 extern
19317  SCIP* scip /**< SCIP data structure */
19318  );
19319 
19320 /** gets number of processed leaf nodes that hit LP objective limit
19321  *
19322  * @return number of processed leaf nodes that hit LP objective limit
19323  *
19324  * @pre This method can be called if SCIP is in one of the following stages:
19325  * - \ref SCIP_STAGE_PROBLEM
19326  * - \ref SCIP_STAGE_TRANSFORMING
19327  * - \ref SCIP_STAGE_TRANSFORMED
19328  * - \ref SCIP_STAGE_INITPRESOLVE
19329  * - \ref SCIP_STAGE_PRESOLVING
19330  * - \ref SCIP_STAGE_EXITPRESOLVE
19331  * - \ref SCIP_STAGE_PRESOLVED
19332  * - \ref SCIP_STAGE_INITSOLVE
19333  * - \ref SCIP_STAGE_SOLVING
19334  * - \ref SCIP_STAGE_SOLVED
19335  * - \ref SCIP_STAGE_EXITSOLVE
19336  * - \ref SCIP_STAGE_FREETRANS
19337  */
19338 extern
19340  SCIP* scip /**< SCIP data structure */
19341  );
19342 
19343 /** gets number of times a selected node was from a cut off subtree
19344  *
19345  * @return number of times a selected node was from a cut off subtree
19346  *
19347  * @pre This method can be called if SCIP is in one of the following stages:
19348  * - \ref SCIP_STAGE_PROBLEM
19349  * - \ref SCIP_STAGE_TRANSFORMING
19350  * - \ref SCIP_STAGE_TRANSFORMED
19351  * - \ref SCIP_STAGE_INITPRESOLVE
19352  * - \ref SCIP_STAGE_PRESOLVING
19353  * - \ref SCIP_STAGE_EXITPRESOLVE
19354  * - \ref SCIP_STAGE_PRESOLVED
19355  * - \ref SCIP_STAGE_INITSOLVE
19356  * - \ref SCIP_STAGE_SOLVING
19357  * - \ref SCIP_STAGE_SOLVED
19358  * - \ref SCIP_STAGE_EXITSOLVE
19359  * - \ref SCIP_STAGE_FREETRANS
19360  */
19361 extern
19363  SCIP* scip /**< SCIP data structure */
19364  );
19365 
19366 /** gets total number of LPs solved so far
19367  *
19368  * @return the total number of LPs solved so far
19369  *
19370  * @pre This method can be called if SCIP is in one of the following stages:
19371  * - \ref SCIP_STAGE_PROBLEM
19372  * - \ref SCIP_STAGE_TRANSFORMING
19373  * - \ref SCIP_STAGE_TRANSFORMED
19374  * - \ref SCIP_STAGE_INITPRESOLVE
19375  * - \ref SCIP_STAGE_PRESOLVING
19376  * - \ref SCIP_STAGE_EXITPRESOLVE
19377  * - \ref SCIP_STAGE_PRESOLVED
19378  * - \ref SCIP_STAGE_INITSOLVE
19379  * - \ref SCIP_STAGE_SOLVING
19380  * - \ref SCIP_STAGE_SOLVED
19381  * - \ref SCIP_STAGE_EXITSOLVE
19382  * - \ref SCIP_STAGE_FREETRANS
19383  */
19384 extern
19386  SCIP* scip /**< SCIP data structure */
19387  );
19388 
19389 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
19390  *
19391  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
19392  *
19393  * @pre This method can be called if SCIP is in one of the following stages:
19394  * - \ref SCIP_STAGE_PRESOLVING
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 number of active non-zeros in the current transformed problem
19405  *
19406  * @return the number of active non-zeros in the current transformed problem
19407  *
19408  * @pre This method can be called if SCIP is in one of the following stages:
19409  * - \ref SCIP_STAGE_PROBLEM
19410  * - \ref SCIP_STAGE_TRANSFORMING
19411  * - \ref SCIP_STAGE_TRANSFORMED
19412  * - \ref SCIP_STAGE_INITPRESOLVE
19413  * - \ref SCIP_STAGE_PRESOLVING
19414  * - \ref SCIP_STAGE_EXITPRESOLVE
19415  * - \ref SCIP_STAGE_PRESOLVED
19416  * - \ref SCIP_STAGE_INITSOLVE
19417  * - \ref SCIP_STAGE_SOLVING
19418  * - \ref SCIP_STAGE_SOLVED
19419  * - \ref SCIP_STAGE_EXITSOLVE
19420  */
19421 extern
19423  SCIP* scip /**< SCIP data structure */
19424  );
19425 
19426 
19427 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
19428  *
19429  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
19430  *
19431  * @pre This method can be called if SCIP is in one of the following stages:
19432  * - \ref SCIP_STAGE_PRESOLVED
19433  * - \ref SCIP_STAGE_SOLVING
19434  * - \ref SCIP_STAGE_SOLVED
19435  */
19436 extern
19438  SCIP* scip /**< SCIP data structure */
19439  );
19440 
19441 /** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
19442  * node
19443  *
19444  * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
19445  *
19446  * @pre This method can be called if SCIP is in one of the following stages:
19447  * - \ref SCIP_STAGE_PRESOLVED
19448  * - \ref SCIP_STAGE_SOLVING
19449  * - \ref SCIP_STAGE_SOLVED
19450  */
19451 extern
19453  SCIP* scip /**< SCIP data structure */
19454  );
19455 
19456 /** gets total number of primal LPs solved so far
19457  *
19458  * @return the total number of primal LPs solved so far
19459  *
19460  * @pre This method can be called if SCIP is in one of the following stages:
19461  * - \ref SCIP_STAGE_PRESOLVED
19462  * - \ref SCIP_STAGE_SOLVING
19463  * - \ref SCIP_STAGE_SOLVED
19464  */
19465 extern
19467  SCIP* scip /**< SCIP data structure */
19468  );
19469 
19470 /** gets total number of iterations used so far in primal simplex
19471  *
19472  * @return total number of iterations used so far in primal simplex
19473  *
19474  * @pre This method can be called if SCIP is in one of the following stages:
19475  * - \ref SCIP_STAGE_PRESOLVED
19476  * - \ref SCIP_STAGE_SOLVING
19477  * - \ref SCIP_STAGE_SOLVED
19478  */
19479 extern
19481  SCIP* scip /**< SCIP data structure */
19482  );
19483 
19484 /** gets total number of dual LPs solved so far
19485  *
19486  * @return the total number of dual LPs solved so far
19487  *
19488  * @pre This method can be called if SCIP is in one of the following stages:
19489  * - \ref SCIP_STAGE_PRESOLVED
19490  * - \ref SCIP_STAGE_SOLVING
19491  * - \ref SCIP_STAGE_SOLVED
19492  */
19493 extern
19495  SCIP* scip /**< SCIP data structure */
19496  );
19497 
19498 /** gets total number of iterations used so far in dual simplex
19499  *
19500  * @return the total number of iterations used so far in dual simplex
19501  *
19502  * @pre This method can be called if SCIP is in one of the following stages:
19503  * - \ref SCIP_STAGE_PRESOLVED
19504  * - \ref SCIP_STAGE_SOLVING
19505  * - \ref SCIP_STAGE_SOLVED
19506  */
19507 extern
19509  SCIP* scip /**< SCIP data structure */
19510  );
19511 
19512 /** gets total number of barrier LPs solved so far
19513  *
19514  * @return the total number of barrier LPs solved so far
19515  *
19516  * @pre This method can be called if SCIP is in one of the following stages:
19517  * - \ref SCIP_STAGE_PRESOLVED
19518  * - \ref SCIP_STAGE_SOLVING
19519  * - \ref SCIP_STAGE_SOLVED
19520  */
19521 extern
19523  SCIP* scip /**< SCIP data structure */
19524  );
19525 
19526 /** gets total number of iterations used so far in barrier algorithm
19527  *
19528  * @return the total number of iterations used so far in barrier algorithm
19529  *
19530  * @pre This method can be called if SCIP is in one of the following stages:
19531  * - \ref SCIP_STAGE_PRESOLVED
19532  * - \ref SCIP_STAGE_SOLVING
19533  * - \ref SCIP_STAGE_SOLVED
19534  */
19535 extern
19537  SCIP* scip /**< SCIP data structure */
19538  );
19539 
19540 /** gets total number of LPs solved so far that were resolved from an advanced start basis
19541  *
19542  * @return the total number of LPs solved so far that were resolved from an advanced start basis
19543  *
19544  * @pre This method can be called if SCIP is in one of the following stages:
19545  * - \ref SCIP_STAGE_PRESOLVED
19546  * - \ref SCIP_STAGE_SOLVING
19547  * - \ref SCIP_STAGE_SOLVED
19548  */
19549 extern
19551  SCIP* scip /**< SCIP data structure */
19552  );
19553 
19554 /** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
19555  * was available
19556  *
19557  * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
19558  * basis was available
19559  *
19560  * @pre This method can be called if SCIP is in one of the following stages:
19561  * - \ref SCIP_STAGE_PRESOLVED
19562  * - \ref SCIP_STAGE_SOLVING
19563  * - \ref SCIP_STAGE_SOLVED
19564  */
19565 extern
19567  SCIP* scip /**< SCIP data structure */
19568  );
19569 
19570 /** gets total number of primal LPs solved so far that were resolved from an advanced start basis
19571  *
19572  * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
19573  *
19574  * @pre This method can be called if SCIP is in one of the following stages:
19575  * - \ref SCIP_STAGE_PRESOLVED
19576  * - \ref SCIP_STAGE_SOLVING
19577  * - \ref SCIP_STAGE_SOLVED
19578  */
19579 extern
19581  SCIP* scip /**< SCIP data structure */
19582  );
19583 
19584 /** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
19585  * was available
19586  *
19587  * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
19588  * basis was available
19589  *
19590  * @pre This method can be called if SCIP is in one of the following stages:
19591  * - \ref SCIP_STAGE_PRESOLVED
19592  * - \ref SCIP_STAGE_SOLVING
19593  * - \ref SCIP_STAGE_SOLVED
19594  */
19595 extern
19597  SCIP* scip /**< SCIP data structure */
19598  );
19599 
19600 /** gets total number of dual LPs solved so far that were resolved from an advanced start basis
19601  *
19602  * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
19603  *
19604  * @pre This method can be called if SCIP is in one of the following stages:
19605  * - \ref SCIP_STAGE_PRESOLVED
19606  * - \ref SCIP_STAGE_SOLVING
19607  * - \ref SCIP_STAGE_SOLVED
19608  */
19609 extern
19611  SCIP* scip /**< SCIP data structure */
19612  );
19613 
19614 /** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
19615  * was available
19616  *
19617  * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
19618  * basis was available
19619  *
19620  * @pre This method can be called if SCIP is in one of the following stages:
19621  * - \ref SCIP_STAGE_PRESOLVED
19622  * - \ref SCIP_STAGE_SOLVING
19623  * - \ref SCIP_STAGE_SOLVED
19624  */
19625 extern
19627  SCIP* scip /**< SCIP data structure */
19628  );
19629 
19630 /** gets total number of LPs solved so far for node relaxations
19631  *
19632  * @return the total number of LPs solved so far for node relaxations
19633  *
19634  * @pre This method can be called if SCIP is in one of the following stages:
19635  * - \ref SCIP_STAGE_PRESOLVED
19636  * - \ref SCIP_STAGE_SOLVING
19637  * - \ref SCIP_STAGE_SOLVED
19638  */
19639 extern
19641  SCIP* scip /**< SCIP data structure */
19642  );
19643 
19644 /** gets total number of simplex iterations used so far for node relaxations
19645  *
19646  * @return the total number of simplex iterations used so far for node relaxations
19647  *
19648  * @pre This method can be called if SCIP is in one of the following stages:
19649  * - \ref SCIP_STAGE_PRESOLVED
19650  * - \ref SCIP_STAGE_SOLVING
19651  * - \ref SCIP_STAGE_SOLVED
19652  */
19653 extern
19655  SCIP* scip /**< SCIP data structure */
19656  );
19657 
19658 /** gets total number of LPs solved so far for initial LP in node relaxations
19659  *
19660  * @return the total number of LPs solved so far for initial LP in node relaxations
19661  *
19662  * @pre This method can be called if SCIP is in one of the following stages:
19663  * - \ref SCIP_STAGE_PRESOLVED
19664  * - \ref SCIP_STAGE_SOLVING
19665  * - \ref SCIP_STAGE_SOLVED
19666  */
19667 extern
19669  SCIP* scip /**< SCIP data structure */
19670  );
19671 
19672 /** gets total number of simplex iterations used so far for initial LP in node relaxations
19673  *
19674  * @return the total number of simplex iterations used so far for initial LP in node relaxations
19675  *
19676  * @pre This method can be called if SCIP is in one of the following stages:
19677  * - \ref SCIP_STAGE_PRESOLVED
19678  * - \ref SCIP_STAGE_SOLVING
19679  * - \ref SCIP_STAGE_SOLVED
19680  */
19681 extern
19683  SCIP* scip /**< SCIP data structure */
19684  );
19685 
19686 /** gets total number of LPs solved so far during diving and probing
19687  *
19688  * @return total number of LPs solved so far during diving and probing
19689  *
19690  * @pre This method can be called if SCIP is in one of the following stages:
19691  * - \ref SCIP_STAGE_PRESOLVED
19692  * - \ref SCIP_STAGE_SOLVING
19693  * - \ref SCIP_STAGE_SOLVED
19694  */
19695 extern
19697  SCIP* scip /**< SCIP data structure */
19698  );
19699 
19700 /** gets total number of simplex iterations used so far during diving and probing
19701  *
19702  * @return the total number of simplex iterations used so far during diving and probing
19703  *
19704  * @pre This method can be called if SCIP is in one of the following stages:
19705  * - \ref SCIP_STAGE_PRESOLVED
19706  * - \ref SCIP_STAGE_SOLVING
19707  * - \ref SCIP_STAGE_SOLVED
19708  */
19709 extern
19711  SCIP* scip /**< SCIP data structure */
19712  );
19713 
19714 /** gets total number of times, strong branching was called (each call represents solving two LPs)
19715  *
19716  * @return the total number of times, strong branching was called (each call represents solving two LPs)
19717  *
19718  * @pre This method can be called if SCIP is in one of the following stages:
19719  * - \ref SCIP_STAGE_PRESOLVED
19720  * - \ref SCIP_STAGE_SOLVING
19721  * - \ref SCIP_STAGE_SOLVED
19722  */
19723 extern
19725  SCIP* scip /**< SCIP data structure */
19726  );
19727 
19728 /** gets total number of simplex iterations used so far in strong branching
19729  *
19730  * @return the total number of simplex iterations used so far in strong branching
19731  *
19732  * @pre This method can be called if SCIP is in one of the following stages:
19733  * - \ref SCIP_STAGE_PRESOLVED
19734  * - \ref SCIP_STAGE_SOLVING
19735  * - \ref SCIP_STAGE_SOLVED
19736  */
19737 extern
19739  SCIP* scip /**< SCIP data structure */
19740  );
19741 
19742 /** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
19743  *
19744  * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
19745  *
19746  * @pre This method can be called if SCIP is in one of the following stages:
19747  * - \ref SCIP_STAGE_PRESOLVED
19748  * - \ref SCIP_STAGE_SOLVING
19749  * - \ref SCIP_STAGE_SOLVED
19750  */
19751 extern
19753  SCIP* scip /**< SCIP data structure */
19754  );
19755 
19756 /** gets total number of simplex iterations used so far in strong branching at the root node
19757  *
19758  * @return the total number of simplex iterations used so far in strong branching at the root node
19759  *
19760  * @pre This method can be called if SCIP is in one of the following stages:
19761  * - \ref SCIP_STAGE_PRESOLVED
19762  * - \ref SCIP_STAGE_SOLVING
19763  * - \ref SCIP_STAGE_SOLVED
19764  */
19765 extern
19767  SCIP* scip /**< SCIP data structure */
19768  );
19769 
19770 /** gets number of pricing rounds performed so far at the current node
19771  *
19772  * @return the number of pricing rounds performed so far at the current node
19773  *
19774  * @pre This method can be called if SCIP is in one of the following stages:
19775  * - \ref SCIP_STAGE_SOLVING
19776  */
19777 extern
19779  SCIP* scip /**< SCIP data structure */
19780  );
19781 
19782 /** get current number of variables in the pricing store
19783  *
19784  * @return the current number of variables in the pricing store
19785  *
19786  * @pre This method can be called if SCIP is in one of the following stages:
19787  * - \ref SCIP_STAGE_PRESOLVED
19788  * - \ref SCIP_STAGE_SOLVING
19789  * - \ref SCIP_STAGE_SOLVED
19790  */
19791 extern
19792 int SCIPgetNPricevars(
19793  SCIP* scip /**< SCIP data structure */
19794  );
19795 
19796 /** get total number of pricing variables found so far
19797  *
19798  * @return the total number of pricing variables found so far
19799  *
19800  * @pre This method can be called if SCIP is in one of the following stages:
19801  * - \ref SCIP_STAGE_PRESOLVED
19802  * - \ref SCIP_STAGE_SOLVING
19803  * - \ref SCIP_STAGE_SOLVED
19804  */
19805 extern
19807  SCIP* scip /**< SCIP data structure */
19808  );
19809 
19810 /** get total number of pricing variables applied to the LPs
19811  *
19812  * @return the total number of pricing variables applied to the LPs
19813  *
19814  * @pre This method can be called if SCIP is in one of the following stages:
19815  * - \ref SCIP_STAGE_PRESOLVED
19816  * - \ref SCIP_STAGE_SOLVING
19817  * - \ref SCIP_STAGE_SOLVED
19818  */
19819 extern
19821  SCIP* scip /**< SCIP data structure */
19822  );
19823 
19824 /** gets number of separation rounds performed so far at the current node
19825  *
19826  * @return the number of separation rounds performed so far at the current node
19827  *
19828  * @pre This method can be called if SCIP is in one of the following stages:
19829  * - \ref SCIP_STAGE_SOLVING
19830  */
19831 extern
19832 int SCIPgetNSepaRounds(
19833  SCIP* scip /**< SCIP data structure */
19834  );
19835 
19836 /** get total number of cuts found so far
19837  *
19838  * @return the total number of cuts found so far
19839  *
19840  * @pre This method can be called if SCIP is in one of the following stages:
19841  * - \ref SCIP_STAGE_PRESOLVED
19842  * - \ref SCIP_STAGE_SOLVING
19843  * - \ref SCIP_STAGE_SOLVED
19844  */
19845 extern
19846 int SCIPgetNCutsFound(
19847  SCIP* scip /**< SCIP data structure */
19848  );
19849 
19850 /** get number of cuts found so far in current separation round
19851  *
19852  * @return the number of cuts found so far in current separation round
19853  *
19854  * @pre This method can be called if SCIP is in one of the following stages:
19855  * - \ref SCIP_STAGE_PRESOLVED
19856  * - \ref SCIP_STAGE_SOLVING
19857  * - \ref SCIP_STAGE_SOLVED
19858  */
19859 extern
19861  SCIP* scip /**< SCIP data structure */
19862  );
19863 
19864 /** get total number of cuts applied to the LPs
19865  *
19866  * @return the total number of cuts applied to the LPs
19867  *
19868  * @pre This method can be called if SCIP is in one of the following stages:
19869  * - \ref SCIP_STAGE_PRESOLVED
19870  * - \ref SCIP_STAGE_SOLVING
19871  * - \ref SCIP_STAGE_SOLVED
19872  */
19873 extern
19875  SCIP* scip /**< SCIP data structure */
19876  );
19877 
19878 /** get total number of constraints found in conflict analysis (conflict and reconvergence constraints)
19879  *
19880  * @return the total number of constraints found in conflict analysis (conflict and reconvergence constraints)
19881  *
19882  * @pre This method can be called if SCIP is in one of the following stages:
19883  * - \ref SCIP_STAGE_TRANSFORMED
19884  * - \ref SCIP_STAGE_INITPRESOLVE
19885  * - \ref SCIP_STAGE_PRESOLVING
19886  * - \ref SCIP_STAGE_EXITPRESOLVE
19887  * - \ref SCIP_STAGE_PRESOLVED
19888  * - \ref SCIP_STAGE_INITSOLVE
19889  * - \ref SCIP_STAGE_SOLVING
19890  * - \ref SCIP_STAGE_SOLVED
19891  * - \ref SCIP_STAGE_EXITSOLVE
19892  */
19893 extern
19895  SCIP* scip /**< SCIP data structure */
19896  );
19897 
19898 /** get number of conflict constraints found so far at the current node
19899  *
19900  * @return the number of conflict constraints found so far at the current node
19901  *
19902  * @pre This method can be called if SCIP is in one of the following stages:
19903  * - \ref SCIP_STAGE_TRANSFORMED
19904  * - \ref SCIP_STAGE_INITPRESOLVE
19905  * - \ref SCIP_STAGE_PRESOLVING
19906  * - \ref SCIP_STAGE_EXITPRESOLVE
19907  * - \ref SCIP_STAGE_PRESOLVED
19908  * - \ref SCIP_STAGE_INITSOLVE
19909  * - \ref SCIP_STAGE_SOLVING
19910  * - \ref SCIP_STAGE_SOLVED
19911  * - \ref SCIP_STAGE_EXITSOLVE
19912  */
19913 extern
19915  SCIP* scip /**< SCIP data structure */
19916  );
19917 
19918 /** get total number of conflict constraints added to the problem
19919  *
19920  * @return the total number of conflict constraints added to the problem
19921  *
19922  * @pre This method can be called if SCIP is in one of the following stages:
19923  * - \ref SCIP_STAGE_TRANSFORMED
19924  * - \ref SCIP_STAGE_INITPRESOLVE
19925  * - \ref SCIP_STAGE_PRESOLVING
19926  * - \ref SCIP_STAGE_EXITPRESOLVE
19927  * - \ref SCIP_STAGE_PRESOLVED
19928  * - \ref SCIP_STAGE_INITSOLVE
19929  * - \ref SCIP_STAGE_SOLVING
19930  * - \ref SCIP_STAGE_SOLVED
19931  * - \ref SCIP_STAGE_EXITSOLVE
19932  */
19933 extern
19935  SCIP* scip /**< SCIP data structure */
19936  );
19937 
19938 /** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
19939  *
19940  * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
19941  *
19942  * @pre This method can be called if SCIP is in one of the following stages:
19943  * - \ref SCIP_STAGE_TRANSFORMED
19944  * - \ref SCIP_STAGE_INITPRESOLVE
19945  * - \ref SCIP_STAGE_PRESOLVING
19946  * - \ref SCIP_STAGE_EXITPRESOLVE
19947  * - \ref SCIP_STAGE_PRESOLVED
19948  * - \ref SCIP_STAGE_INITSOLVE
19949  * - \ref SCIP_STAGE_SOLVING
19950  * - \ref SCIP_STAGE_SOLVED
19951  * - \ref SCIP_STAGE_EXITSOLVE
19952  */
19953 extern
19954 int SCIPgetMaxDepth(
19955  SCIP* scip /**< SCIP data structure */
19956  );
19957 
19958 /** gets maximal depth of all processed nodes over all branch and bound runs
19959  *
19960  * @return the maximal depth of all processed nodes over all branch and bound runs
19961  *
19962  * @pre This method can be called if SCIP is in one of the following stages:
19963  * - \ref SCIP_STAGE_TRANSFORMED
19964  * - \ref SCIP_STAGE_INITPRESOLVE
19965  * - \ref SCIP_STAGE_PRESOLVING
19966  * - \ref SCIP_STAGE_EXITPRESOLVE
19967  * - \ref SCIP_STAGE_PRESOLVED
19968  * - \ref SCIP_STAGE_INITSOLVE
19969  * - \ref SCIP_STAGE_SOLVING
19970  * - \ref SCIP_STAGE_SOLVED
19971  * - \ref SCIP_STAGE_EXITSOLVE
19972  */
19973 extern
19975  SCIP* scip /**< SCIP data structure */
19976  );
19977 
19978 /** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
19979  *
19980  * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
19981  *
19982  * @pre This method can be called if SCIP is in one of the following stages:
19983  * - \ref SCIP_STAGE_TRANSFORMED
19984  * - \ref SCIP_STAGE_INITPRESOLVE
19985  * - \ref SCIP_STAGE_PRESOLVING
19986  * - \ref SCIP_STAGE_EXITPRESOLVE
19987  * - \ref SCIP_STAGE_PRESOLVED
19988  * - \ref SCIP_STAGE_INITSOLVE
19989  * - \ref SCIP_STAGE_SOLVING
19990  * - \ref SCIP_STAGE_SOLVED
19991  * - \ref SCIP_STAGE_EXITSOLVE
19992  */
19993 extern
19995  SCIP* scip /**< SCIP data structure */
19996  );
19997 
19998 /** gets total number of active constraints at the current node
19999  *
20000  * @return the total number of active constraints at the current node
20001  *
20002  * @pre This method can be called if SCIP is in one of the following stages:
20003  * - \ref SCIP_STAGE_PRESOLVED
20004  * - \ref SCIP_STAGE_SOLVING
20005  */
20006 extern
20008  SCIP* scip /**< SCIP data structure */
20009  );
20010 
20011 /** gets total number of enabled constraints at the current node
20012  *
20013  * @return the total number of enabled constraints at the current node
20014  *
20015  * @pre This method can be called if SCIP is in one of the following stages:
20016  * - \ref SCIP_STAGE_PRESOLVED
20017  * - \ref SCIP_STAGE_SOLVING
20018  */
20019 extern
20021  SCIP* scip /**< SCIP data structure */
20022  );
20023 
20024 /** gets average dual bound of all unprocessed nodes for original problem */
20025 extern
20027  SCIP* scip /**< SCIP data structure */
20028  );
20029 
20030 /** gets average lower (dual) bound of all unprocessed nodes in transformed problem
20031  *
20032  * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
20033  *
20034  * @pre This method can be called if SCIP is in one of the following stages:
20035  * - \ref SCIP_STAGE_PRESOLVED
20036  * - \ref SCIP_STAGE_SOLVING
20037  * - \ref SCIP_STAGE_SOLVED
20038  */
20039 extern
20041  SCIP* scip /**< SCIP data structure */
20042  );
20043 
20044 /** gets global dual bound
20045  *
20046  * @return the global dual bound
20047  *
20048  * @pre This method can be called if SCIP is in one of the following stages:
20049  * - \ref SCIP_STAGE_PRESOLVING
20050  * - \ref SCIP_STAGE_EXITPRESOLVE
20051  * - \ref SCIP_STAGE_PRESOLVED
20052  * - \ref SCIP_STAGE_INITSOLVE
20053  * - \ref SCIP_STAGE_SOLVING
20054  * - \ref SCIP_STAGE_SOLVED
20055  */
20056 extern
20058  SCIP* scip /**< SCIP data structure */
20059  );
20060 
20061 /** gets global lower (dual) bound in transformed problem
20062  *
20063  * @return the global lower (dual) bound in transformed problem
20064  *
20065  * @pre This method can be called if SCIP is in one of the following stages:
20066  * - \ref SCIP_STAGE_PRESOLVING
20067  * - \ref SCIP_STAGE_EXITPRESOLVE
20068  * - \ref SCIP_STAGE_PRESOLVED
20069  * - \ref SCIP_STAGE_INITSOLVE
20070  * - \ref SCIP_STAGE_SOLVING
20071  * - \ref SCIP_STAGE_SOLVED
20072  */
20073 extern
20075  SCIP* scip /**< SCIP data structure */
20076  );
20077 
20078 /** gets dual bound of the root node for the original problem
20079  *
20080  * @return the dual bound of the root node for the original problem
20081  *
20082  * @pre This method can be called if SCIP is in one of the following stages:
20083  * - \ref SCIP_STAGE_PRESOLVING
20084  * - \ref SCIP_STAGE_EXITPRESOLVE
20085  * - \ref SCIP_STAGE_PRESOLVED
20086  * - \ref SCIP_STAGE_INITSOLVE
20087  * - \ref SCIP_STAGE_SOLVING
20088  * - \ref SCIP_STAGE_SOLVED
20089  */
20090 extern
20092  SCIP* scip /**< SCIP data structure */
20093  );
20094 
20095 /** gets lower (dual) bound in transformed problem of the root node
20096  *
20097  * @return the lower (dual) bound in transformed problem of the root node
20098  *
20099  * @pre This method can be called if SCIP is in one of the following stages:
20100  * - \ref SCIP_STAGE_PRESOLVING
20101  * - \ref SCIP_STAGE_EXITPRESOLVE
20102  * - \ref SCIP_STAGE_PRESOLVED
20103  * - \ref SCIP_STAGE_INITSOLVE
20104  * - \ref SCIP_STAGE_SOLVING
20105  * - \ref SCIP_STAGE_SOLVED
20106  */
20107 extern
20109  SCIP* scip /**< SCIP data structure */
20110  );
20111 
20112 /** gets dual bound for the original problem obtained by the first LP solve at the root node
20113  *
20114  * @return the dual bound for the original problem of the first LP solve at the root node
20115  *
20116  * @pre This method can be called if SCIP is in one of the following stages:
20117  * - \ref SCIP_STAGE_PRESOLVING
20118  * - \ref SCIP_STAGE_EXITPRESOLVE
20119  * - \ref SCIP_STAGE_PRESOLVED
20120  * - \ref SCIP_STAGE_INITSOLVE
20121  * - \ref SCIP_STAGE_SOLVING
20122  * - \ref SCIP_STAGE_SOLVED
20123  */
20124 extern
20126  SCIP* scip /**< SCIP data structure */
20127  );
20128 
20129 /** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
20130  *
20131  * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
20132  *
20133  * @pre This method can be called if SCIP is in one of the following stages:
20134  * - \ref SCIP_STAGE_PRESOLVING
20135  * - \ref SCIP_STAGE_EXITPRESOLVE
20136  * - \ref SCIP_STAGE_PRESOLVED
20137  * - \ref SCIP_STAGE_INITSOLVE
20138  * - \ref SCIP_STAGE_SOLVING
20139  * - \ref SCIP_STAGE_SOLVED
20140  */
20141 extern
20143  SCIP* scip /**< SCIP data structure */
20144  );
20145 
20146 
20147 /** the primal bound of the very first solution */
20148 extern
20150  SCIP* scip /**< SCIP data structure */
20151  );
20152 
20153 /** gets global primal bound (objective value of best solution or user objective limit) for the original problem
20154  *
20155  * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
20156  *
20157  * @pre This method can be called if SCIP is in one of the following stages:
20158  * - \ref SCIP_STAGE_TRANSFORMED
20159  * - \ref SCIP_STAGE_INITPRESOLVE
20160  * - \ref SCIP_STAGE_PRESOLVING
20161  * - \ref SCIP_STAGE_EXITPRESOLVE
20162  * - \ref SCIP_STAGE_PRESOLVED
20163  * - \ref SCIP_STAGE_INITSOLVE
20164  * - \ref SCIP_STAGE_SOLVING
20165  * - \ref SCIP_STAGE_SOLVED
20166  * - \ref SCIP_STAGE_EXITSOLVE
20167  */
20168 extern
20170  SCIP* scip /**< SCIP data structure */
20171  );
20172 
20173 /** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
20174  *
20175  * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
20176  *
20177  * @pre This method can be called if SCIP is in one of the following stages:
20178  * - \ref SCIP_STAGE_TRANSFORMED
20179  * - \ref SCIP_STAGE_INITPRESOLVE
20180  * - \ref SCIP_STAGE_PRESOLVING
20181  * - \ref SCIP_STAGE_EXITPRESOLVE
20182  * - \ref SCIP_STAGE_PRESOLVED
20183  * - \ref SCIP_STAGE_INITSOLVE
20184  * - \ref SCIP_STAGE_SOLVING
20185  * - \ref SCIP_STAGE_SOLVED
20186  * - \ref SCIP_STAGE_EXITSOLVE
20187  */
20188 extern
20190  SCIP* scip /**< SCIP data structure */
20191  );
20192 
20193 /** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
20194  * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
20195  * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
20196  * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
20197  *
20198  * @return global cutoff bound in transformed problem
20199  *
20200  * @pre This method can be called if SCIP is in one of the following stages:
20201  * - \ref SCIP_STAGE_TRANSFORMED
20202  * - \ref SCIP_STAGE_INITPRESOLVE
20203  * - \ref SCIP_STAGE_PRESOLVING
20204  * - \ref SCIP_STAGE_EXITPRESOLVE
20205  * - \ref SCIP_STAGE_PRESOLVED
20206  * - \ref SCIP_STAGE_INITSOLVE
20207  * - \ref SCIP_STAGE_SOLVING
20208  * - \ref SCIP_STAGE_SOLVED
20209  * - \ref SCIP_STAGE_EXITSOLVE
20210  */
20211 extern
20213  SCIP* scip /**< SCIP data structure */
20214  );
20215 
20216 /** updates the cutoff bound
20217  *
20218  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20219  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20220  *
20221  * @note using this method in the solving stage can lead to an erroneous SCIP solving status; in particular,
20222  * if a solution not respecting the cutoff bound was found before installing a cutoff bound which
20223  * renders the remaining problem infeasible, this solution may be reported as optimal
20224  *
20225  * @pre This method can be called if SCIP is in one of the following stages:
20226  * - \ref SCIP_STAGE_TRANSFORMED
20227  * - \ref SCIP_STAGE_PRESOLVING
20228  * - \ref SCIP_STAGE_PRESOLVED
20229  * - \ref SCIP_STAGE_INITSOLVE
20230  * - \ref SCIP_STAGE_SOLVING
20231  *
20232  * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
20233  */
20234 extern
20236  SCIP* scip, /**< SCIP data structure */
20237  SCIP_Real cutoffbound /**< new cutoff bound */
20238  );
20239 
20240 /** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
20241  * was set from the user as objective limit
20242  *
20243  * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
20244  *
20245  * @pre This method can be called if SCIP is in one of the following stages:
20246  * - \ref SCIP_STAGE_TRANSFORMED
20247  * - \ref SCIP_STAGE_INITPRESOLVE
20248  * - \ref SCIP_STAGE_PRESOLVING
20249  * - \ref SCIP_STAGE_EXITPRESOLVE
20250  * - \ref SCIP_STAGE_PRESOLVED
20251  * - \ref SCIP_STAGE_INITSOLVE
20252  * - \ref SCIP_STAGE_SOLVING
20253  * - \ref SCIP_STAGE_SOLVED
20254  * - \ref SCIP_STAGE_EXITSOLVE
20255  */
20256 extern
20258  SCIP* scip /**< SCIP data structure */
20259  );
20260 
20261 /** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
20262  * or infinity, if they have opposite sign
20263  *
20264  * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
20265  * or infinity, if they have opposite sign
20266  *
20267  * @pre This method can be called if SCIP is in one of the following stages:
20268  * - \ref SCIP_STAGE_PRESOLVED
20269  * - \ref SCIP_STAGE_SOLVING
20270  * - \ref SCIP_STAGE_SOLVED
20271  */
20272 extern
20274  SCIP* scip /**< SCIP data structure */
20275  );
20276 
20277 /** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
20278  * have same sign, or infinity, if they have opposite sign
20279  *
20280  * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
20281  * have same sign, or infinity, if they have opposite sign
20282  *
20283  * @pre This method can be called if SCIP is in one of the following stages:
20284  * - \ref SCIP_STAGE_PRESOLVED
20285  * - \ref SCIP_STAGE_SOLVING
20286  * - \ref SCIP_STAGE_SOLVED
20287  */
20288 extern
20290  SCIP* scip /**< SCIP data structure */
20291  );
20292 
20293 /** gets number of feasible primal solutions found so far
20294  *
20295  * @return the number of feasible primal solutions found so far
20296  *
20297  * @pre This method can be called if SCIP is in one of the following stages:
20298  * - \ref SCIP_STAGE_TRANSFORMED
20299  * - \ref SCIP_STAGE_INITPRESOLVE
20300  * - \ref SCIP_STAGE_PRESOLVING
20301  * - \ref SCIP_STAGE_EXITPRESOLVE
20302  * - \ref SCIP_STAGE_PRESOLVED
20303  * - \ref SCIP_STAGE_INITSOLVE
20304  * - \ref SCIP_STAGE_SOLVING
20305  * - \ref SCIP_STAGE_SOLVED
20306  * - \ref SCIP_STAGE_EXITSOLVE
20307  */
20308 extern
20310  SCIP* scip /**< SCIP data structure */
20311  );
20312 
20313 /** gets number of feasible primal solutions respecting the objective limit found so far
20314  *
20315  * @return the number of feasible primal solutions respecting the objective limit found so far
20316  *
20317  * @pre This method can be called if SCIP is in one of the following stages:
20318  * - \ref SCIP_STAGE_INIT
20319  * - \ref SCIP_STAGE_PROBLEM
20320  * - \ref SCIP_STAGE_TRANSFORMING
20321  * - \ref SCIP_STAGE_TRANSFORMED
20322  * - \ref SCIP_STAGE_INITPRESOLVE
20323  * - \ref SCIP_STAGE_PRESOLVING
20324  * - \ref SCIP_STAGE_EXITPRESOLVE
20325  * - \ref SCIP_STAGE_PRESOLVED
20326  * - \ref SCIP_STAGE_INITSOLVE
20327  * - \ref SCIP_STAGE_SOLVING
20328  * - \ref SCIP_STAGE_SOLVED
20329  * - \ref SCIP_STAGE_EXITSOLVE
20330  */
20331 extern
20333  SCIP* scip /**< SCIP data structure */
20334  );
20335 
20336 /** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
20337  *
20338  * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
20339  *
20340  * @pre This method can be called if SCIP is in one of the following stages:
20341  * - \ref SCIP_STAGE_TRANSFORMED
20342  * - \ref SCIP_STAGE_INITPRESOLVE
20343  * - \ref SCIP_STAGE_PRESOLVING
20344  * - \ref SCIP_STAGE_EXITPRESOLVE
20345  * - \ref SCIP_STAGE_PRESOLVED
20346  * - \ref SCIP_STAGE_INITSOLVE
20347  * - \ref SCIP_STAGE_SOLVING
20348  * - \ref SCIP_STAGE_SOLVED
20349  * - \ref SCIP_STAGE_EXITSOLVE
20350  */
20351 extern
20353  SCIP* scip /**< SCIP data structure */
20354  );
20355 
20356 /** gets the average pseudo cost value for the given direction over all variables
20357  *
20358  * @return the average pseudo cost value for the given direction over all variables
20359  *
20360  * @pre This method can be called if SCIP is in one of the following stages:
20361  * - \ref SCIP_STAGE_SOLVING
20362  * - \ref SCIP_STAGE_SOLVED
20363  */
20364 extern
20366  SCIP* scip, /**< SCIP data structure */
20367  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
20368  );
20369 
20370 /** gets the average pseudo cost value for the given direction over all variables,
20371  * only using the pseudo cost information of the current run
20372  *
20373  * @return the average pseudo cost value for the given direction over all variables,
20374  * only using the pseudo cost information of the current run
20375  *
20376  * @pre This method can be called if SCIP is in one of the following stages:
20377  * - \ref SCIP_STAGE_SOLVING
20378  * - \ref SCIP_STAGE_SOLVED
20379  */
20380 extern
20382  SCIP* scip, /**< SCIP data structure */
20383  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
20384  );
20385 
20386 /** gets the average number of pseudo cost updates for the given direction over all variables
20387  *
20388  * @return the average number of pseudo cost updates for the given direction over all variables
20389  *
20390  * @pre This method can be called if SCIP is in one of the following stages:
20391  * - \ref SCIP_STAGE_SOLVING
20392  * - \ref SCIP_STAGE_SOLVED
20393  */
20394 extern
20396  SCIP* scip, /**< SCIP data structure */
20397  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20398  );
20399 
20400 /** gets the average number of pseudo cost updates for the given direction over all variables,
20401  * only using the pseudo cost information of the current run
20402  *
20403  * @return the average number of pseudo cost updates for the given direction over all variables,
20404  * only using the pseudo cost information of the current run
20405  *
20406  * @pre This method can be called if SCIP is in one of the following stages:
20407  * - \ref SCIP_STAGE_SOLVING
20408  * - \ref SCIP_STAGE_SOLVED
20409  */
20410 extern
20412  SCIP* scip, /**< SCIP data structure */
20413  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20414  );
20415 
20416 /** gets the number of pseudo cost updates for the given direction over all variables
20417  *
20418  * @return the number of pseudo cost updates for the given direction over all variables
20419  *
20420  * @pre This method can be called if SCIP is in one of the following stages:
20421  * - \ref SCIP_STAGE_SOLVING
20422  * - \ref SCIP_STAGE_SOLVED
20423  */
20424 extern
20426  SCIP* scip, /**< SCIP data structure */
20427  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
20428  SCIP_Bool onlycurrentrun /**< use only history of current run? */
20429  );
20430 
20431 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
20432  *
20433  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
20434  *
20435  * @pre This method can be called if SCIP is in one of the following stages:
20436  * - \ref SCIP_STAGE_SOLVING
20437  * - \ref SCIP_STAGE_SOLVED
20438  */
20439 extern
20441  SCIP* scip /**< SCIP data structure */
20442  );
20443 
20444 /** returns the variance of pseudo costs for all variables in the requested direction
20445  *
20446  * @return the variance of pseudo costs for all variables in the requested direction
20447  *
20448  * @pre This method can be called if SCIP is in one of the following stages:
20449  * - \ref SCIP_STAGE_SOLVING
20450  * - \ref SCIP_STAGE_SOLVED
20451  */
20452 extern
20454  SCIP* scip, /**< SCIP data structure */
20455  SCIP_BRANCHDIR branchdir, /**< the branching direction, up or down */
20456  SCIP_Bool onlycurrentrun /**< use only history of current run? */
20457  );
20458 
20459 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
20460  * only using the pseudo cost information of the current run
20461  *
20462  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
20463  * only using the pseudo cost information of the current run
20464  *
20465  * @pre This method can be called if SCIP is in one of the following stages:
20466  * - \ref SCIP_STAGE_SOLVING
20467  * - \ref SCIP_STAGE_SOLVED
20468  */
20469 extern
20471  SCIP* scip /**< SCIP data structure */
20472  );
20473 
20474 /** gets the average conflict score value over all variables */
20475 extern
20477  SCIP* scip /**< SCIP data structure */
20478  );
20479 
20480 /** gets the average conflict score value over all variables, only using the pseudo cost information of the current run
20481  *
20482  * @return the average conflict score value over all variables, only using the pseudo cost information of the current run
20483  *
20484  * @pre This method can be called if SCIP is in one of the following stages:
20485  * - \ref SCIP_STAGE_SOLVING
20486  * - \ref SCIP_STAGE_SOLVED
20487  */
20488 extern
20490  SCIP* scip /**< SCIP data structure */
20491  );
20492 
20493 /** gets the average inference score value over all variables
20494  *
20495  * @return the average inference score value over all variables
20496  *
20497  * @pre This method can be called if SCIP is in one of the following stages:
20498  * - \ref SCIP_STAGE_SOLVING
20499  * - \ref SCIP_STAGE_SOLVED
20500  */
20501 extern
20503  SCIP* scip /**< SCIP data structure */
20504  );
20505 
20506 /** gets the average conflictlength score value over all variables, only using the pseudo cost information of the
20507  * current run
20508  *
20509  * @return the average conflictlength score value over all variables, only using the pseudo cost information of the
20510  * current run
20511  *
20512  * @pre This method can be called if SCIP is in one of the following stages:
20513  * - \ref SCIP_STAGE_SOLVING
20514  * - \ref SCIP_STAGE_SOLVED
20515  */
20516 extern
20518  SCIP* scip /**< SCIP data structure */
20519  );
20520 
20521 /** returns the average number of inferences found after branching in given direction over all variables
20522  *
20523  * @return the average number of inferences found after branching in given direction over all variables
20524  *
20525  * @pre This method can be called if SCIP is in one of the following stages:
20526  * - \ref SCIP_STAGE_SOLVING
20527  * - \ref SCIP_STAGE_SOLVED
20528  */
20529 extern
20531  SCIP* scip, /**< SCIP data structure */
20532  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20533  );
20534 
20535 /** returns the average number of inferences found after branching in given direction over all variables,
20536  * only using the pseudo cost information of the current run
20537  *
20538  * @return the average number of inferences found after branching in given direction over all variables,
20539  * only using the pseudo cost information of the current run
20540  *
20541  * @pre This method can be called if SCIP is in one of the following stages:
20542  * - \ref SCIP_STAGE_SOLVING
20543  * - \ref SCIP_STAGE_SOLVED
20544  */
20545 extern
20547  SCIP* scip, /**< SCIP data structure */
20548  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20549  );
20550 
20551 /** gets the average inference score value over all variables
20552  *
20553  * @return the average inference score value over all variables
20554  *
20555  * @pre This method can be called if SCIP is in one of the following stages:
20556  * - \ref SCIP_STAGE_SOLVING
20557  * - \ref SCIP_STAGE_SOLVED
20558  */
20559 extern
20561  SCIP* scip /**< SCIP data structure */
20562  );
20563 
20564 /** gets the average inference score value over all variables, only using the inference information information of the
20565  * current run
20566  *
20567  * @return the average inference score value over all variables, only using the inference information information of the
20568  * current run
20569  *
20570  * @pre This method can be called if SCIP is in one of the following stages:
20571  * - \ref SCIP_STAGE_SOLVING
20572  * - \ref SCIP_STAGE_SOLVED
20573  */
20574 extern
20576  SCIP* scip /**< SCIP data structure */
20577  );
20578 
20579 /** returns the average number of cutoffs found after branching in given direction over all variables
20580  *
20581  * @return the average number of cutoffs found after branching in given direction over all variables
20582  *
20583  * @pre This method can be called if SCIP is in one of the following stages:
20584  * - \ref SCIP_STAGE_SOLVING
20585  * - \ref SCIP_STAGE_SOLVED
20586  */
20587 extern
20589  SCIP* scip, /**< SCIP data structure */
20590  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20591  );
20592 
20593 /** returns the average number of cutoffs found after branching in given direction over all variables,
20594  * only using the pseudo cost information of the current run
20595  *
20596  * @return the average number of cutoffs found after branching in given direction over all variables,
20597  * only using the pseudo cost information of the current run
20598  *
20599  * @pre This method can be called if SCIP is in one of the following stages:
20600  * - \ref SCIP_STAGE_SOLVING
20601  * - \ref SCIP_STAGE_SOLVED
20602  */
20603 extern
20605  SCIP* scip, /**< SCIP data structure */
20606  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
20607  );
20608 
20609 /** gets the average cutoff score value over all variables
20610  *
20611  * @return the average cutoff score value over all variables
20612  *
20613  * @pre This method can be called if SCIP is in one of the following stages:
20614  * - \ref SCIP_STAGE_SOLVING
20615  * - \ref SCIP_STAGE_SOLVED
20616  */
20617 extern
20619  SCIP* scip /**< SCIP data structure */
20620  );
20621 
20622 /** gets the average cutoff score value over all variables, only using the pseudo cost information of the current run
20623  *
20624  * @return the average cutoff score value over all variables, only using the pseudo cost information of the current run
20625  *
20626  * @pre This method can be called if SCIP is in one of the following stages:
20627  * - \ref SCIP_STAGE_SOLVING
20628  * - \ref SCIP_STAGE_SOLVED
20629  */
20630 extern
20632  SCIP* scip /**< SCIP data structure */
20633  );
20634 
20635 /** gets deterministic time number of LPs solved so far
20636  *
20637  * @return the total number of LPs solved so far
20638  *
20639  * @pre This method can be called if SCIP is in one of the following stages:
20640  * - \ref SCIP_STAGE_PRESOLVED
20641  * - \ref SCIP_STAGE_SOLVING
20642  * - \ref SCIP_STAGE_SOLVED
20643  */
20644 extern
20646  SCIP* scip /**< SCIP data structure */
20647  );
20648 
20649 /** outputs original problem to file stream
20650  *
20651  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20652  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20653  *
20654  * @pre This method can be called if SCIP is in one of the following stages:
20655  * - \ref SCIP_STAGE_PROBLEM
20656  * - \ref SCIP_STAGE_TRANSFORMING
20657  * - \ref SCIP_STAGE_TRANSFORMED
20658  * - \ref SCIP_STAGE_INITPRESOLVE
20659  * - \ref SCIP_STAGE_PRESOLVING
20660  * - \ref SCIP_STAGE_EXITPRESOLVE
20661  * - \ref SCIP_STAGE_PRESOLVED
20662  * - \ref SCIP_STAGE_INITSOLVE
20663  * - \ref SCIP_STAGE_SOLVING
20664  * - \ref SCIP_STAGE_SOLVED
20665  * - \ref SCIP_STAGE_EXITSOLVE
20666  * - \ref SCIP_STAGE_FREETRANS
20667  */
20668 extern
20670  SCIP* scip, /**< SCIP data structure */
20671  FILE* file, /**< output file (or NULL for standard output) */
20672  const char* extension, /**< file format (or NULL for default CIP format)*/
20673  SCIP_Bool genericnames /**< using generic variable and constraint names? */
20674  );
20675 
20676 /** outputs transformed problem of the current node to file stream
20677  *
20678  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20679  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20680  *
20681  * @pre This method can be called if SCIP is in one of the following stages:
20682  * - \ref SCIP_STAGE_TRANSFORMED
20683  * - \ref SCIP_STAGE_INITPRESOLVE
20684  * - \ref SCIP_STAGE_PRESOLVING
20685  * - \ref SCIP_STAGE_EXITPRESOLVE
20686  * - \ref SCIP_STAGE_PRESOLVED
20687  * - \ref SCIP_STAGE_INITSOLVE
20688  * - \ref SCIP_STAGE_SOLVING
20689  * - \ref SCIP_STAGE_SOLVED
20690  * - \ref SCIP_STAGE_EXITSOLVE
20691  * - \ref SCIP_STAGE_FREETRANS
20692  */
20693 extern
20695  SCIP* scip, /**< SCIP data structure */
20696  FILE* file, /**< output file (or NULL for standard output) */
20697  const char* extension, /**< file format (or NULL for default CIP format)*/
20698  SCIP_Bool genericnames /**< using generic variable and constraint names? */
20699  );
20700 
20701 /** outputs solving statistics
20702  *
20703  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20704  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20705  *
20706  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
20707  * thus may to correspond to the original status.
20708  *
20709  * @pre This method can be called if SCIP is in one of the following stages:
20710  * - \ref SCIP_STAGE_INIT
20711  * - \ref SCIP_STAGE_PROBLEM
20712  * - \ref SCIP_STAGE_TRANSFORMED
20713  * - \ref SCIP_STAGE_INITPRESOLVE
20714  * - \ref SCIP_STAGE_PRESOLVING
20715  * - \ref SCIP_STAGE_EXITPRESOLVE
20716  * - \ref SCIP_STAGE_PRESOLVED
20717  * - \ref SCIP_STAGE_SOLVING
20718  * - \ref SCIP_STAGE_SOLVED
20719  */
20720 extern
20722  SCIP* scip, /**< SCIP data structure */
20723  FILE* file /**< output file (or NULL for standard output) */
20724  );
20725 
20726 /** outputs reoptimization statistics
20727  *
20728  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20729  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20730  *
20731  * @pre This method can be called if SCIP is in one of the following stages:
20732  * - \ref SCIP_STAGE_INIT
20733  * - \ref SCIP_STAGE_PROBLEM
20734  * - \ref SCIP_STAGE_TRANSFORMED
20735  * - \ref SCIP_STAGE_INITPRESOLVE
20736  * - \ref SCIP_STAGE_PRESOLVING
20737  * - \ref SCIP_STAGE_EXITPRESOLVE
20738  * - \ref SCIP_STAGE_PRESOLVED
20739  * - \ref SCIP_STAGE_SOLVING
20740  * - \ref SCIP_STAGE_SOLVED
20741  */
20742 extern
20744  SCIP* scip, /**< SCIP data structure */
20745  FILE* file /**< output file (or NULL for standard output) */
20746  );
20747 
20748 /** outputs history statistics about branchings on variables
20749  *
20750  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20751  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20752  *
20753  * @pre This method can be called if SCIP is in one of the following stages:
20754  * - \ref SCIP_STAGE_INIT
20755  * - \ref SCIP_STAGE_PROBLEM
20756  * - \ref SCIP_STAGE_TRANSFORMED
20757  * - \ref SCIP_STAGE_INITPRESOLVE
20758  * - \ref SCIP_STAGE_PRESOLVING
20759  * - \ref SCIP_STAGE_EXITPRESOLVE
20760  * - \ref SCIP_STAGE_PRESOLVED
20761  * - \ref SCIP_STAGE_SOLVING
20762  * - \ref SCIP_STAGE_SOLVED
20763  */
20764 extern
20766  SCIP* scip, /**< SCIP data structure */
20767  FILE* file /**< output file (or NULL for standard output) */
20768  );
20769 
20770 /** outputs node information display line
20771  *
20772  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20773  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20774  *
20775  * @pre This method can be called if SCIP is in one of the following stages:
20776  * - \ref SCIP_STAGE_SOLVING
20777  */
20778 extern
20780  SCIP* scip, /**< SCIP data structure */
20781  FILE* file, /**< output file (or NULL for standard output) */
20782  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
20783  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
20784  );
20785 
20786 /** gets total number of implications between variables that are stored in the implication graph
20787  *
20788  * @return the total number of implications between variables that are stored in the implication graph
20789  *
20790  * @pre This method can be called if SCIP is in one of the following stages:
20791  * - \ref SCIP_STAGE_INITPRESOLVE
20792  * - \ref SCIP_STAGE_PRESOLVING
20793  * - \ref SCIP_STAGE_EXITPRESOLVE
20794  * - \ref SCIP_STAGE_PRESOLVED
20795  * - \ref SCIP_STAGE_INITSOLVE
20796  * - \ref SCIP_STAGE_SOLVING
20797  * - \ref SCIP_STAGE_SOLVED
20798  */
20799 extern
20801  SCIP* scip /**< SCIP data structure */
20802  );
20803 
20804 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
20805  *
20806  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20807  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20808  *
20809  * @pre This method can be called if SCIP is in one of the following stages:
20810  * - \ref SCIP_STAGE_TRANSFORMED
20811  * - \ref SCIP_STAGE_INITPRESOLVE
20812  * - \ref SCIP_STAGE_PRESOLVING
20813  * - \ref SCIP_STAGE_EXITPRESOLVE
20814  * - \ref SCIP_STAGE_PRESOLVED
20815  * - \ref SCIP_STAGE_INITSOLVE
20816  * - \ref SCIP_STAGE_SOLVING
20817  * - \ref SCIP_STAGE_SOLVED
20818  * - \ref SCIP_STAGE_EXITSOLVE
20819  *
20820  * @deprecated because binary implications are now stored as cliques
20821  */
20822 extern
20824  SCIP* scip, /**< SCIP data structure */
20825  const char* filename /**< file name, or NULL for stdout */
20826  );
20827 
20828 
20829 /** update statistical information when a new solution was found */
20830 extern
20832  SCIP* scip /**< SCIP data structure */
20833  );
20834 
20835 /**@} */
20836 
20837 /*
20838  * timing methods
20839  */
20840 
20841 
20842 /**@addtogroup PublicTimingMethods
20843  *
20844  * @{
20845  */
20846 
20847 /** gets current time of day in seconds (standard time zone)
20848  *
20849  * @return the current time of day in seconds (standard time zone).
20850  */
20851 extern
20853  SCIP* scip /**< SCIP data structure */
20854  );
20855 
20856 /** creates a clock using the default clock type
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 /**< pointer to clock timer */
20865  );
20866 
20867 /** creates a clock counting the CPU user seconds
20868  *
20869  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20870  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20871  */
20872 extern
20874  SCIP* scip, /**< SCIP data structure */
20875  SCIP_CLOCK** clck /**< pointer to clock timer */
20876  );
20877 
20878 /** creates a clock counting the wall clock seconds
20879  *
20880  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20881  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20882  */
20883 extern
20885  SCIP* scip, /**< SCIP data structure */
20886  SCIP_CLOCK** clck /**< pointer to clock timer */
20887  );
20888 
20889 /** frees a clock
20890  *
20891  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20892  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20893  */
20894 extern
20896  SCIP* scip, /**< SCIP data structure */
20897  SCIP_CLOCK** clck /**< pointer to clock timer */
20898  );
20899 
20900 /** resets the time measurement of a clock to zero and completely stops the clock
20901  *
20902  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20903  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20904  */
20905 extern
20907  SCIP* scip, /**< SCIP data structure */
20908  SCIP_CLOCK* clck /**< clock timer */
20909  );
20910 
20911 /** starts the time measurement of a clock
20912  *
20913  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20914  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20915  */
20916 extern
20918  SCIP* scip, /**< SCIP data structure */
20919  SCIP_CLOCK* clck /**< clock timer */
20920  );
20921 
20922 /** stops the time measurement of a clock
20923  *
20924  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20925  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20926  */
20927 extern
20929  SCIP* scip, /**< SCIP data structure */
20930  SCIP_CLOCK* clck /**< clock timer */
20931  );
20932 
20933 /** enables or disables all statistic clocks of SCIP concerning plugin statistics,
20934  * LP execution time, strong branching time, etc.
20935  *
20936  * Method reads the value of the parameter timing/statistictiming. In order to disable statistic timing,
20937  * set the parameter to FALSE.
20938  *
20939  * @note: The (pre-)solving time clocks which are relevant for the output during (pre-)solving
20940  * are not affected by this method
20941  *
20942  * @see: For completely disabling all timing of SCIP, consider setting the parameter timing/enabled to FALSE
20943  *
20944  * @pre This method can be called if SCIP is in one of the following stages:
20945  * - \ref SCIP_STAGE_PROBLEM
20946  * - \ref SCIP_STAGE_TRANSFORMING
20947  * - \ref SCIP_STAGE_TRANSFORMED
20948  * - \ref SCIP_STAGE_INITPRESOLVE
20949  * - \ref SCIP_STAGE_PRESOLVING
20950  * - \ref SCIP_STAGE_EXITPRESOLVE
20951  * - \ref SCIP_STAGE_PRESOLVED
20952  * - \ref SCIP_STAGE_INITSOLVE
20953  * - \ref SCIP_STAGE_SOLVING
20954  * - \ref SCIP_STAGE_SOLVED
20955  * - \ref SCIP_STAGE_EXITSOLVE
20956  * - \ref SCIP_STAGE_FREETRANS
20957  *
20958  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
20959  */
20960 extern
20962  SCIP* scip /**< SCIP data structure */
20963  );
20964 
20965 /** starts the current solving time
20966  *
20967  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20968  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20969  *
20970  * @pre This method can be called if SCIP is in one of the following stages:
20971  * - \ref SCIP_STAGE_PROBLEM
20972  * - \ref SCIP_STAGE_TRANSFORMING
20973  * - \ref SCIP_STAGE_TRANSFORMED
20974  * - \ref SCIP_STAGE_INITPRESOLVE
20975  * - \ref SCIP_STAGE_PRESOLVING
20976  * - \ref SCIP_STAGE_EXITPRESOLVE
20977  * - \ref SCIP_STAGE_PRESOLVED
20978  * - \ref SCIP_STAGE_INITSOLVE
20979  * - \ref SCIP_STAGE_SOLVING
20980  * - \ref SCIP_STAGE_SOLVED
20981  * - \ref SCIP_STAGE_EXITSOLVE
20982  * - \ref SCIP_STAGE_FREETRANS
20983  *
20984  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
20985  */
20986 extern
20988  SCIP* scip /**< SCIP data structure */
20989  );
20990 
20991 /** stops the current solving time in seconds
20992  *
20993  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20994  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20995  *
20996  * @pre This method can be called if SCIP is in one of the following stages:
20997  * - \ref SCIP_STAGE_PROBLEM
20998  * - \ref SCIP_STAGE_TRANSFORMING
20999  * - \ref SCIP_STAGE_TRANSFORMED
21000  * - \ref SCIP_STAGE_INITPRESOLVE
21001  * - \ref SCIP_STAGE_PRESOLVING
21002  * - \ref SCIP_STAGE_EXITPRESOLVE
21003  * - \ref SCIP_STAGE_PRESOLVED
21004  * - \ref SCIP_STAGE_INITSOLVE
21005  * - \ref SCIP_STAGE_SOLVING
21006  * - \ref SCIP_STAGE_SOLVED
21007  * - \ref SCIP_STAGE_EXITSOLVE
21008  * - \ref SCIP_STAGE_FREETRANS
21009  *
21010  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21011  */
21012 extern
21014  SCIP* scip /**< SCIP data structure */
21015  );
21016 
21017 /** gets the measured time of a clock in seconds
21018  *
21019  * @return the measured time of a clock in seconds.
21020  */
21021 extern
21023  SCIP* scip, /**< SCIP data structure */
21024  SCIP_CLOCK* clck /**< clock timer */
21025  );
21026 
21027 /** sets the measured time of a clock to the given value in seconds
21028  *
21029  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21030  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21031  */
21032 extern
21034  SCIP* scip, /**< SCIP data structure */
21035  SCIP_CLOCK* clck, /**< clock timer */
21036  SCIP_Real sec /**< time in seconds to set the clock's timer to */
21037  );
21038 
21039 /** gets the current total SCIP time in seconds, possibly accumulated over several problems.
21040  *
21041  * @return the current total SCIP time in seconds, ie. the total time since the SCIP instance has been created
21042  */
21043 extern
21045  SCIP* scip /**< SCIP data structure */
21046  );
21047 
21048 /** gets the current solving time in seconds
21049  *
21050  * @return the current solving time in seconds.
21051  *
21052  * @pre This method can be called if SCIP is in one of the following stages:
21053  * - \ref SCIP_STAGE_PROBLEM
21054  * - \ref SCIP_STAGE_TRANSFORMING
21055  * - \ref SCIP_STAGE_TRANSFORMED
21056  * - \ref SCIP_STAGE_INITPRESOLVE
21057  * - \ref SCIP_STAGE_PRESOLVING
21058  * - \ref SCIP_STAGE_EXITPRESOLVE
21059  * - \ref SCIP_STAGE_PRESOLVED
21060  * - \ref SCIP_STAGE_INITSOLVE
21061  * - \ref SCIP_STAGE_SOLVING
21062  * - \ref SCIP_STAGE_SOLVED
21063  *
21064  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21065  */
21066 extern
21068  SCIP* scip /**< SCIP data structure */
21069  );
21070 
21071 /** gets the current reading time in seconds
21072  *
21073  * @return the current reading time in seconds.
21074  *
21075  * @pre This method can be called if SCIP is in one of the following stages:
21076  * - \ref SCIP_STAGE_PROBLEM
21077  * - \ref SCIP_STAGE_TRANSFORMING
21078  * - \ref SCIP_STAGE_TRANSFORMED
21079  * - \ref SCIP_STAGE_INITPRESOLVE
21080  * - \ref SCIP_STAGE_PRESOLVING
21081  * - \ref SCIP_STAGE_EXITPRESOLVE
21082  * - \ref SCIP_STAGE_PRESOLVED
21083  * - \ref SCIP_STAGE_INITSOLVE
21084  * - \ref SCIP_STAGE_SOLVING
21085  * - \ref SCIP_STAGE_SOLVED
21086  *
21087  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21088  */
21089 extern
21091  SCIP* scip /**< SCIP data structure */
21092  );
21093 
21094 /** gets the current presolving time in seconds
21095  *
21096  * @return the current presolving time in seconds.
21097  *
21098  * @pre This method can be called if SCIP is in one of the following stages:
21099  * - \ref SCIP_STAGE_INITPRESOLVE
21100  * - \ref SCIP_STAGE_PRESOLVING
21101  * - \ref SCIP_STAGE_EXITPRESOLVE
21102  * - \ref SCIP_STAGE_PRESOLVED
21103  * - \ref SCIP_STAGE_INITSOLVE
21104  * - \ref SCIP_STAGE_SOLVING
21105  * - \ref SCIP_STAGE_SOLVED
21106  *
21107  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21108  */
21109 extern
21111  SCIP* scip /**< SCIP data structure */
21112  );
21113 
21114 /** gets the time need to solve the first LP in the root node
21115  *
21116  * @return the solving time for the first LP in the root node in seconds.
21117  *
21118  * @pre This method can be called if SCIP is in one of the following stages:
21119  * - \ref SCIP_STAGE_TRANSFORMING
21120  * - \ref SCIP_STAGE_TRANSFORMED
21121  * - \ref SCIP_STAGE_INITPRESOLVE
21122  * - \ref SCIP_STAGE_PRESOLVING
21123  * - \ref SCIP_STAGE_EXITPRESOLVE
21124  * - \ref SCIP_STAGE_PRESOLVED
21125  * - \ref SCIP_STAGE_INITSOLVE
21126  * - \ref SCIP_STAGE_SOLVING
21127  * - \ref SCIP_STAGE_SOLVED
21128  *
21129  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
21130  */
21131 extern
21133  SCIP* scip /**< SCIP data structure */
21134  );
21135 
21136 /**@} */
21137 
21138 /*
21139  * numeric values and comparisons
21140  */
21141 
21142 /**@addtogroup PublicToleranceMethods
21143  *
21144  * @{
21145  */
21146 
21147 /** returns value treated as zero
21148  *
21149  * @return value treated as zero
21150  */
21151 extern
21153  SCIP* scip /**< SCIP data structure */
21154  );
21155 
21156 /** returns value treated as zero for sums of floating point values
21157  *
21158  * @return value treated as zero for sums of floating point values
21159  */
21160 extern
21162  SCIP* scip /**< SCIP data structure */
21163  );
21164 
21165 /** returns feasibility tolerance for constraints
21166  *
21167  * @return feasibility tolerance for constraints
21168  */
21169 extern
21171  SCIP* scip /**< SCIP data structure */
21172  );
21173 
21174 /** returns primal feasibility tolerance of LP solver
21175  *
21176  * @return primal feasibility tolerance of LP solver
21177  */
21178 extern
21180  SCIP* scip /**< SCIP data structure */
21181  );
21182 
21183 /** returns feasibility tolerance for reduced costs
21184  *
21185  * @return feasibility tolerance for reduced costs
21186  */
21187 extern
21189  SCIP* scip /**< SCIP data structure */
21190  );
21191 
21192 /** returns convergence tolerance used in barrier algorithm
21193  *
21194  * @return convergence tolerance used in barrier algorithm
21195  */
21196 extern
21198  SCIP* scip /**< SCIP data structure */
21199  );
21200 
21201 /** return the cutoff bound delta
21202  *
21203  * @return cutoff bound data
21204  */
21205 extern
21207  SCIP* scip /**< SCIP data structure */
21208  );
21209 
21210 /** sets the feasibility tolerance for constraints
21211  *
21212  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21213  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21214  */
21215 extern
21217  SCIP* scip, /**< SCIP data structure */
21218  SCIP_Real feastol /**< new feasibility tolerance for constraints */
21219  );
21220 
21221 /** sets the primal feasibility tolerance of LP solver
21222  *
21223  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21224  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21225  */
21226 extern
21228  SCIP* scip, /**< SCIP data structure */
21229  SCIP_Real lpfeastol, /**< new primal feasibility tolerance of LP solver */
21230  SCIP_Bool printnewvalue /**< should "numerics/lpfeastol = ..." be printed? */
21231  );
21232 
21233 /** sets the feasibility tolerance for reduced costs
21234  *
21235  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21236  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21237  */
21238 extern
21240  SCIP* scip, /**< SCIP data structure */
21241  SCIP_Real dualfeastol /**< new feasibility tolerance for reduced costs */
21242  );
21243 
21244 /** sets the convergence tolerance used in barrier algorithm
21245  *
21246  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21247  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21248  */
21249 extern
21251  SCIP* scip, /**< SCIP data structure */
21252  SCIP_Real barrierconvtol /**< new convergence tolerance used in barrier algorithm */
21253  );
21254 
21255 /** marks that some limit parameter was changed */
21256 extern
21258  SCIP* scip /**< SCIP data structure */
21259  );
21260 
21261 /** returns value treated as infinity */
21262 extern
21264  SCIP* scip /**< SCIP data structure */
21265  );
21266 
21267 /** returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity
21268  * computation)
21269  */
21270 extern
21272  SCIP* scip /**< SCIP data structure */
21273  );
21274 
21275 /** checks, if values are in range of epsilon */
21276 extern
21278  SCIP* scip, /**< SCIP data structure */
21279  SCIP_Real val1, /**< first value to be compared */
21280  SCIP_Real val2 /**< second value to be compared */
21281  );
21282 
21283 /** checks, if val1 is (more than epsilon) lower than val2 */
21284 extern
21286  SCIP* scip, /**< SCIP data structure */
21287  SCIP_Real val1, /**< first value to be compared */
21288  SCIP_Real val2 /**< second value to be compared */
21289  );
21290 
21291 /** checks, if val1 is not (more than epsilon) greater than val2 */
21292 extern
21294  SCIP* scip, /**< SCIP data structure */
21295  SCIP_Real val1, /**< first value to be compared */
21296  SCIP_Real val2 /**< second value to be compared */
21297  );
21298 
21299 /** checks, if val1 is (more than epsilon) greater than val2 */
21300 extern
21302  SCIP* scip, /**< SCIP data structure */
21303  SCIP_Real val1, /**< first value to be compared */
21304  SCIP_Real val2 /**< second value to be compared */
21305  );
21306 
21307 /** checks, if val1 is not (more than epsilon) lower than val2 */
21308 extern
21310  SCIP* scip, /**< SCIP data structure */
21311  SCIP_Real val1, /**< first value to be compared */
21312  SCIP_Real val2 /**< second value to be compared */
21313  );
21314 
21315 /** checks, if value is (positive) infinite */
21316 extern
21318  SCIP* scip, /**< SCIP data structure */
21319  SCIP_Real val /**< value to be compared against infinity */
21320  );
21321 
21322 /** checks, if value is huge and should be handled separately (e.g., in activity computation) */
21323 extern
21325  SCIP* scip, /**< SCIP data structure */
21326  SCIP_Real val /**< value to be checked whether it is huge */
21327  );
21328 
21329 /** checks, if value is in range epsilon of 0.0 */
21330 extern
21332  SCIP* scip, /**< SCIP data structure */
21333  SCIP_Real val /**< value to process */
21334  );
21335 
21336 /** checks, if value is greater than epsilon */
21337 extern
21339  SCIP* scip, /**< SCIP data structure */
21340  SCIP_Real val /**< value to process */
21341  );
21342 
21343 /** checks, if value is lower than -epsilon */
21344 extern
21346  SCIP* scip, /**< SCIP data structure */
21347  SCIP_Real val /**< value to process */
21348  );
21349 
21350 /** checks, if value is integral within epsilon */
21351 extern
21353  SCIP* scip, /**< SCIP data structure */
21354  SCIP_Real val /**< value to process */
21355  );
21356 
21357 /** checks whether the product val * scalar is integral in epsilon scaled by scalar */
21358 extern
21360  SCIP* scip, /**< SCIP data structure */
21361  SCIP_Real val, /**< unscaled value to check for scaled integrality */
21362  SCIP_Real scalar /**< value to scale val with for checking for integrality */
21363  );
21364 
21365 /** checks, if given fractional part is smaller than epsilon */
21366 extern
21368  SCIP* scip, /**< SCIP data structure */
21369  SCIP_Real val /**< value to process */
21370  );
21371 
21372 /** rounds value + epsilon down to the next integer */
21373 extern
21375  SCIP* scip, /**< SCIP data structure */
21376  SCIP_Real val /**< value to process */
21377  );
21378 
21379 /** rounds value - epsilon up to the next integer */
21380 extern
21382  SCIP* scip, /**< SCIP data structure */
21383  SCIP_Real val /**< value to process */
21384  );
21385 
21386 /** rounds value to the nearest integer with epsilon tolerance */
21387 extern
21389  SCIP* scip, /**< SCIP data structure */
21390  SCIP_Real val /**< value to process */
21391  );
21392 
21393 /** returns fractional part of value, i.e. x - floor(x) in epsilon tolerance */
21394 extern
21396  SCIP* scip, /**< SCIP data structure */
21397  SCIP_Real val /**< value to return fractional part for */
21398  );
21399 
21400 /** checks, if values are in range of sumepsilon */
21401 extern
21403  SCIP* scip, /**< SCIP data structure */
21404  SCIP_Real val1, /**< first value to be compared */
21405  SCIP_Real val2 /**< second value to be compared */
21406  );
21407 
21408 /** checks, if val1 is (more than sumepsilon) lower than val2 */
21409 extern
21411  SCIP* scip, /**< SCIP data structure */
21412  SCIP_Real val1, /**< first value to be compared */
21413  SCIP_Real val2 /**< second value to be compared */
21414  );
21415 
21416 /** checks, if val1 is not (more than sumepsilon) greater than val2 */
21417 extern
21419  SCIP* scip, /**< SCIP data structure */
21420  SCIP_Real val1, /**< first value to be compared */
21421  SCIP_Real val2 /**< second value to be compared */
21422  );
21423 
21424 /** checks, if val1 is (more than sumepsilon) greater than val2 */
21425 extern
21427  SCIP* scip, /**< SCIP data structure */
21428  SCIP_Real val1, /**< first value to be compared */
21429  SCIP_Real val2 /**< second value to be compared */
21430  );
21431 
21432 /** checks, if val1 is not (more than sumepsilon) lower than val2 */
21433 extern
21435  SCIP* scip, /**< SCIP data structure */
21436  SCIP_Real val1, /**< first value to be compared */
21437  SCIP_Real val2 /**< second value to be compared */
21438  );
21439 
21440 /** checks, if value is in range sumepsilon of 0.0 */
21441 extern
21443  SCIP* scip, /**< SCIP data structure */
21444  SCIP_Real val /**< value to process */
21445  );
21446 
21447 /** checks, if value is greater than sumepsilon */
21448 extern
21450  SCIP* scip, /**< SCIP data structure */
21451  SCIP_Real val /**< value to process */
21452  );
21453 
21454 /** checks, if value is lower than -sumepsilon */
21455 extern
21457  SCIP* scip, /**< SCIP data structure */
21458  SCIP_Real val /**< value to process */
21459  );
21460 
21461 /** checks, if relative difference of values is in range of feasibility tolerance */
21462 extern
21464  SCIP* scip, /**< SCIP data structure */
21465  SCIP_Real val1, /**< first value to be compared */
21466  SCIP_Real val2 /**< second value to be compared */
21467  );
21468 
21469 /** checks, if relative difference val1 and val2 is lower than feasibility tolerance */
21470 extern
21472  SCIP* scip, /**< SCIP data structure */
21473  SCIP_Real val1, /**< first value to be compared */
21474  SCIP_Real val2 /**< second value to be compared */
21475  );
21476 
21477 /** checks, if relative difference of val1 and val2 is not greater than feasibility tolerance */
21478 extern
21480  SCIP* scip, /**< SCIP data structure */
21481  SCIP_Real val1, /**< first value to be compared */
21482  SCIP_Real val2 /**< second value to be compared */
21483  );
21484 
21485 /** checks, if relative difference of val1 and val2 is greater than feastol */
21486 extern
21488  SCIP* scip, /**< SCIP data structure */
21489  SCIP_Real val1, /**< first value to be compared */
21490  SCIP_Real val2 /**< second value to be compared */
21491  );
21492 
21493 /** checks, if relative difference of val1 and val2 is not lower than -feastol */
21494 extern
21496  SCIP* scip, /**< SCIP data structure */
21497  SCIP_Real val1, /**< first value to be compared */
21498  SCIP_Real val2 /**< second value to be compared */
21499  );
21500 
21501 /** checks, if value is in range feasibility tolerance of 0.0 */
21502 extern
21504  SCIP* scip, /**< SCIP data structure */
21505  SCIP_Real val /**< value to process */
21506  );
21507 
21508 /** checks, if value is greater than feasibility tolerance */
21509 extern
21511  SCIP* scip, /**< SCIP data structure */
21512  SCIP_Real val /**< value to process */
21513  );
21514 
21515 /** checks, if value is lower than -feasibility tolerance */
21516 extern
21518  SCIP* scip, /**< SCIP data structure */
21519  SCIP_Real val /**< value to process */
21520  );
21521 
21522 /** checks, if value is integral within the LP feasibility bounds */
21523 extern
21525  SCIP* scip, /**< SCIP data structure */
21526  SCIP_Real val /**< value to process */
21527  );
21528 
21529 /** checks, if given fractional part is smaller than feastol */
21530 extern
21532  SCIP* scip, /**< SCIP data structure */
21533  SCIP_Real val /**< value to process */
21534  );
21535 
21536 /** rounds value + feasibility tolerance down to the next integer */
21537 extern
21539  SCIP* scip, /**< SCIP data structure */
21540  SCIP_Real val /**< value to process */
21541  );
21542 
21543 /** rounds value - feasibility tolerance up to the next integer */
21544 extern
21546  SCIP* scip, /**< SCIP data structure */
21547  SCIP_Real val /**< value to process */
21548  );
21549 
21550 /** rounds value to the nearest integer in feasibility tolerance */
21551 extern
21553  SCIP* scip, /**< SCIP data structure */
21554  SCIP_Real val /**< value to process */
21555  );
21556 
21557 /** returns fractional part of value, i.e. x - floor(x) */
21558 extern
21560  SCIP* scip, /**< SCIP data structure */
21561  SCIP_Real val /**< value to process */
21562  );
21563 
21564 /** checks, if relative difference of values is in range of dual feasibility tolerance */
21565 extern
21567  SCIP* scip, /**< SCIP data structure */
21568  SCIP_Real val1, /**< first value to be compared */
21569  SCIP_Real val2 /**< second value to be compared */
21570  );
21571 
21572 /** checks, if relative difference val1 and val2 is lower than dual feasibility tolerance */
21573 extern
21575  SCIP* scip, /**< SCIP data structure */
21576  SCIP_Real val1, /**< first value to be compared */
21577  SCIP_Real val2 /**< second value to be compared */
21578  );
21579 
21580 /** checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance */
21581 extern
21583  SCIP* scip, /**< SCIP data structure */
21584  SCIP_Real val1, /**< first value to be compared */
21585  SCIP_Real val2 /**< second value to be compared */
21586  );
21587 
21588 /** checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance */
21589 extern
21591  SCIP* scip, /**< SCIP data structure */
21592  SCIP_Real val1, /**< first value to be compared */
21593  SCIP_Real val2 /**< second value to be compared */
21594  );
21595 
21596 /** checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance */
21597 extern
21599  SCIP* scip, /**< SCIP data structure */
21600  SCIP_Real val1, /**< first value to be compared */
21601  SCIP_Real val2 /**< second value to be compared */
21602  );
21603 
21604 /** checks, if value is in range dual feasibility tolerance of 0.0 */
21605 extern
21607  SCIP* scip, /**< SCIP data structure */
21608  SCIP_Real val /**< value to process */
21609  );
21610 
21611 /** checks, if value is greater than dual feasibility tolerance */
21612 extern
21614  SCIP* scip, /**< SCIP data structure */
21615  SCIP_Real val /**< value to process */
21616  );
21617 
21618 /** checks, if value is lower than -dual feasibility tolerance */
21619 extern
21621  SCIP* scip, /**< SCIP data structure */
21622  SCIP_Real val /**< value to process */
21623  );
21624 
21625 /** checks, if value is integral within the LP dual feasibility tolerance */
21626 extern
21628  SCIP* scip, /**< SCIP data structure */
21629  SCIP_Real val /**< value to process */
21630  );
21631 
21632 /** checks, if given fractional part is smaller than dual feasibility tolerance */
21633 extern
21635  SCIP* scip, /**< SCIP data structure */
21636  SCIP_Real val /**< value to process */
21637  );
21638 
21639 /** rounds value + dual feasibility tolerance down to the next integer */
21640 extern
21642  SCIP* scip, /**< SCIP data structure */
21643  SCIP_Real val /**< value to process */
21644  );
21645 
21646 /** rounds value - dual feasibility tolerance up to the next integer */
21647 extern
21649  SCIP* scip, /**< SCIP data structure */
21650  SCIP_Real val /**< value to process */
21651  );
21652 
21653 /** rounds value to the nearest integer in dual feasibility tolerance */
21654 extern
21656  SCIP* scip, /**< SCIP data structure */
21657  SCIP_Real val /**< value to process */
21658  );
21659 
21660 /** returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance */
21661 extern
21663  SCIP* scip, /**< SCIP data structure */
21664  SCIP_Real val /**< value to process */
21665  );
21666 
21667 /** checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
21668 extern
21670  SCIP* scip, /**< SCIP data structure */
21671  SCIP_Real newlb, /**< new lower bound */
21672  SCIP_Real oldlb, /**< old lower bound */
21673  SCIP_Real oldub /**< old upper bound */
21674  );
21675 
21676 /** checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
21678  SCIP* scip, /**< SCIP data structure */
21679  SCIP_Real newub, /**< new upper bound */
21680  SCIP_Real oldlb, /**< old lower bound */
21681  SCIP_Real oldub /**< old upper bound */
21682  );
21683 
21684 /** checks, if relative difference of values is in range of epsilon */
21685 extern
21687  SCIP* scip, /**< SCIP data structure */
21688  SCIP_Real val1, /**< first value to be compared */
21689  SCIP_Real val2 /**< second value to be compared */
21690  );
21691 
21692 /** checks, if relative difference of val1 and val2 is lower than epsilon */
21693 extern
21695  SCIP* scip, /**< SCIP data structure */
21696  SCIP_Real val1, /**< first value to be compared */
21697  SCIP_Real val2 /**< second value to be compared */
21698  );
21699 
21700 /** checks, if relative difference of val1 and val2 is not greater than epsilon */
21701 extern
21703  SCIP* scip, /**< SCIP data structure */
21704  SCIP_Real val1, /**< first value to be compared */
21705  SCIP_Real val2 /**< second value to be compared */
21706  );
21707 
21708 /** checks, if relative difference of val1 and val2 is greater than epsilon */
21709 extern
21711  SCIP* scip, /**< SCIP data structure */
21712  SCIP_Real val1, /**< first value to be compared */
21713  SCIP_Real val2 /**< second value to be compared */
21714  );
21715 
21716 /** checks, if relative difference of val1 and val2 is not lower than -epsilon */
21717 extern
21719  SCIP* scip, /**< SCIP data structure */
21720  SCIP_Real val1, /**< first value to be compared */
21721  SCIP_Real val2 /**< second value to be compared */
21722  );
21723 
21724 /** checks, if relative difference of values is in range of sumepsilon */
21725 extern
21727  SCIP* scip, /**< SCIP data structure */
21728  SCIP_Real val1, /**< first value to be compared */
21729  SCIP_Real val2 /**< second value to be compared */
21730  );
21731 
21732 /** checks, if relative difference of val1 and val2 is lower than sumepsilon */
21733 extern
21735  SCIP* scip, /**< SCIP data structure */
21736  SCIP_Real val1, /**< first value to be compared */
21737  SCIP_Real val2 /**< second value to be compared */
21738  );
21739 
21740 /** checks, if relative difference of val1 and val2 is not greater than sumepsilon */
21741 extern
21743  SCIP* scip, /**< SCIP data structure */
21744  SCIP_Real val1, /**< first value to be compared */
21745  SCIP_Real val2 /**< second value to be compared */
21746  );
21747 
21748 /** checks, if relative difference of val1 and val2 is greater than sumepsilon */
21749 extern
21751  SCIP* scip, /**< SCIP data structure */
21752  SCIP_Real val1, /**< first value to be compared */
21753  SCIP_Real val2 /**< second value to be compared */
21754  );
21755 
21756 /** checks, if relative difference of val1 and val2 is not lower than -sumepsilon */
21757 extern
21759  SCIP* scip, /**< SCIP data structure */
21760  SCIP_Real val1, /**< first value to be compared */
21761  SCIP_Real val2 /**< second value to be compared */
21762  );
21763 
21764 /** converts the given real number representing an integer to an int; in optimized mode the function gets inlined for
21765  * performance; in debug mode we check some additional conditions
21766  */
21767 extern
21769  SCIP* scip, /**< SCIP data structure */
21770  SCIP_Real real /**< double bound to convert */
21771  );
21772 
21773 /** converts the given real number representing an integer to a long integer; in optimized mode the function gets inlined for
21774  * performance; in debug mode we check some additional conditions
21775  */
21776 extern
21778  SCIP* scip, /**< SCIP data structure */
21779  SCIP_Real real /**< double bound to convert */
21780  );
21781 
21782 /** Checks, if an iteratively updated value is reliable or should be recomputed from scratch.
21783  * This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high
21784  * absolute value during the optimization process which is later reduced significantly. In this case, the last digits
21785  * were canceled out when increasing the value and are random after decreasing it.
21786  * We do not consider the cancellations which can occur during increasing the absolute value because they just cannot
21787  * be expressed using fixed precision floating point arithmetic, anymore.
21788  * In order to get more reliable values, the idea is to always store the last reliable value, where increasing the
21789  * absolute of the value is viewed as preserving reliability. Then, after each update, the new absolute value can be
21790  * compared against the last reliable one with this method, checking whether it was decreased by a factor of at least
21791  * "lp/recompfac" and should be recomputed.
21792  */
21793 extern
21795  SCIP* scip, /**< SCIP data structure */
21796  SCIP_Real newvalue, /**< new value after update */
21797  SCIP_Real oldvalue /**< old value, i.e., last reliable value */
21798  );
21799 
21800 #ifdef NDEBUG
21801 
21802 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
21803  * speed up the algorithms.
21804  */
21805 
21806 #define SCIPinfinity(scip) SCIPsetInfinity((scip)->set)
21807 #define SCIPisInfinity(scip, val) SCIPsetIsInfinity((scip)->set, val)
21808 #define SCIPisHugeValue(scip, val) SCIPsetIsHugeValue((scip)->set, val)
21809 #define SCIPgetHugeValue(scip) SCIPsetGetHugeValue((scip)->set)
21810 #define SCIPisEQ(scip, val1, val2) SCIPsetIsEQ((scip)->set, val1, val2)
21811 #define SCIPisLT(scip, val1, val2) SCIPsetIsLT((scip)->set, val1, val2)
21812 #define SCIPisLE(scip, val1, val2) SCIPsetIsLE((scip)->set, val1, val2)
21813 #define SCIPisGT(scip, val1, val2) SCIPsetIsGT((scip)->set, val1, val2)
21814 #define SCIPisGE(scip, val1, val2) SCIPsetIsGE((scip)->set, val1, val2)
21815 #define SCIPisZero(scip, val) SCIPsetIsZero((scip)->set, val)
21816 #define SCIPisPositive(scip, val) SCIPsetIsPositive((scip)->set, val)
21817 #define SCIPisNegative(scip, val) SCIPsetIsNegative((scip)->set, val)
21818 #define SCIPisIntegral(scip, val) SCIPsetIsIntegral((scip)->set, val)
21819 #define SCIPisScalingIntegral(scip, val, scalar) SCIPsetIsScalingIntegral((scip)->set, val, scalar)
21820 #define SCIPisFracIntegral(scip, val) SCIPsetIsFracIntegral((scip)->set, val)
21821 #define SCIPfloor(scip, val) SCIPsetFloor((scip)->set, val)
21822 #define SCIPceil(scip, val) SCIPsetCeil((scip)->set, val)
21823 #define SCIPround(scip, val) SCIPsetRound((scip)->set, val)
21824 #define SCIPfrac(scip, val) SCIPsetFrac((scip)->set, val)
21825 
21826 #define SCIPisSumEQ(scip, val1, val2) SCIPsetIsSumEQ((scip)->set, val1, val2)
21827 #define SCIPisSumLT(scip, val1, val2) SCIPsetIsSumLT((scip)->set, val1, val2)
21828 #define SCIPisSumLE(scip, val1, val2) SCIPsetIsSumLE((scip)->set, val1, val2)
21829 #define SCIPisSumGT(scip, val1, val2) SCIPsetIsSumGT((scip)->set, val1, val2)
21830 #define SCIPisSumGE(scip, val1, val2) SCIPsetIsSumGE((scip)->set, val1, val2)
21831 #define SCIPisSumZero(scip, val) SCIPsetIsSumZero((scip)->set, val)
21832 #define SCIPisSumPositive(scip, val) SCIPsetIsSumPositive((scip)->set, val)
21833 #define SCIPisSumNegative(scip, val) SCIPsetIsSumNegative((scip)->set, val)
21834 
21835 #define SCIPisFeasEQ(scip, val1, val2) SCIPsetIsFeasEQ((scip)->set, val1, val2)
21836 #define SCIPisFeasLT(scip, val1, val2) SCIPsetIsFeasLT((scip)->set, val1, val2)
21837 #define SCIPisFeasLE(scip, val1, val2) SCIPsetIsFeasLE((scip)->set, val1, val2)
21838 #define SCIPisFeasGT(scip, val1, val2) SCIPsetIsFeasGT((scip)->set, val1, val2)
21839 #define SCIPisFeasGE(scip, val1, val2) SCIPsetIsFeasGE((scip)->set, val1, val2)
21840 #define SCIPisFeasZero(scip, val) SCIPsetIsFeasZero((scip)->set, val)
21841 #define SCIPisFeasPositive(scip, val) SCIPsetIsFeasPositive((scip)->set, val)
21842 #define SCIPisFeasNegative(scip, val) SCIPsetIsFeasNegative((scip)->set, val)
21843 #define SCIPisFeasIntegral(scip, val) SCIPsetIsFeasIntegral((scip)->set, val)
21844 #define SCIPisFeasFracIntegral(scip, val) SCIPsetIsFeasFracIntegral((scip)->set, val)
21845 #define SCIPfeasFloor(scip, val) SCIPsetFeasFloor((scip)->set, val)
21846 #define SCIPfeasCeil(scip, val) SCIPsetFeasCeil((scip)->set, val)
21847 #define SCIPfeasRound(scip, val) SCIPsetFeasRound((scip)->set, val)
21848 #define SCIPfeasFrac(scip, val) SCIPsetFeasFrac((scip)->set, val)
21849 
21850 #define SCIPisDualfeasEQ(scip, val1, val2) SCIPsetIsDualfeasEQ((scip)->set, val1, val2)
21851 #define SCIPisDualfeasLT(scip, val1, val2) SCIPsetIsDualfeasLT((scip)->set, val1, val2)
21852 #define SCIPisDualfeasLE(scip, val1, val2) SCIPsetIsDualfeasLE((scip)->set, val1, val2)
21853 #define SCIPisDualfeasGT(scip, val1, val2) SCIPsetIsDualfeasGT((scip)->set, val1, val2)
21854 #define SCIPisDualfeasGE(scip, val1, val2) SCIPsetIsDualfeasGE((scip)->set, val1, val2)
21855 #define SCIPisDualfeasZero(scip, val) SCIPsetIsDualfeasZero((scip)->set, val)
21856 #define SCIPisDualfeasPositive(scip, val) SCIPsetIsDualfeasPositive((scip)->set, val)
21857 #define SCIPisDualfeasNegative(scip, val) SCIPsetIsDualfeasNegative((scip)->set, val)
21858 #define SCIPisDualfeasIntegral(scip, val) SCIPsetIsDualfeasIntegral((scip)->set, val)
21859 #define SCIPisDualfeasFracIntegral(scip, val) SCIPsetIsDualfeasFracIntegral((scip)->set, val)
21860 #define SCIPdualfeasFloor(scip, val) SCIPsetDualfeasFloor((scip)->set, val)
21861 #define SCIPdualfeasCeil(scip, val) SCIPsetDualfeasCeil((scip)->set, val)
21862 #define SCIPdualfeasRound(scip, val) SCIPsetDualfeasRound((scip)->set, val)
21863 #define SCIPdualfeasFrac(scip, val) SCIPsetDualfeasFrac((scip)->set, val)
21864 
21865 #define SCIPisLbBetter(scip, newlb, oldlb, oldub) SCIPsetIsLbBetter(scip->set, newlb, oldlb, oldub)
21866 #define SCIPisUbBetter(scip, newub, oldlb, oldub) SCIPsetIsUbBetter(scip->set, newub, oldlb, oldub)
21867 
21868 #define SCIPisRelEQ(scip, val1, val2) SCIPsetIsRelEQ((scip)->set, val1, val2)
21869 #define SCIPisRelLT(scip, val1, val2) SCIPsetIsRelLT((scip)->set, val1, val2)
21870 #define SCIPisRelLE(scip, val1, val2) SCIPsetIsRelLE((scip)->set, val1, val2)
21871 #define SCIPisRelGT(scip, val1, val2) SCIPsetIsRelGT((scip)->set, val1, val2)
21872 #define SCIPisRelGE(scip, val1, val2) SCIPsetIsRelGE((scip)->set, val1, val2)
21873 
21874 #define SCIPisSumRelEQ(scip, val1, val2) SCIPsetIsSumRelEQ((scip)->set, val1, val2)
21875 #define SCIPisSumRelLT(scip, val1, val2) SCIPsetIsSumRelLT((scip)->set, val1, val2)
21876 #define SCIPisSumRelLE(scip, val1, val2) SCIPsetIsSumRelLE((scip)->set, val1, val2)
21877 #define SCIPisSumRelGT(scip, val1, val2) SCIPsetIsSumRelGT((scip)->set, val1, val2)
21878 #define SCIPisSumRelGE(scip, val1, val2) SCIPsetIsSumRelGE((scip)->set, val1, val2)
21879 #define SCIPconvertRealToInt(scip, real) ((int)((real) < 0 ? ((real) - 0.5) : ((real) + 0.5)))
21880 #define SCIPconvertRealToLongint(scip, real) ((SCIP_Longint)((real) < 0 ? ((real) - 0.5) : ((real) + 0.5)))
21881 
21882 #define SCIPisUpdateUnreliable(scip, newval, oldval) SCIPsetIsUpdateUnreliable((scip)->set, newval, oldval)
21883 
21884 #define SCIPmarkConsPropagate(scip, cons) SCIPconsMarkPropagate(cons, (scip)->set)
21885 #define SCIPgetStage(scip) (((scip)->set)->stage)
21886 #define SCIPhasPerformedPresolve(scip) ((scip)->stat->performpresol)
21887 #define SCIPisStopped(scip) SCIPsolveIsStopped((scip)->set, (scip)->stat, 0)
21888 
21889 #endif
21890 
21891 /** outputs a real number, or "+infinity", or "-infinity" to a file */
21892 extern
21893 void SCIPprintReal(
21894  SCIP* scip, /**< SCIP data structure */
21895  FILE* file, /**< output file (or NULL for standard output) */
21896  SCIP_Real val, /**< value to print */
21897  int width, /**< width of the field */
21898  int precision /**< number of significant digits printed */
21899  );
21900 
21901 /** parse a real value that was written with SCIPprintReal() */
21902 extern
21904  SCIP* scip, /**< SCIP data structure */
21905  const char* str, /**< string to search */
21906  SCIP_Real* value, /**< pointer to store the parsed value */
21907  char** endptr /**< pointer to store the final string position if successfully parsed, otherwise @p str */
21908  );
21909 
21910 /**@} */
21911 
21912 
21913 
21914 
21915 /*
21916  * memory management
21917  */
21918 
21919 /**@name Standard Memory Management Macros */
21920 /**@{ */
21921 
21922 #define SCIPallocMemory(scip,ptr) ( (BMSallocMemory((ptr)) == NULL) \
21923  ? SCIP_NOMEMORY : SCIP_OKAY )
21924 #define SCIPallocMemoryArray(scip,ptr,num) ( (BMSallocMemoryArray((ptr), (num)) == NULL) \
21925  ? SCIP_NOMEMORY : SCIP_OKAY )
21926 #define SCIPallocClearMemoryArray(scip,ptr,num) ( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \
21927  ? SCIP_NOMEMORY : SCIP_OKAY )
21928 #define SCIPallocMemorySize(scip,ptr,size) ( (BMSallocMemorySize((ptr), (size)) == NULL) \
21929  ? SCIP_NOMEMORY : SCIP_OKAY )
21930 #define SCIPreallocMemoryArray(scip,ptr,newnum) ( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \
21931  ? SCIP_NOMEMORY : SCIP_OKAY )
21932 #define SCIPreallocMemorySize(scip,ptr,newsize) ( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \
21933  ? SCIP_NOMEMORY : SCIP_OKAY )
21934 #define SCIPduplicateMemory(scip, ptr, source) ( (BMSduplicateMemory((ptr), (source)) == NULL) \
21935  ? SCIP_NOMEMORY : SCIP_OKAY )
21936 #define SCIPduplicateMemoryArray(scip, ptr, source, num) ( (BMSduplicateMemoryArray((ptr), (source), (num)) == NULL) \
21937  ? SCIP_NOMEMORY : SCIP_OKAY )
21938 #define SCIPfreeMemory(scip,ptr) BMSfreeMemory(ptr)
21939 #define SCIPfreeMemoryNull(scip,ptr) BMSfreeMemoryNull(ptr)
21940 #define SCIPfreeMemoryArray(scip,ptr) BMSfreeMemoryArray(ptr)
21941 #define SCIPfreeMemoryArrayNull(scip,ptr) BMSfreeMemoryArrayNull(ptr)
21942 #define SCIPfreeMemorySize(scip,ptr) BMSfreeMemorySize(ptr)
21943 #define SCIPfreeMemorySizeNull(scip,ptr) BMSfreeMemorySizeNull(ptr)
21944 /**@} */
21945 
21946 
21947 /**@addtogroup PublicMemoryMethods
21948  *
21949  * @{
21950  */
21951 
21952 /**@name Block Memory Management Macros
21953  * @{
21954  */
21955 
21956 #define SCIPallocBlockMemory(scip,ptr) ( (BMSallocBlockMemory(SCIPblkmem(scip), (ptr)) == NULL) \
21957  ? SCIP_NOMEMORY : SCIP_OKAY )
21958 #define SCIPallocBlockMemoryArray(scip,ptr,num) ( (BMSallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
21959  ? SCIP_NOMEMORY : SCIP_OKAY )
21960 #define SCIPallocBlockMemorySize(scip,ptr,size) ( (BMSallocBlockMemorySize(SCIPblkmem(scip), (ptr), (size)) == NULL) \
21961  ? SCIP_NOMEMORY : SCIP_OKAY )
21962 #define SCIPallocClearBlockMemoryArray(scip,ptr,num) ( (BMSallocClearBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
21963  ? SCIP_NOMEMORY : SCIP_OKAY )
21964 #define SCIPreallocBlockMemoryArray(scip,ptr,oldnum,newnum) ( (BMSreallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (oldnum), (newnum)) == NULL) \
21965  ? SCIP_NOMEMORY : SCIP_OKAY )
21966 #define SCIPreallocBlockMemorySize(scip,ptr,oldsize,newsize) ( (BMSreallocBlockMemorySize(SCIPblkmem(scip), (ptr), (oldsize), (newsize)) == NULL) \
21967  ? SCIP_NOMEMORY : SCIP_OKAY )
21968 #define SCIPduplicateBlockMemory(scip, ptr, source) ( (BMSduplicateBlockMemory(SCIPblkmem(scip), (ptr), (source)) == NULL) \
21969  ? SCIP_NOMEMORY : SCIP_OKAY )
21970 #define SCIPduplicateBlockMemoryArray(scip, ptr, source, num) ( (BMSduplicateBlockMemoryArray(SCIPblkmem(scip), (ptr), (source), (num)) == NULL) \
21971  ? SCIP_NOMEMORY : SCIP_OKAY )
21972 #define SCIPensureBlockMemoryArray(scip,ptr,arraysizeptr,minsize) ( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), (arraysizeptr), (minsize))) )
21973 #define SCIPfreeBlockMemory(scip,ptr) BMSfreeBlockMemory(SCIPblkmem(scip), (ptr))
21974 #define SCIPfreeBlockMemoryNull(scip,ptr) BMSfreeBlockMemoryNull(SCIPblkmem(scip), (ptr))
21975 #define SCIPfreeBlockMemoryArray(scip,ptr,num) BMSfreeBlockMemoryArray(SCIPblkmem(scip), (ptr), (num))
21976 #define SCIPfreeBlockMemoryArrayNull(scip,ptr,num) BMSfreeBlockMemoryArrayNull(SCIPblkmem(scip), (ptr), (num))
21977 #define SCIPfreeBlockMemorySize(scip,ptr,size) BMSfreeBlockMemorySize(SCIPblkmem(scip), (ptr), (size))
21978 #define SCIPfreeBlockMemorySizeNull(scip,ptr,size) BMSfreeBlockMemorySizeNull(SCIPblkmem(scip), (ptr), (size))
21979 
21980 /**@} */
21981 
21982 
21983 /**@name Buffer Memory Management Macros
21984  *
21985  * @{
21986  */
21987 
21988 
21989 #define SCIPallocBuffer(scip,ptr) ( (BMSallocBufferMemory(SCIPbuffer(scip), (ptr)) == NULL) \
21990  ? SCIP_NOMEMORY : SCIP_OKAY )
21991 #define SCIPallocBufferArray(scip,ptr,num) ( (BMSallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
21992  ? SCIP_NOMEMORY : SCIP_OKAY )
21993 #define SCIPallocClearBufferArray(scip,ptr,num) ( (BMSallocClearBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
21994  ? SCIP_NOMEMORY : SCIP_OKAY )
21995 #define SCIPreallocBufferArray(scip,ptr,num) ( (BMSreallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
21996  ? SCIP_NOMEMORY : SCIP_OKAY )
21997 #define SCIPduplicateBuffer(scip,ptr,source) ( (BMSduplicateBufferMemory(SCIPbuffer(scip), (ptr), (source), (size_t)sizeof(**(ptr))) \
21998  ? SCIP_NOMEMORY : SCIP_OKAY )
21999 #define SCIPduplicateBufferArray(scip,ptr,source,num) ( (BMSduplicateBufferMemoryArray(SCIPbuffer(scip), (ptr), (source), (num)) == NULL) \
22000  ? SCIP_NOMEMORY : SCIP_OKAY )
22001 #define SCIPfreeBuffer(scip,ptr) BMSfreeBufferMemorySize(SCIPbuffer(scip), (ptr))
22002 #define SCIPfreeBufferNull(scip,ptr) BMSfreeBufferMemoryNull(SCIPbuffer(scip), (ptr))
22003 #define SCIPfreeBufferArray(scip,ptr) BMSfreeBufferMemoryArray(SCIPbuffer(scip), (ptr))
22004 #define SCIPfreeBufferArrayNull(scip,ptr) BMSfreeBufferMemoryArrayNull(SCIPbuffer(scip), (ptr))
22005 
22006 
22007 #define SCIPallocCleanBuffer(scip,ptr) ( (BMSallocBufferMemory(SCIPcleanbuffer(scip), (ptr)) == NULL) \
22008  ? SCIP_NOMEMORY : SCIP_OKAY )
22009 #define SCIPallocCleanBufferArray(scip,ptr,num) ( (BMSallocBufferMemoryArray(SCIPcleanbuffer(scip), (ptr), (num)) == NULL) \
22010  ? SCIP_NOMEMORY : SCIP_OKAY )
22011 #define SCIPfreeCleanBuffer(scip,ptr) BMSfreeBufferMemorySize(SCIPcleanbuffer(scip), (ptr))
22012 #define SCIPfreeCleanBufferNull(scip,ptr) BMSfreeBufferMemoryNull(SCIPcleanbuffer(scip), (ptr))
22013 #define SCIPfreeCleanBufferArray(scip,ptr) BMSfreeBufferMemoryArray(SCIPcleanbuffer(scip), (ptr))
22014 #define SCIPfreeCleanBufferArrayNull(scip,ptr) BMSfreeBufferMemoryArrayNull(SCIPcleanbuffer(scip), (ptr))
22015 
22016 /**@} */
22017 
22018 
22019 /**@name Memory Management Functions
22020  *
22021  * @{
22022  */
22023 
22024 /** returns block memory to use at the current time
22025  *
22026  * @return the block memory to use at the current time.
22027  */
22028 extern
22030  SCIP* scip /**< SCIP data structure */
22031  );
22032 
22033 /** returns buffer memory for short living temporary objects
22034  *
22035  * @return the buffer memory for short living temporary objects
22036  */
22037 extern
22039  SCIP* scip /**< SCIP data structure */
22040  );
22041 
22042 /** returns clean buffer memory for short living temporary objects initialized to all zero
22043  *
22044  * @return the buffer memory for short living temporary objects initialized to all zero
22045  */
22046 extern
22048  SCIP* scip /**< SCIP data structure */
22049  );
22050 
22051 /** returns the total number of bytes used in block and buffer memory
22052  *
22053  * @return the total number of bytes used in block and buffer memory.
22054  */
22055 extern
22057  SCIP* scip /**< SCIP data structure */
22058  );
22059 
22060 /** returns the total number of bytes in block and buffer memory
22061  *
22062  * @return the total number of bytes in block and buffer memory.
22063  */
22064 extern
22066  SCIP* scip /**< SCIP data structure */
22067  );
22068 
22069 /** returns the estimated number of bytes used by external software, e.g., the LP solver
22070  *
22071  * @return the estimated number of bytes used by external software, e.g., the LP solver.
22072  */
22073 extern
22075  SCIP* scip /**< SCIP data structure */
22076  );
22077 
22078 /** calculate memory size for dynamically allocated arrays
22079  *
22080  * @return the memory size for dynamically allocated arrays.
22081  */
22082 extern
22084  SCIP* scip, /**< SCIP data structure */
22085  int num /**< minimum number of entries to store */
22086  );
22087 
22088 /** extends a dynamically allocated block memory array to be able to store at least the given number of elements;
22089  * use SCIPensureBlockMemoryArray() define to call this method!
22090  *
22091  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22092  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22093  */
22094 extern
22096  SCIP* scip, /**< SCIP data structure */
22097  void** arrayptr, /**< pointer to dynamically sized array */
22098  size_t elemsize, /**< size in bytes of each element in array */
22099  int* arraysize, /**< pointer to current array size */
22100  int minsize /**< required minimal array size */
22101  );
22102 
22103 /** prints output about used memory */
22104 extern
22106  SCIP* scip /**< SCIP data structure */
22107  );
22108 
22109 /* @} */
22110 
22111 /* @} */
22112 
22113 
22114 /*
22115  * dynamic arrays
22116  */
22117 
22118 /**@defgroup PublicDynamicArrayMethods Dynamic Arrays
22119  * @ingroup DataStructures
22120  * @brief methods for the creation and access of dynamic arrays
22121  *
22122  * @{
22123  */
22124 
22125 /** creates a dynamic array of real values
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 /**< pointer to store the real array */
22134  );
22135 
22136 /** frees a dynamic array of real values
22137  *
22138  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22139  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22140  */
22141 extern
22143  SCIP* scip, /**< SCIP data structure */
22144  SCIP_REALARRAY** realarray /**< pointer to the real array */
22145  );
22146 
22147 /** extends dynamic array to be able to store indices from minidx to maxidx
22148  *
22149  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22150  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22151  */
22152 extern
22154  SCIP* scip, /**< SCIP data structure */
22155  SCIP_REALARRAY* realarray, /**< dynamic real array */
22156  int minidx, /**< smallest index to allocate storage for */
22157  int maxidx /**< largest index to allocate storage for */
22158  );
22159 
22160 /** clears a dynamic real array
22161  *
22162  * @return clears a dynamic real array
22163  */
22164 extern
22166  SCIP* scip, /**< SCIP data structure */
22167  SCIP_REALARRAY* realarray /**< dynamic real array */
22168  );
22169 
22170 /** gets value of entry in dynamic array */
22171 extern
22173  SCIP* scip, /**< SCIP data structure */
22174  SCIP_REALARRAY* realarray, /**< dynamic real array */
22175  int idx /**< array index to get value for */
22176  );
22177 
22178 /** sets value of entry in dynamic array
22179  *
22180  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22181  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22182  */
22183 extern
22185  SCIP* scip, /**< SCIP data structure */
22186  SCIP_REALARRAY* realarray, /**< dynamic real array */
22187  int idx, /**< array index to set value for */
22188  SCIP_Real val /**< value to set array index to */
22189  );
22190 
22191 /** increases value of entry in dynamic array
22192  *
22193  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22194  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22195  */
22196 extern
22198  SCIP* scip, /**< SCIP data structure */
22199  SCIP_REALARRAY* realarray, /**< dynamic real array */
22200  int idx, /**< array index to increase value for */
22201  SCIP_Real incval /**< value to increase array index */
22202  );
22203 
22204 /** returns the minimal index of all stored non-zero elements
22205  *
22206  * @return the minimal index of all stored non-zero elements
22207  */
22208 extern
22210  SCIP* scip, /**< SCIP data structure */
22211  SCIP_REALARRAY* realarray /**< dynamic real array */
22212  );
22213 
22214 /** returns the maximal index of all stored non-zero elements
22215  *
22216  * @return the maximal index of all stored non-zero elements
22217  */
22218 extern
22220  SCIP* scip, /**< SCIP data structure */
22221  SCIP_REALARRAY* realarray /**< dynamic real array */
22222  );
22223 
22224 /** creates a dynamic array of int values
22225  *
22226  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22227  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22228  */
22229 extern
22231  SCIP* scip, /**< SCIP data structure */
22232  SCIP_INTARRAY** intarray /**< pointer to store the int array */
22233  );
22234 
22235 /** frees a dynamic array of int values
22236  *
22237  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22238  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22239  */
22240 extern
22242  SCIP* scip, /**< SCIP data structure */
22243  SCIP_INTARRAY** intarray /**< pointer to the int array */
22244  );
22245 
22246 /** extends dynamic array to be able to store indices from minidx to maxidx
22247  *
22248  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22249  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22250  */
22251 extern
22253  SCIP* scip, /**< SCIP data structure */
22254  SCIP_INTARRAY* intarray, /**< dynamic int array */
22255  int minidx, /**< smallest index to allocate storage for */
22256  int maxidx /**< largest index to allocate storage for */
22257  );
22258 
22259 /** clears a dynamic int array
22260  *
22261  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22262  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22263  */
22264 extern
22266  SCIP* scip, /**< SCIP data structure */
22267  SCIP_INTARRAY* intarray /**< dynamic int array */
22268  );
22269 
22270 /** gets value of entry in dynamic array
22271  *
22272  * @return value of entry in dynamic array
22273  */
22274 extern
22275 int SCIPgetIntarrayVal(
22276  SCIP* scip, /**< SCIP data structure */
22277  SCIP_INTARRAY* intarray, /**< dynamic int array */
22278  int idx /**< array index to get value for */
22279  );
22280 
22281 /** sets value of entry in dynamic array
22282  *
22283  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22284  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22285  */
22286 extern
22288  SCIP* scip, /**< SCIP data structure */
22289  SCIP_INTARRAY* intarray, /**< dynamic int array */
22290  int idx, /**< array index to set value for */
22291  int val /**< value to set array index to */
22292  );
22293 
22294 /** increases value of entry in dynamic array
22295  *
22296  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22297  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22298  */
22299 extern
22301  SCIP* scip, /**< SCIP data structure */
22302  SCIP_INTARRAY* intarray, /**< dynamic int array */
22303  int idx, /**< array index to increase value for */
22304  int incval /**< value to increase array index */
22305  );
22306 
22307 /** returns the minimal index of all stored non-zero elements
22308  *
22309  * @return the minimal index of all stored non-zero elements
22310  */
22311 extern
22313  SCIP* scip, /**< SCIP data structure */
22314  SCIP_INTARRAY* intarray /**< dynamic int array */
22315  );
22316 
22317 /** returns the maximal index of all stored non-zero elements
22318  *
22319  * @return the maximal index of all stored non-zero elements
22320  */
22321 extern
22323  SCIP* scip, /**< SCIP data structure */
22324  SCIP_INTARRAY* intarray /**< dynamic int array */
22325  );
22326 
22327 /** creates a dynamic array of bool values
22328  *
22329  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22330  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22331  */
22332 extern
22334  SCIP* scip, /**< SCIP data structure */
22335  SCIP_BOOLARRAY** boolarray /**< pointer to store the bool array */
22336  );
22337 
22338 /** frees a dynamic array of bool values
22339  *
22340  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22341  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22342  */
22343 extern
22345  SCIP* scip, /**< SCIP data structure */
22346  SCIP_BOOLARRAY** boolarray /**< pointer to the bool array */
22347  );
22348 
22349 /** extends dynamic array to be able to store indices from minidx to maxidx
22350  *
22351  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22352  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22353  */
22354 extern
22356  SCIP* scip, /**< SCIP data structure */
22357  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
22358  int minidx, /**< smallest index to allocate storage for */
22359  int maxidx /**< largest index to allocate storage for */
22360  );
22361 
22362 /** clears a dynamic bool array
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_BOOLARRAY* boolarray /**< dynamic bool array */
22371  );
22372 
22373 /** gets value of entry in dynamic array
22374  *
22375  * @return value of entry in dynamic array at position idx
22376  */
22377 extern
22379  SCIP* scip, /**< SCIP data structure */
22380  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
22381  int idx /**< array index to get value for */
22382  );
22383 
22384 /** sets value of entry in dynamic array
22385  *
22386  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22387  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22388  */
22389 extern
22391  SCIP* scip, /**< SCIP data structure */
22392  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
22393  int idx, /**< array index to set value for */
22394  SCIP_Bool val /**< value to set array index to */
22395  );
22396 
22397 /** returns the minimal index of all stored non-zero elements
22398  *
22399  * @return the minimal index of all stored non-zero elements
22400  */
22401 extern
22403  SCIP* scip, /**< SCIP data structure */
22404  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
22405  );
22406 
22407 /** returns the maximal index of all stored non-zero elements
22408  *
22409  * @return the maximal index of all stored non-zero elements
22410  */
22411 extern
22413  SCIP* scip, /**< SCIP data structure */
22414  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
22415  );
22416 
22417 /** creates a dynamic array of pointers
22418  *
22419  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22420  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22421  */
22422 extern
22424  SCIP* scip, /**< SCIP data structure */
22425  SCIP_PTRARRAY** ptrarray /**< pointer to store the int array */
22426  );
22427 
22428 /** frees a dynamic array of pointers
22429  *
22430  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22431  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22432  */
22433 extern
22435  SCIP* scip, /**< SCIP data structure */
22436  SCIP_PTRARRAY** ptrarray /**< pointer to the int array */
22437  );
22438 
22439 /** extends dynamic array to be able to store indices from minidx to maxidx
22440  *
22441  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22442  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22443  */
22444 extern
22446  SCIP* scip, /**< SCIP data structure */
22447  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
22448  int minidx, /**< smallest index to allocate storage for */
22449  int maxidx /**< largest index to allocate storage for */
22450  );
22451 
22452 /** clears a dynamic pointer array
22453  *
22454  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22455  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22456  */
22457 extern
22459  SCIP* scip, /**< SCIP data structure */
22460  SCIP_PTRARRAY* ptrarray /**< dynamic int array */
22461  );
22462 
22463 /** gets value of entry in dynamic array */
22464 extern
22465 void* SCIPgetPtrarrayVal(
22466  SCIP* scip, /**< SCIP data structure */
22467  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
22468  int idx /**< array index to get value for */
22469  );
22470 
22471 /** sets value of entry in dynamic array
22472  *
22473  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
22474  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
22475  */
22476 extern
22478  SCIP* scip, /**< SCIP data structure */
22479  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
22480  int idx, /**< array index to set value for */
22481  void* val /**< value to set array index to */
22482  );
22483 
22484 /** returns the minimal index of all stored non-zero elements
22485  *
22486  * @return the minimal index of all stored non-zero elements
22487  */
22488 extern
22490  SCIP* scip, /**< SCIP data structure */
22491  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
22492  );
22493 
22494 /** returns the maximal index of all stored non-zero elements
22495  *
22496  * @return the maximal index of all stored non-zero elements
22497  */
22498 extern
22500  SCIP* scip, /**< SCIP data structure */
22501  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
22502  );
22503 
22504 /**@} */
22505 
22506 /**@defgroup PublicValidationMethods Validation
22507  * @ingroup PUBLICCOREAPI
22508  * @brief methods for validating the correctness of a solving process
22509  *
22510  * @{
22511  */
22512 
22513 /** validate the result of the solve
22514  *
22515  * the validation includes
22516  *
22517  * - checking the feasibility of the incumbent solution in the original problem (using SCIPcheckSolOrig())
22518  *
22519  * - checking if the objective bounds computed by SCIP agree with external primal and dual reference bounds.
22520  *
22521  * All external reference bounds the original problem space and the original objective sense.
22522  *
22523  * For infeasible problems, +/-SCIPinfinity() should be passed as reference bounds depending on the objective sense
22524  * of the original problem.
22525  */
22526 extern
22528  SCIP* scip, /**< SCIP data structure */
22529  SCIP_Real primalreference, /**< external primal reference value for the problem, or SCIP_UNKNOWN */
22530  SCIP_Real dualreference, /**< external dual reference value for the problem, or SCIP_UNKNOWN */
22531  SCIP_Real reftol, /**< relative tolerance for acceptable violation of reference values */
22532  SCIP_Bool quiet, /**< TRUE if no status line should be printed */
22533  SCIP_Bool* feasible, /**< pointer to store if the best solution is feasible in the original problem,
22534  * or NULL */
22535  SCIP_Bool* primalboundcheck, /**< pointer to store if the primal bound respects the given dual reference
22536  * value, or NULL */
22537  SCIP_Bool* dualboundcheck /**< pointer to store if the dual bound respects the given primal reference
22538  * value, or NULL */
22539  );
22540 
22541 /* @} */
22542 
22543 #ifdef __cplusplus
22544 }
22545 #endif
22546 
22547 #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:28582
SCIP_RETCODE SCIPaddLinearCoefsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:32146
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_RETCODE SCIPclearConflictStore(SCIP *scip, SCIP_EVENT *event)
Definition: scip.c:12972
SCIP_RETCODE SCIPsetNodeselCopy(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELCOPY((*nodeselcopy)))
Definition: scip.c:8811
SCIP_Real SCIPdualfeasRound(SCIP *scip, SCIP_Real val)
Definition: scip.c:46642
SCIP_RETCODE SCIPcreatePartialSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37355
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
Definition: scip.c:8159
SCIP_RETCODE SCIPsetPropPresol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPPRESOL((*proppresol)), int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming)
Definition: scip.c:7773
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44769
SCIP_RETCODE SCIPprintBestSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39224
SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
Definition: scip.c:36301
SCIP_RETCODE SCIPsetPricerPriority(SCIP *scip, SCIP_PRICER *pricer, int priority)
Definition: scip.c:5701
#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:30490
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:6889
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43023
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
Definition: scip.c:29330
SCIP_RETCODE SCIPclearCuts(SCIP *scip)
Definition: scip.c:34534
int SCIPgetNIntVars(SCIP *scip)
Definition: scip.c:11770
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
Definition: scip.c:42653
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:30054
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:46385
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:30241
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
Definition: scip.c:5150
SCIP_RETCODE SCIPgetStringParam(SCIP *scip, const char *name, char **value)
Definition: scip.c:4499
int SCIPgetNPrioPseudoBranchBins(SCIP *scip)
Definition: scip.c:36702
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28028
int SCIPgetFocusDepth(SCIP *scip)
Definition: scip.c:42347
SCIP_RETCODE SCIPsetRelaxCopy(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXCOPY((*relaxcopy)))
Definition: scip.c:7157
int SCIPgetNCheckConss(SCIP *scip)
Definition: scip.c:12870
SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
Definition: scip.c:27999
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:18906
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
Definition: scip.c:4480
SCIP_Bool SCIPinRepropagation(SCIP *scip)
Definition: scip.c:40735
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
Definition: scip.c:6263
#define SCIP_DECL_NODESELCOMP(x)
Definition: type_nodesel.h:126
int SCIPgetNNLPNlRows(SCIP *scip)
Definition: scip.c:31194
SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29439
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21971
SCIP_RETCODE SCIPlinkLPSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37847
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip.c:45371
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
Definition: scip.c:41653
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:32537
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
Definition: scip.c:43116
SCIP_RETCODE SCIPdisableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28168
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5130
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:8988
SCIP_RETCODE SCIPincIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int incval)
Definition: scip.c:47141
SCIP_RETCODE SCIPsetComprFree(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRFREE((*comprfree)))
Definition: scip.c:8329
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:46594
enum SCIP_NlpTermStat SCIP_NLPTERMSTAT
Definition: type_nlpi.h:85
SCIP_Real SCIPfeastol(SCIP *scip)
Definition: scip.c:45508
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26292
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26546
SCIP_RETCODE SCIPcomputeLPRelIntPoint(SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)
Definition: scip.c:29892
int SCIPgetPlungeDepth(SCIP *scip)
Definition: scip.c:42436
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
Definition: scip.c:30965
int SCIPgetNDelayedPoolCuts(SCIP *scip)
Definition: scip.c:34427
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22212
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30363
SCIP_Bool SCIPisDualfeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46532
SCIP_Bool SCIPisSumRelLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46774
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19346
SCIP_RETCODE SCIPlinkCurrentSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37952
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:3932
SCIP_RETCODE SCIPsetPresolFree(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLFREE((*presolfree)))
Definition: scip.c:6940
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46320
public methods for branching and inference history structure
SCIP_RETCODE SCIPsetEventhdlrInitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINITSOL((*eventinitsol)))
Definition: scip.c:8649
SCIP_VAR ** SCIPgetNLPVars(SCIP *scip)
Definition: scip.c:31032
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition: scip.c:40680
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip.c:814
int SCIPgetSolRunnum(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38456
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
Definition: scip.c:42640
#define SCIP_DECL_CONCSOLVERSYNCREAD(x)
SCIP_RETCODE SCIPextendBoolarray(SCIP *scip, SCIP_BOOLARRAY *boolarray, int minidx, int maxidx)
Definition: scip.c:47222
SCIP_RETCODE SCIPchgBarrierconvtol(SCIP *scip, SCIP_Real barrierconvtol)
Definition: scip.c:45648
SCIP_NODESEL ** SCIPgetNodesels(SCIP *scip)
Definition: scip.c:8920
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:38139
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
Definition: scip.c:6286
public methods for branch and bound tree
SCIP_RETCODE SCIPgetNLPIntPar(SCIP *scip, SCIP_NLPPARAM type, int *ival)
Definition: scip.c:31499
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
Definition: scip.c:18810
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
Definition: scip.c:35291
SCIP_RETCODE SCIPsetBranchruleExecPs(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECPS((*branchexecps)))
Definition: scip.c:9203
internal methods for branch and bound tree
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
Definition: scip.c:41609
SCIP_RETCODE SCIPcopyOrigProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name)
Definition: scip.c:1784
type definitions for miscellaneous datastructures
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip.c:26663
int SCIPgetNRelaxs(SCIP *scip)
Definition: scip.c:7280
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:30210
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46333
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
Definition: scip.c:21591
SCIP_RETCODE SCIPrecalcRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30673
SCIP_Bool SCIPisSumGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46271
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:46696
#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:19206
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:36951
SCIP_RETCODE SCIPcreateBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
Definition: scip.c:47188
SCIP_RETCODE SCIPgetNLPNlRowsData(SCIP *scip, SCIP_NLROW ***nlrows, int *nnlrows)
Definition: scip.c:31144
SCIP_RETCODE SCIPgetSolVarsData(SCIP *scip, SCIP_SOL *sol, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip.c:12309
SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
Definition: scip.c:45327
#define SCIP_DECL_DIALOGCOPY(x)
Definition: type_dialog.h:53
SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)
Definition: scip.c:10982
SCIP_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)
Definition: scip.c:9704
SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26320
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
Definition: scip.c:42571
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:40502
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
Definition: scip.c:6576
int SCIPgetProbingDepth(SCIP *scip)
Definition: scip.c:35264
SCIP_RETCODE SCIPsetPresolExit(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXIT((*presolexit)))
Definition: scip.c:6972
SCIP_Real SCIPgetReadingTime(SCIP *scip)
Definition: scip.c:45398
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
Definition: scip.c:42726
SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
Definition: scip.c:29699
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26207
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30386
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
Definition: scip.c:42675
#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:46683
SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:35978
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:33395
#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:29659
public methods for implications, variable bounds, and cliques
int SCIPgetIntarrayMaxIdx(SCIP *scip, SCIP_INTARRAY *intarray)
Definition: scip.c:47173
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:38558
SCIP_Real * SCIPgetNLPVarsUbDualsol(SCIP *scip)
Definition: scip.c:31122
SCIP_Bool SCIPisFeasFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:46433
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
Definition: scip.c:7823
int SCIPgetNEventhdlrs(SCIP *scip)
Definition: scip.c:8715
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:30088
#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:6516
SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)
Definition: scip.c:13232
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip.c:4461
SCIP_RETCODE SCIPsetComprInit(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINIT((*comprinit)))
Definition: scip.c:8345
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
Definition: scip.c:42754
SCIP_RETCODE SCIPgetLeaves(SCIP *scip, SCIP_NODE ***leaves, int *nleaves)
Definition: scip.c:40837
SCIP_SEPA * SCIPfindSepa(SCIP *scip, const char *name)
Definition: scip.c:7498
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:25687
#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:10000
SCIP_RETCODE SCIPsetEventhdlrExitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXITSOL((*eventexitsol)))
Definition: scip.c:8663
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
Definition: scip.c:45705
int SCIPgetNPrioPseudoBranchImpls(SCIP *scip)
Definition: scip.c:36738
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
Definition: scip.c:42891
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
Definition: scip.c:41762
SCIP_RETCODE SCIPaddSolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool *stored)
Definition: scip.c:39866
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
Definition: scip.c:6008
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:9813
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28056
SCIP_RETCODE SCIPchgConsName(SCIP *scip, SCIP_CONS *cons, const char *name)
Definition: scip.c:27468
SCIP_RETCODE SCIPsetParam(SCIP *scip, const char *name, void *value)
Definition: scip.c:4557
#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:8635
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:12530
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
Definition: scip.c:8127
SCIP_RETCODE SCIPsetRelaxInit(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINIT((*relaxinit)))
Definition: scip.c:7189
int SCIPcalcMemGrowSize(SCIP *scip, int num)
Definition: scip.c:45835
static long bound
SCIP_Bool SCIPisSumPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:46296
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:30418
SCIP_RETCODE SCIPrecomputeSolObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38348
SCIP_RETCODE SCIPcreateCPUClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:45095
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19074
SCIP_RETCODE SCIPevalExprtreeGlobalBounds(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
Definition: scip.c:32898
SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
Definition: scip.c:27615
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:76
SCIP_Real SCIPgetRowPseudoFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30763
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:46110
SCIP_Bool SCIPisSumRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46761
SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
Definition: scip.c:18773
int SCIPgetNOrigVars(SCIP *scip)
Definition: scip.c:12120
#define SCIP_DECL_NODESELINITSOL(x)
Definition: type_nodesel.h:83
int SCIPgetNSiblings(SCIP *scip)
Definition: scip.c:40819
SCIP_Bool SCIPisStringParamValid(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip.c:4907
SCIP_Bool SCIPisUpdateUnreliable(SCIP *scip, SCIP_Real newvalue, SCIP_Real oldvalue)
Definition: scip.c:46868
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:21206
SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)
Definition: scip.c:29950
SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
Definition: scip.c:34411
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:27044
SCIP_RETCODE SCIPchgNlRowRhs(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real rhs)
Definition: scip.c:32076
SCIP_RELAX ** SCIPgetRelaxs(SCIP *scip)
Definition: scip.c:7267
int SCIPgetNPseudoBranchCands(SCIP *scip)
Definition: scip.c:36665
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:8775
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46037
char ** SCIPgetExternalCodeDescriptions(SCIP *scip)
Definition: scip.c:9536
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:22900
SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28225
#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:6378
int SCIPgetNLeaves(SCIP *scip)
Definition: scip.c:40861
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21875
SCIP_Bool SCIPreoptimizeNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:17154
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
Definition: scip.c:43384
SCIP_Bool SCIPisDualfeasFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:46606
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
Definition: scip.c:8561
SCIP_RETCODE SCIPdelConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)
Definition: scip.c:13110
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
Definition: type_branch.h:43
SCIP_RETCODE SCIPcreateRealarray(SCIP *scip, SCIP_REALARRAY **realarray)
Definition: scip.c:46886
SCIP_NLPSOLSTAT SCIPgetNLPSolstat(SCIP *scip)
Definition: scip.c:31348
SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:25932
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:43139
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip.c:18652
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:43536
SCIP_RETCODE SCIPcatchRowEvent(SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:40588
SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip.c:34269
SCIP_Real SCIPfeasRound(SCIP *scip, SCIP_Real val)
Definition: scip.c:46469
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
Definition: scip.c:27768
SCIP_RETCODE SCIPsetNlRowExprtreeParam(SCIP *scip, SCIP_NLROW *nlrow, int paramidx, SCIP_Real paramval)
Definition: scip.c:32386
SCIP_DECL_EVENTEXIT(EventhdlrNewSol::scip_exit)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
Definition: scip.c:17733
SCIP_RETCODE SCIPsetBranchruleInitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINITSOL((*branchinitsol)))
Definition: scip.c:9137
SCIP_RETCODE SCIPextendIntarray(SCIP *scip, SCIP_INTARRAY *intarray, int minidx, int maxidx)
Definition: scip.c:47071
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
Definition: scip.c:41726
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip.c:18461
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:31798
SCIP_Real SCIPgetBranchingPoint(SCIP *scip, SCIP_VAR *var, SCIP_Real suggestion)
Definition: scip.c:36804
SCIP_RETCODE SCIPgetOpenNodesData(SCIP *scip, SCIP_NODE ***leaves, SCIP_NODE ***children, SCIP_NODE ***siblings, int *nleaves, int *nchildren, int *nsiblings)
Definition: scip.c:40987
#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:6177
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:45180
SCIP_RETCODE SCIPaddRowDive(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34836
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:46409
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
Definition: scip.c:29783
SCIP_RETCODE SCIPsetBranchruleExit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))
Definition: scip.c:9121
SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34373
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
Definition: scip.c:22178
SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
SCIP_RETCODE SCIPincRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real incval)
Definition: scip.c:46990
SCIP_Real SCIPdualfeastol(SCIP *scip)
Definition: scip.c:45536
SCIP_RETCODE SCIPsetRelaxExitsol(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXITSOL((*relaxexitsol)))
Definition: scip.c:7237
int SCIPgetMaxDepth(SCIP *scip)
Definition: scip.c:42371
SCIP_RETCODE SCIPconvertCutsToConss(SCIP *scip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
Definition: scip.c:2997
SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip.c:27869
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25823
SCIP_RETCODE SCIPsetNlRowExprtree(SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPRTREE *exprtree)
Definition: scip.c:32360
#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:32183
void SCIPgetDiveBoundChangeData(SCIP *scip, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
Definition: scip.c:36241
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip.c:26014
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46372
SCIP_RETCODE SCIPextendRealarray(SCIP *scip, SCIP_REALARRAY *realarray, int minidx, int maxidx)
Definition: scip.c:46920
SCIP_RETCODE SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
Definition: scip.c:9089
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
Definition: scip.c:44946
#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:11554
SCIP_Real SCIPgetRelaxFeastolFactor(SCIP *scip)
Definition: scip.c:34579
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
Definition: scip.c:41836
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:562
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5078
SCIP_RETCODE SCIPsetProbExitsol(SCIP *scip, SCIP_DECL_PROBEXITSOL((*probexitsol)))
Definition: scip.c:9979
#define SCIP_DECL_CONCSOLVEREXEC(x)
SCIP_Bool SCIPisSumNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:46308
SCIP_RETCODE SCIPchgReoptObjective(SCIP *scip, SCIP_OBJSENSE objsense, SCIP_VAR **vars, SCIP_Real *coefs, int nvars)
Definition: scip.c:10811
SCIP_SOL ** SCIPgetSols(SCIP *scip)
Definition: scip.c:39108
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
Definition: scip.c:21674
#define SCIP_DECL_PRESOLCOPY(x)
Definition: type_presol.h:46
SCIP_Real SCIPgetDeterministicTime(SCIP *scip)
Definition: scip.c:43409
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
Definition: scip.c:42020
SCIP_RETCODE SCIPsetNodeselMemsavePriority(SCIP *scip, SCIP_NODESEL *nodesel, int priority)
Definition: scip.c:8957
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:37049
SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26050
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:4265
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:8232
SCIP_Bool SCIPhasNLPContinuousNonlinearity(SCIP *scip)
Definition: scip.c:30980
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:23121
#define SCIP_DECL_RELAXINIT(x)
Definition: type_relax.h:63
SCIP_RETCODE SCIPcopyLimits(SCIP *sourcescip, SCIP *targetscip)
Definition: scip.c:4164
SCIP_NODE * SCIPgetBestSibling(SCIP *scip)
Definition: scip.c:40925
#define SCIP_DECL_RELAXINITSOL(x)
Definition: type_relax.h:82
int SCIPgetSubscipDepth(SCIP *scip)
Definition: scip.c:3534
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:5866
int SCIPgetNPartialSols(SCIP *scip)
Definition: scip.c:40229
SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34114
SCIP_Bool SCIPisIntParamValid(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip.c:4675
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:27324
int SCIPgetNActivePricers(SCIP *scip)
Definition: scip.c:5690
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23592
SCIP_COMPR * SCIPfindCompr(SCIP *scip, const char *name)
Definition: scip.c:8409
SCIP_RETCODE SCIPaddQuadElementToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelem)
Definition: scip.c:32270
SCIP_RETCODE SCIPsetNodeselExit(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXIT((*nodeselexit)))
Definition: scip.c:8859
SCIP_RETCODE SCIPpropagateProbingImplications(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:35756
void SCIPprintExternalCodes(SCIP *scip, FILE *file)
Definition: scip.c:9561
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:3856
SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:41023
SCIP_Real SCIPinfinity(SCIP *scip)
Definition: scip.c:46050
SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
Definition: scip.c:25715
SCIP_VERBLEVEL SCIPgetVerbLevel(SCIP *scip)
Definition: scip.c:1377
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:46122
SCIP_RETCODE SCIPenableConsSeparation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28140
SCIP_Bool SCIPexistsDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9625
SCIP_PRICER * SCIPfindPricer(SCIP *scip, const char *name)
Definition: scip.c:5653
void SCIPclearExternBranchCands(SCIP *scip)
Definition: scip.c:36596
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:8275
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28286
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:27130
SCIP_RETCODE SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
Definition: scip.c:9073
#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:13271
#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:38429
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:26907
SCIP_RETCODE SCIPsolveNLP(SCIP *scip)
Definition: scip.c:31325
#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:21349
methods commonly used by primal heuristics
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21250
SCIP_RETCODE SCIPcreateIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
Definition: scip.c:47037
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:7984
SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip.c:10303
SCIP_Real SCIPgetBranchScoreMultiple(SCIP *scip, SCIP_VAR *var, int nchildren, SCIP_Real *gains)
Definition: scip.c:36779
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip.c:5104
SCIP_RETCODE SCIPsetComprInitsol(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINITSOL((*comprinitsol)))
Definition: scip.c:8377
int SCIPgetNReoptnodes(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:16517
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
Definition: scip.c:9219
char ** SCIPgetExternalCodeNames(SCIP *scip)
Definition: scip.c:9522
SCIP_DECL_READERWRITE(ReaderTSP::scip_write)
Definition: ReaderTSP.cpp:472
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
Definition: scip.c:8188
SCIP_RETCODE SCIPsetProbData(SCIP *scip, SCIP_PROBDATA *probdata)
Definition: scip.c:10706
SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:34772
SCIP_RETCODE SCIPfreeIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
Definition: scip.c:47054
int SCIPgetNPrioPseudoBranchInts(SCIP *scip)
Definition: scip.c:36720
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
Definition: scip.c:42507
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
Definition: scip.c:41672
SCIP_RETCODE SCIPgetLPBInvCol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29474
#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:17394
SCIP_Longint SCIPgetNNZs(SCIP *scip)
Definition: scip.c:41635
SCIP_RETCODE SCIPisConflictVarUsed(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
Definition: scip.c:27078
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26574
SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
Definition: scip.c:33923
SCIP_Bool SCIPisDualfeasZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:46558
SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
Definition: scip.c:12093
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26082
SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip.c:4750
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26631
struct SCIP_HeurData SCIP_HEURDATA
Definition: type_heur.h:51
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
Definition: scip.c:42074
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:174
public methods for displaying runtime statistics
int SCIPgetNActiveConss(SCIP *scip)
Definition: scip.c:42453
int SCIPgetNNodesLeft(SCIP *scip)
Definition: scip.c:41454
public methods for problem variables
SCIP_RETCODE SCIPevalExprtreeSol(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_SOL *sol, SCIP_Real *val)
Definition: scip.c:32843
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:29603
SCIP_RETCODE SCIPsetSepaPriority(SCIP *scip, SCIP_SEPA *sepa, int priority)
Definition: scip.c:7535
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
Definition: scip.c:26874
SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
Definition: scip.c:36215
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:25951
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:6772
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
Definition: scip.c:26811
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip)
Definition: scip.c:19586
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
Definition: scip.c:42419
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:22328
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
Definition: scip.c:42002
#define SCIP_DECL_BRANCHEXECEXT(x)
Definition: type_branch.h:140
SCIP_Real SCIPgetRelaxSolObj(SCIP *scip)
Definition: scip.c:19834
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:8034
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:4348
SCIP_Bool SCIPgetVarWasFixedAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19504
SCIP_RETCODE SCIPenableOrDisableStatisticTiming(SCIP *scip)
Definition: scip.c:45220
SCIP_READER * SCIPfindReader(SCIP *scip, const char *name)
Definition: scip.c:5362
SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28195
SCIP_Bool SCIPallVarsInProb(SCIP *scip)
Definition: scip.c:12432
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:33141
SCIP_RETCODE SCIPinitRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:16680
type definitions for return codes for SCIP methods
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25741
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:5920
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:35367
SCIP_RETCODE SCIPrecalcRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30781
#define SCIP_DECL_PRICEREXITSOL(x)
Definition: type_pricer.h:92
int SCIPgetPtrarrayMaxIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
Definition: scip.c:47434
SCIP_RETCODE SCIPgetOrigVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip.c:12045
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:32667
SCIP_RETCODE SCIPwriteParam(SCIP *scip, SCIP_PARAM *param, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip.c:4942
public methods for branching rules
SCIP_RETCODE SCIPgetNLPVarsNonlinearity(SCIP *scip, int *nlcount)
Definition: scip.c:31076
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
Definition: scip.c:8691
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:9036
void SCIPprintReal(SCIP *scip, FILE *file, SCIP_Real val, int width, int precision)
Definition: scip.c:45678
SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
SCIP_RETCODE SCIPsetPricerExit(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXIT((*pricerexit)))
Definition: scip.c:5589
#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:21919
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:17604
void SCIPresetReoptSolMarks(SCIP *scip)
Definition: scip.c:17094
SCIP_RETCODE SCIPsetPricerExitsol(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXITSOL((*pricerexitsol)))
Definition: scip.c:5637
SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23562
#define SCIP_DECL_PROBCOPY(x)
Definition: type_prob.h:140
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:45129
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip.c:45753
SCIP_RETCODE SCIPflushNLP(SCIP *scip)
Definition: scip.c:31240
int SCIPgetNCutsFoundRound(SCIP *scip)
Definition: scip.c:42196
enum SCIP_NlpParam SCIP_NLPPARAM
Definition: type_nlpi.h:56
SCIP_CONS ** SCIPgetConss(SCIP *scip)
Definition: scip.c:12774
type definitions for presolvers
SCIP_RETCODE SCIPsetNLPIntPar(SCIP *scip, SCIP_NLPPARAM type, int ival)
Definition: scip.c:31527
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:30122
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21705
SCIP_Bool SCIPisLPDualReliable(SCIP *scip)
Definition: scip.c:28987
int SCIPgetNPresols(SCIP *scip)
Definition: scip.c:7046
SCIP_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:46481
SCIP_RETCODE SCIPsetNLPStringPar(SCIP *scip, SCIP_NLPPARAM type, const char *sval)
Definition: scip.c:31639
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:45985
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:23662
SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:28904
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:36417
#define SCIP_DECL_BRANCHEXITSOL(x)
Definition: type_branch.h:98
SCIP_RETCODE SCIPcaptureDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9640
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37220
SCIP_RETCODE SCIPmarkRelaxSolInvalid(SCIP *scip)
Definition: scip.c:19784
SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
Definition: scip.c:21642
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:39936
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:6660
#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:36334
SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
Definition: scip.c:29217
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:23721
SCIP_Bool SCIPpressedCtrlC(SCIP *scip)
Definition: scip.c:1125
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
Definition: scip.c:7402
SCIP_RETCODE SCIPsetConshdlrDelvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
Definition: scip.c:6447
SCIP_RETCODE SCIPdropRowEvent(SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:40628
#define SCIP_DECL_PRICERCOPY(x)
Definition: type_pricer.h:46
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
Definition: scip.c:4776
#define SCIP_DECL_DIVESETGETSCORE(x)
Definition: type_heur.h:147
SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
Definition: scip.c:4866
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
Definition: scip.c:6309
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
Definition: scip.c:40699
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip.c:1260
SCIP_SOL ** SCIPgetPartialSols(SCIP *scip)
Definition: scip.c:40206
int SCIPgetNPrioExternBranchImpls(SCIP *scip)
Definition: scip.c:36530
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:22058
#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:4237
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip.c:18693
#define SCIP_DECL_COMPRINIT(x)
Definition: type_compr.h:65
SCIP_RETCODE SCIPcopyParamSettings(SCIP *sourcescip, SCIP *targetscip)
Definition: scip.c:3493
SCIP_Bool SCIPisRootLPRelax(SCIP *scip)
Definition: scip.c:29131
SCIP_Bool SCIPisSumZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:46284
int SCIPgetIntarrayMinIdx(SCIP *scip, SCIP_INTARRAY *intarray)
Definition: scip.c:47159
SCIP_RETCODE SCIPaddLinearCoefToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:32122
SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
Definition: scip.c:34135
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
Definition: scip.c:6493
SCIP_RETCODE SCIPfreeReoptSolve(SCIP *scip)
Definition: scip.c:16884
SCIP_Real SCIPgetPresolvingTime(SCIP *scip)
Definition: scip.c:45435
#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:45851
#define SCIP_DECL_CONCSOLVERDESTROYINST(x)
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44659
type definitions for branching rules
SCIP_RETCODE SCIPactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28679
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43323
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip.c:1336
int SCIPgetNContVars(SCIP *scip)
Definition: scip.c:11860
SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30823
#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:27240
SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)
Definition: scip.c:9874
SCIP_Real SCIPgetObjNorm(SCIP *scip)
Definition: scip.c:11333
SCIP_NLROW ** SCIPgetNLPNlRows(SCIP *scip)
Definition: scip.c:31172
SCIP_DISP * SCIPfindDisp(SCIP *scip, const char *name)
Definition: scip.c:9343
SCIP_Real SCIPepsilon(SCIP *scip)
Definition: scip.c:45480
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:17909
SCIP_DECL_EVENTINITSOL(EventhdlrNewSol::scip_initsol)
SCIP_RETCODE SCIPcreateOrigSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37415
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
Definition: scip.c:23610
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:26840
SCIP_RETCODE SCIPgetSiblings(SCIP *scip, SCIP_NODE ***siblings, int *nsiblings)
Definition: scip.c:40795
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
Definition: scip.c:42595
SCIP_Real SCIPbarrierconvtol(SCIP *scip)
Definition: scip.c:45550
SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30621
SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23485
SCIP_RETCODE SCIPdeleteReoptnode(SCIP *scip, SCIP_REOPTNODE **reoptnode)
Definition: scip.c:17194
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
Definition: scip.c:46457
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23506
SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip)
Definition: scip.c:19762
SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30655
SCIP_RETCODE SCIPrepropagateNode(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:41044
SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
Definition: scip.c:18602
SCIP_RETCODE SCIPcreateNlRowFromRow(SCIP *scip, SCIP_NLROW **nlrow, SCIP_ROW *row)
Definition: scip.c:31985
SCIP_RETCODE SCIPsetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx, SCIP_Bool val)
Definition: scip.c:47273
#define SCIP_DECL_COMPRFREE(x)
Definition: type_compr.h:57
SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
Definition: scip.c:25976
SCIP_Bool SCIPisRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46735
SCIP_RETCODE SCIPchgChildPrio(SCIP *scip, SCIP_NODE *child, SCIP_Real priority)
Definition: scip.c:13477
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
Definition: scip.c:24886
enum SCIP_ParamSetting SCIP_PARAMSETTING
Definition: type_paramset.h:56
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:46445
SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
Definition: scip.c:9171
#define SCIP_DECL_NODESELINIT(x)
Definition: type_nodesel.h:64
SCIP_RETCODE SCIPconstructSyncstore(SCIP *scip)
Definition: scip.c:41228
public methods for expressions, expression trees, expression graphs, and related stuff ...
SCIP_RETCODE SCIPclearRealarray(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:46939
int SCIPgetNConshdlrs(SCIP *scip)
Definition: scip.c:6600
#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:46709
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
Definition: scip.c:44831
SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)
SCIP_RETCODE SCIPfreeRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:16739
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
Definition: scip.c:41894
const char * SCIPgetProbName(SCIP *scip)
Definition: scip.c:10759
SCIP_RETCODE SCIPclearPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray)
Definition: scip.c:47373
SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:45112
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
Definition: scip.c:25653
SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
Definition: scip.c:36756
#define SCIP_DECL_DIALOGDESC(x)
Definition: type_dialog.h:73
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
Definition: scip.c:26789
SCIP_RETCODE SCIPsetHeurPriority(SCIP *scip, SCIP_HEUR *heur, int priority)
Definition: scip.c:8212
SCIP_RETCODE SCIPcopyOrigConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip.c:2864
SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
Definition: scip.c:19486
SCIP_RETCODE SCIPlinkNLPSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37873
int SCIPgetNFixedVars(SCIP *scip)
Definition: scip.c:11997
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:28881
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
Definition: scip.c:46668
SCIP_Bool SCIPisLPRelax(SCIP *scip)
Definition: scip.c:29005
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
Definition: scip.c:12374
SCIP_RETCODE SCIPsetConflicthdlrInit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)))
Definition: scip.c:6724
void * SCIPgetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx)
Definition: scip.c:47386
SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28081
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
Definition: scip.c:11954
SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
Definition: scip.c:27540
SCIP_RETCODE SCIPsetReoptCompression(SCIP *scip, SCIP_REOPTNODE **representation, int nrepresentatives, SCIP_Bool *success)
Definition: scip.c:16595
SCIP_Bool SCIPisCharParamValid(SCIP *scip, SCIP_PARAM *param, const char value)
Definition: scip.c:4849
void SCIPclearDiveBoundChanges(SCIP *scip)
Definition: scip.c:36268
int SCIPgetNPrioLPBranchCands(SCIP *scip)
Definition: scip.c:36372
#define SCIP_DECL_CONCSOLVERSTOP(x)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
Definition: scip.c:25139
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
Definition: scip.c:42619
struct SCIP_NodeselData SCIP_NODESELDATA
Definition: type_nodesel.h:38
SCIP_RETCODE SCIPresetParams(SCIP *scip)
Definition: scip.c:5005
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
Definition: scip.c:23909
SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
Definition: scip.c:29392
SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)
Definition: scip.c:9690
SCIP_RETCODE SCIPenableConsCompression(SCIP *scip)
Definition: scip.c:1822
SCIP_READER ** SCIPgetReaders(SCIP *scip)
Definition: scip.c:5375
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
Definition: scip.c:6129
#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:7173
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:9592
void SCIPprintMemoryDiagnostic(SCIP *scip)
Definition: scip.c:45877
#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:25478
SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
Definition: scip.c:11478
#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:33891
public methods for managing constraints
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
Definition: scip.c:10934
SCIP_Bool SCIPisBoolParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip.c:4617
SCIP_RETCODE SCIPsetPropExitpre(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITPRE((*propexitpre)))
Definition: scip.c:7757
SCIP_RETCODE SCIPchgRowLhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)
Definition: scip.c:34875
SCIP_RETCODE SCIPaddReoptDualBndchg(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_Real oldbound)
Definition: scip.c:16369
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:7898
SCIP_RETCODE SCIPsolveProbingRelax(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip.c:36007
#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:17810
int SCIPgetNNLPVars(SCIP *scip)
Definition: scip.c:31054
SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
Definition: scip.c:6562
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
Definition: scip.c:37468
SCIP_NLPTERMSTAT SCIPgetNLPTermstat(SCIP *scip)
Definition: scip.c:31370
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
Definition: scip.c:45768
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:7312
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:34292
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)
Definition: scip.c:6801
SCIP_Real SCIPgetLPLooseObjval(SCIP *scip)
Definition: scip.c:29063
SCIP_Bool SCIPisSumRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46800
SCIP_RETCODE SCIPsetObjIntegral(SCIP *scip)
Definition: scip.c:11211
SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:34998
SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
Definition: scip.c:27718
#define SCIP_DECL_CONFLICTINITSOL(x)
Definition: type_conflict.h:96
SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
Definition: scip.c:34195
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:4014
int SCIPgetNCutsApplied(SCIP *scip)
Definition: scip.c:42214
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
Definition: scip.c:8143
void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30585
SCIP_RETCODE SCIPsolve(SCIP *scip)
Definition: scip.c:15846
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
Definition: scip.c:6032
SCIP_PROP ** SCIPgetProps(SCIP *scip)
Definition: scip.c:7836
#define SCIP_DECL_BRANCHCOPY(x)
Definition: type_branch.h:52
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
Definition: scip.c:45078
#define SCIP_DECL_CONFLICTEXEC(x)
SCIP_Bool SCIPisRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46748
SCIP_RETCODE SCIPsetNodeselExitsol(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)))
Definition: scip.c:8891
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:33188
SCIP_RETCODE SCIPdeactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
Definition: scip.c:5747
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
Definition: scip.c:8175
SCIP_RETCODE SCIPsetComprCopy(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRCOPY((*comprcopy)))
Definition: scip.c:8313
SCIP_RETCODE SCIPbranchVar(SCIP *scip, SCIP_VAR *var, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
Definition: scip.c:36910
SCIP_RETCODE SCIPsetNlRowExprtreeParams(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *paramvals)
Definition: scip.c:32410
SCIP_Real SCIPdualfeasCeil(SCIP *scip, SCIP_Real val)
Definition: scip.c:46630
SCIP_RETCODE SCIPsolveDiveNLP(SCIP *scip)
Definition: scip.c:31889
SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
Definition: scip.c:34226
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip.c:25849
type definitions for variable pricers
SCIP_Bool SCIPisSumRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46787
SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30603
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
Definition: scip.c:18857
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
Definition: scip.c:41912
SCIP_RETCODE SCIPchgNlRowQuadElement(SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelement)
Definition: scip.c:32337
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
Definition: scip.c:4373
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
Definition: scip.c:28831
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:12459
SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
Definition: scip.c:6589
#define SCIP_DECL_PRESOLFREE(x)
Definition: type_presol.h:54
void SCIPstoreSolutionGap(SCIP *scip)
Definition: scip.c:45015
int SCIPgetCutoffdepth(SCIP *scip)
Definition: scip.c:41063
SCIP_RETCODE SCIPgetReoptChildIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
Definition: scip.c:16460
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:5469
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
Definition: scip.c:22145
SCIP_RETCODE SCIPsetEventhdlrFree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))
Definition: scip.c:8607
SCIP_RETCODE SCIPrecalcNlRowPseudoActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32516
SCIP_RETCODE SCIPsetEventhdlrCopy(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTCOPY((*eventcopy)))
Definition: scip.c:8593
SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:35031
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: scip.c:8095
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:45998
SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
Definition: scip.c:13079
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:31216
SCIP_RETCODE SCIPwriteNLP(SCIP *scip, const char *filename)
Definition: scip.c:31667
#define SCIP_DECL_PRICERFARKAS(x)
Definition: type_pricer.h:165
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:25528
type definitions for primal heuristics
SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
Definition: scip.c:34313
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
Definition: scip.c:35650
#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:40163
SCIP_RETCODE SCIPfreeProb(SCIP *scip)
Definition: scip.c:10396
SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)
Definition: scip.c:10033
int SCIPgetNCutsFound(SCIP *scip)
Definition: scip.c:42178
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:13160
SCIP_RETCODE SCIPsetSepaExit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))
Definition: scip.c:7450
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:38219
SCIP_RETCODE SCIPaddDialogHistoryLine(SCIP *scip, const char *inputline)
Definition: scip.c:9742
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:22439
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
Definition: scip.c:35484
SCIP_Bool SCIPisFracIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:46159
SCIP_RETCODE SCIPrecalcRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30727
int SCIPgetNConflicthdlrs(SCIP *scip)
Definition: scip.c:6814
SCIP_RETCODE SCIPreadSol(SCIP *scip, const char *filename)
Definition: scip.c:39394
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:26410
SCIP_RETCODE SCIPlinkPseudoSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37932
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:653
SCIP_RETCODE SCIPgetChildren(SCIP *scip, SCIP_NODE ***children, int *nchildren)
Definition: scip.c:40753
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
Definition: scip.c:32031
SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)
Definition: scip.c:4808
SCIP_Real SCIPgetDualbound(SCIP *scip)
Definition: scip.c:42529
#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:19006
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:28617
SCIP_Bool SCIPisDualfeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46545
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:2333
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:23781
SCIP_RETCODE SCIPchgCutoffboundDive(SCIP *scip, SCIP_Real newcutoffbound)
Definition: scip.c:34701
SCIP_Bool SCIPisDualSolAvailable(SCIP *scip, SCIP_Bool printreason)
Definition: scip.c:38927
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
Definition: scip.c:4602
SCIP_STATUS SCIPgetStatus(SCIP *scip)
Definition: scip.c:921
SCIP_RETCODE SCIPpresolve(SCIP *scip)
Definition: scip.c:15685
SCIP_CONS * SCIPfindOrigCons(SCIP *scip, const char *name)
Definition: scip.c:12585
SCIP_Real SCIPversion(void)
Definition: scip.c:554
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
Definition: scip.c:33909
#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:3057
SCIP_Real SCIPgetTransGap(SCIP *scip)
Definition: scip.c:42839
int SCIPgetNDisps(SCIP *scip)
Definition: scip.c:9367
SCIP_RETCODE SCIPgetReoptSolsRun(SCIP *scip, int run, SCIP_SOL **sols, int allocmem, int *nsols)
Definition: scip.c:17068
SCIP_RETCODE SCIPsetEventhdlrInit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINIT((*eventinit)))
Definition: scip.c:8621
SCIP_RETCODE SCIPchgVarBoundsDiveNLP(SCIP *scip, SCIP_VAR *var, SCIP_Real lb, SCIP_Real ub)
Definition: scip.c:31828
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:28346
SCIP_Bool SCIPisReoptEnabled(SCIP *scip)
Definition: scip.c:17058
SCIP_RETCODE SCIPprintTransSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:38683
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:27106
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
Definition: scip.c:41818
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip.c:21477
#define SCIP_DECL_PROPEXITSOL(x)
Definition: type_prop.h:127
SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
Definition: scip.c:27590
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:21795
#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:6956
SCIP_RETCODE SCIPsetConsDynamic(SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)
Definition: scip.c:27693
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
Definition: scip.c:25871
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
Definition: scip.c:40313
#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:31555
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:25588
int SCIPgetNChildren(SCIP *scip)
Definition: scip.c:40777
SCIP_Real SCIPdualfeasFloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:46618
SCIP_RETCODE SCIPsumLPRows(SCIP *scip, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
Definition: scip.c:29577
SCIP_RETCODE SCIPendProbing(SCIP *scip)
Definition: scip.c:35326
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:155
SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)
Definition: scip.c:12847
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
Definition: scip.c:6057
SCIP_PRESOL * SCIPfindPresol(SCIP *scip, const char *name)
Definition: scip.c:7020
#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:32736
SCIP_RETCODE SCIPmergeVariableStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **sourcevars, SCIP_VAR **targetvars, int nvars)
Definition: scip.c:2420
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:6846
SCIP_RETCODE SCIPsetBranchruleMaxbounddist(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_Real maxbounddist)
Definition: scip.c:9286
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23229
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:13291
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
Definition: scip.c:4404
SCIP_RETCODE SCIPaddNlpiProbRows(SCIP *scip, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *nlpiprob, SCIP_HASHMAP *var2idx, SCIP_ROW **rows, int nrows)
Definition: scip.c:33770
SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
Definition: scip.c:12633
SCIP_Bool SCIPisNLPEnabled(SCIP *scip)
Definition: scip.c:30927
SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip.c:28435
SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)
Definition: scip.c:41563
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:43492
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:20881
SCIP_RETCODE SCIPgetExprtreeTransformedVars(SCIP *scip, SCIP_EXPRTREE *tree)
Definition: scip.c:32804
#define SCIP_DECL_RELAXCOPY(x)
Definition: type_relax.h:47
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28258
SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26176
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38317
SCIP_RETCODE SCIPsetNLPInitialGuess(SCIP *scip, SCIP_Real *initialguess)
Definition: scip.c:31266
SCIP_Bool SCIPisObjChangedProbing(SCIP *scip)
Definition: scip.c:35627
SCIP_RETCODE SCIPclearBoolarray(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:47241
int SCIPgetNNlpis(SCIP *scip)
Definition: scip.c:9479
int SCIPgetNPrioExternBranchCands(SCIP *scip)
Definition: scip.c:36469
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:683
SCIP_RETCODE SCIPchgDualfeastol(SCIP *scip, SCIP_Real dualfeastol)
Definition: scip.c:45623
SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
Definition: scip.c:13252
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
Definition: scip.c:4423
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
Definition: scip.c:4539
SCIP_RETCODE SCIPsetNLPInitialGuessSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:31293
void SCIPupdateDivesetLPStats(SCIP *scip, SCIP_DIVESET *diveset, SCIP_Longint niterstoadd)
Definition: scip.c:36100
SCIP_PARAM * SCIPgetParam(SCIP *scip, const char *name)
Definition: scip.c:4388
SCIP_RETCODE SCIPsetPresolPriority(SCIP *scip, SCIP_PRESOL *presol, int priority)
Definition: scip.c:7057
SCIP_RETCODE SCIPsetBranchrulePriority(SCIP *scip, SCIP_BRANCHRULE *branchrule, int priority)
Definition: scip.c:9256
SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip.c:27828
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26377
SCIP_RETCODE SCIPaddConflictRelaxedBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
Definition: scip.c:27010
int SCIPgetEffectiveRootDepth(SCIP *scip)
Definition: scip.c:40716
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
Definition: scip.c:36877
SCIP_RETCODE SCIPsetSepaInitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
Definition: scip.c:7466
int SCIPgetNLPRows(SCIP *scip)
Definition: scip.c:29351
SCIP_RETCODE SCIPfreeBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
Definition: scip.c:47205
public methods for primal CIP solutions
SCIP_Bool SCIPareSolsEqual(SCIP *scip, SCIP_SOL *sol1, SCIP_SOL *sol2)
Definition: scip.c:38538
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
Definition: scip.c:34443
SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))
Definition: scip.c:6708
SCIP_Bool SCIPisSumEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46219
SCIP_RETCODE SCIPcopyOrigVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars)
Definition: scip.c:2390
SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:35454
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:7860
SCIP_RETCODE SCIPgetNLPI(SCIP *scip, SCIP_NLPI **nlpi, SCIP_NLPIPROBLEM **nlpiproblem)
Definition: scip.c:31704
SCIP_Real SCIPgetLowerbound(SCIP *scip)
Definition: scip.c:42550
SCIP_SOL * SCIPgetReoptLastOptSol(SCIP *scip)
Definition: scip.c:16387
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
Definition: scip.c:42786
SCIP_RETCODE SCIPrecalcNlRowActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32581
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:52
SCIP main data structure.
SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
Definition: scip.c:34553
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip.c:42982
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:25902
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
Definition: scip.c:41436
int SCIPgetNTotalVars(SCIP *scip)
Definition: scip.c:12257
#define SCIP_DECL_CONCSOLVERINITSEEDS(x)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46359
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:35886
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23527
int SCIPgetNOrigConss(SCIP *scip)
Definition: scip.c:12820
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:23013
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:18950
SCIP_RETCODE SCIPbranchVarVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
Definition: scip.c:36986
SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26238
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:24824
#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:40973
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
Definition: scip.c:23633
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:5033
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21284
int SCIPgetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx)
Definition: scip.c:47106
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46346
SCIP_NODESEL * SCIPgetNodesel(SCIP *scip)
Definition: scip.c:8972
#define SCIP_DECL_CONFLICTCOPY(x)
Definition: type_conflict.h:61
void SCIPmarkLimitChanged(SCIP *scip)
Definition: scip.c:45667
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
Definition: scip.c:27191
BMS_BUFMEM * SCIPcleanbuffer(SCIP *scip)
Definition: scip.c:45782
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
Definition: scip.c:1353
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
Definition: scip.c:41780
SCIP_RETCODE SCIPgetNLPStringPar(SCIP *scip, SCIP_NLPPARAM type, const char **sval)
Definition: scip.c:31611
SCIP_RETCODE SCIPfreeRealarray(SCIP *scip, SCIP_REALARRAY **realarray)
Definition: scip.c:46903
type definitions for relaxators
SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30692
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:30020
SCIP_RETCODE SCIPsetPricerInit(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINIT((*pricerinit)))
Definition: scip.c:5565
SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
Definition: scip.c:27918
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:27382
SCIP_Bool SCIPisLongintParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip.c:4733
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
Definition: scip.c:41856
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
Definition: scip.c:6332
SCIP_RETCODE SCIPsetRelaxPriority(SCIP *scip, SCIP_RELAX *relax, int priority)
Definition: scip.c:7291
SCIP_RETCODE SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)
Definition: scip.c:4442
SCIP_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition: scip.c:33999
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:3309
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:50
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28115
SCIP_RETCODE SCIPgetPseudoBranchCands(SCIP *scip, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
Definition: scip.c:36640
SCIP_RETCODE SCIPsetPresolInitpre(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINITPRE((*presolinitpre)))
Definition: scip.c:6988
type definitions for conflict analysis
SCIP_RETCODE SCIPsetConflicthdlrInitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)))
Definition: scip.c:6756
int SCIPgetNPrioExternBranchBins(SCIP *scip)
Definition: scip.c:36489
int SCIPgetNPrioExternBranchInts(SCIP *scip)
Definition: scip.c:36510
int SCIPgetRealarrayMaxIdx(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:47022
SCIP_RETCODE SCIPsetConflicthdlrExit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)))
Definition: scip.c:6740
type definitions for managing events
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
Definition: scip.c:28787
SCIP_RETCODE SCIPsetRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real val)
Definition: scip.c:46971
SCIP_Bool SCIPisDualfeasNegative(SCIP *scip, SCIP_Real val)
Definition: scip.c:46582
SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25795
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip.c:28863
SCIP_Bool SCIPhasPrimalRay(SCIP *scip)
Definition: scip.c:40351
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:33091
SCIP_RETCODE SCIPstopSolvingTime(SCIP *scip)
Definition: scip.c:45296
int SCIPgetBoolarrayMinIdx(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:47291
SCIP_RETCODE SCIPgetLPBInvACol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29544
SCIP_Longint SCIPgetLastDivenode(SCIP *scip)
Definition: scip.c:35099
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
Definition: scip.c:41930
SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:25769
public methods for NLP management
SCIP_RETCODE SCIPsetRelaxExit(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXIT((*relaxexit)))
Definition: scip.c:7205
public methods for node selectors
SCIP_RETCODE SCIPchgNlRowLhs(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real lhs)
Definition: scip.c:32053
wrapper functions to map file i/o to standard or zlib file i/o
SCIP_NODE * SCIPgetBestNode(SCIP *scip)
Definition: scip.c:40957
#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:3149
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:2525
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
Definition: scip.c:46073
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:7360
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
Definition: scip.c:13009
#define SCIP_DECL_PROBTRANS(x)
Definition: type_prob.h:74
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:21542
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43257
internal methods for problem variables
SCIP_RETCODE SCIPsetNLPRealPar(SCIP *scip, SCIP_NLPPARAM type, SCIP_Real dval)
Definition: scip.c:31583
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:814
SCIP_RETCODE SCIPactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
Definition: scip.c:5726
SCIP_RETCODE SCIPpropCons(SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
Definition: scip.c:28551
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:94
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
Definition: scip.c:19864
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:38042
SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
Definition: scip.c:29510
SCIP_RETCODE SCIPgetNlRowFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
Definition: scip.c:32638
SCIP_RETCODE SCIPresetReoptnodeDualcons(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:17246
SCIP_RETCODE SCIPclearSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37983
SCIP_RETCODE SCIPsetPropInit(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINIT((*propinit)))
Definition: scip.c:7677
SCIP_RETCODE SCIPcheckReoptRestart(SCIP *scip, SCIP_NODE *node, SCIP_Bool *restart)
Definition: scip.c:17118
public data structures and miscellaneous methods
SCIP_COMPR ** SCIPgetComprs(SCIP *scip)
Definition: scip.c:8422
SCIP_Bool SCIPisSumGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46258
int SCIPgetNPrioExternBranchConts(SCIP *scip)
Definition: scip.c:36550
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
Definition: scip.c:16947
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:10473
SCIP_RETCODE SCIPincludeNlpi(SCIP *scip, SCIP_NLPI *nlpi)
Definition: scip.c:9417
SCIP_RETCODE SCIPsetSepaExitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
Definition: scip.c:7482
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:40256
int SCIPgetNExternalCodes(SCIP *scip)
Definition: scip.c:9547
#define SCIP_Bool
Definition: def.h:61
SCIP_RETCODE SCIPsetProbTrans(SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))
Definition: scip.c:9915
SCIP_RETCODE SCIPgetNLPStatistics(SCIP *scip, SCIP_NLPSTATISTICS *statistics)
Definition: scip.c:31395
#define SCIP_DECL_SEPAINIT(x)
Definition: type_sepa.h:63
SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
Definition: scip.c:30335
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:22831
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip.c:40434
#define SCIP_DECL_PRICERINITSOL(x)
Definition: type_pricer.h:81
int SCIPgetMaxTotalDepth(SCIP *scip)
Definition: scip.c:42395
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip.c:28948
SCIP_RETCODE SCIPfreeSyncstore(SCIP *scip)
Definition: scip.c:41261
SCIP_RETCODE SCIPsetConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)
Definition: scip.c:27642
SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
int SCIPgetNImplVars(SCIP *scip)
Definition: scip.c:11815
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:9301
#define SCIP_DECL_PRESOLEXITPRE(x)
Definition: type_presol.h:102
SCIP_Real SCIPgetObjlimit(SCIP *scip)
Definition: scip.c:11184
#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:5236
SCIP_RETCODE SCIPcreateSolCopyOrig(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
Definition: scip.c:37508
#define SCIP_DECL_NODESELEXIT(x)
Definition: type_nodesel.h:72
SCIP_Real SCIPgetRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30746
SCIP_Real SCIPgetOrigObjscale(SCIP *scip)
Definition: scip.c:11036
SCIP_RETCODE SCIPchgNlRowConstant(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real constant)
Definition: scip.c:32099
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:34467
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip.c:10350
SCIP_Bool SCIPisSumLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46245
SCIP_RETCODE SCIPrecalcNlRowNLPActivity(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32433
SCIP_RETCODE SCIPprintRay(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39023
SCIP_RETCODE SCIPvalidateSolve(SCIP *scip, SCIP_Real primalreference, SCIP_Real dualreference, SCIP_Real reftol, SCIP_Bool quiet, SCIP_Bool *feasible, SCIP_Bool *primalboundcheck, SCIP_Bool *dualboundcheck)
Definition: scip.c:47457
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:41
SCIP_RETCODE SCIPprintBestTransSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:39264
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:8393
#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:30152
SCIP_RETCODE SCIProundSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *success)
Definition: scip.c:39300
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
Definition: scip.c:11114
SCIP_RETCODE SCIPautoselectDisps(SCIP *scip)
Definition: scip.c:9378
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:45312
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:33718
int SCIPgetNPricers(SCIP *scip)
Definition: scip.c:5679
SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
Definition: scip.c:43065
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
Definition: scip.c:41293
int SCIPgetDepth(SCIP *scip)
Definition: scip.c:42321
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:16623
SCIP_Real SCIPlpfeastol(SCIP *scip)
Definition: scip.c:45522
SCIP_RETCODE SCIPupdateNodeDualbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip.c:13421
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:8519
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip.c:13443
SCIP_Real SCIPgetGap(SCIP *scip)
Definition: scip.c:42808
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
Definition: scip.c:43214
SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:34804
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:2661
SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
Definition: scip.c:4692
int SCIPgetNPrioPseudoBranchCands(SCIP *scip)
Definition: scip.c:36684
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
Definition: scip.c:28746
SCIP_RETCODE SCIPcaptureRow(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30268
SCIP_RETCODE SCIPstartSolvingTime(SCIP *scip)
Definition: scip.c:45263
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:20551
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
Definition: scip.c:45004
SCIP_RETCODE SCIPgetNLPVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars)
Definition: scip.c:31002
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:138
SCIP_Bool SCIPisLPPrimalReliable(SCIP *scip)
Definition: scip.c:28969
SCIP_RETCODE SCIPchgVarsBoundsDiveNLP(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *lbs, SCIP_Real *ubs)
Definition: scip.c:31859
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:40070
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:36153
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
Definition: scip.c:41690
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34094
SCIP_RETCODE SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip.c:24246
SCIP_RETCODE SCIPgetNlRowPseudoFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudofeasibility)
Definition: scip.c:32559
SCIP_RETCODE SCIPgetNlRowActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
Definition: scip.c:32609
methods for debugging
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
Definition: scip.c:26942
SCIP_RETCODE SCIPaddConflictBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
Definition: scip.c:26975
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:5194
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
Definition: scip.c:4660
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:8471
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:30181
SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
Definition: scip.c:30311
unsigned int SCIPinitializeRandomSeed(SCIP *scip, int initialseedvalue)
Definition: scip.c:25561
#define SCIP_DECL_PROPINITSOL(x)
Definition: type_prop.h:115
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
Definition: scip.c:33868
SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
Definition: scip.c:6424
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
Definition: scip.c:24675
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:40468
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
Definition: scip.c:37806
SCIP_RETCODE SCIPsetBranchruleExitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))
Definition: scip.c:9153
void SCIPenableVarHistory(SCIP *scip)
Definition: scip.c:25614
SCIP_RETCODE SCIPsetPricerFree(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERFREE((*pricerfree)))
Definition: scip.c:5541
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23464
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
Definition: scip.c:26707
SCIP_RETCODE SCIPsetBranchruleExecExt(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECEXT((*branchexecext)))
Definition: scip.c:9187
SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPCOPY((*propcopy)))
Definition: scip.c:7645
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip.c:40548
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:21079
SCIP_RETCODE SCIPsetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int val)
Definition: scip.c:47122
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:6617
SCIP_RETCODE SCIPaddReoptnodeBndchg(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR *var, SCIP_Real bound, SCIP_BOUNDTYPE boundtype)
Definition: scip.c:16567
SCIP_Real SCIPcalcNodeselPriority(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
Definition: scip.c:36827
SCIP_Real SCIPgetLPRootLooseObjval(SCIP *scip)
Definition: scip.c:29198
SCIP_RETCODE SCIPsetBranchruleMaxdepth(SCIP *scip, SCIP_BRANCHRULE *branchrule, int maxdepth)
Definition: scip.c:9271
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:17314
void SCIPmarkColNotRemovableLocal(SCIP *scip, SCIP_COL *col)
Definition: scip.c:29997
SCIP_Real SCIPgetReoptSimilarity(SCIP *scip, int run1, int run2)
Definition: scip.c:17137
SCIP_RETCODE SCIPprintDualSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:38990
SCIP_RETCODE SCIPaddExternBranchCand(SCIP *scip, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
Definition: scip.c:36572
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
Definition: scip.c:42238
#define SCIP_DECL_CONCSOLVERCOPYSOLVINGDATA(x)
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43343
SCIP_RETCODE SCIPsetStringParam(SCIP *scip, const char *name, const char *value)
Definition: scip.c:4892
type definitions for branch and bound tree
int SCIPgetNSols(SCIP *scip)
Definition: scip.c:39059
SCIP_RETCODE SCIPsetReaderWrite(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERWRITE((*readerwrite)))
Definition: scip.c:5346
SCIP_RETCODE SCIPsetNodeselInitsol(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELINITSOL((*nodeselinitsol)))
Definition: scip.c:8875
SCIP_RETCODE SCIPgetDualSolVal(SCIP *scip, SCIP_CONS *cons, SCIP_Real *dualsolval, SCIP_Bool *boundconstraint)
Definition: scip.c:38783
SCIP_Real SCIPgetLPRootColumnObjval(SCIP *scip)
Definition: scip.c:29175
SCIP_RETCODE SCIPretransformSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:39336
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
Definition: scip.c:41874
SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip.c:28521
SCIP_RETCODE SCIPupdateLocalDualbound(SCIP *scip, SCIP_Real newbound)
Definition: scip.c:13332
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
Definition: scip.c:25235
#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:7078
#define SCIP_DECL_COMPREXIT(x)
Definition: type_compr.h:73
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
Definition: scip.c:41744
int SCIPgetNRuns(SCIP *scip)
Definition: scip.c:41326
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip.c:24945
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:16651
SCIP_RETCODE SCIPsetPropPresolPriority(SCIP *scip, SCIP_PROP *prop, int presolpriority)
Definition: scip.c:7875
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
Definition: scip.c:21403
SCIP_RETCODE SCIPcreateEmptyNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real lhs, SCIP_Real rhs)
Definition: scip.c:31959
SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
Definition: scip.c:29411
SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
Definition: scip.c:28405
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38268
int SCIPtechVersion(void)
Definition: scip.c:587
SCIP_RETCODE SCIPcaptureNlRow(SCIP *scip, SCIP_NLROW *nlrow)
Definition: scip.c:32008
SCIP_COL ** SCIPgetLPCols(SCIP *scip)
Definition: scip.c:29252
SCIP_RETCODE SCIPstartInteraction(SCIP *scip)
Definition: scip.c:9775
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
Definition: scip.c:6470
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
Definition: scip.c:45579
SCIP_RETCODE SCIPsetConflicthdlrCopy(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)))
Definition: scip.c:6692
SCIP_RETCODE SCIPfixParam(SCIP *scip, const char *name)
Definition: scip.c:4521
SCIP_RETCODE SCIPflushLP(SCIP *scip)
Definition: scip.c:28928
SCIP_RETCODE SCIPcreateUnknownSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37383
int SCIPgetNObjVars(SCIP *scip)
Definition: scip.c:11908
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
Definition: scip.c:42295
datastructures for problem statistics
SCIP_Bool SCIPisRealParamValid(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
Definition: scip.c:4791
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
Definition: scip.c:33981
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
Definition: scip.c:41535
#define SCIP_DECL_SEPAEXITSOL(x)
Definition: type_sepa.h:93
SCIP_Real SCIPdualfeasFrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:46654
SCIP_Bool SCIPisSumRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46813
#define SCIP_DECL_SEPAEXECSOL(x)
Definition: type_sepa.h:138
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
Definition: scip.c:46061
SCIP_Real SCIPgetTimeOfDay(SCIP *scip)
Definition: scip.c:45064
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip.c:30843
#define SCIP_DECL_CONCSOLVERTYPEFREEDATA(x)
type definitions for clocks and timing issues
int SCIPconvertRealToInt(SCIP *scip, SCIP_Real real)
Definition: scip.c:46828
SCIP_RETCODE SCIPchgLpfeastol(SCIP *scip, SCIP_Real lpfeastol, SCIP_Bool printnewvalue)
Definition: scip.c:45597
SCIP_Longint SCIPconvertRealToLongint(SCIP *scip, SCIP_Real real)
Definition: scip.c:46844
SCIP_RETCODE SCIPcreateRelaxSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37283
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:22508
int SCIPgetNOrigContVars(SCIP *scip)
Definition: scip.c:12228
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:39976
SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
Definition: scip.c:6401
SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))
Definition: scip.c:5274
SCIP_NODE * SCIPgetFocusNode(SCIP *scip)
Definition: scip.c:40661
void SCIPchgDispMode(SCIP_DISP *disp, SCIP_DISPMODE mode)
Definition: scip.c:9391
SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
Definition: scip.c:36854
SCIP_Real * SCIPgetNLPVarsLbDualsol(SCIP *scip)
Definition: scip.c:31100
SCIP_EVENTHDLR ** SCIPgetEventhdlrs(SCIP *scip)
Definition: scip.c:8704
SCIP_RETCODE SCIPextendPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray, int minidx, int maxidx)
Definition: scip.c:47354
int SCIPgetNConcsolverTypes(SCIP *scip)
Definition: scip.c:7961
SCIP_RETCODE SCIPcreatePseudoSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37310
SCIP_Real SCIPgetTransObjscale(SCIP *scip)
Definition: scip.c:11082
SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITSOL((*propexitsol)))
Definition: scip.c:7725
int SCIPgetNBinVars(SCIP *scip)
Definition: scip.c:11725
SCIP_RETCODE SCIPsetPricerInitsol(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINITSOL((*pricerinitsol)))
Definition: scip.c:5613
type definitions for storing and manipulating the main problem
SCIP_Bool SCIPinProbing(SCIP *scip)
Definition: scip.c:35163
SCIP_CONCSOLVERTYPE ** SCIPgetConcsolverTypes(SCIP *scip)
Definition: scip.c:7950
SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:19658
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
Definition: scip.c:4834
SCIP_NODE * SCIPgetPrioSibling(SCIP *scip)
Definition: scip.c:40893
#define SCIP_DECL_READERCOPY(x)
Definition: type_reader.h:46
int SCIPgetNVars(SCIP *scip)
Definition: scip.c:11680
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
Definition: type_paramset.h:73
SCIP_RETCODE SCIPsetComprPriority(SCIP *scip, SCIP_COMPR *compr, int priority)
Definition: scip.c:8446
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23577
SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:34392
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
Definition: scip.c:17543
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:109
void SCIPenableNLP(SCIP *scip)
Definition: scip.c:30950
SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)
Definition: scip.c:13382
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
Definition: scip.c:42488
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
Definition: scip.c:7033
SCIP_RETCODE SCIPaddPricedVar(SCIP *scip, SCIP_VAR *var, SCIP_Real score)
Definition: scip.c:11425
int SCIPgetBoolarrayMaxIdx(SCIP *scip, SCIP_BOOLARRAY *boolarray)
Definition: scip.c:47305
SCIP_RETCODE SCIPaddSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *stored)
Definition: scip.c:39776
SCIP_Bool SCIPinDive(SCIP *scip)
Definition: scip.c:35129
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
Definition: scip.c:41798
type definitions for propagators
SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
Definition: scip.c:34247
#define SCIP_DECL_DIALOGEXEC(x)
Definition: type_dialog.h:87
SCIP_Bool SCIPhasNLPSolution(SCIP *scip)
Definition: scip.c:31443
SCIP_RETCODE SCIPgetReoptOldObjCoef(SCIP *scip, SCIP_VAR *var, int run, SCIP_Real *objcoef)
Definition: scip.c:16414
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
Definition: scip.c:6201
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
Definition: scip.c:43361
SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
Definition: scip.c:24593
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
Definition: scip.c:26264
enum SCIP_ExprCurv SCIP_EXPRCURV
Definition: type_expr.h:93
SCIP_Real SCIPgetTransObjoffset(SCIP *scip)
Definition: scip.c:11059
SCIP_RETCODE SCIPprintNodeRootPath(SCIP *scip, SCIP_NODE *node, FILE *file)
Definition: scip.c:41096
SCIP_RETCODE SCIPsetProbInitsol(SCIP *scip, SCIP_DECL_PROBINITSOL((*probinitsol)))
Definition: scip.c:9957
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
Definition: scip.c:24914
int SCIPgetNHeurs(SCIP *scip)
Definition: scip.c:8201
SCIP_Bool SCIPisDualfeasPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:46570
SCIP_RETCODE SCIPsetConsStickingAtNode(SCIP *scip, SCIP_CONS *cons, SCIP_Bool stickingatnode)
Definition: scip.c:27743
SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
Definition: scip.c:21184
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
Definition: scip.c:30290
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
Definition: scip.c:11254
SCIP_RETCODE SCIPcopyProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, const char *name)
Definition: scip.c:1731
public methods for presolvers
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
Definition: scip.c:17492
public methods for managing events
#define SCIP_DECL_DISPEXITSOL(x)
Definition: type_disp.h:117
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
Definition: scip.c:41966
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
Definition: scip.c:41948
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:7122
SCIP_RETCODE SCIPreadSolFile(SCIP *scip, const char *filename, SCIP_SOL *sol, SCIP_Bool xml, SCIP_Bool *partial, SCIP_Bool *error)
Definition: scip.c:39736
SCIP_Longint SCIPgetMemTotal(SCIP *scip)
Definition: scip.c:45809
SCIP_RETCODE SCIPcreateNLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37248
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
Definition: scip.c:43189
SCIP_RETCODE SCIPcreatePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
Definition: scip.c:47320
SCIP_RETCODE SCIPaddQuadVarToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var)
Definition: scip.c:32211
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
Definition: scip.c:7418
SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)
Definition: scip.c:29819
int SCIPgetNOrigIntVars(SCIP *scip)
Definition: scip.c:12174
SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPRESPROP((*propresprop)))
Definition: scip.c:7806
SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition: scip.c:29027
SCIP_RETCODE SCIPsetSepaInit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
Definition: scip.c:7434
SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
Definition: scip.c:29733
SCIP_RETCODE SCIPbranchPseudo(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:37142
SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val)
Definition: scip.c:19628
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition: scip.c:39158
SCIP_RETCODE SCIPaddQuadVarsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars)
Definition: scip.c:32236
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:46024
#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:10787
SCIP_RETCODE SCIPsolveProbingLPWithPricing(SCIP *scip, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip.c:35910
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:46134
SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:34731
SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
Definition: scip.c:19120
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:4321
SCIP_RETCODE SCIPgetNlRowSolFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Real *feasibility)
Definition: scip.c:32701
SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
Definition: scip.c:28374
SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
Definition: scip.c:28494
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
Definition: scip.c:18371
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
Definition: scip.c:45796
SCIP_RETCODE SCIPprintMIPStart(SCIP *scip, SCIP_SOL *sol, FILE *file)
Definition: scip.c:38740
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
Definition: scip.c:42038
static const SCIP_Real scalars[]
Definition: lp.c:5573
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:1912
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:11360
SCIP_NLPI * SCIPfindNlpi(SCIP *scip, const char *name)
Definition: scip.c:9453
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:22621
int SCIPgetNNodesels(SCIP *scip)
Definition: scip.c:8931
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:20968
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:6081
SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)
Definition: scip.c:10656
SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:19549
SCIP_Real SCIPtransformObj(SCIP *scip, SCIP_Real obj)
Definition: scip.c:38377
int SCIPgetNReoptRuns(SCIP *scip)
Definition: scip.c:41353
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
Definition: scip.c:41984
SCIP_RETCODE SCIPsetEventhdlrDelete(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTDELETE((*eventdelete)))
Definition: scip.c:8677
SCIP_Real SCIPgetHugeValue(SCIP *scip)
Definition: scip.c:46087
SCIP_RETCODE SCIPrestartSolve(SCIP *scip)
Definition: scip.c:17045
SCIP_Real SCIPgetRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx)
Definition: scip.c:46955
SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
Definition: scip.c:27565
int SCIPgetNReaders(SCIP *scip)
Definition: scip.c:5386
SCIP_RETCODE SCIPendDiveNLP(SCIP *scip)
Definition: scip.c:31772
#define SCIP_DECL_SEPAEXIT(x)
Definition: type_sepa.h:71
int SCIPgetNBranchrules(SCIP *scip)
Definition: scip.c:9245
SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
Definition: scip.c:6105
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:45146
int SCIPgetNPricevars(SCIP *scip)
Definition: scip.c:42108
public methods for conflict analysis handlers
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
Definition: scip.c:41708
int SCIPgetNConss(SCIP *scip)
Definition: scip.c:12728
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:74
SCIP_BRANCHRULE ** SCIPgetBranchrules(SCIP *scip)
Definition: scip.c:9234
SCIP_Bool SCIPisConsCompressionEnabled(SCIP *scip)
Definition: scip.c:1862
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:19923
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip.c:27417
SCIP_RETCODE SCIPsetComprExit(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPREXIT((*comprexit)))
Definition: scip.c:8361
#define SCIP_DECL_DISPEXIT(x)
Definition: type_disp.h:95
SCIP_RETCODE SCIPreadParams(SCIP *scip, const char *filename)
Definition: scip.c:4924
SCIP_RETCODE SCIPsetPresolCopy(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLCOPY((*presolcopy)))
Definition: scip.c:6924
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43002
int SCIPgetRealarrayMinIdx(SCIP *scip, SCIP_REALARRAY *realarray)
Definition: scip.c:47008
#define SCIP_DECL_SEPAINITSOL(x)
Definition: type_sepa.h:82
SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
Definition: scip.c:19742
#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:47090
SCIP_Bool SCIPallowDualReds(SCIP *scip)
Definition: scip.c:25541
int SCIPgetNCuts(SCIP *scip)
Definition: scip.c:34517
int SCIPgetNPriceRounds(SCIP *scip)
Definition: scip.c:42090
SCIP_RETCODE SCIPsetNodeselFree(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELFREE((*nodeselfree)))
Definition: scip.c:8827
int SCIPgetRepropdepth(SCIP *scip)
Definition: scip.c:41079
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
Definition: scip.c:6225
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:3767
SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:35938
public methods for message output
#define SCIP_DECL_HEURINIT(x)
Definition: type_heur.h:76
int SCIPgetNUpgrConss(SCIP *scip)
Definition: scip.c:12686
int SCIPgetNCliques(SCIP *scip)
Definition: scip.c:24566
SCIP_RETCODE SCIPsplitReoptRoot(SCIP *scip, int *ncreatedchilds, int *naddedconss)
Definition: scip.c:17219
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30709
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
Definition: scip.c:8111
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
Definition: scip.c:25019
#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:38402
SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
SCIP_DECL_EVENTEXEC(EventhdlrNewSol::scip_exec)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
Definition: scip.c:46397
int SCIPgetNImplications(SCIP *scip)
Definition: scip.c:44976
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
Definition: scip.c:43300
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
Definition: scip.c:45822
SCIP_NODESEL * SCIPfindNodesel(SCIP *scip, const char *name)
Definition: scip.c:8907
SCIP_VAR ** SCIPgetVars(SCIP *scip)
Definition: scip.c:11635
SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITSOL((*propinitsol)))
Definition: scip.c:7709
SCIP_RETCODE SCIPgetNLPFracVars(SCIP *scip, SCIP_VAR ***fracvars, SCIP_Real **fracvarssol, SCIP_Real **fracvarsfrac, int *nfracvars, int *npriofracvars)
Definition: scip.c:31468
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:16773
SCIP_HEUR * SCIPgetSolHeur(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38510
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:40396
SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
Definition: scip.c:24466
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:25344
#define SCIP_DECL_CONSENFORELAX(x)
Definition: type_cons.h:346
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
Definition: scip.c:42945
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:18427
#define SCIP_Real
Definition: def.h:145
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:30444
int SCIPgetNPricevarsFound(SCIP *scip)
Definition: scip.c:42126
SCIP_RETCODE SCIPgetNlRowNLPFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
Definition: scip.c:32488
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:19697
SCIP_RETCODE SCIPsolveParallel(SCIP *scip)
Definition: scip.c:16126
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:25050
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
Definition: scip.c:6539
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:7555
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:5411
SCIP_Bool SCIPisScalingIntegral(SCIP *scip, SCIP_Real val, SCIP_Real scalar)
Definition: scip.c:46146
public methods for input file readers
SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30638
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:24623
#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:9105
SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
Definition: scip.c:29088
#define SCIP_DECL_HEURFREE(x)
Definition: type_heur.h:68
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
Definition: scip.c:25508
int SCIPgetNPoolCuts(SCIP *scip)
Definition: scip.c:34153
SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
Definition: scip.c:18562
SCIP_RETCODE SCIPgetReoptLeaveIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
Definition: scip.c:16492
#define SCIP_DECL_CONFLICTINIT(x)
Definition: type_conflict.h:77
SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)
Definition: scip.c:13213
internal methods for constraints and constraint handlers
SCIP_RETCODE SCIPsetPropFree(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPFREE((*propfree)))
Definition: scip.c:7661
SCIP_DECL_READERREAD(ReaderTSP::scip_read)
Definition: ReaderTSP.cpp:150
int SCIPgetNConflictConssFoundNode(SCIP *scip)
Definition: scip.c:42271
SCIP_Bool SCIPisDualfeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46519
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
Definition: scip.c:30892
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:30532
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:638
SCIP_RETCODE SCIPsetConsModifiable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)
Definition: scip.c:27668
SCIP_RETCODE SCIPlinkRelaxSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:37905
SCIP_RETCODE SCIPprintNlRow(SCIP *scip, SCIP_NLROW *nlrow, FILE *file)
Definition: scip.c:32760
SCIP_RETCODE SCIPaddConsLocks(SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
Definition: scip.c:28316
SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)
Definition: scip.c:11011
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))
Definition: scip.c:5322
int SCIPgetNCompr(SCIP *scip)
Definition: scip.c:8435
SCIP_Real SCIPcutoffbounddelta(SCIP *scip)
Definition: scip.c:45564
SCIP_RETCODE SCIPcreateCurrentSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37333
#define SCIP_Longint
Definition: def.h:130
SCIP_Bool SCIPallColsInLP(SCIP *scip)
Definition: scip.c:29374
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:8843
SCIP_Real SCIPgetTotalTime(SCIP *scip)
Definition: scip.c:45344
SCIP_NODE * SCIPgetPrioChild(SCIP *scip)
Definition: scip.c:40877
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
Definition: scip.c:30866
SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:34969
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38011
SCIP_RETCODE SCIPbranchLP(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:37094
SCIP_NODE * SCIPgetBestChild(SCIP *scip)
Definition: scip.c:40909
SCIP_Real SCIPfrac(SCIP *scip, SCIP_Real val)
Definition: scip.c:46207
SCIP_RETCODE SCIPcheckCopyLimits(SCIP *sourcescip, SCIP_Bool *success)
Definition: scip.c:4128
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
Definition: scip.c:10917
SCIP_RETCODE SCIPreleaseDialog(SCIP *scip, SCIP_DIALOG **dialog)
Definition: scip.c:9657
SCIP_RETCODE SCIPstartDive(SCIP *scip)
Definition: scip.c:34607
SCIP_RETCODE SCIPincludeExternalCodeInformation(SCIP *scip, const char *name, const char *description)
Definition: scip.c:9505
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
Definition: scip.c:38084
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:18019
SCIP_Real SCIPgetNodeLowerbound(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:13308
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
Definition: scip.c:13717
SCIP_RETCODE SCIPsetNlpiPriority(SCIP *scip, SCIP_NLPI *nlpi, int priority)
Definition: scip.c:9490
SCIP_Bool SCIPgetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx)
Definition: scip.c:47257
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
Definition: scip.c:46098
SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
Definition: scip.c:25518
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26145
struct SCIP_PricerData SCIP_PRICERDATA
Definition: type_pricer.h:36
SCIP_RETCODE SCIPbranchExtern(SCIP *scip, SCIP_RESULT *result)
Definition: scip.c:37118
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
Definition: scip.c:7511
SCIP_Real SCIPgetNLPObjval(SCIP *scip)
Definition: scip.c:31419
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46011
#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:43042
SCIP_Real SCIPgetLPRootObjval(SCIP *scip)
Definition: scip.c:29152
SCIP_DECL_EVENTDELETE(EventhdlrNewSol::scip_delete)
SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19529
SCIP_RETCODE SCIPstartDiveNLP(SCIP *scip)
Definition: scip.c:31744
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
Definition: scip.c:42918
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:12201
SCIP_RETCODE SCIPsetProbDeltrans(SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))
Definition: scip.c:9936
SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)
Definition: scip.c:29975
int SCIPgetNLPCols(SCIP *scip)
Definition: scip.c:29273
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: scip.c:8079
SCIP_RETCODE SCIPsetPricerCopy(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERCOPY((*pricercopy)))
Definition: scip.c:5517
#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:47420
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:23547
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
Definition: scip.c:35231
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:36075
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
Definition: scip.c:46421
SCIP_Bool SCIPisDualfeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46493
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
Definition: scip.c:4965
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip.c:23349
int SCIPgetNPricevarsApplied(SCIP *scip)
Definition: scip.c:42144
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
Definition: scip.c:42962
SCIP_Real SCIPsumepsilon(SCIP *scip)
Definition: scip.c:45494
#define SCIP_DECL_RELAXEXITSOL(x)
Definition: type_relax.h:93
SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)
Definition: scip.c:17019
SCIP_NLPI ** SCIPgetNlpis(SCIP *scip)
Definition: scip.c:9466
SCIP_Real SCIPgetUpperbound(SCIP *scip)
Definition: scip.c:42699
SCIP_NODE * SCIPgetBestLeaf(SCIP *scip)
Definition: scip.c:40941
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:26481
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
Definition: scip.c:35185
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:5773
SCIP_DISP ** SCIPgetDisps(SCIP *scip)
Definition: scip.c:9356
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:20098
SCIP_Bool SCIPisSumLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46232
public methods for primal heuristics
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
Definition: scip.c:29295
int SCIPgetNSepas(SCIP *scip)
Definition: scip.c:7524
SCIP_RETCODE SCIPgetTransformedConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
Definition: scip.c:27958
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:6355
int SCIPgetNExternBranchCands(SCIP *scip)
Definition: scip.c:36449
int SCIPgetNOrigBinVars(SCIP *scip)
Definition: scip.c:12147
SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
Definition: scip.c:24986
SCIP_RETCODE SCIPsetProbDelorig(SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))
Definition: scip.c:9894
#define SCIP_DECL_DISPOUTPUT(x)
Definition: type_disp.h:126
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
Definition: scip.c:29113
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:31923
struct BMS_BlkMem BMS_BLKMEM
Definition: memory.h:396
void SCIPdisableDebugSol(SCIP *scip)
Definition: scip.c:1168
SCIP_RETCODE SCIPendDive(SCIP *scip)
Definition: scip.c:34650
void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)
Definition: scip.c:41380
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
Definition: scip.c:12915
#define SCIP_DECL_CONFLICTFREE(x)
Definition: type_conflict.h:69
SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
Definition: scip.c:34171
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
Definition: scip.c:46183
void SCIPprintError(SCIP_RETCODE retcode)
Definition: scip.c:670
SCIP_RETCODE SCIPsetPropInitpre(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITPRE((*propinitpre)))
Definition: scip.c:7741
SCIP_RETCODE SCIPfreeSolve(SCIP *scip, SCIP_Bool restart)
Definition: scip.c:16817
type definitions for node selectors
SCIP_RETCODE SCIPchgRowRhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)
Definition: scip.c:34908
int SCIPgetNEnabledConss(SCIP *scip)
Definition: scip.c:42470
SCIP_REOPTNODE * SCIPgetReoptnode(SCIP *scip, unsigned int id)
Definition: scip.c:16545
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
Definition: scip.c:24523
SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19168
SCIP_Bool SCIPisDualfeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46506
SCIP_RETCODE SCIPgetNlRowNLPActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
Definition: scip.c:32460
SCIP_RETCODE SCIPsetConflicthdlrPriority(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)
Definition: scip.c:6825
SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)
Definition: scip.c:4634
#define SCIP_DECL_CONCSOLVERSYNCWRITE(x)
int SCIPgetNReoptLeaves(SCIP *scip, SCIP_NODE *node)
Definition: scip.c:16532
SCIP_RETCODE SCIPresetParam(SCIP *scip, const char *name)
Definition: scip.c:4987
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
Definition: scip.c:6153
SCIP_Longint SCIPgetNNodes(SCIP *scip)
Definition: scip.c:41409
SCIP_RETCODE SCIPsetPropExit(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXIT((*propexit)))
Definition: scip.c:7693
SCIP_Longint SCIPgetNLPs(SCIP *scip)
Definition: scip.c:41590
SCIP_RETCODE SCIPresetRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
Definition: scip.c:16710
SCIP_ROW ** SCIPgetCuts(SCIP *scip)
Definition: scip.c:34499
SCIP_RETCODE SCIPsetRootDialog(SCIP *scip, SCIP_DIALOG *dialog)
Definition: scip.c:9674
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
Definition: scip.c:17430
#define SCIP_DECL_PRICERREDCOST(x)
Definition: type_pricer.h:130
SCIP_Real SCIPround(SCIP *scip, SCIP_Real val)
Definition: scip.c:46195
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
Definition: scip.c:41508
#define SCIP_DECL_HEUREXITSOL(x)
Definition: type_heur.h:106
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:21316
SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
Definition: scip.c:19042
#define SCIP_DECL_NODESELSELECT(x)
Definition: type_nodesel.h:109
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip.c:35411
#define SCIP_DECL_CONCSOLVERCREATEINST(x)
int SCIPminorVersion(void)
Definition: scip.c:576
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
Definition: scip.c:43164
int SCIPgetNParams(SCIP *scip)
Definition: scip.c:5164
SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)
Definition: scip.c:41481
void SCIPupdateDivesetStats(SCIP *scip, SCIP_DIVESET *diveset, int nprobingnodes, int nbacktracks, SCIP_Longint nsolsfound, SCIP_Longint nbestsolsfound, SCIP_Bool leavewassol)
Definition: scip.c:36113
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:30561
void SCIPdisableVarHistory(SCIP *scip)
Definition: scip.c:25633
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
Definition: scip.c:45163
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition: scip.c:38182
SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26346
SCIP_RETCODE SCIPaddObjoffset(SCIP *scip, SCIP_Real addval)
Definition: scip.c:10960
SCIP_Real SCIPgetVarObjDive(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:34940
SCIP_RETCODE SCIPdeactiveCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip.c:28707
SCIP_Bool SCIPisInRestart(SCIP *scip)
Definition: scip.c:17277
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:41192
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
Definition: scip.c:4576
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:4293
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:22728
SCIP_Bool SCIPisRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip.c:46722
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:17674
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
Definition: scip.c:42056
SCIP_CONCSOLVERTYPE * SCIPfindConcsolverType(SCIP *scip, const char *name)
Definition: scip.c:7937
SCIP_Real SCIPgetFirstLPTime(SCIP *scip)
Definition: scip.c:45461
int SCIPgetNProps(SCIP *scip)
Definition: scip.c:7849
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
Definition: scip.c:5055
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
Definition: scip.c:46171
SCIP_RETCODE SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
Definition: scip.c:27160
SCIP_RETCODE SCIPsetRelaxInitsol(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINITSOL((*relaxinitsol)))
Definition: scip.c:7221
SCIP_RETCODE SCIPaddDialogInputLine(SCIP *scip, const char *inputline)
Definition: scip.c:9725
#define SCIP_DECL_SEPAFREE(x)
Definition: type_sepa.h:55
SCIP_RETCODE SCIPsetNodeselStdPriority(SCIP *scip, SCIP_NODESEL *nodesel, int priority)
Definition: scip.c:8942
SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
Definition: scip.c:24858
SCIP_RETCODE SCIPaddQuadElementsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nquadelems, SCIP_QUADELEM *quadelems)
Definition: scip.c:32299
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
Definition: scip.c:26758
SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))
Definition: scip.c:5298
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
Definition: scip.c:4718
SCIP_Real SCIPgetPrimalRayVal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:40369
SCIP_RETCODE SCIPenableReoptimization(SCIP *scip, SCIP_Bool enable)
Definition: scip.c:16299
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:32963
struct SCIP_SepaData SCIP_SEPADATA
Definition: type_sepa.h:38
SCIP_Bool SCIPallowObjProp(SCIP *scip)
Definition: scip.c:25551
SCIP_RETCODE SCIPsetPresolExitpre(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXITPRE((*presolexitpre)))
Definition: scip.c:7004
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
Definition: scip.c:43275
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
Definition: scip.c:18740
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:8731
SCIP_RETCODE SCIPinitlpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
Definition: scip.c:28467
SCIP_RETCODE SCIPsetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx, void *val)
Definition: scip.c:47402
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:4211
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26114
int SCIPgetNSepaRounds(SCIP *scip)
Definition: scip.c:42160
SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
Definition: scip.c:43090
SCIP_Bool SCIPcontainsExternBranchCand(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:36616
SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)
Definition: scip.c:30803
public methods for propagators
SCIP_Real SCIPgetLPColumnObjval(SCIP *scip)
Definition: scip.c:29045
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)
Definition: scip.c:43237
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:37566
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:33023
SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:19805
#define SCIP_DECL_PROPINIT(x)
Definition: type_prop.h:63
SCIP_RELAX * SCIPfindRelax(SCIP *scip, const char *name)
Definition: scip.c:7254
type definitions for specific NLP solver interfaces
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip.c:37178
SCIP_Longint SCIPgetSolNodenum(SCIP *scip, SCIP_SOL *sol)
Definition: scip.c:38483
SCIP_CONFLICTHDLR * SCIPfindConflicthdlr(SCIP *scip, const char *name)
Definition: scip.c:6788
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:7608
SCIP_RETCODE SCIPfreePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
Definition: scip.c:47337
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
Definition: scip.c:5966
SCIP_PRICER ** SCIPgetPricers(SCIP *scip)
Definition: scip.c:5666
type definitions for concurrent solvers
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
Definition: scip.c:27515
SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
Definition: scip.c:18512
SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: scip.c:34343
type definitions for displaying runtime statistics
memory allocation routines
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip.c:35540
SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
Definition: scip.c:26600
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition: scip.c:38601