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-2016 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip.h
17  * @ingroup PUBLICMETHODS
18  * @brief SCIP callable library
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  */
26 
27 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
28 
29 #ifndef __SCIP_SCIP_H__
30 #define __SCIP_SCIP_H__
31 
32 
33 #include <stdio.h>
34 
35 #include "scip/def.h"
36 #include "blockmemshell/memory.h"
37 #include "scip/type_retcode.h"
38 #include "scip/type_result.h"
39 #include "scip/type_clock.h"
40 #include "scip/type_misc.h"
41 #include "scip/type_timing.h"
42 #include "scip/type_paramset.h"
43 #include "scip/type_event.h"
44 #include "scip/type_lp.h"
45 #include "scip/type_nlp.h"
46 #include "scip/type_var.h"
47 #include "scip/type_prob.h"
48 #include "scip/type_tree.h"
49 #include "scip/type_scip.h"
50 
51 #include "scip/type_branch.h"
52 #include "scip/type_conflict.h"
53 #include "scip/type_cons.h"
54 #include "scip/type_dialog.h"
55 #include "scip/type_disp.h"
56 #include "scip/type_heur.h"
57 #include "scip/type_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 
68 /* include public interfaces, s.t. the user only needs to include scip.h */
69 #include "scip/pub_branch.h"
70 #include "scip/pub_conflict.h"
71 #include "scip/pub_cons.h"
72 #include "scip/pub_cutpool.h"
73 #include "scip/pub_dialog.h"
74 #include "scip/pub_disp.h"
75 #include "scip/pub_event.h"
76 #include "scip/pub_fileio.h"
77 #include "scip/pub_heur.h"
78 #include "scip/pub_compr.h"
79 #include "scip/pub_history.h"
80 #include "scip/pub_implics.h"
81 #include "scip/pub_lp.h"
82 #include "scip/pub_nlp.h"
83 #include "scip/pub_message.h"
84 #include "scip/pub_misc.h"
85 #include "scip/pub_nodesel.h"
86 #include "scip/pub_paramset.h"
87 #include "scip/pub_presol.h"
88 #include "scip/pub_pricer.h"
89 #include "scip/pub_reader.h"
90 #include "scip/pub_relax.h"
91 #include "scip/pub_sepa.h"
92 #include "scip/pub_prop.h"
93 #include "scip/pub_sol.h"
94 #include "scip/pub_tree.h"
95 #include "scip/pub_var.h"
96 #include "lpi/lpi.h"
97 #include "nlpi/pub_expr.h"
98 
99 /* include global presolving methods */
100 #include "scip/presolve.h"
101 
102 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
103  * this structure except the interface methods in scip.c.
104  * In optimized mode, the structure is included in scip.h, because some of the methods
105  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
106  * Additionally, the internal "set.h" is included, such that the defines in set.h are
107  * available in optimized mode.
108  */
109 #ifdef NDEBUG
110 #include "scip/struct_scip.h"
111 #include "scip/set.h"
112 #include "scip/tree.h"
113 #include "scip/misc.h"
114 #include "scip/var.h"
115 #endif
116 
117 #ifdef __cplusplus
118 extern "C" {
119 #endif
120 
121 /*
122  * miscellaneous methods
123  */
124 
125 /**@name Miscellaneous Methods */
126 /**@{ */
127 
128 /** returns complete SCIP version number in the format "major . minor tech"
129  *
130  * @return complete SCIP version
131  */
132 extern
134  void
135  );
136 
137 /** returns SCIP major version
138  *
139  * @return major SCIP version
140  */
141 extern
142 int SCIPmajorVersion(
143  void
144  );
145 
146 /** returns SCIP minor version
147  *
148  * @return minor SCIP version
149  */
150 extern
151 int SCIPminorVersion(
152  void
153  );
154 
155 /** returns SCIP technical version
156  *
157  * @return technical SCIP version
158  */
159 extern
160 int SCIPtechVersion(
161  void
162  );
163 
164 /** returns SCIP sub version number
165  *
166  * @return subversion SCIP version
167  */
168 extern
169 int SCIPsubversion(
170  void
171  );
172 
173 /** prints a version information line to a file stream via the message handler system
174  *
175  * @note If the message handler is set to a NULL pointer nothing will be printed
176  */
177 extern
178 void SCIPprintVersion(
179  SCIP* scip, /**< SCIP data structure */
180  FILE* file /**< output file (or NULL for standard output) */
181  );
182 
183 /** prints error message for the given SCIP_RETCODE via the error prints method */
184 extern
185 void SCIPprintError(
186  SCIP_RETCODE retcode /**< SCIP return code causing the error */
187  );
188 
189 /** update statistical information when a new solution was found */
190 extern
192  SCIP* scip /**< SCIP data structure */
193  );
194 
195 /**@} */
196 
197 
198 
199 
200 /*
201  * general SCIP methods
202  */
203 
204 /**@name General SCIP Methods */
205 /**@{ */
206 
207 /** creates and initializes SCIP data structures
208  *
209  * @note The SCIP default message handler is installed. Use the method SCIPsetMessagehdlr() to install your own
210  * message handler or SCIPsetMessagehdlrLogfile() and SCIPsetMessagehdlrQuiet() to write into a log
211  * file and turn off/on the display output, respectively.
212  *
213  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
214  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
215  *
216  * @post After calling this method @p scip reached the solving stage \ref SCIP_STAGE_INIT
217  *
218  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
219  */
220 extern
222  SCIP** scip /**< pointer to SCIP data structure */
223  );
224 
225 /** frees SCIP data structures
226  *
227  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
228  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
229  *
230  * @pre This method can be called if @p scip is in one of the following stages:
231  * - \ref SCIP_STAGE_INIT
232  * - \ref SCIP_STAGE_PROBLEM
233  * - \ref SCIP_STAGE_TRANSFORMED
234  * - \ref SCIP_STAGE_INITPRESOLVE
235  * - \ref SCIP_STAGE_PRESOLVING
236  * - \ref SCIP_STAGE_PRESOLVED
237  * - \ref SCIP_STAGE_EXITPRESOLVE
238  * - \ref SCIP_STAGE_SOLVING
239  * - \ref SCIP_STAGE_SOLVED
240  * - \ref SCIP_STAGE_FREE
241  *
242  * @post After calling this method \SCIP reached the solving stage \ref SCIP_STAGE_FREE
243  *
244  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
245  */
246 extern
248  SCIP** scip /**< pointer to SCIP data structure */
249  );
250 
251 /** returns current stage of SCIP
252  *
253  * @return the current SCIP stage
254  *
255  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
256  */
257 extern
259  SCIP* scip /**< SCIP data structure */
260  );
261 
262 /** outputs SCIP stage and solution status if applicable via the message handler
263  *
264  * @note If the message handler is set to a NULL pointer nothing will be printed
265  *
266  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
267  * thus may to correspond to the original status.
268  *
269  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
270  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
271  *
272  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
273  */
274 extern
276  SCIP* scip, /**< SCIP data structure */
277  FILE* file /**< output file (or NULL for standard output) */
278  );
279 
280 /** gets solution status
281  *
282  * @return SCIP solution status
283  *
284  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
285  */
286 extern
288  SCIP* scip /**< SCIP data structure */
289  );
290 
291 /** outputs solution status
292  *
293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
295  *
296  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
297  */
298 extern
300  SCIP* scip, /**< SCIP data structure */
301  FILE* file /**< output file (or NULL for standard output) */
302  );
303 
304 /** returns whether the current stage belongs to the transformed problem space
305  *
306  * @return Returns TRUE if the \SCIP instance is transformed, otherwise FALSE
307  */
308 extern
310  SCIP* scip /**< SCIP data structure */
311  );
312 
313 /** returns whether the solution process should be probably correct
314  *
315  * @note This feature is not supported yet!
316  *
317  * @return Returns TRUE if \SCIP is exact solving mode, otherwise FALSE
318  */
319 extern
321  SCIP* scip /**< SCIP data structure */
322  );
323 
324 /** returns whether the presolving process would be finished given no more presolving reductions are found in this
325  * presolving round
326  *
327  * Checks whether the number of presolving rounds is not exceeded and the presolving reductions found in the current
328  * presolving round suffice to trigger another presolving round.
329  *
330  * @note if subsequent presolvers find more reductions, presolving might continue even if the method returns FALSE
331  * @note does not check whether infeasibility or unboundedness was already detected in presolving (which would result
332  * in presolving being stopped although the method returns TRUE)
333  *
334  * @return Returns TRUE if presolving is finished if no further reductions are detected
335  */
336 extern
338  SCIP* scip /**< SCIP data structure */
339  );
340 
341 /** returns whether SCIP has performed presolving during the last solve
342  *
343  * @return Returns TRUE if presolving was performed during the last solve
344  */
345 extern
347  SCIP* scip /**< SCIP data structure */
348  );
349 
350 /** returns whether the user pressed CTRL-C to interrupt the solving process
351  *
352  * @return Returns TRUE if Ctrl-C was pressed, otherwise FALSE.
353  */
354 extern
356  SCIP* scip /**< SCIP data structure */
357  );
358 
359 /** returns whether the solving process should be / was stopped before proving optimality;
360  * if the solving process should be / was stopped, the status returned by SCIPgetStatus() yields
361  * the reason for the premature abort
362  *
363  * @return Returns TRUE if solving process is stopped/interrupted, otherwise FALSE.
364  */
365 extern
367  SCIP* scip /**< SCIP data structure */
368  );
369 
370 
371 /**@} */
372 
373 /*
374  * debug solution methods
375  */
376 
377 /**@name Debug Solution Methods */
378 /**@{ */
379 
380 /** enable debug solution mechanism
381  *
382  * the debug solution mechanism allows to trace back the invalidation of
383  * a debug solution during the solution process of SCIP. It must be explicitly
384  * enabled for the SCIP data structure.
385  *
386  * @see debug.h for more information on debug solution mechanism
387  */
388 extern
389 void SCIPenableDebugSol(
390  SCIP* scip /**< SCIP data structure */
391  );
392 
393 /** disable solution debugging mechanism
394  *
395  * @see debug.h for more information on debug solution mechanism
396  */
397 extern
399  SCIP* scip /**< SCIP data structure */
400  );
401 
402 /**@} */
403 
404 
405 /*
406  * message output methods
407  */
408 
409 /**@name Message Output Methods */
410 /**@{ */
411 
412 /** installs the given message handler, such that all messages are passed to this handler. A messages handler can be
413  * created via SCIPmessagehdlrCreate().
414  *
415  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
416  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
417  *
418  * @pre this method can be called in one of the following stages of the SCIP solving process:
419  * - \ref SCIP_STAGE_INIT
420  * - \ref SCIP_STAGE_PROBLEM
421  *
422  * @note The currently installed messages handler gets freed if this SCIP instance is its last user (w.r.t. capture/release).
423  */
424 extern
426  SCIP* scip, /**< SCIP data structure */
427  SCIP_MESSAGEHDLR* messagehdlr /**< message handler to install, or NULL to suppress all output */
428  );
429 
430 /** returns the currently installed message handler
431  *
432  * @return the currently installed message handler, or NULL if messages are currently suppressed
433  */
434 extern
436  SCIP* scip /**< SCIP data structure */
437  );
438 
439 /** sets the log file name for the currently installed message handler */
440 extern
442  SCIP* scip, /**< SCIP data structure */
443  const char* filename /**< name of log file, or NULL (no log) */
444  );
445 
446 /** sets the currently installed message handler to be quiet (or not) */
447 extern
449  SCIP* scip, /**< SCIP data structure */
450  SCIP_Bool quiet /**< should screen messages be suppressed? */
451  );
452 
453 /** prints a warning message via the message handler */
454 extern
455 void SCIPwarningMessage(
456  SCIP* scip, /**< SCIP data structure */
457  const char* formatstr, /**< format string like in printf() function */
458  ... /**< format arguments line in printf() function */
459  );
460 
461 /** prints a dialog message that requests user interaction or is a direct response to a user interactive command */
462 extern
463 void SCIPdialogMessage(
464  SCIP* scip, /**< SCIP data structure */
465  FILE* file, /**< file stream to print into, or NULL for stdout */
466  const char* formatstr, /**< format string like in printf() function */
467  ... /**< format arguments line in printf() function */
468  );
469 
470 /** prints a message */
471 extern
472 void SCIPinfoMessage(
473  SCIP* scip, /**< SCIP data structure */
474  FILE* file, /**< file stream to print into, or NULL for stdout */
475  const char* formatstr, /**< format string like in printf() function */
476  ... /**< format arguments line in printf() function */
477  );
478 
479 /** prints a message depending on the verbosity level */
480 extern
481 void SCIPverbMessage(
482  SCIP* scip, /**< SCIP data structure */
483  SCIP_VERBLEVEL msgverblevel, /**< verbosity level of this message */
484  FILE* file, /**< file stream to print into, or NULL for stdout */
485  const char* formatstr, /**< format string like in printf() function */
486  ... /**< format arguments line in printf() function */
487  );
488 
489 /** returns the current message verbosity level
490  *
491  * @return message verbosity level of SCIP
492  *
493  * @see \ref SCIP_VerbLevel "SCIP_VERBLEVEL" for a list of all verbosity levels
494  */
495 extern
497  SCIP* scip /**< SCIP data structure */
498  );
499 
500 
501 /**@} */
502 
503 
504 
505 
506 /*
507  * SCIP copy methods
508  */
509 
510 /**@name Copy Methods */
511 /**@{ */
512 
513 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
514  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
515  * copied SCIP instance might not represent the same problem semantics as the original.
516  * Note that in this case dual reductions might be invalid.
517  *
518  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
519  * Also, 'passmessagehdlr' should be set to FALSE.
520  * @note Do not change the source SCIP environment during the copying process
521  *
522  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
523  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
524  *
525  * @pre This method can be called if sourcescip is in one of the following stages:
526  * - \ref SCIP_STAGE_PROBLEM
527  * - \ref SCIP_STAGE_TRANSFORMED
528  * - \ref SCIP_STAGE_INITPRESOLVE
529  * - \ref SCIP_STAGE_PRESOLVING
530  * - \ref SCIP_STAGE_EXITPRESOLVE
531  * - \ref SCIP_STAGE_PRESOLVED
532  * - \ref SCIP_STAGE_INITSOLVE
533  * - \ref SCIP_STAGE_SOLVING
534  * - \ref SCIP_STAGE_SOLVED
535  *
536  * @pre This method can be called if targetscip is in one of the following stages:
537  * - \ref SCIP_STAGE_INIT
538  * - \ref SCIP_STAGE_FREE
539  *
540  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
541  * process was interrupted:
542  * - \ref SCIP_STAGE_PROBLEM
543  *
544  * @note sourcescip stage does not get changed
545  *
546  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
547  */
548 extern
550  SCIP* sourcescip, /**< source SCIP data structure */
551  SCIP* targetscip, /**< target SCIP data structure */
552  SCIP_Bool copyreaders, /**< should the file readers be copied */
553  SCIP_Bool copypricers, /**< should the variable pricers be copied */
554  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
555  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
556  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
557  SCIP_Bool copyrelaxators, /**< should the relaxation handler be copied */
558  SCIP_Bool copyseparators, /**< should the separators be copied */
559  SCIP_Bool copypropagators, /**< should the propagators be copied */
560  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
561  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
562  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
563  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
564  SCIP_Bool copydisplays, /**< should the display columns be copied */
565  SCIP_Bool copydialogs, /**< should the dialogs be copied */
566  SCIP_Bool copynlpis, /**< should the NLPIs be copied */
567  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
568  SCIP_Bool* valid /**< pointer to store whether plugins, in particular all constraint
569  * handlers which do not need constraints were validly copied */
570  );
571 
572 /** create a problem by copying the problem data of the source SCIP
573  *
574  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
575  * @note Do not change the source SCIP environment during the copying process
576  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
577  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
578  *
579  * @pre This method can be called if sourcescip is in one of the following stages:
580  * - \ref SCIP_STAGE_PROBLEM
581  * - \ref SCIP_STAGE_TRANSFORMED
582  * - \ref SCIP_STAGE_INITPRESOLVE
583  * - \ref SCIP_STAGE_PRESOLVING
584  * - \ref SCIP_STAGE_EXITPRESOLVE
585  * - \ref SCIP_STAGE_PRESOLVED
586  * - \ref SCIP_STAGE_INITSOLVE
587  * - \ref SCIP_STAGE_SOLVING
588  * - \ref SCIP_STAGE_SOLVED
589  *
590  * @pre This method can be called if targetscip is in one of the following stages:
591  * - \ref SCIP_STAGE_INIT
592  * - \ref SCIP_STAGE_FREE
593  *
594  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
595  * process was interrupted:
596  * - \ref SCIP_STAGE_PROBLEM
597  *
598  * @note sourcescip stage does not get changed
599  *
600  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
601  */
602 extern
604  SCIP* sourcescip, /**< source SCIP data structure */
605  SCIP* targetscip, /**< target SCIP data structure */
606  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
607  * target variables, or NULL */
608  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
609  * target constraints, or NULL */
610  SCIP_Bool global, /**< create a global or a local copy? */
611  const char* name /**< problem name */
612  );
613 
614 /** create a problem by copying the original problem data of the source SCIP
615  *
616  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
617  * @note Do not change the source SCIP environment during the copying process
618  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
619  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
620  *
621  * @pre This method can be called if sourcescip is in one of the following stages:
622  * - \ref SCIP_STAGE_PROBLEM
623  * - \ref SCIP_STAGE_TRANSFORMED
624  * - \ref SCIP_STAGE_INITPRESOLVE
625  * - \ref SCIP_STAGE_PRESOLVING
626  * - \ref SCIP_STAGE_EXITPRESOLVE
627  * - \ref SCIP_STAGE_PRESOLVED
628  * - \ref SCIP_STAGE_INITSOLVE
629  * - \ref SCIP_STAGE_SOLVING
630  * - \ref SCIP_STAGE_SOLVED
631  *
632  * @pre This method can be called if targetscip is in one of the following stages:
633  * - \ref SCIP_STAGE_INIT
634  * - \ref SCIP_STAGE_FREE
635  *
636  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
637  * process was interrupted:
638  * - \ref SCIP_STAGE_PROBLEM
639  *
640  * @note sourcescip stage does not get changed
641  *
642  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
643  */
644 extern
646  SCIP* sourcescip, /**< source SCIP data structure */
647  SCIP* targetscip, /**< target SCIP data structure */
648  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
649  * target variables, or NULL */
650  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
651  * target constraints, or NULL */
652  const char* name /**< problem name of target */
653  );
654 
655 /** returns copy of the source variable; if there already is a copy of the source variable in the variable hash map,
656  * it is just returned as target variable; elsewise a new variable will be created and added to the target SCIP; this
657  * created variable is added to the variable hash map and returned as target variable
658  *
659  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
660  * @note Do not change the source SCIP environment during the copying process
661  * @note if a new variable was created, this variable will be added to the target-SCIP, but it is not captured
662  *
663  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
664  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
665  *
666  * @pre This method can be called if sourcescip is in one of the following stages:
667  * - \ref SCIP_STAGE_PROBLEM
668  * - \ref SCIP_STAGE_TRANSFORMED
669  * - \ref SCIP_STAGE_INITPRESOLVE
670  * - \ref SCIP_STAGE_PRESOLVING
671  * - \ref SCIP_STAGE_EXITPRESOLVE
672  * - \ref SCIP_STAGE_PRESOLVED
673  * - \ref SCIP_STAGE_INITSOLVE
674  * - \ref SCIP_STAGE_SOLVING
675  * - \ref SCIP_STAGE_SOLVED
676  *
677  * @pre This method can be called if targetscip is in one of the following stages:
678  * - \ref SCIP_STAGE_PROBLEM
679  * - \ref SCIP_STAGE_TRANSFORMED
680  * - \ref SCIP_STAGE_INITPRESOLVE
681  * - \ref SCIP_STAGE_PRESOLVING
682  * - \ref SCIP_STAGE_EXITPRESOLVE
683  * - \ref SCIP_STAGE_SOLVING
684  *
685  * @note targetscip stage does not get changed
686  *
687  * @note sourcescip stage does not get changed
688  *
689  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
690  */
691 extern
693  SCIP* sourcescip, /**< source SCIP data structure */
694  SCIP* targetscip, /**< target SCIP data structure */
695  SCIP_VAR* sourcevar, /**< source variable */
696  SCIP_VAR** targetvar, /**< pointer to store the target variable */
697  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
698  * target variables, or NULL */
699  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
700  * target constraints, or NULL */
701  SCIP_Bool global, /**< should global or local bounds be used? */
702  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
703  );
704 
705 /** copies all active variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
706  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
707  * variables do not get copied
708  *
709  * @note the variables are added to the target-SCIP but not captured
710  *
711  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
712  * @note Do not change the source SCIP environment during the copying process
713  *
714  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
715  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
716  *
717  * @pre This method can be called if sourcescip is in one of the following stages:
718  * - \ref SCIP_STAGE_PROBLEM
719  * - \ref SCIP_STAGE_TRANSFORMED
720  * - \ref SCIP_STAGE_INITPRESOLVE
721  * - \ref SCIP_STAGE_PRESOLVING
722  * - \ref SCIP_STAGE_EXITPRESOLVE
723  * - \ref SCIP_STAGE_PRESOLVED
724  * - \ref SCIP_STAGE_INITSOLVE
725  * - \ref SCIP_STAGE_SOLVING
726  * - \ref SCIP_STAGE_SOLVED
727  *
728  * @pre This method can be called if targetscip is in one of the following stages:
729  * - \ref SCIP_STAGE_PROBLEM
730  *
731  * @note sourcescip stage does not get changed
732  *
733  * @note targetscip stage does not get changed
734  *
735  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
736  */
737 extern
739  SCIP* sourcescip, /**< source SCIP data structure */
740  SCIP* targetscip, /**< target SCIP data structure */
741  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
742  * target variables, or NULL */
743  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
744  * target constraints, or NULL */
745  SCIP_Bool global /**< should global or local bounds be used? */
746  );
747 
748 /** copies all original variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
749  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
750  * variables do not get copied
751  *
752  * @note the variables are added to the target-SCIP but not captured
753  *
754  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
755  * @note Do not change the source SCIP environment during the copying process
756  *
757  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
758  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
759  *
760  * @pre This method can be called if sourcescip is in one of the following stages:
761  * - \ref SCIP_STAGE_PROBLEM
762  * - \ref SCIP_STAGE_TRANSFORMED
763  * - \ref SCIP_STAGE_INITPRESOLVE
764  * - \ref SCIP_STAGE_PRESOLVING
765  * - \ref SCIP_STAGE_EXITPRESOLVE
766  * - \ref SCIP_STAGE_PRESOLVED
767  * - \ref SCIP_STAGE_INITSOLVE
768  * - \ref SCIP_STAGE_SOLVING
769  * - \ref SCIP_STAGE_SOLVED
770  *
771  * @pre This method can be called if targetscip is in one of the following stages:
772  * - \ref SCIP_STAGE_PROBLEM
773  *
774  * @note sourcescip stage does not get changed
775  *
776  * @note targetscip stage does not get changed
777  *
778  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
779  */
780 extern
782  SCIP* sourcescip, /**< source SCIP data structure */
783  SCIP* targetscip, /**< target SCIP data structure */
784  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
785  * target variables, or NULL */
786  SCIP_HASHMAP* consmap /**< a hashmap to store the mapping of source constraints to the corresponding
787  * target constraints, or NULL */
788  );
789 
790 /** merges the histories of variables from a source SCIP into a target SCIP. The two data structures should point to
791  * different SCIP instances.
792  *
793  * @note the notion of source and target is inverted here; \p sourcescip usually denotes a copied SCIP instance, whereas
794  * \p targetscip denotes the original instance
795  */
796 
797 extern
799  SCIP* sourcescip, /**< source SCIP data structure */
800  SCIP* targetscip, /**< target SCIP data structure */
801  SCIP_VAR** sourcevars, /**< source variables for history merge */
802  SCIP_VAR** targetvars, /**< target variables for history merge */
803  int nvars /**< number of variables in both variable arrays */
804  );
805 
806 /** returns copy of the source constraint; if there already is a copy of the source constraint in the constraint hash
807  * map, it is just returned as target constraint; elsewise a new constraint will be created; this created constraint is
808  * added to the constraint hash map and returned as target constraint; the variable map is used to map the variables of
809  * the source SCIP to the variables of the target SCIP
810  *
811  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
812  * be declared feasible even if it violates this particular constraint. This constellation should only be
813  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
814  * to the variable's local bounds.
815  *
816  * @note The constraint is not added to the target SCIP. You can check whether a constraint is added by calling
817  * SCIPconsIsAdded(). (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add
818  * explicitly and what is already added.)
819  *
820  * @note The constraint is always captured, either during the creation of the copy or after finding the copy of the
821  * constraint in the constraint hash map
822  *
823  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
824  * @note Do not change the source SCIP environment during the copying process
825  *
826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
828  *
829  * @pre This method can be called if sourcescip is in one of the following stages:
830  * - \ref SCIP_STAGE_PROBLEM
831  * - \ref SCIP_STAGE_TRANSFORMED
832  * - \ref SCIP_STAGE_INITPRESOLVE
833  * - \ref SCIP_STAGE_PRESOLVING
834  * - \ref SCIP_STAGE_EXITPRESOLVE
835  * - \ref SCIP_STAGE_PRESOLVED
836  * - \ref SCIP_STAGE_INITSOLVE
837  * - \ref SCIP_STAGE_SOLVING
838  * - \ref SCIP_STAGE_SOLVED
839  *
840  * @pre This method can be called if targetscip is in one of the following stages:
841  * - \ref SCIP_STAGE_PROBLEM
842  * - \ref SCIP_STAGE_TRANSFORMING
843  * - \ref SCIP_STAGE_INITPRESOLVE
844  * - \ref SCIP_STAGE_PRESOLVING
845  * - \ref SCIP_STAGE_EXITPRESOLVE
846  * - \ref SCIP_STAGE_PRESOLVED
847  * - \ref SCIP_STAGE_SOLVING
848  * - \ref SCIP_STAGE_EXITSOLVE
849  *
850  * @note sourcescip stage does not get changed
851  *
852  * @note targetscip stage does not get changed
853  *
854  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
855  */
856 extern
858  SCIP* sourcescip, /**< source SCIP data structure */
859  SCIP* targetscip, /**< target SCIP data structure */
860  SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
861  SCIP_CONS** targetcons, /**< pointer to store the created target constraint */
862  SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
863  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
864  * variables of the target SCIP, or NULL */
865  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
866  * target constraints, or NULL */
867  const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
868  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
869  SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
870  SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
871  SCIP_Bool check, /**< should the constraint be checked for feasibility? */
872  SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
873  SCIP_Bool local, /**< is constraint only valid locally? */
874  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
875  SCIP_Bool dynamic, /**< is constraint subject to aging? */
876  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
877  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
878  * if it may be moved to a more global node? */
879  SCIP_Bool global, /**< create a global or a local copy? */
880  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
881  );
882 
883 /** copies constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
884  * variables between the source and the target SCIP a hash map can be given; if the variable hash
885  * map is NULL or necessary variable mapping is missing, the required variables are created in the
886  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
887  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
888  * between the constraints of the source and target-SCIP is stored
889  *
890  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
891  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
892  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
893  *
894  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
895  * @note Do not change the source SCIP environment during the copying process
896  *
897  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
898  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
899  *
900  * @pre This method can be called if sourcescip is in one of the following stages:
901  * - \ref SCIP_STAGE_PROBLEM
902  * - \ref SCIP_STAGE_TRANSFORMED
903  * - \ref SCIP_STAGE_INITPRESOLVE
904  * - \ref SCIP_STAGE_PRESOLVING
905  * - \ref SCIP_STAGE_EXITPRESOLVE
906  * - \ref SCIP_STAGE_PRESOLVED
907  * - \ref SCIP_STAGE_INITSOLVE
908  * - \ref SCIP_STAGE_SOLVING
909  * - \ref SCIP_STAGE_SOLVED
910  *
911  * @pre This method can be called if targetscip is in one of the following stages:
912  * - \ref SCIP_STAGE_PROBLEM
913  *
914  * @note sourcescip stage does not get changed
915  *
916  * @note targetscip stage does not get changed
917  *
918  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
919  */
920 extern
922  SCIP* sourcescip, /**< source SCIP data structure */
923  SCIP* targetscip, /**< target SCIP data structure */
924  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
925  * variables of the target SCIP, or NULL */
926  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
927  * target constraints, or NULL */
928  SCIP_Bool global, /**< create a global or a local copy? */
929  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
930  * If TRUE, the modifiable flag of constraints will be copied. */
931  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
932  );
933 
934 /** copies all original constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
935  * variables between the source and the target SCIP a hash map can be given; if the variable hash
936  * map is NULL or necessary variable mapping is missing, the required variables are created in the
937  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
938  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
939  * between the constraints of the source and target-SCIP is stored
940  *
941  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
942  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
943  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
944  *
945  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
946  * @note Do not change the source SCIP environment during the copying process
947  *
948  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
949  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
950  *
951  * @pre This method can be called if sourcescip is in one of the following stages:
952  * - \ref SCIP_STAGE_PROBLEM
953  * - \ref SCIP_STAGE_TRANSFORMED
954  * - \ref SCIP_STAGE_INITPRESOLVE
955  * - \ref SCIP_STAGE_PRESOLVING
956  * - \ref SCIP_STAGE_EXITPRESOLVE
957  * - \ref SCIP_STAGE_PRESOLVED
958  * - \ref SCIP_STAGE_INITSOLVE
959  * - \ref SCIP_STAGE_SOLVING
960  * - \ref SCIP_STAGE_SOLVED
961  *
962  * @pre This method can be called if targetscip is in one of the following stages:
963  * - \ref SCIP_STAGE_PROBLEM
964  *
965  * @note sourcescip stage does not get changed
966  *
967  * @note targetscip stage does not get changed
968  *
969  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
970  */
971 extern
973  SCIP* sourcescip, /**< source SCIP data structure */
974  SCIP* targetscip, /**< target SCIP data structure */
975  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
976  * variables of the target SCIP, or NULL */
977  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
978  * target constraints, or NULL */
979  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
980  * If TRUE, the modifiable flag of constraints will be copied. */
981  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
982  );
983 
984 /** convert all active cuts from cutpool to linear constraints
985  *
986  * @note Do not change the source SCIP environment during the copying process
987  *
988  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
989  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
990  *
991  * @pre This method can be called if SCIP is in one of the following stages:
992  * - \ref SCIP_STAGE_PROBLEM
993  * - \ref SCIP_STAGE_INITPRESOLVE
994  * - \ref SCIP_STAGE_PRESOLVING
995  * - \ref SCIP_STAGE_EXITPRESOLVE
996  * - \ref SCIP_STAGE_PRESOLVED
997  * - \ref SCIP_STAGE_SOLVING
998  * - \ref SCIP_STAGE_EXITSOLVE
999  *
1000  * @note SCIP stage does not get changed
1001  *
1002  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1003  */
1004 extern
1006  SCIP* scip, /**< SCIP data structure */
1007  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1008  * target variables, or NULL */
1009  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1010  * target constraints, or NULL */
1011  SCIP_Bool global, /**< create a global or a local copy? */
1012  int* ncutsadded /**< pointer to store number of added cuts, or NULL */
1013  );
1014 
1015 /** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip
1016  *
1017  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1018  * @note Do not change the source SCIP environment during the copying process
1019  *
1020  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1021  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1022  *
1023  * @pre This method can be called if sourcescip is in one of the following stages:
1024  * - \ref SCIP_STAGE_PROBLEM
1025  * - \ref SCIP_STAGE_TRANSFORMED
1026  * - \ref SCIP_STAGE_INITPRESOLVE
1027  * - \ref SCIP_STAGE_PRESOLVING
1028  * - \ref SCIP_STAGE_EXITPRESOLVE
1029  * - \ref SCIP_STAGE_PRESOLVED
1030  * - \ref SCIP_STAGE_SOLVING
1031  * - \ref SCIP_STAGE_SOLVED
1032  * - \ref SCIP_STAGE_EXITSOLVE
1033  *
1034  * @pre This method can be called if targetscip is in one of the following stages:
1035  * - \ref SCIP_STAGE_PROBLEM
1036  * - \ref SCIP_STAGE_INITPRESOLVE
1037  * - \ref SCIP_STAGE_PRESOLVING
1038  * - \ref SCIP_STAGE_EXITPRESOLVE
1039  * - \ref SCIP_STAGE_PRESOLVED
1040  * - \ref SCIP_STAGE_SOLVING
1041  * - \ref SCIP_STAGE_EXITSOLVE
1042  *
1043  * @note sourcescip stage does not get changed
1044  *
1045  * @note targetscip stage does not get changed
1046  *
1047  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1048  */
1049 extern
1051  SCIP* sourcescip, /**< source SCIP data structure */
1052  SCIP* targetscip, /**< target SCIP data structure */
1053  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1054  * target variables, or NULL */
1055  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1056  * target constraints, or NULL */
1057  SCIP_Bool global, /**< create a global or a local copy? */
1058  int* ncutsadded /**< pointer to store number of copied cuts, or NULL */
1059  );
1060 
1061 /** copies implications and cliques of sourcescip to targetscip
1062  *
1063  * This function should be called for a targetscip in transformed stage. It can save time in presolving of the
1064  * targetscip, since implications and cliques are copied.
1065  *
1066  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1067  * @note Do not change the source SCIP environment during the copying process
1068  *
1069  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1070  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1071  *
1072  * @pre This method can be called if sourcescip is in one of the following stages:
1073  * - \ref SCIP_STAGE_TRANSFORMED
1074  * - \ref SCIP_STAGE_INITPRESOLVE
1075  * - \ref SCIP_STAGE_PRESOLVING
1076  * - \ref SCIP_STAGE_EXITPRESOLVE
1077  * - \ref SCIP_STAGE_PRESOLVED
1078  * - \ref SCIP_STAGE_SOLVING
1079  * - \ref SCIP_STAGE_SOLVED
1080  * - \ref SCIP_STAGE_EXITSOLVE
1081  *
1082  * @pre This method can be called if targetscip is in one of the following stages:
1083  * - \ref SCIP_STAGE_TRANSFORMED
1084  * - \ref SCIP_STAGE_INITPRESOLVE
1085  * - \ref SCIP_STAGE_PRESOLVING
1086  * - \ref SCIP_STAGE_EXITPRESOLVE
1087  * - \ref SCIP_STAGE_PRESOLVED
1088  * - \ref SCIP_STAGE_INITSOLVE
1089  * - \ref SCIP_STAGE_SOLVING
1090  *
1091  * @note sourcescip stage does not get changed
1092  *
1093  * @note targetscip stage does not get changed
1094  *
1095  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1096  */
1097 extern
1099  SCIP* sourcescip, /**< source SCIP data structure */
1100  SCIP* targetscip, /**< target SCIP data structure */
1101  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1102  * target variables, or NULL */
1103  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1104  * target constraints, or NULL */
1105  SCIP_Bool global, /**< create a global or a local copy? */
1106  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1107  int* nbdchgs, /**< pointer to store the number of performed bound changes, or NULL */
1108  int* ncopied /**< pointer to store number of copied implications and cliques, or NULL */
1109  );
1110 
1111 /** copies parameter settings from sourcescip to targetscip
1112  *
1113  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1114  * @note Do not change the source SCIP environment during the copying process
1115  *
1116  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1117  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1118  *
1119  * @pre This method can be called if sourcescip is in one of the following stages:
1120  * - \ref SCIP_STAGE_PROBLEM
1121  * - \ref SCIP_STAGE_TRANSFORMED
1122  * - \ref SCIP_STAGE_INITPRESOLVE
1123  * - \ref SCIP_STAGE_PRESOLVING
1124  * - \ref SCIP_STAGE_EXITPRESOLVE
1125  * - \ref SCIP_STAGE_PRESOLVED
1126  * - \ref SCIP_STAGE_INITSOLVE
1127  * - \ref SCIP_STAGE_SOLVING
1128  * - \ref SCIP_STAGE_SOLVED
1129  *
1130  * @pre This method can be called if targetscip is in one of the following stages:
1131  * - \ref SCIP_STAGE_INIT
1132  * - \ref SCIP_STAGE_PROBLEM
1133  * - \ref SCIP_STAGE_FREE
1134  *
1135  * @note sourcescip stage does not get changed
1136  *
1137  * @note targetscip stage does not get changed
1138  *
1139  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1140  */
1141 extern
1143  SCIP* sourcescip, /**< source SCIP data structure */
1144  SCIP* targetscip /**< target SCIP data structure */
1145  );
1146 
1147 /** gets depth of current scip instance (increased by each copy call)
1148  *
1149  * @return Depth of subscip of SCIP is returned.
1150  *
1151  * @pre This method can be called if SCIP is in one of the following stages:
1152  * - \ref SCIP_STAGE_PROBLEM
1153  * - \ref SCIP_STAGE_TRANSFORMING
1154  * - \ref SCIP_STAGE_TRANSFORMED
1155  * - \ref SCIP_STAGE_INITPRESOLVE
1156  * - \ref SCIP_STAGE_PRESOLVING
1157  * - \ref SCIP_STAGE_EXITPRESOLVE
1158  * - \ref SCIP_STAGE_PRESOLVED
1159  * - \ref SCIP_STAGE_INITSOLVE
1160  * - \ref SCIP_STAGE_SOLVING
1161  * - \ref SCIP_STAGE_SOLVED
1162  * - \ref SCIP_STAGE_EXITSOLVE
1163  * - \ref SCIP_STAGE_FREETRANS
1164  *
1165  * @note SCIP stage does not get changed
1166  *
1167  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1168  */
1169 extern
1171  SCIP* scip /**< SCIP data structure */
1172  );
1173 
1174 /** copies source SCIP to target SCIP; the copying process is done in the following order:
1175  * 1) copy the plugins
1176  * 2) copy the settings
1177  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1178  * 4) copy all active variables
1179  * 5) copy all constraints
1180  *
1181  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1182  *
1183  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1184  * Also, 'passmessagehdlr' should be set to FALSE.
1185  * @note Do not change the source SCIP environment during the copying process
1186  *
1187  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1188  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1189  *
1190  * @pre This method can be called if sourcescip is in one of the following stages:
1191  * - \ref SCIP_STAGE_PROBLEM
1192  * - \ref SCIP_STAGE_TRANSFORMED
1193  * - \ref SCIP_STAGE_INITPRESOLVE
1194  * - \ref SCIP_STAGE_PRESOLVING
1195  * - \ref SCIP_STAGE_EXITPRESOLVE
1196  * - \ref SCIP_STAGE_PRESOLVED
1197  * - \ref SCIP_STAGE_INITSOLVE
1198  * - \ref SCIP_STAGE_SOLVING
1199  * - \ref SCIP_STAGE_SOLVED
1200  *
1201  * @pre This method can be called if targetscip is in one of the following stages:
1202  * - \ref SCIP_STAGE_INIT
1203  * - \ref SCIP_STAGE_FREE
1204  *
1205  * @note sourcescip stage does not get changed
1206  *
1207  * @note targetscip stage does not get changed
1208  *
1209  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1210  */
1211 extern
1213  SCIP* sourcescip, /**< source SCIP data structure */
1214  SCIP* targetscip, /**< target SCIP data structure */
1215  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1216  * target variables, or NULL */
1217  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1218  * target constraints, or NULL */
1219  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1220  SCIP_Bool global, /**< create a global or a local copy? */
1221  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1222  * plugins will be copied and activated, and the modifiable flag of
1223  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1224  * there are pricers present */
1225  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1226  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
1227  );
1228 
1229 /** copies source SCIP original problem to target SCIP; the copying process is done in the following order:
1230  * 1) copy the plugins
1231  * 2) copy the settings
1232  * 3) create problem data in target-SCIP and copy the original problem data of the source-SCIP
1233  * 4) copy all original variables
1234  * 5) copy all original constraints
1235  *
1236  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1237  *
1238  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1239  * Also, 'passmessagehdlr' should be set to FALSE.
1240  * @note Do not change the source SCIP environment during the copying process
1241  *
1242  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1243  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1244  *
1245  * @pre This method can be called if sourcescip is in one of the following stages:
1246  * - \ref SCIP_STAGE_PROBLEM
1247  * - \ref SCIP_STAGE_TRANSFORMED
1248  * - \ref SCIP_STAGE_INITPRESOLVE
1249  * - \ref SCIP_STAGE_PRESOLVING
1250  * - \ref SCIP_STAGE_EXITPRESOLVE
1251  * - \ref SCIP_STAGE_PRESOLVED
1252  * - \ref SCIP_STAGE_INITSOLVE
1253  * - \ref SCIP_STAGE_SOLVING
1254  * - \ref SCIP_STAGE_SOLVED
1255  *
1256  * @pre This method can be called if targetscip is in one of the following stages:
1257  * - \ref SCIP_STAGE_INIT
1258  * - \ref SCIP_STAGE_FREE
1259  *
1260  * @note sourcescip stage does not get changed
1261  *
1262  * @note targetscip stage does not get changed
1263  *
1264  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1265  */
1266 extern
1268  SCIP* sourcescip, /**< source SCIP data structure */
1269  SCIP* targetscip, /**< target SCIP data structure */
1270  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1271  * target variables, or NULL */
1272  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1273  * target constraints, or NULL */
1274  const char* suffix, /**< suffix which will be added to the names of the target SCIP, might be empty */
1275  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1276  * plugins will be copied and activated, and the modifiable flag of
1277  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1278  * there are pricers present */
1279  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1280  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
1281  );
1282 
1283 /**@} */
1284 
1285 /*
1286  * parameter settings
1287  */
1288 
1289 /**@name Parameter Methods */
1290 /**@{ */
1291 
1292 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
1293  *
1294  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1295  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1296  */
1297 extern
1299  SCIP* scip, /**< SCIP data structure */
1300  const char* name, /**< name of the parameter */
1301  const char* desc, /**< description of the parameter */
1302  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
1303  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1304  SCIP_Bool defaultvalue, /**< default value of the parameter */
1305  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1306  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1307  );
1308 
1309 /** creates a int parameter, sets it to its default value, and adds it to the parameter set
1310  *
1311  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1312  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1313  */
1314 extern
1316  SCIP* scip, /**< SCIP data structure */
1317  const char* name, /**< name of the parameter */
1318  const char* desc, /**< description of the parameter */
1319  int* valueptr, /**< pointer to store the current parameter value, or NULL */
1320  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1321  int defaultvalue, /**< default value of the parameter */
1322  int minvalue, /**< minimum value for parameter */
1323  int maxvalue, /**< maximum value for parameter */
1324  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1325  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1326  );
1327 
1328 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
1329  *
1330  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1331  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1332  */
1333 extern
1335  SCIP* scip, /**< SCIP data structure */
1336  const char* name, /**< name of the parameter */
1337  const char* desc, /**< description of the parameter */
1338  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
1339  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1340  SCIP_Longint defaultvalue, /**< default value of the parameter */
1341  SCIP_Longint minvalue, /**< minimum value for parameter */
1342  SCIP_Longint maxvalue, /**< maximum value for parameter */
1343  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1344  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1345  );
1346 
1347 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
1348  *
1349  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1350  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1351  */
1352 extern
1354  SCIP* scip, /**< SCIP data structure */
1355  const char* name, /**< name of the parameter */
1356  const char* desc, /**< description of the parameter */
1357  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
1358  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1359  SCIP_Real defaultvalue, /**< default value of the parameter */
1360  SCIP_Real minvalue, /**< minimum value for parameter */
1361  SCIP_Real maxvalue, /**< maximum value for parameter */
1362  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1363  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1364  );
1365 
1366 /** creates a char parameter, sets it to its default value, and adds it to the parameter set
1367  *
1368  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1369  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1370  */
1371 extern
1373  SCIP* scip, /**< SCIP data structure */
1374  const char* name, /**< name of the parameter */
1375  const char* desc, /**< description of the parameter */
1376  char* valueptr, /**< pointer to store the current parameter value, or NULL */
1377  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1378  char defaultvalue, /**< default value of the parameter */
1379  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
1380  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1381  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1382  );
1383 
1384 /** creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
1385  *
1386  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1387  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1388  */
1389 extern
1391  SCIP* scip, /**< SCIP data structure */
1392  const char* name, /**< name of the parameter */
1393  const char* desc, /**< description of the parameter */
1394  char** valueptr, /**< pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL */
1395  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1396  const char* defaultvalue, /**< default value of the parameter */
1397  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1398  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1399  );
1400 
1401 /** gets the fixing status of an existing parameter
1402  *
1403  * @return TRUE if the parameter is fixed to a value, otherwise FALSE.
1404  */
1405 extern
1407  SCIP* scip, /**< SCIP data structure */
1408  const char* name /**< name of the parameter */
1409  );
1410 
1411 /** returns the pointer to the SCIP parameter with the given name
1412  *
1413  * @return pointer to the parameter with the given name
1414  */
1415 extern
1417  SCIP* scip, /**< SCIP data structure */
1418  const char* name /**< name of the parameter */
1419  );
1420 
1421 /** gets the value of an existing SCIP_Bool parameter
1422  *
1423  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1424  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1425  */
1426 extern
1428  SCIP* scip, /**< SCIP data structure */
1429  const char* name, /**< name of the parameter */
1430  SCIP_Bool* value /**< pointer to store the parameter */
1431  );
1432 
1433 /** gets the value of an existing int parameter
1434  *
1435  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1436  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1437  */
1438 extern
1440  SCIP* scip, /**< SCIP data structure */
1441  const char* name, /**< name of the parameter */
1442  int* value /**< pointer to store the parameter */
1443  );
1444 
1445 /** gets the value of an existing SCIP_Longint parameter
1446  *
1447  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1448  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1449  */
1450 extern
1452  SCIP* scip, /**< SCIP data structure */
1453  const char* name, /**< name of the parameter */
1454  SCIP_Longint* value /**< pointer to store the parameter */
1455  );
1456 
1457 /** gets the value of an existing SCIP_Real parameter
1458  *
1459  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1460  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1461  */
1462 extern
1464  SCIP* scip, /**< SCIP data structure */
1465  const char* name, /**< name of the parameter */
1466  SCIP_Real* value /**< pointer to store the parameter */
1467  );
1468 
1469 /** gets the value of an existing char parameter
1470  *
1471  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1472  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1473  */
1474 extern
1476  SCIP* scip, /**< SCIP data structure */
1477  const char* name, /**< name of the parameter */
1478  char* value /**< pointer to store the parameter */
1479  );
1480 
1481 /** gets the value of an existing string(char*) parameter
1482  *
1483  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1484  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1485  */
1486 extern
1488  SCIP* scip, /**< SCIP data structure */
1489  const char* name, /**< name of the parameter */
1490  char** value /**< pointer to store the parameter */
1491  );
1492 
1493 /** fixes the value of an existing parameter
1494  *
1495  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1496  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1497  *
1498  * @note: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because
1499  * they have to be changed for sub-SCIPs.
1500  */
1501 extern
1503  SCIP* scip, /**< SCIP data structure */
1504  const char* name /**< name of the parameter */
1505  );
1506 
1507 /** unfixes the value of an existing parameter
1508  *
1509  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1510  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1511  */
1512 extern
1514  SCIP* scip, /**< SCIP data structure */
1515  const char* name /**< name of the parameter */
1516  );
1517 
1518 /** changes the value of an existing parameter
1519  *
1520  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1521  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1522  */
1523 extern
1525  SCIP* scip, /**< SCIP data structure */
1526  const char* name, /**< name of the parameter */
1527  void* value /**< new value of the parameter */
1528  );
1529 
1530 /** changes the value of an existing SCIP_Bool parameter
1531  *
1532  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1533  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1534  */
1535 extern
1537  SCIP* scip, /**< SCIP data structure */
1538  SCIP_PARAM* param, /**< parameter */
1539  SCIP_Bool value /**< new value of the parameter */
1540  );
1541 
1542 /** changes the value of an existing SCIP_Bool parameter
1543  *
1544  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1545  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1546  */
1547 extern
1549  SCIP* scip, /**< SCIP data structure */
1550  const char* name, /**< name of the parameter */
1551  SCIP_Bool value /**< new value of the parameter */
1552  );
1553 
1554 /** checks the value of an existing SCIP_Bool parameter; issues a warning message if value was invalid
1555  *
1556  * @return \ref SCIP_OKAY is returned if value is valid. Otherwise \ref SCIP_PARAMETERWRONGVAL is returned.
1557  */
1558 extern
1560  SCIP* scip, /**< SCIP data structure */
1561  SCIP_PARAM* param, /**< parameter */
1562  SCIP_Bool value /**< value to check */
1563  );
1564 
1565 /** changes the value of an existing int parameter
1566  *
1567  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1568  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1569  */
1570 extern
1572  SCIP* scip, /**< SCIP data structure */
1573  SCIP_PARAM* param, /**< parameter */
1574  int value /**< new value of the parameter */
1575  );
1576 
1577 /** changes the value of an existing int parameter
1578  *
1579  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1580  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1581  */
1582 extern
1584  SCIP* scip, /**< SCIP data structure */
1585  const char* name, /**< name of the parameter */
1586  int value /**< new value of the parameter */
1587  );
1588 
1589 /** changes the value of an existing SCIP_Longint parameter
1590  *
1591  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1592  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1593  */
1594 extern
1596  SCIP* scip, /**< SCIP data structure */
1597  SCIP_PARAM* param, /**< parameter */
1598  SCIP_Longint value /**< new value of the parameter */
1599  );
1600 
1601 /** changes the value of an existing SCIP_Longint parameter
1602  *
1603  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1604  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1605  */
1606 extern
1608  SCIP* scip, /**< SCIP data structure */
1609  const char* name, /**< name of the parameter */
1610  SCIP_Longint value /**< new value of the parameter */
1611  );
1612 
1613 /** checks parameter value according to the given feasible domain; issues a warning message if value was invalid
1614  *
1615  * @return \ref SCIP_OKAY is returned if value is valid. Otherwise \ref SCIP_PARAMETERWRONGVAL is returned.
1616  */
1617 extern
1619  SCIP* scip, /**< SCIP data structure */
1620  SCIP_PARAM* param, /**< parameter */
1621  SCIP_Longint value /**< value to check */
1622  );
1623 
1624 /** changes the value of an existing SCIP_Real parameter
1625  *
1626  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1627  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1628  */
1629 extern
1631  SCIP* scip, /**< SCIP data structure */
1632  SCIP_PARAM* param, /**< parameter */
1633  SCIP_Real value /**< new value of the parameter */
1634  );
1635 
1636 /** changes the value of an existing SCIP_Real parameter
1637  *
1638  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1639  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1640  */
1641 extern
1643  SCIP* scip, /**< SCIP data structure */
1644  const char* name, /**< name of the parameter */
1645  SCIP_Real value /**< new value of the parameter */
1646  );
1647 
1648 /** changes the value of an existing char parameter
1649  *
1650  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1651  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1652  */
1653 extern
1655  SCIP* scip, /**< SCIP data structure */
1656  SCIP_PARAM* param, /**< parameter */
1657  char value /**< new value of the parameter */
1658  );
1659 
1660 /** changes the value of an existing char parameter
1661  *
1662  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1663  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1664  */
1665 extern
1667  SCIP* scip, /**< SCIP data structure */
1668  const char* name, /**< name of the parameter */
1669  char value /**< new value of the parameter */
1670  );
1671 
1672 /** checks parameter value according to the given feasible domain; issues a warning message if value was invalid
1673  *
1674  * @return \ref SCIP_OKAY is returned if value is valid. Otherwise \ref SCIP_PARAMETERWRONGVAL is returned.
1675  */
1676 extern
1678  SCIP* scip, /**< SCIP data structure */
1679  SCIP_PARAM* param, /**< parameter */
1680  const char value /**< value to check */
1681  );
1682 
1683 /** changes the value of an existing string(char*) parameter
1684  *
1685  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1686  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1687  */
1688 extern
1690  SCIP* scip, /**< SCIP data structure */
1691  SCIP_PARAM* param, /**< parameter */
1692  const char* value /**< new value of the parameter */
1693  );
1694 
1695 /** changes the value of an existing string(char*) parameter
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* value /**< new value of the parameter */
1705  );
1706 
1707 /** checks parameter value according to the given feasible domain; issues a warning message if value was invalid
1708  *
1709  * @return \ref SCIP_OKAY is returned if value is valid. Otherwise \ref SCIP_PARAMETERWRONGVAL is returned.
1710  */
1711 extern
1713  SCIP* scip, /**< SCIP data structure */
1714  SCIP_PARAM* param, /**< parameter */
1715  const char* value /**< value to check */
1716  );
1717 
1718 /** reads parameters from a file
1719  *
1720  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1721  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1722  */
1723 extern
1725  SCIP* scip, /**< SCIP data structure */
1726  const char* filename /**< file name */
1727  );
1728 
1729 /** writes a single parameter to a file
1730  *
1731  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1732  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1733  */
1734 extern
1736  SCIP* scip, /**< SCIP data structure */
1737  SCIP_PARAM* param, /**< parameter */
1738  const char* filename, /**< file name, or NULL for stdout */
1739  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
1740  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
1741  * default value?
1742  */
1743  );
1744 
1745 /** writes all parameters in the parameter set to a file
1746  *
1747  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1748  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1749  */
1750 extern
1752  SCIP* scip, /**< SCIP data structure */
1753  const char* filename, /**< file name, or NULL for stdout */
1754  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
1755  SCIP_Bool onlychanged /**< should only those parameters be written that are changed from their
1756  * default value?
1757  */
1758  );
1759 
1760 /** resets a single parameter to its default value
1761  *
1762  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1763  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1764  */
1765 extern
1767  SCIP* scip, /**< SCIP data structure */
1768  const char* name /**< name of the parameter */
1769  );
1770 
1771 /** resets all parameters to their default values
1772  *
1773  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1774  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1775  */
1776 extern
1778  SCIP* scip /**< SCIP data structure */
1779  );
1780 
1781 /** sets parameters to
1782  *
1783  * - SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
1784  * - SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
1785  * - SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
1786  * - SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
1787  * - SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
1788  * - SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
1789  * - SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
1790  *
1791  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1792  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1793  */
1794 extern
1796  SCIP* scip, /**< SCIP data structure */
1797  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
1798  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1799  );
1800 
1801 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
1802  * auxiliary SCIP instances to avoid recursion
1803  *
1804  * @note only deactivates plugins which could cause recursion, some plugins which use sub-SCIPs stay activated
1805  *
1806  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1807  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1808  */
1809 extern
1811  SCIP* scip, /**< (auxiliary) SCIP data structure */
1812  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1813  );
1814 
1815 /** sets heuristic parameters values to
1816  *
1817  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
1818  * - SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
1819  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
1820  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
1821  *
1822  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1823  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1824  */
1825 extern
1827  SCIP* scip, /**< SCIP data structure */
1828  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1829  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1830  );
1831 
1832 /** sets presolving parameters to
1833  *
1834  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
1835  * - SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
1836  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
1837  * - SCIP_PARAMSETTING_OFF which turn off all presolving
1838  *
1839  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1840  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1841  */
1842 extern
1844  SCIP* scip, /**< SCIP data structure */
1845  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1846  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1847  );
1848 
1849 /** sets separating parameters to
1850  *
1851  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
1852  * - SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
1853  * - SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
1854  * - SCIP_PARAMSETTING_OFF which turn off all separating
1855  *
1856  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1857  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1858  */
1859 extern
1861  SCIP* scip, /**< SCIP data structure */
1862  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1863  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1864  );
1865 
1866 /** returns the array of all available SCIP parameters
1867  *
1868  * @return SCIP_PARAM* array, containing all SCIP parameters.
1869  */
1870 extern
1872  SCIP* scip /**< SCIP data structure */
1873  );
1874 
1875 /** returns the total number of all available SCIP parameters
1876  *
1877  * @return number of all SCIP parameters.
1878  */
1879 extern
1880 int SCIPgetNParams(
1881  SCIP* scip /**< SCIP data structure */
1882  );
1883 
1884 /**@} */
1885 
1886 
1887 /*
1888  * SCIP user functionality methods: managing plugins
1889  */
1890 
1891 /**@name SCIP User Functionality Methods: Managing Plugins */
1892 /**@{ */
1893 
1894 /** creates a reader and includes it in SCIP
1895  *
1896  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1897  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1898  *
1899  * @pre This method can be called if SCIP is in one of the following stages:
1900  * - \ref SCIP_STAGE_INIT
1901  * - \ref SCIP_STAGE_PROBLEM
1902  *
1903  * @note method has all reader callbacks as arguments and is thus changed every time a new callback is added
1904  * in future releases; consider using SCIPincludeReaderBasic() and setter functions
1905  * if you seek for a method which is less likely to change in future releases
1906  */
1907 extern
1909  SCIP* scip, /**< SCIP data structure */
1910  const char* name, /**< name of reader */
1911  const char* desc, /**< description of reader */
1912  const char* extension, /**< file extension that reader processes */
1913  SCIP_DECL_READERCOPY ((*readercopy)), /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
1914  SCIP_DECL_READERFREE ((*readerfree)), /**< destructor of reader */
1915  SCIP_DECL_READERREAD ((*readerread)), /**< read method */
1916  SCIP_DECL_READERWRITE ((*readerwrite)), /**< write method */
1917  SCIP_READERDATA* readerdata /**< reader data */
1918  );
1919 
1920 /** creates a reader and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
1921  * Optional callbacks can be set via specific setter functions, see
1922  * SCIPsetReaderCopy(), SCIPsetReaderFree(), SCIPsetReaderRead(), SCIPsetReaderWrite().
1923  *
1924  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1925  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1926  *
1927  * @pre This method can be called if SCIP is in one of the following stages:
1928  * - \ref SCIP_STAGE_INIT
1929  * - \ref SCIP_STAGE_PROBLEM
1930  *
1931  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeReader() instead
1932  */
1933 extern
1935  SCIP* scip, /**< SCIP data structure */
1936  SCIP_READER** readerptr, /**< reference to reader pointer, or NULL */
1937  const char* name, /**< name of reader */
1938  const char* desc, /**< description of reader */
1939  const char* extension, /**< file extension that reader processes */
1940  SCIP_READERDATA* readerdata /**< reader data */
1941  );
1942 
1943 /** set copy method of reader
1944  *
1945  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1946  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1947  *
1948  * @pre This method can be called if SCIP is in one of the following stages:
1949  * - \ref SCIP_STAGE_INIT
1950  * - \ref SCIP_STAGE_PROBLEM
1951  */
1952 extern
1954  SCIP* scip, /**< SCIP data structure */
1955  SCIP_READER* reader, /**< reader */
1956  SCIP_DECL_READERCOPY ((*readercopy)) /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
1957  );
1958 
1959 /** set deinitialization method of reader
1960  *
1961  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1962  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1963  *
1964  * @pre This method can be called if SCIP is in one of the following stages:
1965  * - \ref SCIP_STAGE_INIT
1966  * - \ref SCIP_STAGE_PROBLEM
1967  */
1968 extern
1970  SCIP* scip, /**< SCIP data structure */
1971  SCIP_READER* reader, /**< reader */
1972  SCIP_DECL_READERFREE ((*readerfree)) /**< destructor of reader */
1973  );
1974 
1975 /** set read method of reader
1976  *
1977  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1978  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1979  *
1980  * @pre This method can be called if SCIP is in one of the following stages:
1981  * - \ref SCIP_STAGE_INIT
1982  * - \ref SCIP_STAGE_PROBLEM
1983  */
1984 extern
1986  SCIP* scip, /**< SCIP data structure */
1987  SCIP_READER* reader, /**< reader */
1988  SCIP_DECL_READERREAD ((*readerread)) /**< read method of reader */
1989  );
1990 
1991 /** set write method of reader
1992  *
1993  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1994  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1995  *
1996  * @pre This method can be called if SCIP is in one of the following stages:
1997  * - \ref SCIP_STAGE_INIT
1998  * - \ref SCIP_STAGE_PROBLEM
1999  */
2000 extern
2002  SCIP* scip, /**< SCIP data structure */
2003  SCIP_READER* reader, /**< reader */
2004  SCIP_DECL_READERWRITE ((*readerwrite)) /**< write method of reader */
2005  );
2006 
2007 /** returns the reader of the given name, or NULL if not existing */
2008 extern
2010  SCIP* scip, /**< SCIP data structure */
2011  const char* name /**< name of reader */
2012  );
2013 
2014 /** returns the array of currently available readers */
2015 extern
2017  SCIP* scip /**< SCIP data structure */
2018  );
2019 
2020 /** returns the number of currently available readers */
2021 extern
2022 int SCIPgetNReaders(
2023  SCIP* scip /**< SCIP data structure */
2024  );
2025 
2026 /** creates a variable pricer and includes it in SCIP
2027  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2028  * This should be done during the problem creation stage.
2029  *
2030  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2031  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2032  *
2033  * @pre This method can be called if SCIP is in one of the following stages:
2034  * - \ref SCIP_STAGE_INIT
2035  * - \ref SCIP_STAGE_PROBLEM
2036  *
2037  * @note method has all pricer callbacks as arguments and is thus changed every time a new callback is added
2038  * in future releases; consider using SCIPincludePricerBasic() and setter functions
2039  * if you seek for a method which is less likely to change in future releases
2040  */
2041 extern
2043  SCIP* scip, /**< SCIP data structure */
2044  const char* name, /**< name of variable pricer */
2045  const char* desc, /**< description of variable pricer */
2046  int priority, /**< priority of the variable pricer */
2047  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2048  * problem variables with negative reduced costs are found?
2049  * if this is set to FALSE it may happen that the pricer produces columns
2050  * that already exist in the problem (which are also priced in by the
2051  * default problem variable pricing in the same round) */
2052  SCIP_DECL_PRICERCOPY ((*pricercopy)), /**< copy method of variable pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2053  SCIP_DECL_PRICERFREE ((*pricerfree)), /**< destructor of variable pricer */
2054  SCIP_DECL_PRICERINIT ((*pricerinit)), /**< initialize variable pricer */
2055  SCIP_DECL_PRICEREXIT ((*pricerexit)), /**< deinitialize variable pricer */
2056  SCIP_DECL_PRICERINITSOL((*pricerinitsol)),/**< solving process initialization method of variable pricer */
2057  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)),/**< solving process deinitialization method of variable pricer */
2058  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2059  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2060  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2061  );
2062 
2063 /** creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL;
2064  * if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(),
2065  * SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(),
2066  * SCIPsetPricerFarkas();
2067  *
2068  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
2069  * This should be done during the problem creation stage.
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  * @pre This method can be called if SCIP is in one of the following stages:
2075  * - \ref SCIP_STAGE_INIT
2076  * - \ref SCIP_STAGE_PROBLEM
2077  *
2078  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePricer() instead
2079  */
2080 extern
2082  SCIP* scip, /**< SCIP data structure */
2083  SCIP_PRICER** pricerptr, /**< reference to a pricer, or NULL */
2084  const char* name, /**< name of variable pricer */
2085  const char* desc, /**< description of variable pricer */
2086  int priority, /**< priority of the variable pricer */
2087  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
2088  * problem variables with negative reduced costs are found?
2089  * if this is set to FALSE it may happen that the pricer produces columns
2090  * that already exist in the problem (which are also priced in by the
2091  * default problem variable pricing in the same round) */
2092  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
2093  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
2094  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
2095  );
2096 
2097 /** sets copy method of pricer
2098  *
2099  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2100  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2101  *
2102  * @pre This method can be called if SCIP is in one of the following stages:
2103  * - \ref SCIP_STAGE_INIT
2104  * - \ref SCIP_STAGE_PROBLEM
2105  */
2106 extern
2108  SCIP* scip, /**< SCIP data structure */
2109  SCIP_PRICER* pricer, /**< pricer */
2110  SCIP_DECL_PRICERCOPY ((*pricercopy)) /**< copy method of pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
2111  );
2112 
2113 /** sets destructor method of pricer
2114  *
2115  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2116  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2117  *
2118  * @pre This method can be called if SCIP is in one of the following stages:
2119  * - \ref SCIP_STAGE_INIT
2120  * - \ref SCIP_STAGE_PROBLEM
2121  */
2122 extern
2124  SCIP* scip, /**< SCIP data structure */
2125  SCIP_PRICER* pricer, /**< pricer */
2126  SCIP_DECL_PRICERFREE ((*pricerfree)) /**< destructor of pricer */
2127  );
2128 
2129 /** sets initialization method of pricer
2130  *
2131  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2132  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2133  *
2134  * @pre This method can be called if SCIP is in one of the following stages:
2135  * - \ref SCIP_STAGE_INIT
2136  * - \ref SCIP_STAGE_PROBLEM
2137  */
2138 extern
2140  SCIP* scip, /**< SCIP data structure */
2141  SCIP_PRICER* pricer, /**< pricer */
2142  SCIP_DECL_PRICERINIT ((*pricerinit)) /**< initialize pricer */
2143  );
2144 
2145 /** sets deinitialization method of pricer
2146  *
2147  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2148  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2149  *
2150  * @pre This method can be called if SCIP is in one of the following stages:
2151  * - \ref SCIP_STAGE_INIT
2152  * - \ref SCIP_STAGE_PROBLEM
2153  */
2154 extern
2156  SCIP* scip, /**< SCIP data structure */
2157  SCIP_PRICER* pricer, /**< pricer */
2158  SCIP_DECL_PRICEREXIT ((*pricerexit)) /**< deinitialize pricer */
2159  );
2160 
2161 /** sets solving process initialization method of pricer
2162  *
2163  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2164  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2165  *
2166  * @pre This method can be called if SCIP is in one of the following stages:
2167  * - \ref SCIP_STAGE_INIT
2168  * - \ref SCIP_STAGE_PROBLEM
2169  */
2170 extern
2172  SCIP* scip, /**< SCIP data structure */
2173  SCIP_PRICER* pricer, /**< pricer */
2174  SCIP_DECL_PRICERINITSOL ((*pricerinitsol))/**< solving process initialization method of pricer */
2175  );
2176 
2177 /** sets solving process deinitialization method of pricer
2178  *
2179  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2180  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2181  *
2182  * @pre This method can be called if SCIP is in one of the following stages:
2183  * - \ref SCIP_STAGE_INIT
2184  * - \ref SCIP_STAGE_PROBLEM
2185  */
2186 extern
2188  SCIP* scip, /**< SCIP data structure */
2189  SCIP_PRICER* pricer, /**< pricer */
2190  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)) /**< solving process deinitialization method of pricer */
2191  );
2192 
2193 /** returns the variable pricer of the given name, or NULL if not existing */
2194 extern
2196  SCIP* scip, /**< SCIP data structure */
2197  const char* name /**< name of variable pricer */
2198  );
2199 
2200 /** returns the array of currently available variable pricers; active pricers are in the first slots of the array */
2201 extern
2203  SCIP* scip /**< SCIP data structure */
2204  );
2205 
2206 /** returns the number of currently available variable pricers */
2207 extern
2208 int SCIPgetNPricers(
2209  SCIP* scip /**< SCIP data structure */
2210  );
2211 
2212 /** returns the number of currently active variable pricers, that are used in the LP solving loop */
2213 extern
2215  SCIP* scip /**< SCIP data structure */
2216  );
2217 
2218 /** sets the priority of a variable pricer */
2219 extern
2221  SCIP* scip, /**< SCIP data structure */
2222  SCIP_PRICER* pricer, /**< variable pricer */
2223  int priority /**< new priority of the variable pricer */
2224  );
2225 
2226 /** activates pricer to be used for the current problem
2227  * This method should be called during the problem creation stage for all pricers that are necessary to solve
2228  * the problem model.
2229  * The pricers are automatically deactivated when the problem is freed.
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  * @pre This method can be called if SCIP is in one of the following stages:
2235  * - \ref SCIP_STAGE_PROBLEM
2236  */
2237 extern
2239  SCIP* scip, /**< SCIP data structure */
2240  SCIP_PRICER* pricer /**< variable pricer */
2241  );
2242 
2243 /** deactivates pricer
2244  *
2245  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2246  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2247  *
2248  * @pre This method can be called if SCIP is in one of the following stages:
2249  * - \ref SCIP_STAGE_PROBLEM
2250  * - \ref SCIP_STAGE_EXITSOLVE
2251  */
2252 extern
2254  SCIP* scip, /**< SCIP data structure */
2255  SCIP_PRICER* pricer /**< variable pricer */
2256  );
2257 
2258 /** creates a constraint handler and includes it in SCIP.
2259  *
2260  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2261  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2262  *
2263  * @pre This method can be called if SCIP is in one of the following stages:
2264  * - \ref SCIP_STAGE_INIT
2265  * - \ref SCIP_STAGE_PROBLEM
2266  *
2267  * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
2268  * callback is added
2269  * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
2270  * if you seek for a method which is less likely to change in future releases
2271  */
2272 extern
2274  SCIP* scip, /**< SCIP data structure */
2275  const char* name, /**< name of constraint handler */
2276  const char* desc, /**< description of constraint handler */
2277  int sepapriority, /**< priority of the constraint handler for separation */
2278  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2279  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2280  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2281  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2282  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2283  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2284  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2285  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
2286  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2287  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2288  SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
2289  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
2290  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2291  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
2292  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
2293  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
2294  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
2295  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
2296  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
2297  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
2298  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
2299  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
2300  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
2301  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2302  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2303  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2304  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2305  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2306  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2307  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
2308  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
2309  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2310  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
2311  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
2312  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
2313  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
2314  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
2315  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
2316  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
2317  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
2318  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
2319  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
2320  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
2321  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2322  );
2323 
2324 /** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2325  * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
2326  * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
2327  * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
2328  * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
2329  * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
2330  * SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and
2331  * SCIPsetConshdlrGetDiveBdChgs().
2332  *
2333  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2334  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2335  *
2336  * @pre This method can be called if SCIP is in one of the following stages:
2337  * - \ref SCIP_STAGE_INIT
2338  * - \ref SCIP_STAGE_PROBLEM
2339  *
2340  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
2341  */
2342 extern
2344  SCIP* scip, /**< SCIP data structure */
2345  SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
2346  const char* name, /**< name of constraint handler */
2347  const char* desc, /**< description of constraint handler */
2348  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2349  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2350  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2351  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2352  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2353  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2354  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2355  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2356  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2357  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2358  );
2359 
2360 /** sets all separation related callbacks/parameters of the constraint handler
2361  *
2362  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2363  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2364  *
2365  * @pre This method can be called if SCIP is in one of the following stages:
2366  * - \ref SCIP_STAGE_INIT
2367  * - \ref SCIP_STAGE_PROBLEM
2368  */
2369 extern
2371  SCIP* scip, /**< SCIP data structure */
2372  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2373  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2374  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2375  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2376  int sepapriority, /**< priority of the constraint handler for separation */
2377  SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
2378  );
2379 
2380 /** sets both the propagation callback and the propagation frequency of the constraint handler
2381  *
2382  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2383  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2384  *
2385  * @pre This method can be called if SCIP is in one of the following stages:
2386  * - \ref SCIP_STAGE_INIT
2387  * - \ref SCIP_STAGE_PROBLEM
2388  */
2389 extern
2391  SCIP* scip, /**< SCIP data structure */
2392  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2393  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2394  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2395  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2396  SCIP_PROPTIMING proptiming /**< positions in the node solving loop where propagation should be executed */
2397  );
2398 
2399 /** sets copy method of both the constraint handler and each associated constraint
2400  *
2401  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2402  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2403  *
2404  * @pre This method can be called if SCIP is in one of the following stages:
2405  * - \ref SCIP_STAGE_INIT
2406  * - \ref SCIP_STAGE_PROBLEM
2407  */
2408 extern
2410  SCIP* scip, /**< SCIP data structure */
2411  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2412  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2413  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
2414  );
2415 
2416 /** sets destructor method of constraint handler
2417  *
2418  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2419  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2420  *
2421  * @pre This method can be called if SCIP is in one of the following stages:
2422  * - \ref SCIP_STAGE_INIT
2423  * - \ref SCIP_STAGE_PROBLEM
2424  */
2425 extern
2427  SCIP* scip, /**< SCIP data structure */
2428  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2429  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
2430  );
2431 
2432 /** sets initialization method of constraint handler
2433  *
2434  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2435  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2436  *
2437  * @pre This method can be called if SCIP is in one of the following stages:
2438  * - \ref SCIP_STAGE_INIT
2439  * - \ref SCIP_STAGE_PROBLEM
2440  */
2441 extern
2443  SCIP* scip, /**< SCIP data structure */
2444  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2445  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
2446  );
2447 
2448 /** sets deinitialization method of constraint handler
2449  *
2450  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2451  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2452  *
2453  * @pre This method can be called if SCIP is in one of the following stages:
2454  * - \ref SCIP_STAGE_INIT
2455  * - \ref SCIP_STAGE_PROBLEM
2456  */
2457 extern
2459  SCIP* scip, /**< SCIP data structure */
2460  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2461  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
2462  );
2463 
2464 /** sets solving process initialization method of constraint handler
2465  *
2466  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2467  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2468  *
2469  * @pre This method can be called if SCIP is in one of the following stages:
2470  * - \ref SCIP_STAGE_INIT
2471  * - \ref SCIP_STAGE_PROBLEM
2472  */
2473 extern
2475  SCIP* scip, /**< SCIP data structure */
2476  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2477  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
2478  );
2479 
2480 /** sets solving process deinitialization method of constraint handler
2481  *
2482  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2483  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2484  *
2485  * @pre This method can be called if SCIP is in one of the following stages:
2486  * - \ref SCIP_STAGE_INIT
2487  * - \ref SCIP_STAGE_PROBLEM
2488  */
2489 extern
2491  SCIP* scip, /**< SCIP data structure */
2492  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2493  SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
2494  );
2495 
2496 /** sets preprocessing initialization method of constraint handler
2497  *
2498  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2499  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2500  *
2501  * @pre This method can be called if SCIP is in one of the following stages:
2502  * - \ref SCIP_STAGE_INIT
2503  * - \ref SCIP_STAGE_PROBLEM
2504  */
2505 extern
2507  SCIP* scip, /**< SCIP data structure */
2508  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2509  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
2510  );
2511 
2512 /** sets preprocessing deinitialization method of constraint handler
2513  *
2514  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2515  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2516  *
2517  * @pre This method can be called if SCIP is in one of the following stages:
2518  * - \ref SCIP_STAGE_INIT
2519  * - \ref SCIP_STAGE_PROBLEM
2520  */
2521 extern
2523  SCIP* scip, /**< SCIP data structure */
2524  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2525  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
2526  );
2527 
2528 /** sets presolving method of constraint handler
2529  *
2530  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2531  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2532  *
2533  * @pre This method can be called if SCIP is in one of the following stages:
2534  * - \ref SCIP_STAGE_INIT
2535  * - \ref SCIP_STAGE_PROBLEM
2536  */
2537 extern
2539  SCIP* scip, /**< SCIP data structure */
2540  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2541  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
2542  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2543  SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
2544  );
2545 
2546 /** sets method of constraint handler to free specific constraint data
2547  *
2548  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2549  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2550  *
2551  * @pre This method can be called if SCIP is in one of the following stages:
2552  * - \ref SCIP_STAGE_INIT
2553  * - \ref SCIP_STAGE_PROBLEM
2554  */
2555 extern
2557  SCIP* scip, /**< SCIP data structure */
2558  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2559  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
2560  );
2561 
2562 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
2563  *
2564  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2565  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2566  *
2567  * @pre This method can be called if SCIP is in one of the following stages:
2568  * - \ref SCIP_STAGE_INIT
2569  * - \ref SCIP_STAGE_PROBLEM
2570  */
2571 extern
2573  SCIP* scip, /**< SCIP data structure */
2574  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2575  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
2576  );
2577 
2578 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
2579  *
2580  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2581  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2582  *
2583  * @pre This method can be called if SCIP is in one of the following stages:
2584  * - \ref SCIP_STAGE_INIT
2585  * - \ref SCIP_STAGE_PROBLEM
2586  */
2587 extern
2589  SCIP* scip, /**< SCIP data structure */
2590  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2591  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
2592  );
2593 
2594 /** sets propagation conflict resolving method of constraint handler
2595  *
2596  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2597  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2598  *
2599  * @pre This method can be called if SCIP is in one of the following stages:
2600  * - \ref SCIP_STAGE_INIT
2601  * - \ref SCIP_STAGE_PROBLEM
2602  */
2603 extern
2605  SCIP* scip, /**< SCIP data structure */
2606  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2607  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
2608  );
2609 
2610 /** sets activation notification method of constraint handler
2611  *
2612  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2613  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2614  *
2615  * @pre This method can be called if SCIP is in one of the following stages:
2616  * - \ref SCIP_STAGE_INIT
2617  * - \ref SCIP_STAGE_PROBLEM
2618  */
2619 extern
2621  SCIP* scip, /**< SCIP data structure */
2622  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2623  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
2624  );
2625 
2626 /** sets deactivation notification method of constraint handler
2627  *
2628  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2629  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2630  *
2631  * @pre This method can be called if SCIP is in one of the following stages:
2632  * - \ref SCIP_STAGE_INIT
2633  * - \ref SCIP_STAGE_PROBLEM
2634  */
2635 extern
2637  SCIP* scip, /**< SCIP data structure */
2638  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2639  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
2640  );
2641 
2642 /** sets enabling notification method of constraint handler
2643  *
2644  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2645  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2646  *
2647  * @pre This method can be called if SCIP is in one of the following stages:
2648  * - \ref SCIP_STAGE_INIT
2649  * - \ref SCIP_STAGE_PROBLEM
2650  */
2651 extern
2653  SCIP* scip, /**< SCIP data structure */
2654  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2655  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
2656  );
2657 
2658 /** sets disabling notification method of constraint handler
2659  *
2660  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2661  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2662  *
2663  * @pre This method can be called if SCIP is in one of the following stages:
2664  * - \ref SCIP_STAGE_INIT
2665  * - \ref SCIP_STAGE_PROBLEM
2666  */
2667 extern
2669  SCIP* scip, /**< SCIP data structure */
2670  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2671  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
2672  );
2673 
2674 /** sets variable deletion method of constraint handler
2675  *
2676  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2677  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2678  *
2679  * @pre This method can be called if SCIP is in one of the following stages:
2680  * - \ref SCIP_STAGE_INIT
2681  * - \ref SCIP_STAGE_PROBLEM
2682  */
2683 extern
2685  SCIP* scip, /**< SCIP data structure */
2686  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2687  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
2688  );
2689 
2690 /** sets constraint display method of constraint handler
2691  *
2692  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2693  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2694  *
2695  * @pre This method can be called if SCIP is in one of the following stages:
2696  * - \ref SCIP_STAGE_INIT
2697  * - \ref SCIP_STAGE_PROBLEM
2698  */
2699 extern
2701  SCIP* scip, /**< SCIP data structure */
2702  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2703  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
2704  );
2705 
2706 /** sets constraint parsing method of constraint handler
2707  *
2708  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2709  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2710  *
2711  * @pre This method can be called if SCIP is in one of the following stages:
2712  * - \ref SCIP_STAGE_INIT
2713  * - \ref SCIP_STAGE_PROBLEM
2714  */
2715 extern
2717  SCIP* scip, /**< SCIP data structure */
2718  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2719  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
2720  );
2721 
2722 /** sets constraint variable getter method of constraint handler
2723  *
2724  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2725  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2726  *
2727  * @pre This method can be called if SCIP is in one of the following stages:
2728  * - \ref SCIP_STAGE_INIT
2729  * - \ref SCIP_STAGE_PROBLEM
2730  */
2731 extern
2733  SCIP* scip, /**< SCIP data structure */
2734  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2735  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
2736  );
2737 
2738 /** sets constraint variable number getter method of constraint handler
2739  *
2740  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2741  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2742  *
2743  * @pre This method can be called if SCIP is in one of the following stages:
2744  * - \ref SCIP_STAGE_INIT
2745  * - \ref SCIP_STAGE_PROBLEM
2746  */
2747 extern
2749  SCIP* scip, /**< SCIP data structure */
2750  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2751  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
2752  );
2753 
2754 /** sets diving enforcement method of constraint handler
2755  *
2756  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2757  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2758  *
2759  * @pre This method can be called if SCIP is in one of the following stages:
2760  * - \ref SCIP_STAGE_INIT
2761  * - \ref SCIP_STAGE_PROBLEM
2762  */
2763 extern
2765  SCIP* scip, /**< SCIP data structure */
2766  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2767  SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
2768  );
2769 
2770 /** returns the constraint handler of the given name, or NULL if not existing */
2771 extern
2773  SCIP* scip, /**< SCIP data structure */
2774  const char* name /**< name of constraint handler */
2775  );
2776 
2777 /** returns the array of currently available constraint handlers */
2778 extern
2780  SCIP* scip /**< SCIP data structure */
2781  );
2782 
2783 /** returns the number of currently available constraint handlers */
2784 extern
2785 int SCIPgetNConshdlrs(
2786  SCIP* scip /**< SCIP data structure */
2787  );
2788 
2789 /** creates a conflict handler and includes it in SCIP
2790  *
2791  * @note method has all conflict handler callbacks as arguments and is thus changed every time a new
2792  * callback is added
2793  * in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions
2794  * if you seek for a method which is less likely to change in future releases
2795  */
2796 extern
2798  SCIP* scip, /**< SCIP data structure */
2799  const char* name, /**< name of conflict handler */
2800  const char* desc, /**< description of conflict handler */
2801  int priority, /**< priority of the conflict handler */
2802  SCIP_DECL_CONFLICTCOPY((*conflictcopy)), /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2803  SCIP_DECL_CONFLICTFREE((*conflictfree)), /**< destructor of conflict handler */
2804  SCIP_DECL_CONFLICTINIT((*conflictinit)), /**< initialize conflict handler */
2805  SCIP_DECL_CONFLICTEXIT((*conflictexit)), /**< deinitialize conflict handler */
2806  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
2807  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
2808  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
2809  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
2810  );
2811 
2812 /** creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental
2813  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
2814  * Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(),
2815  * SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(),
2816  * and SCIPsetConflicthdlrExitsol()
2817  *
2818  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead
2819  */
2820 extern
2822  SCIP* scip, /**< SCIP data structure */
2823  SCIP_CONFLICTHDLR** conflicthdlrptr, /**< reference to a conflict handler pointer, or NULL */
2824  const char* name, /**< name of conflict handler */
2825  const char* desc, /**< description of conflict handler */
2826  int priority, /**< priority of the conflict handler */
2827  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
2828  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
2829  );
2830 
2831 /** set copy method of conflict handler */
2832 extern
2834  SCIP* scip, /**< SCIP data structure */
2835  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2836  SCIP_DECL_CONFLICTCOPY((*conflictcopy)) /**< copy method of conflict handler */
2837  );
2838 
2839 /** set destructor of conflict handler */
2840 extern
2842  SCIP* scip, /**< SCIP data structure */
2843  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2844  SCIP_DECL_CONFLICTFREE((*conflictfree)) /**< destructor of conflict handler */
2845  );
2846 
2847 /** set initialization method of conflict handler */
2848 extern
2850  SCIP* scip, /**< SCIP data structure */
2851  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2852  SCIP_DECL_CONFLICTINIT((*conflictinit)) /**< initialize conflict handler */
2853  );
2854 
2855 /** set deinitialization method of conflict handler */
2856 extern
2858  SCIP* scip, /**< SCIP data structure */
2859  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2860  SCIP_DECL_CONFLICTEXIT((*conflictexit)) /**< deinitialize conflict handler */
2861  );
2862 
2863 /** set solving process initialization method of conflict handler */
2864 extern
2866  SCIP* scip, /**< SCIP data structure */
2867  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2868  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
2869  );
2870 
2871 /** set solving process deinitialization method of conflict handler */
2872 extern
2874  SCIP* scip, /**< SCIP data structure */
2875  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2876  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
2877  );
2878 
2879 /** returns the conflict handler of the given name, or NULL if not existing */
2880 extern
2882  SCIP* scip, /**< SCIP data structure */
2883  const char* name /**< name of conflict handler */
2884  );
2885 
2886 /** returns the array of currently available conflict handlers */
2887 extern
2889  SCIP* scip /**< SCIP data structure */
2890  );
2891 
2892 /** returns the number of currently available conflict handlers */
2893 extern
2895  SCIP* scip /**< SCIP data structure */
2896  );
2897 
2898 /** sets the priority of a conflict handler */
2899 extern
2901  SCIP* scip, /**< SCIP data structure */
2902  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2903  int priority /**< new priority of the conflict handler */
2904  );
2905 
2906 /** creates a presolver and includes it in SCIP
2907  *
2908  * @note method has all presolver callbacks as arguments and is thus changed every time a new
2909  * callback is added
2910  * in future releases; consider using SCIPincludePresolBasic() and setter functions
2911  * if you seek for a method which is less likely to change in future releases
2912  */
2913 extern
2915  SCIP* scip, /**< SCIP data structure */
2916  const char* name, /**< name of presolver */
2917  const char* desc, /**< description of presolver */
2918  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
2919  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
2920  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
2921  SCIP_DECL_PRESOLCOPY ((*presolcopy)), /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
2922  SCIP_DECL_PRESOLFREE ((*presolfree)), /**< destructor of presolver to free user data (called when SCIP is exiting) */
2923  SCIP_DECL_PRESOLINIT ((*presolinit)), /**< initialization method of presolver (called after problem was transformed) */
2924  SCIP_DECL_PRESOLEXIT ((*presolexit)), /**< deinitialization method of presolver (called before transformed problem is freed) */
2925  SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
2926  SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
2927  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
2928  SCIP_PRESOLDATA* presoldata /**< presolver data */
2929  );
2930 
2931 /** Creates a presolver and includes it in SCIP with its fundamental callback. All non-fundamental (or optional)
2932  * callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter
2933  * functions. These are SCIPsetPresolCopy(), SCIPsetPresolFree(), SCIPsetPresolInit(), SCIPsetPresolExit(),
2934  * SCIPsetPresolInitpre(), and SCIPsetPresolExitPre().
2935  *
2936  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePresol() instead
2937  */
2938 extern
2940  SCIP* scip, /**< SCIP data structure */
2941  SCIP_PRESOL** presolptr, /**< reference to presolver, or NULL */
2942  const char* name, /**< name of presolver */
2943  const char* desc, /**< description of presolver */
2944  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
2945  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
2946  SCIP_PRESOLTIMING timing, /**< timing mask of the presolver */
2947  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
2948  SCIP_PRESOLDATA* presoldata /**< presolver data */
2949  );
2950 
2951 /** sets copy method of presolver */
2952 extern
2954  SCIP* scip, /**< SCIP data structure */
2955  SCIP_PRESOL* presol, /**< presolver */
2956  SCIP_DECL_PRESOLCOPY ((*presolcopy)) /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
2957  );
2958 
2959 /** sets destructor method of presolver */
2960 extern
2962  SCIP* scip, /**< SCIP data structure */
2963  SCIP_PRESOL* presol, /**< presolver */
2964  SCIP_DECL_PRESOLFREE ((*presolfree)) /**< destructor of presolver */
2965  );
2966 
2967 /** sets initialization method of presolver */
2968 extern
2970  SCIP* scip, /**< SCIP data structure */
2971  SCIP_PRESOL* presol, /**< presolver */
2972  SCIP_DECL_PRESOLINIT ((*presolinit)) /**< initialize presolver */
2973  );
2974 
2975 /** sets deinitialization method of presolver */
2976 extern
2978  SCIP* scip, /**< SCIP data structure */
2979  SCIP_PRESOL* presol, /**< presolver */
2980  SCIP_DECL_PRESOLEXIT ((*presolexit)) /**< deinitialize presolver */
2981  );
2982 
2983 /** sets solving process initialization method of presolver */
2984 extern
2986  SCIP* scip, /**< SCIP data structure */
2987  SCIP_PRESOL* presol, /**< presolver */
2988  SCIP_DECL_PRESOLINITPRE ((*presolinitpre))/**< solving process initialization method of presolver */
2989  );
2990 
2991 /** sets solving process deinitialization method of presolver */
2993  SCIP* scip, /**< SCIP data structure */
2994  SCIP_PRESOL* presol, /**< presolver */
2995  SCIP_DECL_PRESOLEXITPRE ((*presolexitpre))/**< solving process deinitialization method of presolver */
2996  );
2997 
2998 /** returns the presolver of the given name, or NULL if not existing */
2999 extern
3001  SCIP* scip, /**< SCIP data structure */
3002  const char* name /**< name of presolver */
3003  );
3004 
3005 /** returns the array of currently available presolvers */
3006 extern
3008  SCIP* scip /**< SCIP data structure */
3009  );
3010 
3011 /** returns the number of currently available presolvers */
3012 extern
3013 int SCIPgetNPresols(
3014  SCIP* scip /**< SCIP data structure */
3015  );
3016 
3017 /** sets the priority of a presolver */
3018 extern
3020  SCIP* scip, /**< SCIP data structure */
3021  SCIP_PRESOL* presol, /**< presolver */
3022  int priority /**< new priority of the presolver */
3023  );
3024 
3025 /** creates a relaxation handler and includes it in SCIP
3026  *
3027  * @note method has all relaxation handler callbacks as arguments and is thus changed every time a new
3028  * callback is added
3029  * in future releases; consider using SCIPincludeRelaxBasic() and setter functions
3030  * if you seek for a method which is less likely to change in future releases
3031  */
3032 extern
3034  SCIP* scip, /**< SCIP data structure */
3035  const char* name, /**< name of relaxation handler */
3036  const char* desc, /**< description of relaxation handler */
3037  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3038  int freq, /**< frequency for calling relaxation handler */
3039  SCIP_DECL_RELAXCOPY ((*relaxcopy)), /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3040  SCIP_DECL_RELAXFREE ((*relaxfree)), /**< destructor of relaxation handler */
3041  SCIP_DECL_RELAXINIT ((*relaxinit)), /**< initialize relaxation handler */
3042  SCIP_DECL_RELAXEXIT ((*relaxexit)), /**< deinitialize relaxation handler */
3043  SCIP_DECL_RELAXINITSOL((*relaxinitsol)), /**< solving process initialization method of relaxation handler */
3044  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), /**< solving process deinitialization method of relaxation handler */
3045  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3046  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3047  );
3048 
3049 /** creates a relaxation handler and includes it in SCIP. All non fundamental
3050  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3051  * Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(),
3052  * SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()
3053  *
3054  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeRelax() instead
3055  */
3056 extern
3058  SCIP* scip, /**< SCIP data structure */
3059  SCIP_RELAX** relaxptr, /**< reference to relaxation pointer, or NULL */
3060  const char* name, /**< name of relaxation handler */
3061  const char* desc, /**< description of relaxation handler */
3062  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
3063  int freq, /**< frequency for calling relaxation handler */
3064  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
3065  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
3066  );
3067 
3068 /** sets copy method of relaxation handler */
3069 extern
3071  SCIP* scip, /**< SCIP data structure */
3072  SCIP_RELAX* relax, /**< relaxation handler */
3073  SCIP_DECL_RELAXCOPY ((*relaxcopy)) /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3074  );
3075 
3076 /** sets destructor method of relaxation handler */
3077 extern
3079  SCIP* scip, /**< SCIP data structure */
3080  SCIP_RELAX* relax, /**< relaxation handler */
3081  SCIP_DECL_RELAXFREE ((*relaxfree)) /**< destructor of relaxation handler */
3082  );
3083 
3084 /** sets initialization method of relaxation handler */
3085 extern
3087  SCIP* scip, /**< SCIP data structure */
3088  SCIP_RELAX* relax, /**< relaxation handler */
3089  SCIP_DECL_RELAXINIT ((*relaxinit)) /**< initialize relaxation handler */
3090  );
3091 
3092 /** sets deinitialization method of relaxation handler */
3093 extern
3095  SCIP* scip, /**< SCIP data structure */
3096  SCIP_RELAX* relax, /**< relaxation handler */
3097  SCIP_DECL_RELAXEXIT ((*relaxexit)) /**< deinitialize relaxation handler */
3098  );
3099 
3100 /** sets solving process initialization method of relaxation handler */
3101 extern
3103  SCIP* scip, /**< SCIP data structure */
3104  SCIP_RELAX* relax, /**< relaxation handler */
3105  SCIP_DECL_RELAXINITSOL((*relaxinitsol)) /**< solving process initialization method of relaxation handler */
3106  );
3107 
3108 /** sets solving process deinitialization method of relaxation handler */
3109 extern
3111  SCIP* scip, /**< SCIP data structure */
3112  SCIP_RELAX* relax, /**< relaxation handler */
3113  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)) /**< solving process deinitialization method of relaxation handler */
3114  );
3115 
3116 /** returns the relaxation handler of the given name, or NULL if not existing */
3117 extern
3119  SCIP* scip, /**< SCIP data structure */
3120  const char* name /**< name of relaxation handler */
3121  );
3122 
3123 /** returns the array of currently available relaxation handlers */
3124 extern
3126  SCIP* scip /**< SCIP data structure */
3127  );
3128 
3129 /** returns the number of currently available relaxation handlers */
3130 extern
3131 int SCIPgetNRelaxs(
3132  SCIP* scip /**< SCIP data structure */
3133  );
3134 
3135 /** sets the priority of a relaxation handler*/
3136 extern
3138  SCIP* scip, /**< SCIP data structure */
3139  SCIP_RELAX* relax, /**< relaxation handler */
3140  int priority /**< new priority of the relaxation handler */
3141  );
3142 
3143 /** creates a separator and includes it in SCIP.
3144  *
3145  * @note method has all separator callbacks as arguments and is thus changed every time a new
3146  * callback is added
3147  * in future releases; consider using SCIPincludeSepaBasic() and setter functions
3148  * if you seek for a method which is less likely to change in future releases
3149  */
3150 extern
3152  SCIP* scip, /**< SCIP data structure */
3153  const char* name, /**< name of separator */
3154  const char* desc, /**< description of separator */
3155  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3156  int freq, /**< frequency for calling separator */
3157  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3158  * to best node's dual bound for applying separation */
3159  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3160  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3161  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3162  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
3163  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
3164  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
3165  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
3166  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
3167  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3168  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3169  SCIP_SEPADATA* sepadata /**< separator data */
3170  );
3171 
3172 /** creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3173  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3174  * Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(),
3175  * SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().
3176  *
3177  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeSepa() instead
3178  */
3179 extern
3181  SCIP* scip, /**< SCIP data structure */
3182  SCIP_SEPA** sepa, /**< reference to a separator, or NULL */
3183  const char* name, /**< name of separator */
3184  const char* desc, /**< description of separator */
3185  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3186  int freq, /**< frequency for calling separator */
3187  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3188  * to best node's dual bound for applying separation */
3189  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3190  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3191  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3192  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3193  SCIP_SEPADATA* sepadata /**< separator data */
3194  );
3195 
3196 /** sets copy method of separator */
3197 extern
3199  SCIP* scip, /**< SCIP data structure */
3200  SCIP_SEPA* sepa, /**< separator */
3201  SCIP_DECL_SEPACOPY ((*sepacopy)) /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3202  );
3203 
3204 /** sets destructor method of separator */
3205 extern
3207  SCIP* scip, /**< SCIP data structure */
3208  SCIP_SEPA* sepa, /**< separator */
3209  SCIP_DECL_SEPAFREE ((*sepafree)) /**< destructor of separator */
3210  );
3211 
3212 /** sets initialization method of separator */
3213 extern
3215  SCIP* scip, /**< SCIP data structure */
3216  SCIP_SEPA* sepa, /**< separator */
3217  SCIP_DECL_SEPAINIT ((*sepainit)) /**< initialize separator */
3218  );
3219 
3220 /** sets deinitialization method of separator */
3221 extern
3223  SCIP* scip, /**< SCIP data structure */
3224  SCIP_SEPA* sepa, /**< separator */
3225  SCIP_DECL_SEPAEXIT ((*sepaexit)) /**< deinitialize separator */
3226  );
3227 
3228 /** sets solving process initialization method of separator */
3229 extern
3231  SCIP* scip, /**< SCIP data structure */
3232  SCIP_SEPA* sepa, /**< separator */
3233  SCIP_DECL_SEPAINITSOL ((*sepainitsol)) /**< solving process initialization method of separator */
3234  );
3235 
3236 /** sets solving process deinitialization method of separator */
3237 extern
3239  SCIP* scip, /**< SCIP data structure */
3240  SCIP_SEPA* sepa, /**< separator */
3241  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)) /**< solving process deinitialization method of separator */
3242  );
3243 
3244 /** returns the separator of the given name, or NULL if not existing */
3245 extern
3247  SCIP* scip, /**< SCIP data structure */
3248  const char* name /**< name of separator */
3249  );
3250 
3251 /** returns the array of currently available separators */
3252 extern
3254  SCIP* scip /**< SCIP data structure */
3255  );
3256 
3257 /** returns the number of currently available separators */
3258 extern
3259 int SCIPgetNSepas(
3260  SCIP* scip /**< SCIP data structure */
3261  );
3262 
3263 /** sets the priority of a separator */
3264 extern
3266  SCIP* scip, /**< SCIP data structure */
3267  SCIP_SEPA* sepa, /**< separator */
3268  int priority /**< new priority of the separator */
3269  );
3270 
3271 /** creates a propagator and includes it in SCIP.
3272  *
3273  * @note method has all propagator callbacks as arguments and is thus changed every time a new
3274  * callback is added in future releases; consider using SCIPincludePropBasic() and setter functions
3275  * if you seek for a method which is less likely to change in future releases
3276  */
3277 extern
3279  SCIP* scip, /**< SCIP data structure */
3280  const char* name, /**< name of propagator */
3281  const char* desc, /**< description of propagator */
3282  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3283  int freq, /**< frequency for calling propagator */
3284  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3285  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagator should be executed */
3286  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3287  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3288  SCIP_PRESOLTIMING presoltiming, /**< timing mask of the propagator's presolving method */
3289  SCIP_DECL_PROPCOPY ((*propcopy)), /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3290  SCIP_DECL_PROPFREE ((*propfree)), /**< destructor of propagator */
3291  SCIP_DECL_PROPINIT ((*propinit)), /**< initialize propagator */
3292  SCIP_DECL_PROPEXIT ((*propexit)), /**< deinitialize propagator */
3293  SCIP_DECL_PROPINITPRE ((*propinitpre)), /**< presolving initialization method of propagator */
3294  SCIP_DECL_PROPEXITPRE ((*propexitpre)), /**< presolving deinitialization method of propagator */
3295  SCIP_DECL_PROPINITSOL ((*propinitsol)), /**< solving process initialization method of propagator */
3296  SCIP_DECL_PROPEXITSOL ((*propexitsol)), /**< solving process deinitialization method of propagator */
3297  SCIP_DECL_PROPPRESOL ((*proppresol)), /**< presolving method */
3298  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3299  SCIP_DECL_PROPRESPROP ((*propresprop)), /**< propagation conflict resolving method */
3300  SCIP_PROPDATA* propdata /**< propagator data */
3301  );
3302 
3303 /** creates a propagator and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
3304  * Optional callbacks can be set via specific setter functions, see SCIPsetPropInit(), SCIPsetPropExit(),
3305  * SCIPsetPropCopy(), SCIPsetPropFree(), SCIPsetPropInitsol(), SCIPsetPropExitsol(),
3306  * SCIPsetPropInitpre(), SCIPsetPropExitpre(), SCIPsetPropPresol(), and SCIPsetPropResprop().
3307  *
3308  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeProp() instead
3309  */
3310 extern
3312  SCIP* scip, /**< SCIP data structure */
3313  SCIP_PROP** propptr, /**< reference to a propagator pointer, or NULL */
3314  const char* name, /**< name of propagator */
3315  const char* desc, /**< description of propagator */
3316  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3317  int freq, /**< frequency for calling propagator */
3318  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3319  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagators should be executed */
3320  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3321  SCIP_PROPDATA* propdata /**< propagator data */
3322  );
3323 
3324 /** sets copy method of propagator */
3325 extern
3327  SCIP* scip, /**< SCIP data structure */
3328  SCIP_PROP* prop, /**< propagator */
3329  SCIP_DECL_PROPCOPY ((*propcopy)) /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3330  );
3331 
3332 /** sets destructor method of propagator */
3333 extern
3335  SCIP* scip, /**< SCIP data structure */
3336  SCIP_PROP* prop, /**< propagator */
3337  SCIP_DECL_PROPFREE ((*propfree)) /**< destructor of propagator */
3338  );
3339 
3340 /** sets initialization method of propagator */
3341 extern
3343  SCIP* scip, /**< SCIP data structure */
3344  SCIP_PROP* prop, /**< propagator */
3345  SCIP_DECL_PROPINIT ((*propinit)) /**< initialize propagator */
3346  );
3347 
3348 /** sets deinitialization method of propagator */
3349 extern
3351  SCIP* scip, /**< SCIP data structure */
3352  SCIP_PROP* prop, /**< propagator */
3353  SCIP_DECL_PROPEXIT ((*propexit)) /**< deinitialize propagator */
3354  );
3355 
3356 /** sets solving process initialization method of propagator */
3357 extern
3359  SCIP* scip, /**< SCIP data structure */
3360  SCIP_PROP* prop, /**< propagator */
3361  SCIP_DECL_PROPINITSOL((*propinitsol)) /**< solving process initialization method of propagator */
3362  );
3363 
3364 /** sets solving process deinitialization method of propagator */
3365 extern
3367  SCIP* scip, /**< SCIP data structure */
3368  SCIP_PROP* prop, /**< propagator */
3369  SCIP_DECL_PROPEXITSOL ((*propexitsol)) /**< solving process deinitialization method of propagator */
3370  );
3371 
3372 /** sets preprocessing initialization method of propagator */
3373 extern
3375  SCIP* scip, /**< SCIP data structure */
3376  SCIP_PROP* prop, /**< propagator */
3377  SCIP_DECL_PROPINITPRE((*propinitpre)) /**< preprocessing initialization method of propagator */
3378  );
3379 
3380 /** sets preprocessing deinitialization method of propagator */
3381 extern
3383  SCIP* scip, /**< SCIP data structure */
3384  SCIP_PROP* prop, /**< propagator */
3385  SCIP_DECL_PROPEXITPRE((*propexitpre)) /**< preprocessing deinitialization method of propagator */
3386  );
3387 
3388 /** sets presolving method of propagator */
3389 extern
3391  SCIP* scip, /**< SCIP data structure */
3392  SCIP_PROP* prop, /**< propagator */
3393  SCIP_DECL_PROPPRESOL((*proppresol)), /**< presolving method of propagator */
3394  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3395  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3396  SCIP_PRESOLTIMING presoltiming /**< timing mask of the propagator's presolving method */
3397  );
3398 
3399 /** sets propagation conflict resolving callback of propagator */
3400 extern
3402  SCIP* scip, /**< SCIP data structure */
3403  SCIP_PROP* prop, /**< propagator */
3404  SCIP_DECL_PROPRESPROP ((*propresprop)) /**< propagation conflict resolving callback */
3405  );
3406 
3407 /** returns the propagator of the given name, or NULL if not existing */
3408 extern
3410  SCIP* scip, /**< SCIP data structure */
3411  const char* name /**< name of propagator */
3412  );
3413 
3414 /** returns the array of currently available propagators */
3415 extern
3417  SCIP* scip /**< SCIP data structure */
3418  );
3419 
3420 /** returns the number of currently available propagators */
3421 extern
3422 int SCIPgetNProps(
3423  SCIP* scip /**< SCIP data structure */
3424  );
3425 
3426 /** sets the priority of a propagator */
3427 extern
3429  SCIP* scip, /**< SCIP data structure */
3430  SCIP_PROP* prop, /**< propagator */
3431  int priority /**< new priority of the propagator */
3432  );
3433 
3434 /** sets the presolving priority of a propagator */
3435 extern
3437  SCIP* scip, /**< SCIP data structure */
3438  SCIP_PROP* prop, /**< propagator */
3439  int presolpriority /**< new presol priority of the propagator */
3440  );
3441 
3442 
3443 /** creates a primal heuristic and includes it in SCIP.
3444  *
3445  * @note method has all heuristic callbacks as arguments and is thus changed every time a new
3446  * callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions
3447  * if you seek for a method which is less likely to change in future releases
3448  *
3449  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3450  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3451  *
3452  * @pre This method can be called if @p scip is in one of the following stages:
3453  * - \ref SCIP_STAGE_INIT
3454  * - \ref SCIP_STAGE_PROBLEM
3455  */
3456 extern
3458  SCIP* scip, /**< SCIP data structure */
3459  const char* name, /**< name of primal heuristic */
3460  const char* desc, /**< description of primal heuristic */
3461  char dispchar, /**< display character of primal heuristic */
3462  int priority, /**< priority of the primal heuristic */
3463  int freq, /**< frequency for calling primal heuristic */
3464  int freqofs, /**< frequency offset for calling primal heuristic */
3465  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3466  unsigned int timingmask, /**< positions in the node solving loop where heuristic should be executed;
3467  * see definition of SCIP_HeurTiming for possible values */
3468  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3469  SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
3470  SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
3471  SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
3472  SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
3473  SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
3474  SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
3475  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
3476  SCIP_HEURDATA* heurdata /**< primal heuristic data */
3477  );
3478 
3479 /** creates a primal heuristic and includes it in SCIP with its most fundamental callbacks.
3480  * All non-fundamental (or optional) callbacks
3481  * as, e. g., init and exit callbacks, will be set to NULL.
3482  * Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(),
3483  * SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
3484  *
3485 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead
3486  */
3487 extern
3489  SCIP* scip, /**< SCIP data structure */
3490  SCIP_HEUR** heur, /**< pointer to the heuristic */
3491  const char* name, /**< name of primal heuristic */
3492  const char* desc, /**< description of primal heuristic */
3493  char dispchar, /**< display character of primal heuristic */
3494  int priority, /**< priority of the primal heuristic */
3495  int freq, /**< frequency for calling primal heuristic */
3496  int freqofs, /**< frequency offset for calling primal heuristic */
3497  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3498  unsigned int timingmask, /**< positions in the node solving loop where heuristic should be executed;
3499  * see definition of SCIP_HeurTiming for possible values */
3500  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3501  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
3502  SCIP_HEURDATA* heurdata /**< primal heuristic data */
3503  );
3504 
3505 /** sets copy method of primal heuristic */
3506 extern
3508  SCIP* scip, /**< SCIP data structure */
3509  SCIP_HEUR* heur, /**< primal heuristic */
3510  SCIP_DECL_HEURCOPY ((*heurcopy)) /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
3511  );
3512 
3513 /** sets destructor method of primal heuristic */
3514 extern
3516  SCIP* scip, /**< SCIP data structure */
3517  SCIP_HEUR* heur, /**< primal heuristic */
3518  SCIP_DECL_HEURFREE ((*heurfree)) /**< destructor of primal heuristic */
3519  );
3520 
3521 /** sets initialization method of primal heuristic */
3522 extern
3524  SCIP* scip, /**< SCIP data structure */
3525  SCIP_HEUR* heur, /**< primal heuristic */
3526  SCIP_DECL_HEURINIT ((*heurinit)) /**< initialize primal heuristic */
3527  );
3528 
3529 /** sets deinitialization method of primal heuristic */
3530 extern
3532  SCIP* scip, /**< SCIP data structure */
3533  SCIP_HEUR* heur, /**< primal heuristic */
3534  SCIP_DECL_HEUREXIT ((*heurexit)) /**< deinitialize primal heuristic */
3535  );
3536 
3537 /** sets solving process initialization method of primal heuristic */
3538 extern
3540  SCIP* scip, /**< SCIP data structure */
3541  SCIP_HEUR* heur, /**< primal heuristic */
3542  SCIP_DECL_HEURINITSOL ((*heurinitsol)) /**< solving process initialization method of primal heuristic */
3543  );
3544 
3545 /** sets solving process deinitialization method of primal heuristic */
3546 extern
3548  SCIP* scip, /**< SCIP data structure */
3549  SCIP_HEUR* heur, /**< primal heuristic */
3550  SCIP_DECL_HEUREXITSOL ((*heurexitsol)) /**< solving process deinitialization method of primal heuristic */
3551  );
3552 
3553 /** returns the primal heuristic of the given name, or NULL if not existing */
3554 extern
3556  SCIP* scip, /**< SCIP data structure */
3557  const char* name /**< name of primal heuristic */
3558  );
3559 
3560 /** returns the array of currently available primal heuristics */
3561 extern
3563  SCIP* scip /**< SCIP data structure */
3564  );
3565 
3566 /** returns the number of currently available primal heuristics */
3567 extern
3568 int SCIPgetNHeurs(
3569  SCIP* scip /**< SCIP data structure */
3570  );
3571 
3572 /** sets the priority of a primal heuristic */
3573 extern
3575  SCIP* scip, /**< SCIP data structure */
3576  SCIP_HEUR* heur, /**< primal heuristic */
3577  int priority /**< new priority of the primal heuristic */
3578  );
3579 
3580 /** creates a tree compression and includes it in SCIP.
3581  *
3582  * @note method has all compression callbacks as arguments and is thus changed every time a new
3583  * callback is added in future releases; consider using SCIPincludeComprBasic() and setter functions
3584  * if you seek for a method which is less likely to change in future releases
3585  */
3586 extern
3588  SCIP* scip, /**< SCIP data structure */
3589  const char* name, /**< name of tree compression */
3590  const char* desc, /**< description of tree compression */
3591  int priority, /**< priority of the tree compression */
3592  int minnnodes, /**< minimal number of nodes to call compression */
3593  SCIP_DECL_COMPRCOPY ((*comprcopy)), /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
3594  SCIP_DECL_COMPRFREE ((*comprfree)), /**< destructor of tree compression */
3595  SCIP_DECL_COMPRINIT ((*comprinit)), /**< initialize tree compression */
3596  SCIP_DECL_COMPREXIT ((*comprexit)), /**< deinitialize tree compression */
3597  SCIP_DECL_COMPRINITSOL ((*comprinitsol)), /**< solving process initialization method of tree compression */
3598  SCIP_DECL_COMPREXITSOL ((*comprexitsol)), /**< solving process deinitialization method of tree compression */
3599  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
3600  SCIP_COMPRDATA* comprdata /**< tree compression data */
3601  );
3602 
3603 /** creates a tree compression and includes it in SCIP with its most fundamental callbacks.
3604  * All non-fundamental (or optional) callbacks
3605  * as, e. g., init and exit callbacks, will be set to NULL.
3606  * Optional callbacks can be set via specific setter functions, see SCIPsetComprCopy(), SCIPsetComprFree(),
3607  * SCIPsetComprInit(), SCIPsetComprExit(), SCIPsetComprInitsol(), and SCIPsetComprExitsol()
3608  *
3609  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeCompr() instead
3610  */
3611 extern
3613  SCIP* scip, /**< SCIP data structure */
3614  SCIP_COMPR** compr, /**< pointer to tree compression */
3615  const char* name, /**< name of tree compression */
3616  const char* desc, /**< description of tree compression */
3617  int priority, /**< priority of the tree compression */
3618  int minnnodes, /**< minimal number of nodes to call the compression */
3619  SCIP_DECL_COMPREXEC ((*comprexec)), /**< execution method of tree compression */
3620  SCIP_COMPRDATA* comprdata /**< tree compression data */
3621  );
3622 
3623 /** sets copy method of tree compression */
3624 extern
3626  SCIP* scip, /**< SCIP data structure */
3627  SCIP_COMPR* compr, /**< tree compression */
3628  SCIP_DECL_COMPRCOPY ((*comprcopy)) /**< copy method of tree compression or NULL if you don't want to copy your plugin into sub-SCIPs */
3629  );
3630 
3631 /** sets destructor method of tree compression */
3632 extern
3634  SCIP* scip, /**< SCIP data structure */
3635  SCIP_COMPR* compr, /**< tree compression */
3636  SCIP_DECL_COMPRFREE ((*comprfree)) /**< destructor of tree compression */
3637  );
3638 
3639 /** sets initialization method of tree compression */
3640 extern
3642  SCIP* scip, /**< SCIP data structure */
3643  SCIP_COMPR* compr, /**< tree compression */
3644  SCIP_DECL_COMPRINIT ((*comprinit)) /**< initialize tree compression */
3645  );
3646 
3647 /** sets deinitialization method of tree compression */
3648 extern
3650  SCIP* scip, /**< SCIP data structure */
3651  SCIP_COMPR* compr, /**< tree compression */
3652  SCIP_DECL_COMPREXIT ((*comprexit)) /**< deinitialize tree compression */
3653  );
3654 
3655 /** sets solving process initialization method of tree compression */
3656 extern
3658  SCIP* scip, /**< SCIP data structure */
3659  SCIP_COMPR* compr, /**< tree compression */
3660  SCIP_DECL_COMPRINITSOL ((*comprinitsol)) /**< solving process initialization method of tree compression */
3661  );
3662 
3663 /** sets solving process deinitialization method of tree compression */
3664 extern
3666  SCIP* scip, /**< SCIP data structure */
3667  SCIP_COMPR* compr, /**< tree compression */
3668  SCIP_DECL_COMPREXITSOL ((*comprexitsol)) /**< solving process deinitialization method of tree compression */
3669  );
3670 
3671 /** returns the tree compression of the given name, or NULL if not existing */
3672 extern
3674  SCIP* scip, /**< SCIP data structure */
3675  const char* name /**< name of tree compression */
3676  );
3677 
3678 /** returns the array of currently available tree compression */
3679 extern
3681  SCIP* scip /**< SCIP data structure */
3682  );
3683 
3684 /** returns the number of currently available tree compression */
3685 extern
3686 int SCIPgetNCompr(
3687  SCIP* scip /**< SCIP data structure */
3688  );
3689 
3690 /** set the priority of a tree compression method */
3692  SCIP* scip, /**< SCIP data structure */
3693  SCIP_COMPR* compr, /**< compression */
3694  int priority /**< new priority of the tree compression */
3695  );
3696 
3697 /** create a diving set associated with a primal heuristic. The primal heuristic needs to be included
3698  * before this method can be called. The diveset is installed in the array of divesets of the heuristic
3699  * and can be retrieved later by accessing SCIPheurGetDivesets()
3700  *
3701  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
3702  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3703  *
3704  * @pre This method can be called if @p scip is in one of the following stages:
3705  * - \ref SCIP_STAGE_INIT
3706  * - \ref SCIP_STAGE_PROBLEM
3707  */
3708 extern
3710  SCIP* scip, /**< SCIP data structure */
3711  SCIP_DIVESET** diveset, /**< pointer to created diving heuristic settings, or NULL if not needed */
3712  SCIP_HEUR* heur, /**< primal heuristic to which the diveset belongs */
3713  const char* name, /**< name for the diveset, or NULL if the name of the heuristic should be used */
3714  SCIP_Real minreldepth, /**< minimal relative depth to start diving */
3715  SCIP_Real maxreldepth, /**< maximal relative depth to start diving */
3716  SCIP_Real maxlpiterquot, /**< maximal fraction of diving LP iterations compared to node LP iterations */
3717  SCIP_Real maxdiveubquot, /**< maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound)
3718  * where diving is performed (0.0: no limit) */
3719  SCIP_Real maxdiveavgquot, /**< maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound)
3720  * where diving is performed (0.0: no limit) */
3721  SCIP_Real maxdiveubquotnosol, /**< maximal UBQUOT when no solution was found yet (0.0: no limit) */
3722  SCIP_Real maxdiveavgquotnosol,/**< maximal AVGQUOT when no solution was found yet (0.0: no limit) */
3723  SCIP_Real lpresolvedomchgquot,/**< percentage of immediate domain changes during probing to trigger LP resolve */
3724  int lpsolvefreq, /**< LP solve frequency for (0: only if enough domain reductions are found by propagation)*/
3725  int maxlpiterofs, /**< additional number of allowed LP iterations */
3726  SCIP_Bool backtrack, /**< use one level of backtracking if infeasibility is encountered? */
3727  SCIP_Bool onlylpbranchcands, /**< should only LP branching candidates be considered instead of the slower but
3728  * more general constraint handler diving variable selection? */
3729  SCIP_Bool specificsos1score, /**< should SOS1 variables be scored by the diving heuristics specific score function;
3730  * otherwise use the score function of the SOS1 constraint handler */
3731  SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)) /**< method for candidate score and rounding direction */
3732 
3733  );
3734 
3735 /** creates an event handler and includes it in SCIP
3736  *
3737  * @note method has all event handler callbacks as arguments and is thus changed every time a new
3738  * callback is added in future releases; consider using SCIPincludeEventhdlrBasic() and setter functions
3739  * if you seek for a method which is less likely to change in future releases
3740  */
3741 extern
3743  SCIP* scip, /**< SCIP data structure */
3744  const char* name, /**< name of event handler */
3745  const char* desc, /**< description of event handler */
3746  SCIP_DECL_EVENTCOPY ((*eventcopy)), /**< copy method of event handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3747  SCIP_DECL_EVENTFREE ((*eventfree)), /**< destructor of event handler */
3748  SCIP_DECL_EVENTINIT ((*eventinit)), /**< initialize event handler */
3749  SCIP_DECL_EVENTEXIT ((*eventexit)), /**< deinitialize event handler */
3750  SCIP_DECL_EVENTINITSOL((*eventinitsol)), /**< solving process initialization method of event handler */
3751  SCIP_DECL_EVENTEXITSOL((*eventexitsol)), /**< solving process deinitialization method of event handler */
3752  SCIP_DECL_EVENTDELETE ((*eventdelete)), /**< free specific event data */
3753  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
3754  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
3755  );
3756 
3757 /** creates an event handler and includes it in SCIP with all its non-fundamental callbacks set
3758  * to NULL; if needed, non-fundamental callbacks can be set afterwards via setter functions
3759  * SCIPsetEventhdlrCopy(), SCIPsetEventhdlrFree(), SCIPsetEventhdlrInit(), SCIPsetEventhdlrExit(),
3760  * SCIPsetEventhdlrInitsol(), SCIPsetEventhdlrExitsol(), and SCIPsetEventhdlrDelete()
3761  *
3762  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeEventhdlr() instead
3763  */
3764 extern
3766  SCIP* scip, /**< SCIP data structure */
3767  SCIP_EVENTHDLR** eventhdlrptr, /**< reference to an event handler, or NULL */
3768  const char* name, /**< name of event handler */
3769  const char* desc, /**< description of event handler */
3770  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
3771  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
3772  );
3773 
3774 /** sets copy callback of the event handler */
3775 extern
3777  SCIP* scip, /**< scip instance */
3778  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3779  SCIP_DECL_EVENTCOPY ((*eventcopy)) /**< copy callback of the event handler */
3780  );
3781 
3782 /** sets deinitialization callback of the event handler */
3783 extern
3785  SCIP* scip, /**< scip instance */
3786  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3787  SCIP_DECL_EVENTFREE ((*eventfree)) /**< deinitialization callback of the event handler */
3788  );
3789 
3790 /** sets initialization callback of the event handler */
3791 extern
3793  SCIP* scip, /**< scip instance */
3794  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3795  SCIP_DECL_EVENTINIT ((*eventinit)) /**< initialize event handler */
3796  );
3797 
3798 /** sets deinitialization callback of the event handler */
3799 extern
3801  SCIP* scip, /**< scip instance */
3802  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3803  SCIP_DECL_EVENTEXIT ((*eventexit)) /**< deinitialize event handler */
3804  );
3805 
3806 /** sets solving process initialization callback of the event handler */
3807 extern
3809  SCIP* scip, /**< scip instance */
3810  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3811  SCIP_DECL_EVENTINITSOL((*eventinitsol)) /**< solving process initialization callback of event handler */
3812  );
3813 
3814 /** sets solving process deinitialization callback of the event handler */
3815 extern
3817  SCIP* scip, /**< scip instance */
3818  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3819  SCIP_DECL_EVENTEXITSOL((*eventexitsol)) /**< solving process deinitialization callback of event handler */
3820  );
3821 
3822 /** sets callback of the event handler to free specific event data */
3823 extern
3825  SCIP* scip, /**< scip instance */
3826  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3827  SCIP_DECL_EVENTDELETE ((*eventdelete)) /**< free specific event data */
3828  );
3829 
3830 /** returns the event handler of the given name, or NULL if not existing */
3831 extern
3833  SCIP* scip, /**< SCIP data structure */
3834  const char* name /**< name of event handler */
3835  );
3836 
3837 /** returns the array of currently available event handlers */
3838 extern
3840  SCIP* scip /**< SCIP data structure */
3841  );
3842 
3843 /** returns the number of currently available event handlers */
3844 extern
3845 int SCIPgetNEventhdlrs(
3846  SCIP* scip /**< SCIP data structure */
3847  );
3848 
3849 /** creates a node selector and includes it in SCIP.
3850  *
3851  * @note method has all node selector callbacks as arguments and is thus changed every time a new
3852  * callback is added in future releases; consider using SCIPincludeNodeselBasic() and setter functions
3853  * if you seek for a method which is less likely to change in future releases
3854  */
3855 extern
3857  SCIP* scip, /**< SCIP data structure */
3858  const char* name, /**< name of node selector */
3859  const char* desc, /**< description of node selector */
3860  int stdpriority, /**< priority of the node selector in standard mode */
3861  int memsavepriority, /**< priority of the node selector in memory saving mode */
3862  SCIP_DECL_NODESELCOPY ((*nodeselcopy)), /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
3863  SCIP_DECL_NODESELFREE ((*nodeselfree)), /**< destructor of node selector */
3864  SCIP_DECL_NODESELINIT ((*nodeselinit)), /**< initialize node selector */
3865  SCIP_DECL_NODESELEXIT ((*nodeselexit)), /**< deinitialize node selector */
3866  SCIP_DECL_NODESELINITSOL((*nodeselinitsol)),/**< solving process initialization method of node selector */
3867  SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)),/**< solving process deinitialization method of node selector */
3868  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
3869  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
3870  SCIP_NODESELDATA* nodeseldata /**< node selector data */
3871  );
3872 
3873 /** Creates a node selector and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3874  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3875  * Optional callbacks can be set via specific setter functions, see SCIPsetNodeselCopy(), SCIPsetNodeselFree(),
3876  * SCIPsetNodeselInit(), SCIPsetNodeselExit(), SCIPsetNodeselInitsol(), and SCIPsetNodeselExitsol()
3877  *
3878  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeNodesel() instead
3879  */
3880 extern
3882  SCIP* scip, /**< SCIP data structure */
3883  SCIP_NODESEL** nodesel, /**< reference to a node selector, or NULL */
3884  const char* name, /**< name of node selector */
3885  const char* desc, /**< description of node selector */
3886  int stdpriority, /**< priority of the node selector in standard mode */
3887  int memsavepriority, /**< priority of the node selector in memory saving mode */
3888  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
3889  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
3890  SCIP_NODESELDATA* nodeseldata /**< node selector data */
3891  );
3892 
3893 /** sets copy method of node selector */
3894 extern
3896  SCIP* scip, /**< SCIP data structure */
3897  SCIP_NODESEL* nodesel, /**< node selector */
3898  SCIP_DECL_NODESELCOPY ((*nodeselcopy)) /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
3899  );
3900 
3901 /** sets destructor method of node selector */
3902 extern
3904  SCIP* scip, /**< SCIP data structure */
3905  SCIP_NODESEL* nodesel, /**< node selector */
3906  SCIP_DECL_NODESELFREE ((*nodeselfree)) /**< destructor of node selector */
3907  );
3908 
3909 /** sets initialization method of node selector */
3910 extern
3912  SCIP* scip, /**< SCIP data structure */
3913  SCIP_NODESEL* nodesel, /**< node selector */
3914  SCIP_DECL_NODESELINIT ((*nodeselinit)) /**< initialize node selector */
3915  );
3916 
3917 /** sets deinitialization method of node selector */
3918 extern
3920  SCIP* scip, /**< SCIP data structure */
3921  SCIP_NODESEL* nodesel, /**< node selector */
3922  SCIP_DECL_NODESELEXIT ((*nodeselexit)) /**< deinitialize node selector */
3923  );
3924 
3925 /** sets solving process initialization method of node selector */
3926 extern
3928  SCIP* scip, /**< SCIP data structure */
3929  SCIP_NODESEL* nodesel, /**< node selector */
3930  SCIP_DECL_NODESELINITSOL ((*nodeselinitsol))/**< solving process initialization method of node selector */
3931  );
3932 
3933 /** sets solving process deinitialization method of node selector */
3934 extern
3936  SCIP* scip, /**< SCIP data structure */
3937  SCIP_NODESEL* nodesel, /**< node selector */
3938  SCIP_DECL_NODESELEXITSOL ((*nodeselexitsol))/**< solving process deinitialization method of node selector */
3939  );
3940 
3941 /** returns the node selector of the given name, or NULL if not existing */
3942 extern
3944  SCIP* scip, /**< SCIP data structure */
3945  const char* name /**< name of node selector */
3946  );
3947 
3948 /** returns the array of currently available node selectors */
3949 extern
3951  SCIP* scip /**< SCIP data structure */
3952  );
3953 
3954 /** returns the number of currently available node selectors */
3955 extern
3956 int SCIPgetNNodesels(
3957  SCIP* scip /**< SCIP data structure */
3958  );
3959 
3960 /** sets the priority of a node selector in standard mode */
3961 extern
3963  SCIP* scip, /**< SCIP data structure */
3964  SCIP_NODESEL* nodesel, /**< node selector */
3965  int priority /**< new standard priority of the node selector */
3966  );
3967 
3968 /** sets the priority of a node selector in memory saving mode */
3969 extern
3971  SCIP* scip, /**< SCIP data structure */
3972  SCIP_NODESEL* nodesel, /**< node selector */
3973  int priority /**< new memory saving priority of the node selector */
3974  );
3975 
3976 /** returns the currently used node selector */
3977 extern
3979  SCIP* scip /**< SCIP data structure */
3980  );
3981 
3982 /** creates a branching rule and includes it in SCIP
3983  *
3984  * @note method has all branching rule callbacks as arguments and is thus changed every time a new
3985  * callback is added in future releases; consider using SCIPincludeBranchruleBasic() and setter functions
3986  * if you seek for a method which is less likely to change in future releases
3987  */
3988 extern
3990  SCIP* scip, /**< SCIP data structure */
3991  const char* name, /**< name of branching rule */
3992  const char* desc, /**< description of branching rule */
3993  int priority, /**< priority of the branching rule */
3994  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
3995  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
3996  * compared to best node's dual bound for applying branching rule
3997  * (0.0: only on current best node, 1.0: on all nodes) */
3998  SCIP_DECL_BRANCHCOPY ((*branchcopy)), /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
3999  SCIP_DECL_BRANCHFREE ((*branchfree)), /**< destructor of branching rule */
4000  SCIP_DECL_BRANCHINIT ((*branchinit)), /**< initialize branching rule */
4001  SCIP_DECL_BRANCHEXIT ((*branchexit)), /**< deinitialize branching rule */
4002  SCIP_DECL_BRANCHINITSOL((*branchinitsol)),/**< solving process initialization method of branching rule */
4003  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)),/**< solving process deinitialization method of branching rule */
4004  SCIP_DECL_BRANCHEXECLP((*branchexeclp)), /**< branching execution method for fractional LP solutions */
4005  SCIP_DECL_BRANCHEXECEXT((*branchexecext)),/**< branching execution method for external candidates */
4006  SCIP_DECL_BRANCHEXECPS((*branchexecps)), /**< branching execution method for not completely fixed pseudo solutions */
4007  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
4008  );
4009 
4010 /** creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
4011  * Optional callbacks can be set via specific setter functions, see SCIPsetBranchruleInit(), SCIPsetBranchruleExit(),
4012  * SCIPsetBranchruleCopy(), SCIPsetBranchruleFree(), SCIPsetBranchruleInitsol(), SCIPsetBranchruleExitsol(),
4013  * SCIPsetBranchruleExecLp(), SCIPsetBranchruleExecExt(), and SCIPsetBranchruleExecPs().
4014  *
4015  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeBranchrule() instead
4016  */
4017 extern
4019  SCIP* scip, /**< SCIP data structure */
4020  SCIP_BRANCHRULE** branchruleptr, /**< pointer to branching rule, or NULL */
4021  const char* name, /**< name of branching rule */
4022  const char* desc, /**< description of branching rule */
4023  int priority, /**< priority of the branching rule */
4024  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
4025  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
4026  * compared to best node's dual bound for applying branching rule
4027  * (0.0: only on current best node, 1.0: on all nodes) */
4028  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
4029  );
4030 
4031 /** sets copy method of branching rule */
4032 extern
4034  SCIP* scip, /**< SCIP data structure */
4035  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4036  SCIP_DECL_BRANCHCOPY ((*branchcopy)) /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
4037  );
4038 
4039 /** sets destructor method of branching rule */
4040 extern
4042  SCIP* scip, /**< SCIP data structure */
4043  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4044  SCIP_DECL_BRANCHFREE ((*branchfree)) /**< destructor of branching rule */
4045  );
4046 
4047 /** sets initialization method of branching rule */
4048 extern
4050  SCIP* scip, /**< SCIP data structure */
4051  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4052  SCIP_DECL_BRANCHINIT ((*branchinit)) /**< initialize branching rule */
4053  );
4054 
4055 /** sets deinitialization method of branching rule */
4056 extern
4058  SCIP* scip, /**< SCIP data structure */
4059  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4060  SCIP_DECL_BRANCHEXIT ((*branchexit)) /**< deinitialize branching rule */
4061  );
4062 
4063 /** sets solving process initialization method of branching rule */
4064 extern
4066  SCIP* scip, /**< SCIP data structure */
4067  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4068  SCIP_DECL_BRANCHINITSOL((*branchinitsol)) /**< solving process initialization method of branching rule */
4069  );
4070 
4071 /** sets solving process deinitialization method of branching rule */
4072 extern
4074  SCIP* scip, /**< SCIP data structure */
4075  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4076  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)) /**< solving process deinitialization method of branching rule */
4077  );
4078 
4079 /** sets branching execution method for fractional LP solutions */
4080 extern
4082  SCIP* scip, /**< SCIP data structure */
4083  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4084  SCIP_DECL_BRANCHEXECLP((*branchexeclp)) /**< branching execution method for fractional LP solutions */
4085  );
4086 
4087 /** sets branching execution method for external candidates */
4088 extern
4090  SCIP* scip, /**< SCIP data structure */
4091  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4092  SCIP_DECL_BRANCHEXECEXT((*branchexecext)) /**< branching execution method for external candidates */
4093  );
4094 
4095 /** sets branching execution method for not completely fixed pseudo solutions */
4096 extern
4098  SCIP* scip, /**< SCIP data structure */
4099  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4100  SCIP_DECL_BRANCHEXECPS((*branchexecps)) /**< branching execution method for not completely fixed pseudo solutions */
4101  );
4102 
4103 /** returns the branching rule of the given name, or NULL if not existing */
4104 extern
4106  SCIP* scip, /**< SCIP data structure */
4107  const char* name /**< name of branching rule */
4108  );
4109 
4110 /** returns the array of currently available branching rules */
4111 extern
4113  SCIP* scip /**< SCIP data structure */
4114  );
4115 
4116 /** returns the number of currently available branching rules */
4117 extern
4119  SCIP* scip /**< SCIP data structure */
4120  );
4121 
4122 /** sets the priority of a branching rule */
4123 extern
4125  SCIP* scip, /**< SCIP data structure */
4126  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4127  int priority /**< new priority of the branching rule */
4128  );
4129 
4130 /** sets maximal depth level, up to which this branching rule should be used (-1 for no limit) */
4131 extern
4133  SCIP* scip, /**< SCIP data structure */
4134  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4135  int maxdepth /**< new maxdepth of the branching rule */
4136  );
4137 
4138 /** sets maximal relative distance from current node's dual bound to primal bound for applying branching rule */
4139 extern
4141  SCIP* scip, /**< SCIP data structure */
4142  SCIP_BRANCHRULE* branchrule, /**< branching rule */
4143  SCIP_Real maxbounddist /**< new maxbounddist of the branching rule */
4144  );
4145 
4146 /** creates a display column and includes it in SCIP */
4147 extern
4149  SCIP* scip, /**< SCIP data structure */
4150  const char* name, /**< name of display column */
4151  const char* desc, /**< description of display column */
4152  const char* header, /**< head line of display column */
4153  SCIP_DISPSTATUS dispstatus, /**< display activation status of display column */
4154  SCIP_DECL_DISPCOPY ((*dispcopy)), /**< copy method of display column or NULL if you don't want to copy your plugin into sub-SCIPs */
4155  SCIP_DECL_DISPFREE ((*dispfree)), /**< destructor of display column */
4156  SCIP_DECL_DISPINIT ((*dispinit)), /**< initialize display column */
4157  SCIP_DECL_DISPEXIT ((*dispexit)), /**< deinitialize display column */
4158  SCIP_DECL_DISPINITSOL ((*dispinitsol)), /**< solving process initialization method of display column */
4159  SCIP_DECL_DISPEXITSOL ((*dispexitsol)), /**< solving process deinitialization method of display column */
4160  SCIP_DECL_DISPOUTPUT ((*dispoutput)), /**< output method */
4161  SCIP_DISPDATA* dispdata, /**< display column data */
4162  int width, /**< width of display column (no. of chars used) */
4163  int priority, /**< priority of display column */
4164  int position, /**< relative position of display column */
4165  SCIP_Bool stripline /**< should the column be separated with a line from its right neighbor? */
4166  );
4167 
4168 /** returns the display column of the given name, or NULL if not existing */
4169 extern
4171  SCIP* scip, /**< SCIP data structure */
4172  const char* name /**< name of display column */
4173  );
4174 
4175 /** returns the array of currently available display columns */
4176 extern
4178  SCIP* scip /**< SCIP data structure */
4179  );
4180 
4181 /** returns the number of currently available display columns */
4182 extern
4183 int SCIPgetNDisps(
4184  SCIP* scip /**< SCIP data structure */
4185  );
4186 
4187 /** automatically selects display columns for being shown w.r.t. the display width parameter */
4188 extern
4190  SCIP* scip /**< SCIP data structure */
4191  );
4192 
4193 /** includes an NLPI in SCIP */
4194 extern
4196  SCIP* scip, /**< SCIP data structure */
4197  SCIP_NLPI* nlpi /**< NLPI data structure */
4198  );
4199 
4200 /** returns the NLPI of the given name, or NULL if not existing */
4201 extern
4203  SCIP* scip, /**< SCIP data structure */
4204  const char* name /**< name of NLPI */
4205  );
4206 
4207 /** returns the array of currently available NLPIs (sorted by priority) */
4208 extern
4210  SCIP* scip /**< SCIP data structure */
4211  );
4212 
4213 /** returns the number of currently available NLPIs */
4214 extern
4215 int SCIPgetNNlpis(
4216  SCIP* scip /**< SCIP data structure */
4217  );
4218 
4219 /** sets the priority of an NLPI */
4220 extern
4222  SCIP* scip, /**< SCIP data structure */
4223  SCIP_NLPI* nlpi, /**< NLPI */
4224  int priority /**< new priority of the NLPI */
4225  );
4226 
4227 /** includes information about an external code linked into the SCIP library */
4228 extern
4230  SCIP* scip, /**< SCIP data structure */
4231  const char* name, /**< name of external code */
4232  const char* description /**< description of external code, or NULL */
4233  );
4234 
4235 /** returns an array of names of currently included external codes */
4236 extern
4238  SCIP* scip /**< SCIP data structure */
4239  );
4240 
4241 /** returns an array of the descriptions of currently included external codes
4242  *
4243  * @note some descriptions may be NULL
4244  */
4245 extern
4247  SCIP* scip /**< SCIP data structure */
4248  );
4249 
4250 /** returns the number of currently included information on external codes */
4251 extern
4253  SCIP* scip /**< SCIP data structure */
4254  );
4255 
4256 /** prints information on external codes to a file stream via the message handler system
4257  *
4258  * @note If the message handler is set to a NULL pointer nothing will be printed
4259  */
4260 extern
4262  SCIP* scip, /**< SCIP data structure */
4263  FILE* file /**< output file (or NULL for standard output) */
4264  );
4265 
4266 /**@} */
4267 
4268 
4269 
4270 
4271 /*
4272  * user interactive dialog methods
4273  */
4274 
4275 /**@name User Interactive Dialog Methods */
4276 /**@{ */
4277 
4278 /** creates and includes dialog
4279  *
4280  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4281  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4282  */
4283 extern
4285  SCIP* scip, /**< SCIP data structure */
4286  SCIP_DIALOG** dialog, /**< pointer to store the dialog */
4287  SCIP_DECL_DIALOGCOPY ((*dialogcopy)), /**< copy method of dialog or NULL if you don't want to copy your plugin into sub-SCIPs */
4288  SCIP_DECL_DIALOGEXEC ((*dialogexec)), /**< execution method of dialog */
4289  SCIP_DECL_DIALOGDESC ((*dialogdesc)), /**< description output method of dialog, or NULL */
4290  SCIP_DECL_DIALOGFREE ((*dialogfree)), /**< destructor of dialog to free user data, or NULL */
4291  const char* name, /**< name of dialog: command name appearing in parent's dialog menu */
4292  const char* desc, /**< description of dialog used if description output method is NULL */
4293  SCIP_Bool issubmenu, /**< is the dialog a submenu? */
4294  SCIP_DIALOGDATA* dialogdata /**< user defined dialog data */
4295  );
4296 
4297 /** returns if the dialog already exists
4298  *
4299  * @return TRUE is returned if the dialog exits, otherwise FALSE.
4300  */
4301 extern
4303  SCIP* scip, /**< SCIP data structure */
4304  SCIP_DIALOG* dialog /**< dialog */
4305  );
4306 
4307 /** captures a dialog
4308  *
4309  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4310  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4311  */
4312 extern
4314  SCIP* scip, /**< SCIP data structure */
4315  SCIP_DIALOG* dialog /**< dialog */
4316  );
4317 
4318 /** releases a dialog
4319  *
4320  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4321  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4322  */
4323 extern
4325  SCIP* scip, /**< SCIP data structure */
4326  SCIP_DIALOG** dialog /**< pointer to the dialog */
4327  );
4328 
4329 /** makes given dialog the root dialog of SCIP's interactive user shell; captures dialog and releases former root dialog
4330  *
4331  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4332  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4333  */
4334 extern
4336  SCIP* scip, /**< SCIP data structure */
4337  SCIP_DIALOG* dialog /**< dialog to be the root */
4338  );
4339 
4340 /** returns the root dialog of SCIP's interactive user shell
4341  *
4342  * @return the root dialog of SCIP's interactive user shell is returned.
4343  */
4344 extern
4346  SCIP* scip /**< SCIP data structure */
4347  );
4348 
4349 /** adds a sub dialog to the given dialog as menu entry and captures it
4350  *
4351  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4352  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4353  */
4354 extern
4356  SCIP* scip, /**< SCIP data structure */
4357  SCIP_DIALOG* dialog, /**< dialog to extend, or NULL for root dialog */
4358  SCIP_DIALOG* subdialog /**< subdialog to add as menu entry in dialog */
4359  );
4360 
4361 /** adds a single line of input which is treated as if the user entered the command line
4362  *
4363  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4364  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4365  */
4366 extern
4368  SCIP* scip, /**< SCIP data structure */
4369  const char* inputline /**< input line to add */
4370  );
4371 
4372 /** adds a single line of input to the command history which can be accessed with the cursor keys
4373  *
4374  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4375  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4376  */
4377 extern
4379  SCIP* scip, /**< SCIP data structure */
4380  const char* inputline /**< input line to add */
4381  );
4382 
4383 /** starts interactive mode of SCIP by executing the root dialog
4384  *
4385  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4386  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4387  *
4388  * @pre This method can be called if @p scip is in one of the following stages:
4389  * - \ref SCIP_STAGE_INIT
4390  * - \ref SCIP_STAGE_FREE
4391  *
4392  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the
4393  * interactive shell was closed:
4394  * - \ref SCIP_STAGE_PROBLEM if the interactive shell was closed after the problem was created
4395  * - \ref SCIP_STAGE_TRANSFORMED if the interactive shell was closed after the problem was transformed
4396  * - \ref SCIP_STAGE_PRESOLVING if the interactive shell was closed during presolving
4397  * - \ref SCIP_STAGE_PRESOLVED if the interactive shell was closed after presolve
4398  * - \ref SCIP_STAGE_SOLVING if the interactive shell was closed during the tree search
4399  * - \ref SCIP_STAGE_SOLVED if the interactive shell was closed after the problem was solved
4400  * - \ref SCIP_STAGE_FREE if the interactive shell was closed after the problem was freed
4401  *
4402  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
4403  */
4404 extern
4406  SCIP* scip /**< SCIP data structure */
4407  );
4408 
4409 /**@} */
4410 
4411 /*
4412  * global problem methods
4413  */
4414 
4415 /**@name Global Problem Methods */
4416 /**@{ */
4417 
4418 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
4419  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
4420  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
4421  *
4422  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4423  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4424  *
4425  * @pre This method can be called if @p scip is in one of the following stages:
4426  * - \ref SCIP_STAGE_INIT
4427  * - \ref SCIP_STAGE_PROBLEM
4428  * - \ref SCIP_STAGE_TRANSFORMED
4429  * - \ref SCIP_STAGE_PRESOLVING
4430  * - \ref SCIP_STAGE_PRESOLVED
4431  * - \ref SCIP_STAGE_SOLVING
4432  * - \ref SCIP_STAGE_SOLVED
4433  * - \ref SCIP_STAGE_FREE
4434  *
4435  * @post After calling this method, \SCIP reaches the following stage:
4436  * - \ref SCIP_STAGE_PROBLEM
4437  */
4438 extern
4440  SCIP* scip, /**< SCIP data structure */
4441  const char* name, /**< problem name */
4442  SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
4443  SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
4444  SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
4445  SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
4446  SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
4447  SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
4448  SCIP_PROBDATA* probdata /**< user problem data set by the reader */
4449  );
4450 
4451 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
4452  * all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(),
4453  * SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and
4454  * SCIPsetProbCopy()
4455  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
4456  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
4457  *
4458  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4459  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4460  *
4461  * @pre This method can be called if @p scip is in one of the following stages:
4462  * - \ref SCIP_STAGE_INIT
4463  * - \ref SCIP_STAGE_PROBLEM
4464  * - \ref SCIP_STAGE_TRANSFORMED
4465  * - \ref SCIP_STAGE_PRESOLVING
4466  * - \ref SCIP_STAGE_PRESOLVED
4467  * - \ref SCIP_STAGE_SOLVING
4468  * - \ref SCIP_STAGE_SOLVED
4469  * - \ref SCIP_STAGE_FREE
4470  *
4471  * @post After calling this method, \SCIP reaches the following stage:
4472  * - \ref SCIP_STAGE_PROBLEM
4473  */
4474 extern
4476  SCIP* scip, /**< SCIP data structure */
4477  const char* name /**< problem name */
4478  );
4479 
4480 /** sets callback to free user data of original problem
4481  *
4482  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4483  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4484  *
4485  * @pre This method can be called if @p scip is in one of the following stages:
4486  * - \ref SCIP_STAGE_PROBLEM
4487  */
4489  SCIP* scip, /**< SCIP data structure */
4490  SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
4491  );
4492 
4493 /** sets callback to create user data of transformed problem by transforming original user data
4494  *
4495  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4496  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4497  *
4498  * @pre This method can be called if @p scip is in one of the following stages:
4499  * - \ref SCIP_STAGE_PROBLEM
4500  */
4501 extern
4503  SCIP* scip, /**< SCIP data structure */
4504  SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
4505  );
4506 
4507 /** sets callback to free user data of transformed problem
4508  *
4509  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4510  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4511  *
4512  * @pre This method can be called if @p scip is in one of the following stages:
4513  * - \ref SCIP_STAGE_PROBLEM
4514  */
4515 extern
4517  SCIP* scip, /**< SCIP data structure */
4518  SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
4519  );
4520 
4521 /** sets solving process initialization callback of transformed data
4522  *
4523  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4524  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4525  *
4526  * @pre This method can be called if @p scip is in one of the following stages:
4527  * - \ref SCIP_STAGE_PROBLEM
4528  */
4529 extern
4531  SCIP* scip, /**< SCIP data structure */
4532  SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization method of transformed data */
4533  );
4534 
4535 /** sets solving process deinitialization callback of transformed data
4536  *
4537  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4538  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4539  *
4540  * @pre This method can be called if @p scip is in one of the following stages:
4541  * - \ref SCIP_STAGE_PROBLEM
4542  */
4543 extern
4545  SCIP* scip, /**< SCIP data structure */
4546  SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization method of transformed data */
4547  );
4548 
4549 /** sets callback to copy user data to a subscip
4550  *
4551  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4552  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4553  *
4554  * @pre This method can be called if @p scip is in one of the following stages:
4555  * - \ref SCIP_STAGE_PROBLEM
4556  */
4557 extern
4559  SCIP* scip, /**< SCIP data structure */
4560  SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
4561  );
4562 
4563 /** reads problem from file and initializes all solving data structures
4564  *
4565  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4566  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4567  *
4568  * @pre This method can be called if @p scip is in one of the following stages:
4569  * - \ref SCIP_STAGE_INIT
4570  * - \ref SCIP_STAGE_PROBLEM
4571  * - \ref SCIP_STAGE_TRANSFORMED
4572  * - \ref SCIP_STAGE_INITPRESOLVE
4573  * - \ref SCIP_STAGE_PRESOLVING
4574  * - \ref SCIP_STAGE_EXITPRESOLVE
4575  * - \ref SCIP_STAGE_PRESOLVED
4576  * - \ref SCIP_STAGE_SOLVING
4577  * - \ref SCIP_STAGE_EXITSOLVE
4578  *
4579  * @post After the method was called, \SCIP is in one of the following stages:
4580  * - \ref SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
4581  * - \ref SCIP_STAGE_PROBLEM if the problem file was successfully read
4582  */
4583 extern
4585  SCIP* scip, /**< SCIP data structure */
4586  const char* filename, /**< problem file name */
4587  const char* extension /**< extension of the desired file reader,
4588  * or NULL if file extension should be used */
4589  );
4590 
4591 /** writes original problem to file
4592  *
4593  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4594  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4595  *
4596  * @pre This method can be called if @p scip is in one of the following stages:
4597  * - \ref SCIP_STAGE_PROBLEM
4598  * - \ref SCIP_STAGE_TRANSFORMING
4599  * - \ref SCIP_STAGE_TRANSFORMED
4600  * - \ref SCIP_STAGE_INITPRESOLVE
4601  * - \ref SCIP_STAGE_PRESOLVING
4602  * - \ref SCIP_STAGE_EXITPRESOLVE
4603  * - \ref SCIP_STAGE_PRESOLVED
4604  * - \ref SCIP_STAGE_INITSOLVE
4605  * - \ref SCIP_STAGE_SOLVING
4606  * - \ref SCIP_STAGE_SOLVED
4607  * - \ref SCIP_STAGE_EXITSOLVE
4608  * - \ref SCIP_STAGE_FREETRANS
4609  */
4610 extern
4612  SCIP* scip, /**< SCIP data structure */
4613  const char* filename, /**< output file (or NULL for standard output) */
4614  const char* extension, /**< extension of the desired file reader,
4615  * or NULL if file extension should be used */
4616  SCIP_Bool genericnames /**< use generic variable and constraint names? */
4617  );
4618 
4619 /** writes transformed problem which are valid in the current node to file
4620  *
4621  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4622  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4623  *
4624  * @pre This method can be called if @p scip is in one of the following stages:
4625  * - \ref SCIP_STAGE_TRANSFORMED
4626  * - \ref SCIP_STAGE_INITPRESOLVE
4627  * - \ref SCIP_STAGE_PRESOLVING
4628  * - \ref SCIP_STAGE_EXITPRESOLVE
4629  * - \ref SCIP_STAGE_PRESOLVED
4630  * - \ref SCIP_STAGE_INITSOLVE
4631  * - \ref SCIP_STAGE_SOLVING
4632  * - \ref SCIP_STAGE_SOLVED
4633  * - \ref SCIP_STAGE_EXITSOLVE
4634  *
4635  * @note If you want the write all constraints (including the once which are redundant for example), you need to set
4636  * the parameter <write/allconss> to TRUE
4637  */
4638 extern
4640  SCIP* scip, /**< SCIP data structure */
4641  const char* filename, /**< output file (or NULL for standard output) */
4642  const char* extension, /**< extension of the desired file reader,
4643  * or NULL if file extension should be used */
4644  SCIP_Bool genericnames /**< using generic variable and constraint names? */
4645  );
4646 
4647 /** frees problem and solution process data
4648  *
4649  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4650  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4651  *
4652  * @pre This method can be called if @p scip is in one of the following stages:
4653  * - \ref SCIP_STAGE_INIT
4654  * - \ref SCIP_STAGE_PROBLEM
4655  * - \ref SCIP_STAGE_TRANSFORMED
4656  * - \ref SCIP_STAGE_PRESOLVING
4657  * - \ref SCIP_STAGE_PRESOLVED
4658  * - \ref SCIP_STAGE_SOLVING
4659  * - \ref SCIP_STAGE_SOLVED
4660  * - \ref SCIP_STAGE_FREE
4661  *
4662  * @post After this method was called, SCIP is in the following stage:
4663  * - \ref SCIP_STAGE_INIT
4664  */
4665 extern
4667  SCIP* scip /**< SCIP data structure */
4668  );
4669 
4670 /** permutes parts of the problem data structure
4671  *
4672  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4673  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4674  *
4675  * @pre This method can be called if @p scip is in one of the following stages:
4676  * - \ref SCIP_STAGE_PROBLEM
4677  * - \ref SCIP_STAGE_TRANSFORMED
4678  */
4679 extern
4681  SCIP* scip, /**< SCIP data structure */
4682  unsigned int randseed, /**< seed value for random generator */
4683  SCIP_Bool permuteconss, /**< should the list of constraints in each constraint handler be permuted? */
4684  SCIP_Bool permutebinvars, /**< should the list of binary variables be permuted? */
4685  SCIP_Bool permuteintvars, /**< should the list of integer variables be permuted? */
4686  SCIP_Bool permuteimplvars, /**< should the list of implicit integer variables be permuted? */
4687  SCIP_Bool permutecontvars /**< should the list of continuous integer variables be permuted? */
4688  );
4689 
4690 /** gets user problem data
4691  *
4692  * @return a SCIP_PROBDATA pointer, or NULL if no problem data was allocated
4693  *
4694  * @pre This method can be called if @p scip is in one of the following stages:
4695  * - \ref SCIP_STAGE_PROBLEM
4696  * - \ref SCIP_STAGE_TRANSFORMING
4697  * - \ref SCIP_STAGE_TRANSFORMED
4698  * - \ref SCIP_STAGE_INITPRESOLVE
4699  * - \ref SCIP_STAGE_PRESOLVING
4700  * - \ref SCIP_STAGE_EXITPRESOLVE
4701  * - \ref SCIP_STAGE_PRESOLVED
4702  * - \ref SCIP_STAGE_INITSOLVE
4703  * - \ref SCIP_STAGE_SOLVING
4704  * - \ref SCIP_STAGE_SOLVED
4705  * - \ref SCIP_STAGE_EXITSOLVE
4706  * - \ref SCIP_STAGE_FREETRANS
4707  */
4708 extern
4710  SCIP* scip /**< SCIP data structure */
4711  );
4712 
4713 /** sets user problem data
4714  *
4715  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4716  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4717  *
4718  * @pre This method can be called if @p scip is in one of the following stages:
4719  * - \ref SCIP_STAGE_PROBLEM
4720  * - \ref SCIP_STAGE_TRANSFORMING
4721  * - \ref SCIP_STAGE_TRANSFORMED
4722  * - \ref SCIP_STAGE_INITPRESOLVE
4723  * - \ref SCIP_STAGE_PRESOLVING
4724  * - \ref SCIP_STAGE_EXITPRESOLVE
4725  * - \ref SCIP_STAGE_PRESOLVED
4726  * - \ref SCIP_STAGE_INITSOLVE
4727  * - \ref SCIP_STAGE_SOLVING
4728  * - \ref SCIP_STAGE_SOLVED
4729  * - \ref SCIP_STAGE_EXITSOLVE
4730  * - \ref SCIP_STAGE_FREETRANS
4731  */
4732 extern
4734  SCIP* scip, /**< SCIP data structure */
4735  SCIP_PROBDATA* probdata /**< user problem data to use */
4736  );
4737 
4738 /** returns name of the current problem instance
4739  *
4740  * @return name of the current problem instance
4741  *
4742  * @pre This method can be called if @p scip is in one of the following stages:
4743  * - \ref SCIP_STAGE_PROBLEM
4744  * - \ref SCIP_STAGE_TRANSFORMING
4745  * - \ref SCIP_STAGE_TRANSFORMED
4746  * - \ref SCIP_STAGE_INITPRESOLVE
4747  * - \ref SCIP_STAGE_PRESOLVING
4748  * - \ref SCIP_STAGE_EXITPRESOLVE
4749  * - \ref SCIP_STAGE_PRESOLVED
4750  * - \ref SCIP_STAGE_INITSOLVE
4751  * - \ref SCIP_STAGE_SOLVING
4752  * - \ref SCIP_STAGE_SOLVED
4753  * - \ref SCIP_STAGE_EXITSOLVE
4754  * - \ref SCIP_STAGE_FREETRANS
4755  */
4756 extern
4757 const char* SCIPgetProbName(
4758  SCIP* scip /**< SCIP data structure */
4759  );
4760 
4761 /** sets name of the current problem instance
4762  *
4763  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4764  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4765  *
4766  * @pre This method can be called if @p scip is in one of the following stages:
4767  * - \ref SCIP_STAGE_PROBLEM
4768  * - \ref SCIP_STAGE_TRANSFORMING
4769  * - \ref SCIP_STAGE_TRANSFORMED
4770  * - \ref SCIP_STAGE_INITPRESOLVE
4771  * - \ref SCIP_STAGE_PRESOLVING
4772  * - \ref SCIP_STAGE_EXITPRESOLVE
4773  * - \ref SCIP_STAGE_PRESOLVED
4774  * - \ref SCIP_STAGE_INITSOLVE
4775  * - \ref SCIP_STAGE_SOLVING
4776  * - \ref SCIP_STAGE_SOLVED
4777  * - \ref SCIP_STAGE_EXITSOLVE
4778  * - \ref SCIP_STAGE_FREETRANS
4779  */
4780 extern
4782  SCIP* scip, /**< SCIP data structure */
4783  const char* name /**< name to be set */
4784  );
4785 
4786 /** returns objective sense of original problem
4787  *
4788  * @return objective sense of original problem
4789  *
4790  * @pre This method can be called if @p scip is in one of the following stages:
4791  * - \ref SCIP_STAGE_PROBLEM
4792  * - \ref SCIP_STAGE_TRANSFORMING
4793  * - \ref SCIP_STAGE_TRANSFORMED
4794  * - \ref SCIP_STAGE_INITPRESOLVE
4795  * - \ref SCIP_STAGE_PRESOLVING
4796  * - \ref SCIP_STAGE_EXITPRESOLVE
4797  * - \ref SCIP_STAGE_PRESOLVED
4798  * - \ref SCIP_STAGE_INITSOLVE
4799  * - \ref SCIP_STAGE_SOLVING
4800  * - \ref SCIP_STAGE_SOLVED
4801  * - \ref SCIP_STAGE_EXITSOLVE
4802  * - \ref SCIP_STAGE_FREETRANS
4803  */
4804 extern
4806  SCIP* scip /**< SCIP data structure */
4807  );
4808 
4809 /** sets objective sense of problem
4810  *
4811  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4812  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4813  *
4814  * @pre This method can be called if @p scip is in one of the following stages:
4815  * - \ref SCIP_STAGE_PROBLEM
4816  */
4817 extern
4819  SCIP* scip, /**< SCIP data structure */
4820  SCIP_OBJSENSE objsense /**< new objective sense */
4821  );
4822 
4823 /** adds offset of objective function
4824  *
4825  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4826  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4827  *
4828  * @pre This method can be called if @p scip is in one of the following stages:
4829  * - \ref SCIP_STAGE_PRESOLVING
4830  */
4831 extern
4833  SCIP* scip, /**< SCIP data structure */
4834  SCIP_Real addval /**< value to add to objective offset */
4835  );
4836 
4837 /** adds offset of objective function to original problem and to all existing solution in original space
4838  *
4839  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4840  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4841  *
4842  * @pre This method can be called if @p scip is in one of the following stages:
4843  * - \ref SCIP_STAGE_PROBLEM
4844  */
4845 extern
4847  SCIP* scip, /**< SCIP data structure */
4848  SCIP_Real addval /**< value to add to objective offset */
4849  );
4850 
4851 /** returns the objective offset of the original problem
4852  *
4853  * @return the objective offset of the original problem
4854  *
4855  * @pre This method can be called if @p scip is in one of the following stages:
4856  * - \ref SCIP_STAGE_PROBLEM
4857  * - \ref SCIP_STAGE_TRANSFORMING
4858  * - \ref SCIP_STAGE_TRANSFORMED
4859  * - \ref SCIP_STAGE_INITPRESOLVE
4860  * - \ref SCIP_STAGE_PRESOLVING
4861  * - \ref SCIP_STAGE_EXITPRESOLVE
4862  * - \ref SCIP_STAGE_PRESOLVED
4863  * - \ref SCIP_STAGE_INITSOLVE
4864  * - \ref SCIP_STAGE_SOLVING
4865  * - \ref SCIP_STAGE_SOLVED
4866  */
4867 extern
4869  SCIP* scip /**< SCIP data structure */
4870  );
4871 
4872 /** returns the objective scale of the original problem
4873  *
4874  * @return the objective scale of the original problem
4875  *
4876  * @pre This method can be called if @p scip is in one of the following stages:
4877  * - \ref SCIP_STAGE_PROBLEM
4878  * - \ref SCIP_STAGE_TRANSFORMING
4879  * - \ref SCIP_STAGE_TRANSFORMED
4880  * - \ref SCIP_STAGE_INITPRESOLVE
4881  * - \ref SCIP_STAGE_PRESOLVING
4882  * - \ref SCIP_STAGE_EXITPRESOLVE
4883  * - \ref SCIP_STAGE_PRESOLVED
4884  * - \ref SCIP_STAGE_INITSOLVE
4885  * - \ref SCIP_STAGE_SOLVING
4886  * - \ref SCIP_STAGE_SOLVED
4887  */
4888 extern
4890  SCIP* scip /**< SCIP data structure */
4891  );
4892 
4893 /** returns the objective offset of the transformed problem
4894  *
4895  * @return the objective offset of the transformed problem
4896  *
4897  * @pre This method can be called if @p scip is in one of the following stages:
4898  * - \ref SCIP_STAGE_TRANSFORMED
4899  * - \ref SCIP_STAGE_INITPRESOLVE
4900  * - \ref SCIP_STAGE_PRESOLVING
4901  * - \ref SCIP_STAGE_EXITPRESOLVE
4902  * - \ref SCIP_STAGE_PRESOLVED
4903  * - \ref SCIP_STAGE_INITSOLVE
4904  * - \ref SCIP_STAGE_SOLVING
4905  * - \ref SCIP_STAGE_SOLVED
4906  */
4907 extern
4909  SCIP* scip /**< SCIP data structure */
4910  );
4911 
4912 /** returns the objective scale of the transformed problem
4913  *
4914  * @return the objective scale of the transformed problem
4915  *
4916  * @pre This method can be called if @p scip is in one of the following stages:
4917  * - \ref SCIP_STAGE_TRANSFORMED
4918  * - \ref SCIP_STAGE_INITPRESOLVE
4919  * - \ref SCIP_STAGE_PRESOLVING
4920  * - \ref SCIP_STAGE_EXITPRESOLVE
4921  * - \ref SCIP_STAGE_PRESOLVED
4922  * - \ref SCIP_STAGE_INITSOLVE
4923  * - \ref SCIP_STAGE_SOLVING
4924  * - \ref SCIP_STAGE_SOLVED
4925  */
4926 extern
4928  SCIP* scip /**< SCIP data structure */
4929  );
4930 
4931 /** sets limit on objective function, such that only solutions better than this limit are accepted
4932  *
4933  * @note SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune
4934  * all branch-and-bound nodes with dual bound equal or worse to the objective limit.
4935  * However, SCIP will also collect solutions with objective value worse than the objective limit and
4936  * use them to run improvement heuristics on them.
4937  * @note If SCIP can prove that there exists no solution with a strictly better objective value, the solving status
4938  * will normally be infeasible (the objective limit is interpreted as part of the problem).
4939  * The only exception is that by chance, SCIP found a solution with the same objective value and thus
4940  * proved the optimality of this solution, resulting in solution status optimal.
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  * @pre This method can be called if @p scip is in one of the following stages:
4946  * - \ref SCIP_STAGE_PROBLEM
4947  * - \ref SCIP_STAGE_TRANSFORMED
4948  * - \ref SCIP_STAGE_INITPRESOLVE
4949  * - \ref SCIP_STAGE_PRESOLVING
4950  * - \ref SCIP_STAGE_EXITPRESOLVE
4951  * - \ref SCIP_STAGE_PRESOLVED
4952  * - \ref SCIP_STAGE_SOLVING
4953  */
4954 extern
4956  SCIP* scip, /**< SCIP data structure */
4957  SCIP_Real objlimit /**< new primal objective limit */
4958  );
4959 
4960 /** returns current limit on objective function
4961  *
4962  * @return the current objective limit of the original problem
4963  *
4964  * @pre This method can be called if @p scip is in one of the following stages:
4965  * - \ref SCIP_STAGE_PROBLEM
4966  * - \ref SCIP_STAGE_TRANSFORMING
4967  * - \ref SCIP_STAGE_TRANSFORMED
4968  * - \ref SCIP_STAGE_INITPRESOLVE
4969  * - \ref SCIP_STAGE_PRESOLVING
4970  * - \ref SCIP_STAGE_EXITPRESOLVE
4971  * - \ref SCIP_STAGE_PRESOLVED
4972  * - \ref SCIP_STAGE_INITSOLVE
4973  * - \ref SCIP_STAGE_SOLVING
4974  * - \ref SCIP_STAGE_SOLVED
4975  */
4976 extern
4978  SCIP* scip /**< SCIP data structure */
4979  );
4980 
4981 /** informs SCIP, that the objective value is always integral in every feasible solution
4982  *
4983  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4984  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4985  *
4986  * @pre This method can be called if @p scip is in one of the following stages:
4987  * - \ref SCIP_STAGE_PROBLEM
4988  * - \ref SCIP_STAGE_TRANSFORMING
4989  * - \ref SCIP_STAGE_INITPRESOLVE
4990  * - \ref SCIP_STAGE_EXITPRESOLVE
4991  * - \ref SCIP_STAGE_SOLVING
4992  */
4993 extern
4995  SCIP* scip /**< SCIP data structure */
4996  );
4997 
4998 /** returns whether the objective value is known to be integral in every feasible solution
4999  *
5000  * @return TRUE, if objective value is known to be always integral, otherwise FALSE
5001  *
5002  * @pre This method can be called if @p scip is in one of the following stages:
5003  * - \ref SCIP_STAGE_PROBLEM
5004  * - \ref SCIP_STAGE_TRANSFORMING
5005  * - \ref SCIP_STAGE_INITPRESOLVE
5006  * - \ref SCIP_STAGE_PRESOLVING
5007  * - \ref SCIP_STAGE_EXITPRESOLVE
5008  * - \ref SCIP_STAGE_PRESOLVED
5009  * - \ref SCIP_STAGE_SOLVING
5010  */
5011 extern
5013  SCIP* scip /**< SCIP data structure */
5014  );
5015 
5016 /** returns the Euclidean norm of the objective function vector (available only for transformed problem)
5017  *
5018  * @return the Euclidean norm of the transformed objective function vector
5019  *
5020  * @pre This method can be called if @p scip is in one of the following stages:
5021  * - \ref SCIP_STAGE_TRANSFORMED
5022  * - \ref SCIP_STAGE_INITPRESOLVE
5023  * - \ref SCIP_STAGE_PRESOLVING
5024  * - \ref SCIP_STAGE_EXITPRESOLVE
5025  * - \ref SCIP_STAGE_PRESOLVED
5026  * - \ref SCIP_STAGE_INITSOLVE
5027  * - \ref SCIP_STAGE_SOLVING
5028  * - \ref SCIP_STAGE_SOLVED
5029  * - \ref SCIP_STAGE_EXITSOLVE
5030  */
5031 extern
5033  SCIP* scip /**< SCIP data structure */
5034  );
5035 
5036 /** adds variable to the problem
5037  *
5038  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5039  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5040  *
5041  * @pre This method can be called if @p scip is in one of the following stages:
5042  * - \ref SCIP_STAGE_PROBLEM
5043  * - \ref SCIP_STAGE_TRANSFORMING
5044  * - \ref SCIP_STAGE_INITPRESOLVE
5045  * - \ref SCIP_STAGE_PRESOLVING
5046  * - \ref SCIP_STAGE_EXITPRESOLVE
5047  * - \ref SCIP_STAGE_PRESOLVED
5048  * - \ref SCIP_STAGE_SOLVING
5049  */
5050 extern
5052  SCIP* scip, /**< SCIP data structure */
5053  SCIP_VAR* var /**< variable to add */
5054  );
5055 
5056 /** adds variable to the problem and uses it as pricing candidate to enter the LP
5057  *
5058  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5059  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5060  *
5061  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
5062  */
5063 extern
5065  SCIP* scip, /**< SCIP data structure */
5066  SCIP_VAR* var, /**< variable to add */
5067  SCIP_Real score /**< pricing score of variable (the larger, the better the variable) */
5068  );
5069 
5070 /** removes variable from the problem
5071  *
5072  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5073  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5074  *
5075  * @pre This method can be called if @p scip is in one of the following stages:
5076  * - \ref SCIP_STAGE_PROBLEM
5077  * - \ref SCIP_STAGE_TRANSFORMING
5078  * - \ref SCIP_STAGE_TRANSFORMED
5079  * - \ref SCIP_STAGE_PRESOLVING
5080  * - \ref SCIP_STAGE_PRESOLVED
5081  * - \ref SCIP_STAGE_SOLVING
5082  * - \ref SCIP_STAGE_EXITSOLVE
5083  * - \ref SCIP_STAGE_FREETRANS
5084  */
5085 extern
5087  SCIP* scip, /**< SCIP data structure */
5088  SCIP_VAR* var, /**< variable to delete */
5089  SCIP_Bool* deleted /**< pointer to store whether variable was successfully marked to be deleted */
5090  );
5091 
5092 /** gets variables of the problem along with the numbers of different variable types; data may become invalid after
5093  * calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5094  *
5095  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5096  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5097  *
5098  * @pre This method can be called if @p scip is in one of the following stages:
5099  * - \ref SCIP_STAGE_PROBLEM
5100  * - \ref SCIP_STAGE_TRANSFORMED
5101  * - \ref SCIP_STAGE_INITPRESOLVE
5102  * - \ref SCIP_STAGE_PRESOLVING
5103  * - \ref SCIP_STAGE_EXITPRESOLVE
5104  * - \ref SCIP_STAGE_PRESOLVED
5105  * - \ref SCIP_STAGE_INITSOLVE
5106  * - \ref SCIP_STAGE_SOLVING
5107  * - \ref SCIP_STAGE_SOLVED
5108  * - \ref SCIP_STAGE_EXITSOLVE
5109  *
5110  * @note Variables in the vars array are ordered: binaries first, then integers, implicit integers and continuous last.
5111  */
5112 extern
5114  SCIP* scip, /**< SCIP data structure */
5115  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5116  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5117  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5118  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5119  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5120  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5121  );
5122 
5123 /** gets array with active problem variables
5124  *
5125  * @return array with active problem variables
5126  *
5127  * @pre This method can be called if @p scip is in one of the following stages:
5128  * - \ref SCIP_STAGE_PROBLEM
5129  * - \ref SCIP_STAGE_TRANSFORMED
5130  * - \ref SCIP_STAGE_INITPRESOLVE
5131  * - \ref SCIP_STAGE_PRESOLVING
5132  * - \ref SCIP_STAGE_EXITPRESOLVE
5133  * - \ref SCIP_STAGE_PRESOLVED
5134  * - \ref SCIP_STAGE_INITSOLVE
5135  * - \ref SCIP_STAGE_SOLVING
5136  * - \ref SCIP_STAGE_SOLVED
5137  * - \ref SCIP_STAGE_EXITSOLVE
5138  *
5139  * @warning If your are using the methods which add or change bound of variables (e.g., SCIPchgVarType(), SCIPfixVar(),
5140  * SCIPaggregateVars(), and SCIPmultiaggregateVar()), it can happen that the internal variable array (which is
5141  * accessed via this method) gets resized and/or resorted. This can invalid the data pointer which is returned
5142  * by this method.
5143  *
5144  * @note Variables in the array are ordered: binaries first, then integers, implicit integers and continuous last.
5145  */
5146 extern
5148  SCIP* scip /**< SCIP data structure */
5149  );
5150 
5151 /** gets number of active problem variables
5152  *
5153  * @return the number of active problem variables
5154  *
5155  * @pre This method can be called if @p scip is in one of the following stages:
5156  * - \ref SCIP_STAGE_PROBLEM
5157  * - \ref SCIP_STAGE_TRANSFORMED
5158  * - \ref SCIP_STAGE_INITPRESOLVE
5159  * - \ref SCIP_STAGE_PRESOLVING
5160  * - \ref SCIP_STAGE_EXITPRESOLVE
5161  * - \ref SCIP_STAGE_PRESOLVED
5162  * - \ref SCIP_STAGE_INITSOLVE
5163  * - \ref SCIP_STAGE_SOLVING
5164  * - \ref SCIP_STAGE_SOLVED
5165  * - \ref SCIP_STAGE_EXITSOLVE
5166  */
5167 extern
5168 int SCIPgetNVars(
5169  SCIP* scip /**< SCIP data structure */
5170  );
5171 
5172 /** gets number of binary active problem variables
5173  *
5174  * @return the number of binary active problem variables
5175  *
5176  * @pre This method can be called if @p scip is in one of the following stages:
5177  * - \ref SCIP_STAGE_PROBLEM
5178  * - \ref SCIP_STAGE_TRANSFORMED
5179  * - \ref SCIP_STAGE_INITPRESOLVE
5180  * - \ref SCIP_STAGE_PRESOLVING
5181  * - \ref SCIP_STAGE_EXITPRESOLVE
5182  * - \ref SCIP_STAGE_PRESOLVED
5183  * - \ref SCIP_STAGE_INITSOLVE
5184  * - \ref SCIP_STAGE_SOLVING
5185  * - \ref SCIP_STAGE_SOLVED
5186  * - \ref SCIP_STAGE_EXITSOLVE
5187  */
5188 extern
5189 int SCIPgetNBinVars(
5190  SCIP* scip /**< SCIP data structure */
5191  );
5192 
5193 /** gets number of integer active problem variables
5194  *
5195  * @return the number of integer active problem variables
5196  *
5197  * @pre This method can be called if @p scip is in one of the following stages:
5198  * - \ref SCIP_STAGE_PROBLEM
5199  * - \ref SCIP_STAGE_TRANSFORMED
5200  * - \ref SCIP_STAGE_INITPRESOLVE
5201  * - \ref SCIP_STAGE_PRESOLVING
5202  * - \ref SCIP_STAGE_EXITPRESOLVE
5203  * - \ref SCIP_STAGE_PRESOLVED
5204  * - \ref SCIP_STAGE_INITSOLVE
5205  * - \ref SCIP_STAGE_SOLVING
5206  * - \ref SCIP_STAGE_SOLVED
5207  * - \ref SCIP_STAGE_EXITSOLVE
5208  */
5209 extern
5210 int SCIPgetNIntVars(
5211  SCIP* scip /**< SCIP data structure */
5212  );
5213 
5214 /** gets number of implicit integer active problem variables
5215  *
5216  * @return the number of implicit integer active problem variables
5217  *
5218  * @pre This method can be called if @p scip is in one of the following stages:
5219  * - \ref SCIP_STAGE_PROBLEM
5220  * - \ref SCIP_STAGE_TRANSFORMED
5221  * - \ref SCIP_STAGE_INITPRESOLVE
5222  * - \ref SCIP_STAGE_PRESOLVING
5223  * - \ref SCIP_STAGE_EXITPRESOLVE
5224  * - \ref SCIP_STAGE_PRESOLVED
5225  * - \ref SCIP_STAGE_INITSOLVE
5226  * - \ref SCIP_STAGE_SOLVING
5227  * - \ref SCIP_STAGE_SOLVED
5228  * - \ref SCIP_STAGE_EXITSOLVE
5229  */
5230 extern
5231 int SCIPgetNImplVars(
5232  SCIP* scip /**< SCIP data structure */
5233  );
5234 
5235 /** gets number of continuous active problem variables
5236  *
5237  * @return the number of continuous active problem variables
5238  *
5239  * @pre This method can be called if @p scip is in one of the following stages:
5240  * - \ref SCIP_STAGE_PROBLEM
5241  * - \ref SCIP_STAGE_TRANSFORMED
5242  * - \ref SCIP_STAGE_INITPRESOLVE
5243  * - \ref SCIP_STAGE_PRESOLVING
5244  * - \ref SCIP_STAGE_EXITPRESOLVE
5245  * - \ref SCIP_STAGE_PRESOLVED
5246  * - \ref SCIP_STAGE_INITSOLVE
5247  * - \ref SCIP_STAGE_SOLVING
5248  * - \ref SCIP_STAGE_SOLVED
5249  * - \ref SCIP_STAGE_EXITSOLVE
5250  */
5251 extern
5252 int SCIPgetNContVars(
5253  SCIP* scip /**< SCIP data structure */
5254  );
5255 
5256 /** gets number of active problem variables with a non-zero objective coefficient
5257  *
5258  * @note In case of the original problem the number of variables is counted. In case of the transformed problem the
5259  * number of variables is just returned since it is stored internally
5260  *
5261  * @return the number of active problem variables with a non-zero objective coefficient
5262  *
5263  * @pre This method can be called if @p scip is in one of the following stages:
5264  * - \ref SCIP_STAGE_PROBLEM
5265  * - \ref SCIP_STAGE_TRANSFORMED
5266  * - \ref SCIP_STAGE_INITPRESOLVE
5267  * - \ref SCIP_STAGE_PRESOLVING
5268  * - \ref SCIP_STAGE_EXITPRESOLVE
5269  * - \ref SCIP_STAGE_PRESOLVED
5270  * - \ref SCIP_STAGE_INITSOLVE
5271  * - \ref SCIP_STAGE_SOLVING
5272  * - \ref SCIP_STAGE_SOLVED
5273  */
5274 extern
5275 int SCIPgetNObjVars(
5276  SCIP* scip /**< SCIP data structure */
5277  );
5278 
5279 /** gets array with fixed and aggregated problem variables; data may become invalid after
5280  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5281  *
5282  * @return an array with fixed and aggregated problem variables; data may become invalid after
5283  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
5284  *
5285  * @pre This method can be called if @p scip is in one of the following stages:
5286  * - \ref SCIP_STAGE_PROBLEM
5287  * - \ref SCIP_STAGE_TRANSFORMED
5288  * - \ref SCIP_STAGE_INITPRESOLVE
5289  * - \ref SCIP_STAGE_PRESOLVING
5290  * - \ref SCIP_STAGE_EXITPRESOLVE
5291  * - \ref SCIP_STAGE_PRESOLVED
5292  * - \ref SCIP_STAGE_INITSOLVE
5293  * - \ref SCIP_STAGE_SOLVING
5294  * - \ref SCIP_STAGE_SOLVED
5295  */
5296 extern
5298  SCIP* scip /**< SCIP data structure */
5299  );
5300 
5301 /** gets number of fixed or aggregated problem variables
5302  *
5303  * @return the number of fixed or aggregated problem variables
5304  *
5305  * @pre This method can be called if @p scip is in one of the following stages:
5306  * - \ref SCIP_STAGE_PROBLEM
5307  * - \ref SCIP_STAGE_TRANSFORMED
5308  * - \ref SCIP_STAGE_INITPRESOLVE
5309  * - \ref SCIP_STAGE_PRESOLVING
5310  * - \ref SCIP_STAGE_EXITPRESOLVE
5311  * - \ref SCIP_STAGE_PRESOLVED
5312  * - \ref SCIP_STAGE_INITSOLVE
5313  * - \ref SCIP_STAGE_SOLVING
5314  * - \ref SCIP_STAGE_SOLVED
5315  */
5316 extern
5317 int SCIPgetNFixedVars(
5318  SCIP* scip /**< SCIP data structure */
5319  );
5320 
5321 /** gets variables of the original problem along with the numbers of different variable types; data may become invalid
5322  * after a call to SCIPchgVarType()
5323  *
5324  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5325  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5326  *
5327  * @pre This method can be called if @p scip is in one of the following stages:
5328  * - \ref SCIP_STAGE_PROBLEM
5329  * - \ref SCIP_STAGE_TRANSFORMING
5330  * - \ref SCIP_STAGE_TRANSFORMED
5331  * - \ref SCIP_STAGE_INITPRESOLVE
5332  * - \ref SCIP_STAGE_PRESOLVING
5333  * - \ref SCIP_STAGE_EXITPRESOLVE
5334  * - \ref SCIP_STAGE_PRESOLVED
5335  * - \ref SCIP_STAGE_INITSOLVE
5336  * - \ref SCIP_STAGE_SOLVING
5337  * - \ref SCIP_STAGE_SOLVED
5338  * - \ref SCIP_STAGE_EXITSOLVE
5339  * - \ref SCIP_STAGE_FREETRANS
5340  */
5341 extern
5343  SCIP* scip, /**< SCIP data structure */
5344  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5345  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5346  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5347  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5348  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5349  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5350  );
5351 
5352 /** gets array with original problem variables; data may become invalid after
5353  * a call to SCIPchgVarType()
5354  *
5355  * @return an array with original problem variables; data may become invalid after
5356  * a call to SCIPchgVarType()
5357  *
5358  * @pre This method can be called if @p scip is in one of the following stages:
5359  * - \ref SCIP_STAGE_PROBLEM
5360  * - \ref SCIP_STAGE_TRANSFORMING
5361  * - \ref SCIP_STAGE_TRANSFORMED
5362  * - \ref SCIP_STAGE_INITPRESOLVE
5363  * - \ref SCIP_STAGE_PRESOLVING
5364  * - \ref SCIP_STAGE_EXITPRESOLVE
5365  * - \ref SCIP_STAGE_PRESOLVED
5366  * - \ref SCIP_STAGE_INITSOLVE
5367  * - \ref SCIP_STAGE_SOLVING
5368  * - \ref SCIP_STAGE_SOLVED
5369  * - \ref SCIP_STAGE_EXITSOLVE
5370  * - \ref SCIP_STAGE_FREETRANS
5371  */
5372 extern
5374  SCIP* scip /**< SCIP data structure */
5375  );
5376 
5377 /** gets number of original problem variables
5378  *
5379  * @return the number of original problem variables
5380  *
5381  * @pre This method can be called if @p scip is in one of the following stages:
5382  * - \ref SCIP_STAGE_PROBLEM
5383  * - \ref SCIP_STAGE_TRANSFORMING
5384  * - \ref SCIP_STAGE_TRANSFORMED
5385  * - \ref SCIP_STAGE_INITPRESOLVE
5386  * - \ref SCIP_STAGE_PRESOLVING
5387  * - \ref SCIP_STAGE_EXITPRESOLVE
5388  * - \ref SCIP_STAGE_PRESOLVED
5389  * - \ref SCIP_STAGE_INITSOLVE
5390  * - \ref SCIP_STAGE_SOLVING
5391  * - \ref SCIP_STAGE_SOLVED
5392  * - \ref SCIP_STAGE_EXITSOLVE
5393  * - \ref SCIP_STAGE_FREETRANS
5394  */
5395 extern
5396 int SCIPgetNOrigVars(
5397  SCIP* scip /**< SCIP data structure */
5398  );
5399 
5400 /** gets number of binary variables in the original problem
5401  *
5402  * @return the number of binary variables in the original problem
5403  *
5404  * @pre This method can be called if @p scip is in one of the following stages:
5405  * - \ref SCIP_STAGE_PROBLEM
5406  * - \ref SCIP_STAGE_TRANSFORMING
5407  * - \ref SCIP_STAGE_TRANSFORMED
5408  * - \ref SCIP_STAGE_INITPRESOLVE
5409  * - \ref SCIP_STAGE_PRESOLVING
5410  * - \ref SCIP_STAGE_EXITPRESOLVE
5411  * - \ref SCIP_STAGE_PRESOLVED
5412  * - \ref SCIP_STAGE_INITSOLVE
5413  * - \ref SCIP_STAGE_SOLVING
5414  * - \ref SCIP_STAGE_SOLVED
5415  * - \ref SCIP_STAGE_EXITSOLVE
5416  * - \ref SCIP_STAGE_FREETRANS
5417  */
5418 extern
5420  SCIP* scip /**< SCIP data structure */
5421  );
5422 
5423 /** gets the number of integer variables in the original problem
5424  *
5425  * @return the number of integer variables in the original problem
5426  *
5427  * @pre This method can be called if @p scip is in one of the following stages:
5428  * - \ref SCIP_STAGE_PROBLEM
5429  * - \ref SCIP_STAGE_TRANSFORMING
5430  * - \ref SCIP_STAGE_TRANSFORMED
5431  * - \ref SCIP_STAGE_INITPRESOLVE
5432  * - \ref SCIP_STAGE_PRESOLVING
5433  * - \ref SCIP_STAGE_EXITPRESOLVE
5434  * - \ref SCIP_STAGE_PRESOLVED
5435  * - \ref SCIP_STAGE_INITSOLVE
5436  * - \ref SCIP_STAGE_SOLVING
5437  * - \ref SCIP_STAGE_SOLVED
5438  * - \ref SCIP_STAGE_EXITSOLVE
5439  * - \ref SCIP_STAGE_FREETRANS
5440  */
5441 extern
5443  SCIP* scip /**< SCIP data structure */
5444  );
5445 
5446 /** gets number of implicit integer variables in the original problem
5447  *
5448  * @return the number of implicit integer variables in the original problem
5449  *
5450  * @pre This method can be called if @p scip is in one of the following stages:
5451  * - \ref SCIP_STAGE_PROBLEM
5452  * - \ref SCIP_STAGE_TRANSFORMING
5453  * - \ref SCIP_STAGE_TRANSFORMED
5454  * - \ref SCIP_STAGE_INITPRESOLVE
5455  * - \ref SCIP_STAGE_PRESOLVING
5456  * - \ref SCIP_STAGE_EXITPRESOLVE
5457  * - \ref SCIP_STAGE_PRESOLVED
5458  * - \ref SCIP_STAGE_INITSOLVE
5459  * - \ref SCIP_STAGE_SOLVING
5460  * - \ref SCIP_STAGE_SOLVED
5461  * - \ref SCIP_STAGE_EXITSOLVE
5462  * - \ref SCIP_STAGE_FREETRANS
5463  */
5464 extern
5466  SCIP* scip /**< SCIP data structure */
5467  );
5468 
5469 /** gets number of continuous variables in the original problem
5470  *
5471  * @return the number of continuous variables in the original problem
5472  *
5473  * @pre This method can be called if @p scip is in one of the following stages:
5474  * - \ref SCIP_STAGE_PROBLEM
5475  * - \ref SCIP_STAGE_TRANSFORMING
5476  * - \ref SCIP_STAGE_TRANSFORMED
5477  * - \ref SCIP_STAGE_INITPRESOLVE
5478  * - \ref SCIP_STAGE_PRESOLVING
5479  * - \ref SCIP_STAGE_EXITPRESOLVE
5480  * - \ref SCIP_STAGE_PRESOLVED
5481  * - \ref SCIP_STAGE_INITSOLVE
5482  * - \ref SCIP_STAGE_SOLVING
5483  * - \ref SCIP_STAGE_SOLVED
5484  * - \ref SCIP_STAGE_EXITSOLVE
5485  * - \ref SCIP_STAGE_FREETRANS
5486  */
5487 extern
5489  SCIP* scip /**< SCIP data structure */
5490  );
5491 
5492 /** gets number of all problem variables created during creation and solving of problem;
5493  * this includes also variables that were deleted in the meantime
5494  *
5495  * @return the number of all problem variables created during creation and solving of problem;
5496  * this includes also variables that were deleted in the meantime
5497  *
5498  * @pre This method can be called if @p scip is in one of the following stages:
5499  * - \ref SCIP_STAGE_PROBLEM
5500  * - \ref SCIP_STAGE_TRANSFORMING
5501  * - \ref SCIP_STAGE_TRANSFORMED
5502  * - \ref SCIP_STAGE_INITPRESOLVE
5503  * - \ref SCIP_STAGE_PRESOLVING
5504  * - \ref SCIP_STAGE_EXITPRESOLVE
5505  * - \ref SCIP_STAGE_PRESOLVED
5506  * - \ref SCIP_STAGE_INITSOLVE
5507  * - \ref SCIP_STAGE_SOLVING
5508  * - \ref SCIP_STAGE_SOLVED
5509  * - \ref SCIP_STAGE_EXITSOLVE
5510  * - \ref SCIP_STAGE_FREETRANS
5511  */
5512 extern
5513 int SCIPgetNTotalVars(
5514  SCIP* scip /**< SCIP data structure */
5515  );
5516 
5517 /** gets variables of the original or transformed problem along with the numbers of different variable types;
5518  * the returned problem space (original or transformed) corresponds to the given solution;
5519  * data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and
5520  * SCIPmultiaggregateVar()
5521  *
5522  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5523  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5524  *
5525  * @pre This method can be called if @p scip is in one of the following stages:
5526  * - \ref SCIP_STAGE_PROBLEM
5527  * - \ref SCIP_STAGE_TRANSFORMED
5528  * - \ref SCIP_STAGE_INITPRESOLVE
5529  * - \ref SCIP_STAGE_PRESOLVING
5530  * - \ref SCIP_STAGE_EXITPRESOLVE
5531  * - \ref SCIP_STAGE_PRESOLVED
5532  * - \ref SCIP_STAGE_INITSOLVE
5533  * - \ref SCIP_STAGE_SOLVING
5534  * - \ref SCIP_STAGE_SOLVED
5535  */
5536 extern
5538  SCIP* scip, /**< SCIP data structure */
5539  SCIP_SOL* sol, /**< primal solution that selects the problem space, NULL for current solution */
5540  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5541  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5542  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5543  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5544  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5545  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5546  );
5547 
5548 /** returns variable of given name in the problem, or NULL if not existing
5549  *
5550  * @return variable of given name in the problem, or NULL if not existing
5551  *
5552  * @pre This method can be called if @p scip is in one of the following stages:
5553  * - \ref SCIP_STAGE_PROBLEM
5554  * - \ref SCIP_STAGE_TRANSFORMING
5555  * - \ref SCIP_STAGE_TRANSFORMED
5556  * - \ref SCIP_STAGE_INITPRESOLVE
5557  * - \ref SCIP_STAGE_PRESOLVING
5558  * - \ref SCIP_STAGE_EXITPRESOLVE
5559  * - \ref SCIP_STAGE_PRESOLVED
5560  * - \ref SCIP_STAGE_INITSOLVE
5561  * - \ref SCIP_STAGE_SOLVING
5562  * - \ref SCIP_STAGE_SOLVED
5563  * - \ref SCIP_STAGE_EXITSOLVE
5564  * - \ref SCIP_STAGE_FREETRANS
5565  */
5566 extern
5568  SCIP* scip, /**< SCIP data structure */
5569  const char* name /**< name of variable to find */
5570  );
5571 
5572 /** returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables,
5573  * that will be added in pricing and improve the objective value
5574  *
5575  * @return TRUE, if all potential variables exist in the problem; FALSE, otherwise
5576  *
5577  * @pre This method can be called if @p scip is in one of the following stages:
5578  * - \ref SCIP_STAGE_TRANSFORMING
5579  * - \ref SCIP_STAGE_TRANSFORMED
5580  * - \ref SCIP_STAGE_INITPRESOLVE
5581  * - \ref SCIP_STAGE_PRESOLVING
5582  * - \ref SCIP_STAGE_EXITPRESOLVE
5583  * - \ref SCIP_STAGE_PRESOLVED
5584  * - \ref SCIP_STAGE_INITSOLVE
5585  * - \ref SCIP_STAGE_SOLVING
5586  * - \ref SCIP_STAGE_SOLVED
5587  * - \ref SCIP_STAGE_EXITSOLVE
5588  * - \ref SCIP_STAGE_FREETRANS
5589  */
5590 extern
5592  SCIP* scip /**< SCIP data structure */
5593  );
5594 
5595 /** adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the
5596  * current node (and all of its subnodes); otherwise it is added to the global problem;
5597  * if a local constraint is added at the root node, it is automatically upgraded into a global constraint
5598  *
5599  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5600  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5601  *
5602  * @pre This method can be called if @p scip is in one of the following stages:
5603  * - \ref SCIP_STAGE_PROBLEM
5604  * - \ref SCIP_STAGE_INITPRESOLVE
5605  * - \ref SCIP_STAGE_PRESOLVING
5606  * - \ref SCIP_STAGE_EXITPRESOLVE
5607  * - \ref SCIP_STAGE_PRESOLVED
5608  * - \ref SCIP_STAGE_INITSOLVE
5609  * - \ref SCIP_STAGE_SOLVING
5610  * - \ref SCIP_STAGE_EXITSOLVE
5611  */
5612 extern
5614  SCIP* scip, /**< SCIP data structure */
5615  SCIP_CONS* cons /**< constraint to add */
5616  );
5617 
5618 /** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
5619  * node, where it was added, or from the problem, if it was a problem constraint
5620  *
5621  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5622  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5623  *
5624  * @pre This method can be called if @p scip is in one of the following stages:
5625  * - \ref SCIP_STAGE_PROBLEM
5626  * - \ref SCIP_STAGE_INITPRESOLVE
5627  * - \ref SCIP_STAGE_PRESOLVING
5628  * - \ref SCIP_STAGE_EXITPRESOLVE
5629  * - \ref SCIP_STAGE_INITSOLVE
5630  * - \ref SCIP_STAGE_SOLVING
5631  */
5632 extern
5634  SCIP* scip, /**< SCIP data structure */
5635  SCIP_CONS* cons /**< constraint to delete */
5636  );
5637 
5638 /** returns original constraint of given name in the problem, or NULL if not existing
5639  *
5640  * @return original constraint of given name in the problem, or NULL if not existing
5641  *
5642  * @pre This method can be called if @p scip is in one of the following stages:
5643  * - \ref SCIP_STAGE_PROBLEM
5644  * - \ref SCIP_STAGE_TRANSFORMING
5645  * - \ref SCIP_STAGE_TRANSFORMED
5646  * - \ref SCIP_STAGE_INITPRESOLVE
5647  * - \ref SCIP_STAGE_PRESOLVING
5648  * - \ref SCIP_STAGE_EXITPRESOLVE
5649  * - \ref SCIP_STAGE_INITSOLVE
5650  * - \ref SCIP_STAGE_SOLVING
5651  * - \ref SCIP_STAGE_SOLVED
5652  * - \ref SCIP_STAGE_EXITSOLVE
5653  * - \ref SCIP_STAGE_FREETRANS */
5654 extern
5656  SCIP* scip, /**< SCIP data structure */
5657  const char* name /**< name of constraint to find */
5658  );
5659 
5660 /** returns constraint of given name in the problem, or NULL if not existing
5661  *
5662  * @return constraint of given name in the problem, or NULL if not existing
5663  *
5664  * @pre This method can be called if @p scip is in one of the following stages:
5665  * - \ref SCIP_STAGE_PROBLEM
5666  * - \ref SCIP_STAGE_TRANSFORMING
5667  * - \ref SCIP_STAGE_TRANSFORMED
5668  * - \ref SCIP_STAGE_INITPRESOLVE
5669  * - \ref SCIP_STAGE_PRESOLVING
5670  * - \ref SCIP_STAGE_EXITPRESOLVE
5671  * - \ref SCIP_STAGE_PRESOLVED
5672  * - \ref SCIP_STAGE_INITSOLVE
5673  * - \ref SCIP_STAGE_SOLVING
5674  * - \ref SCIP_STAGE_SOLVED
5675  * - \ref SCIP_STAGE_EXITSOLVE
5676  * - \ref SCIP_STAGE_FREETRANS
5677  */
5678 extern
5680  SCIP* scip, /**< SCIP data structure */
5681  const char* name /**< name of constraint to find */
5682  );
5683 
5684 /** gets number of upgraded constraints
5685  *
5686  * @return number of upgraded constraints
5687  *
5688  * @pre This method can be called if @p scip is in one of the following stages:
5689  * - \ref SCIP_STAGE_PROBLEM
5690  * - \ref SCIP_STAGE_TRANSFORMED
5691  * - \ref SCIP_STAGE_INITPRESOLVE
5692  * - \ref SCIP_STAGE_PRESOLVING
5693  * - \ref SCIP_STAGE_PRESOLVED
5694  * - \ref SCIP_STAGE_EXITPRESOLVE
5695  * - \ref SCIP_STAGE_SOLVING
5696  * - \ref SCIP_STAGE_SOLVED
5697  */
5698 extern
5699 int SCIPgetNUpgrConss(
5700  SCIP* scip /**< SCIP data structure */
5701  );
5702 
5703 /** gets total number of globally valid constraints currently in the problem
5704  *
5705  * @return total number of globally valid constraints currently in the problem
5706  *
5707  * @pre This method can be called if @p scip is in one of the following stages:
5708  * - \ref SCIP_STAGE_PROBLEM
5709  * - \ref SCIP_STAGE_TRANSFORMED
5710  * - \ref SCIP_STAGE_INITPRESOLVE
5711  * - \ref SCIP_STAGE_PRESOLVING
5712  * - \ref SCIP_STAGE_EXITPRESOLVE
5713  * - \ref SCIP_STAGE_PRESOLVED
5714  * - \ref SCIP_STAGE_INITSOLVE
5715  * - \ref SCIP_STAGE_SOLVING
5716  * - \ref SCIP_STAGE_SOLVED
5717  */
5718 extern
5719 int SCIPgetNConss(
5720  SCIP* scip /**< SCIP data structure */
5721  );
5722 
5723 /** gets array of globally valid constraints currently in the problem
5724  *
5725  * @return array of globally valid constraints currently in the problem
5726  *
5727  * @pre This method can be called if @p scip is in one of the following stages:
5728  * - \ref SCIP_STAGE_PROBLEM
5729  * - \ref SCIP_STAGE_TRANSFORMED
5730  * - \ref SCIP_STAGE_INITPRESOLVE
5731  * - \ref SCIP_STAGE_PRESOLVING
5732  * - \ref SCIP_STAGE_EXITPRESOLVE
5733  * - \ref SCIP_STAGE_PRESOLVED
5734  * - \ref SCIP_STAGE_SOLVING
5735  * - \ref SCIP_STAGE_SOLVED
5736  *
5737  * @warning If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is
5738  * accessed via this method) gets resized. This can invalid the pointer which is returned by this method.
5739  */
5740 extern
5742  SCIP* scip /**< SCIP data structure */
5743  );
5744 
5745 /** gets total number of constraints in the original problem
5746  *
5747  * @return total number of constraints in the original problem
5748  *
5749  * @pre This method can be called if @p scip is in one of the following stages:
5750  * - \ref SCIP_STAGE_PROBLEM
5751  * - \ref SCIP_STAGE_TRANSFORMING
5752  * - \ref SCIP_STAGE_TRANSFORMED
5753  * - \ref SCIP_STAGE_INITPRESOLVE
5754  * - \ref SCIP_STAGE_PRESOLVING
5755  * - \ref SCIP_STAGE_EXITPRESOLVE
5756  * - \ref SCIP_STAGE_PRESOLVED
5757  * - \ref SCIP_STAGE_INITSOLVE
5758  * - \ref SCIP_STAGE_SOLVING
5759  * - \ref SCIP_STAGE_SOLVED
5760  * - \ref SCIP_STAGE_EXITSOLVE
5761  * - \ref SCIP_STAGE_FREETRANS
5762  */
5763 extern
5764 int SCIPgetNOrigConss(
5765  SCIP* scip /**< SCIP data structure */
5766  );
5767 
5768 /** gets array of constraints in the original problem
5769  *
5770  * @return array of constraints in the original problem
5771  *
5772  * @pre This method can be called if @p scip is in one of the following stages:
5773  * - \ref SCIP_STAGE_PROBLEM
5774  * - \ref SCIP_STAGE_TRANSFORMING
5775  * - \ref SCIP_STAGE_TRANSFORMED
5776  * - \ref SCIP_STAGE_INITPRESOLVE
5777  * - \ref SCIP_STAGE_PRESOLVING
5778  * - \ref SCIP_STAGE_EXITPRESOLVE
5779  * - \ref SCIP_STAGE_PRESOLVED
5780  * - \ref SCIP_STAGE_INITSOLVE
5781  * - \ref SCIP_STAGE_SOLVING
5782  * - \ref SCIP_STAGE_SOLVED
5783  * - \ref SCIP_STAGE_EXITSOLVE
5784  * - \ref SCIP_STAGE_FREETRANS
5785  */
5786 extern
5788  SCIP* scip /**< SCIP data structure */
5789  );
5790 
5791 /** computes the number of check constraint in the current node (loop over all constraint handler and cumulates the
5792  * number of check constraints)
5793  *
5794  * @return returns the number of check constraints
5795  *
5796  * @pre This method can be called if @p scip is in one of the following stages:
5797  * - \ref SCIP_STAGE_TRANSFORMED
5798  * - \ref SCIP_STAGE_INITPRESOLVE
5799  * - \ref SCIP_STAGE_PRESOLVING
5800  * - \ref SCIP_STAGE_EXITPRESOLVE
5801  * - \ref SCIP_STAGE_PRESOLVED
5802  * - \ref SCIP_STAGE_INITSOLVE
5803  * - \ref SCIP_STAGE_SOLVING
5804  */
5805 extern
5806 int SCIPgetNCheckConss(
5807  SCIP* scip /**< SCIP data structure */
5808  );
5809 
5810 /**@} */
5811 
5812 
5813 
5814 
5815 /*
5816  * local subproblem methods
5817  */
5818 
5819 /**@name Local Subproblem Methods */
5820 /**@{ */
5821 
5822 /** adds constraint to the given node (and all of its subnodes), even if it is a global constraint;
5823  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
5824  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
5825  * only active in a small part of the tree although it is valid in a larger part.
5826  * In this case, one should pass the more global node where the constraint is valid as "validnode".
5827  * Note that the same constraint cannot be added twice to the branching tree with different "validnode" parameters.
5828  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
5829  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
5830  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
5831  *
5832  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5833  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5834  *
5835  * @pre this method can be called in one of the following stages of the SCIP solving process:
5836  * - \ref SCIP_STAGE_INITPRESOLVE
5837  * - \ref SCIP_STAGE_PRESOLVING
5838  * - \ref SCIP_STAGE_EXITPRESOLVE
5839  * - \ref SCIP_STAGE_SOLVING
5840  */
5841 extern
5843  SCIP* scip, /**< SCIP data structure */
5844  SCIP_NODE* node, /**< node to add constraint to */
5845  SCIP_CONS* cons, /**< constraint to add */
5846  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
5847  );
5848 
5849 /** adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint;
5850  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
5851  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
5852  * only active in a small part of the tree although it is valid in a larger part.
5853  *
5854  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
5855  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
5856  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
5857  *
5858  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5859  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5860  *
5861  * @pre this method can be called in one of the following stages of the SCIP solving process:
5862  * - \ref SCIP_STAGE_INITPRESOLVE
5863  * - \ref SCIP_STAGE_PRESOLVING
5864  * - \ref SCIP_STAGE_EXITPRESOLVE
5865  * - \ref SCIP_STAGE_SOLVING
5866  *
5867  * @note The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is
5868  * the case due internal data structures and performance issues. In such a case you should try to realize your
5869  * issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.
5870  */
5871 extern
5873  SCIP* scip, /**< SCIP data structure */
5874  SCIP_CONS* cons, /**< constraint to add */
5875  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
5876  );
5877 
5878 /** disables constraint's separation, enforcing, and propagation capabilities at the given node (and all subnodes);
5879  * if the method is called at the root node, the constraint is globally deleted from the problem;
5880  * the constraint deletion is being remembered at the given node, s.t. after leaving the node's subtree, the constraint
5881  * is automatically enabled again, and after entering the node's subtree, it is automatically disabled;
5882  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
5883  * alternatively, use SCIPdisableCons()
5884  *
5885  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5886  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5887  *
5888  * @pre this method can be called in one of the following stages of the SCIP solving process:
5889  * - \ref SCIP_STAGE_INITPRESOLVE
5890  * - \ref SCIP_STAGE_PRESOLVING
5891  * - \ref SCIP_STAGE_EXITPRESOLVE
5892  * - \ref SCIP_STAGE_SOLVING
5893  */
5894 extern
5896  SCIP* scip, /**< SCIP data structure */
5897  SCIP_NODE* node, /**< node to disable constraint in */
5898  SCIP_CONS* cons /**< constraint to locally delete */
5899  );
5900 
5901 /** disables constraint's separation, enforcing, and propagation capabilities at the current node (and all subnodes);
5902  * if the method is called during problem modification or at the root node, the constraint is globally deleted from
5903  * the problem;
5904  * the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the
5905  * constraint is automatically enabled again, and after reentering the current node's subtree, it is automatically
5906  * disabled again;
5907  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
5908  * alternatively, use SCIPdisableCons()
5909  *
5910  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5911  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5912  *
5913  * @pre this method can be called in one of the following stages of the SCIP solving process:
5914  * - \ref SCIP_STAGE_PROBLEM
5915  * - \ref SCIP_STAGE_INITPRESOLVE
5916  * - \ref SCIP_STAGE_PRESOLVING
5917  * - \ref SCIP_STAGE_EXITPRESOLVE
5918  * - \ref SCIP_STAGE_SOLVING
5919  */
5920 extern
5922  SCIP* scip, /**< SCIP data structure */
5923  SCIP_CONS* cons /**< constraint to locally delete */
5924  );
5925 
5926 /** gets estimate of best primal solution w.r.t. original problem contained in current subtree
5927  *
5928  * @return estimate of best primal solution w.r.t. original problem contained in current subtree
5929  *
5930  * @pre this method can be called in one of the following stages of the SCIP solving process:
5931  * - \ref SCIP_STAGE_SOLVING
5932  */
5933 extern
5935  SCIP* scip /**< SCIP data structure */
5936  );
5937 
5938 /** gets estimate of best primal solution w.r.t. transformed problem contained in current subtree
5939  *
5940  * @return estimate of best primal solution w.r.t. transformed problem contained in current subtree
5941  *
5942  * @pre this method can be called in one of the following stages of the SCIP solving process:
5943  * - \ref SCIP_STAGE_SOLVING
5944  */
5945 extern
5947  SCIP* scip /**< SCIP data structure */
5948  );
5949 
5950 /** gets dual bound of current node
5951  *
5952  * @return dual bound of current node
5953  *
5954  * @pre this method can be called in one of the following stages of the SCIP solving process:
5955  * - \ref SCIP_STAGE_SOLVING
5956  */
5957 extern
5959  SCIP* scip /**< SCIP data structure */
5960  );
5961 
5962 /** gets lower bound of current node in transformed problem
5963  *
5964  * @return lower bound of current node in transformed problem
5965  *
5966  * @pre this method can be called in one of the following stages of the SCIP solving process:
5967  * - \ref SCIP_STAGE_SOLVING
5968  */
5969 extern
5971  SCIP* scip /**< SCIP data structure */
5972  );
5973 
5974 /** gets dual bound of given node
5975  *
5976  * @return dual bound of a given node
5977  *
5978  * @pre this method can be called in one of the following stages of the SCIP solving process:
5979  * - \ref SCIP_STAGE_SOLVING
5980  */
5981 extern
5983  SCIP* scip, /**< SCIP data structure */
5984  SCIP_NODE* node /**< node to get dual bound for */
5985  );
5986 
5987 /** gets lower bound of given node in transformed problem
5988  *
5989  * @return lower bound of given node in transformed problem
5990  *
5991  * @pre this method can be called in one of the following stages of the SCIP solving process:
5992  * - \ref SCIP_STAGE_SOLVING
5993  */
5994 extern
5996  SCIP* scip, /**< SCIP data structure */
5997  SCIP_NODE* node /**< node to get dual bound for */
5998  );
5999 
6000 /** if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in
6001  * original problem space), sets the current node's dual bound to the new value
6002  *
6003  * @note the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.
6004  *
6005  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6006  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6007  *
6008  * @pre this method can be called in one of the following stages of the SCIP solving process:
6009  * - \ref SCIP_STAGE_PROBLEM
6010  * - \ref SCIP_STAGE_PRESOLVING
6011  * - \ref SCIP_STAGE_PRESOLVED
6012  * - \ref SCIP_STAGE_SOLVING
6013  */
6014 extern
6016  SCIP* scip, /**< SCIP data structure */
6017  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
6018  );
6019 
6020 /** if given value is larger than the current node's lower bound (in transformed problem), sets the current node's
6021  * lower bound to the new value
6022  *
6023  * @note the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.
6024  *
6025  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6026  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6027  *
6028  * @pre this method can be called in one of the following stages of the SCIP solving process:
6029  * - \ref SCIP_STAGE_PRESOLVING
6030  * - \ref SCIP_STAGE_PRESOLVED
6031  * - \ref SCIP_STAGE_SOLVING
6032  */
6033 extern
6035  SCIP* scip, /**< SCIP data structure */
6036  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
6037  );
6038 
6039 /** if given value is tighter (larger for minimization, smaller for maximization) than the node's dual bound,
6040  * sets the node's dual bound to the new value
6041  *
6042  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6043  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6044  *
6045  * @pre this method can be called in one of the following stages of the SCIP solving process:
6046  * - \ref SCIP_STAGE_SOLVING
6047  */
6048 extern
6050  SCIP* scip, /**< SCIP data structure */
6051  SCIP_NODE* node, /**< node to update dual bound for */
6052  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
6053  );
6054 
6055 /** if given value is larger than the node's lower bound (in transformed problem), sets the node's lower bound
6056  * to the new value
6057  *
6058  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6059  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6060  *
6061  * @pre this method can be called in one of the following stages of the SCIP solving process:
6062  * - \ref SCIP_STAGE_SOLVING
6063  */
6064 extern
6066  SCIP* scip, /**< SCIP data structure */
6067  SCIP_NODE* node, /**< node to update lower bound for */
6068  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
6069  );
6070 
6071 /** change the node selection priority of the given child
6072  *
6073  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6074  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6075  *
6076  * @pre this method can be called in one of the following stages of the SCIP solving process:
6077  * - \ref SCIP_STAGE_SOLVING
6078  */
6079 extern
6081  SCIP* scip, /**< SCIP data structure */
6082  SCIP_NODE* child, /**< child to update the node selection priority */
6083  SCIP_Real priority /**< node selection priority value */
6084  );
6085 
6086 /**@} */
6087 
6088 
6089 
6090 
6091 /*
6092  * solve methods
6093  */
6094 
6095 /**@name Solve Methods */
6096 /**@{ */
6097 
6098 /** initializes solving data structures and transforms problem
6099  *
6100  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6101  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6102  *
6103  * @pre This method can be called if @p scip is in one of the following stages:
6104  * - \ref SCIP_STAGE_PROBLEM
6105  * - \ref SCIP_STAGE_TRANSFORMED
6106  * - \ref SCIP_STAGE_INITPRESOLVE
6107  * - \ref SCIP_STAGE_PRESOLVING
6108  * - \ref SCIP_STAGE_EXITPRESOLVE
6109  * - \ref SCIP_STAGE_PRESOLVED
6110  * - \ref SCIP_STAGE_INITSOLVE
6111  * - \ref SCIP_STAGE_SOLVING
6112  * - \ref SCIP_STAGE_SOLVED
6113  * - \ref SCIP_STAGE_EXITSOLVE
6114  * - \ref SCIP_STAGE_FREETRANS
6115  * - \ref SCIP_STAGE_FREE
6116  *
6117  * @post When calling this method in the \ref SCIP_STAGE_PROBLEM stage, the \SCIP stage is changed to \ref
6118  * SCIP_STAGE_TRANSFORMED; otherwise, the stage is not changed
6119  *
6120  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6121  */
6122 extern
6124  SCIP* scip /**< SCIP data structure */
6125  );
6126 
6127 /** transforms and presolves problem
6128  *
6129  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6130  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6131  *
6132  * @pre This method can be called if @p scip is in one of the following stages:
6133  * - \ref SCIP_STAGE_PROBLEM
6134  * - \ref SCIP_STAGE_TRANSFORMED
6135  * - \ref SCIP_STAGE_PRESOLVING
6136  * - \ref SCIP_STAGE_PRESOLVED
6137  *
6138  * @post After calling this method \SCIP reaches one of the following stages:
6139  * - \ref SCIP_STAGE_PRESOLVING if the presolving process was interrupted
6140  * - \ref SCIP_STAGE_PRESOLVED if the presolving process was finished and did not solve the problem
6141  * - \ref SCIP_STAGE_SOLVED if the problem was solved during presolving
6142  *
6143  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6144  */
6145 extern
6147  SCIP* scip /**< SCIP data structure */
6148  );
6149 
6150 /** transforms, presolves, and solves problem
6151  *
6152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6154  *
6155  * @pre This method can be called if @p scip is in one of the following stages:
6156  * - \ref SCIP_STAGE_PROBLEM
6157  * - \ref SCIP_STAGE_TRANSFORMED
6158  * - \ref SCIP_STAGE_PRESOLVING
6159  * - \ref SCIP_STAGE_PRESOLVED
6160  * - \ref SCIP_STAGE_SOLVING
6161  * - \ref SCIP_STAGE_SOLVED
6162  *
6163  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
6164  * process was interrupted:
6165 
6166  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
6167  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
6168  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
6169  *
6170  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6171  */
6172 extern
6174  SCIP* scip /**< SCIP data structure */
6175  );
6176 
6177 /** frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is
6178  * preserved
6179  *
6180  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6181  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6182  *
6183  * @pre This method can be called if @p scip is in one of the following stages:
6184  * - \ref SCIP_STAGE_INIT
6185  * - \ref SCIP_STAGE_PROBLEM
6186  * - \ref SCIP_STAGE_TRANSFORMED
6187  * - \ref SCIP_STAGE_PRESOLVING
6188  * - \ref SCIP_STAGE_PRESOLVED
6189  * - \ref SCIP_STAGE_SOLVING
6190  * - \ref SCIP_STAGE_SOLVED
6191  *
6192  * @post If this method is called in \SCIP stage \ref SCIP_STAGE_INIT or \ref SCIP_STAGE_PROBLEM, the stage of
6193  * \SCIP is not changed; otherwise, the \SCIP stage is changed to \ref SCIP_STAGE_TRANSFORMED
6194  *
6195  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6196  */
6197 extern
6199  SCIP* scip, /**< SCIP data structure */
6200  SCIP_Bool restart /**< should certain data be preserved for improved restarting? */
6201  );
6202 
6203 /** frees all solution process data including presolving and transformed problem, only original problem is kept
6204  *
6205  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6206  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6207  *
6208  * @pre This method can be called if @p scip is in one of the following stages:
6209  * - \ref SCIP_STAGE_INIT
6210  * - \ref SCIP_STAGE_PROBLEM
6211  * - \ref SCIP_STAGE_TRANSFORMED
6212  * - \ref SCIP_STAGE_PRESOLVING
6213  * - \ref SCIP_STAGE_PRESOLVED
6214  * - \ref SCIP_STAGE_SOLVING
6215  * - \ref SCIP_STAGE_SOLVED
6216  *
6217  * @post After calling this method \SCIP reaches one of the following stages:
6218  * - \ref SCIP_STAGE_INIT if the method was called from \SCIP stage \ref SCIP_STAGE_INIT
6219  * - \ref SCIP_STAGE_PROBLEM if the method was called from any other of the allowed stages
6220  *
6221  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
6222  */
6223 extern
6225  SCIP* scip /**< SCIP data structure */
6226  );
6227 
6228 /** informs \SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has
6229  * been solved)
6230  *
6231  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6232  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6233  *
6234  * @pre This method can be called if @p scip is in one of the following stages:
6235  * - \ref SCIP_STAGE_PROBLEM
6236  * - \ref SCIP_STAGE_TRANSFORMING
6237  * - \ref SCIP_STAGE_TRANSFORMED
6238  * - \ref SCIP_STAGE_INITPRESOLVE
6239  * - \ref SCIP_STAGE_PRESOLVING
6240  * - \ref SCIP_STAGE_EXITPRESOLVE
6241  * - \ref SCIP_STAGE_PRESOLVED
6242  * - \ref SCIP_STAGE_SOLVING
6243  * - \ref SCIP_STAGE_SOLVED
6244  * - \ref SCIP_STAGE_EXITSOLVE
6245  * - \ref SCIP_STAGE_FREETRANS
6246  *
6247  * @note the \SCIP stage does not get changed
6248  */
6249 extern
6251  SCIP* scip /**< SCIP data structure */
6252  );
6253 
6254 /** informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has
6255  * been solved)
6256  *
6257  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6258  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6259  *
6260  * @pre This method can be called if @p scip is in one of the following stages:
6261  * - \ref SCIP_STAGE_INITPRESOLVE
6262  * - \ref SCIP_STAGE_PRESOLVING
6263  * - \ref SCIP_STAGE_EXITPRESOLVE
6264  * - \ref SCIP_STAGE_SOLVING
6265  *
6266  * @note the \SCIP stage does not get changed
6267  */
6268 extern
6270  SCIP* scip /**< SCIP data structure */
6271  );
6272 
6273 /** include specific heuristics and branching rules for reoptimization
6274  *
6275  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6276  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6277  *
6278  * @pre This method can be called if @p scip is in one of the following stages:
6279  * - \ref SCIP_STAGE_PROBLEM
6280  */
6281 extern
6283  SCIP* scip, /**< SCIP data structure */
6284  SCIP_Bool enable /**< enable reoptimization (TRUE) or disable it (FALSE) */
6285  );
6286 
6287 /** returns whether reoptimization is enabled or not */
6288 extern
6290  SCIP* scip /**< SCIP data structure */
6291  );
6292 
6293 /** returns the stored solutions corresponding to a given run */
6294 extern
6296  SCIP* scip, /**< SCIP data structue */
6297  int run, /**< number of the run */
6298  SCIP_SOL** sols, /**< array to store solutions */
6299  int allocmem, /**< allocated size of the array */
6300  int* nsols /**< number of solutions */
6301  );
6302 
6303 /** mark all stored solutions as not updated */
6304 extern
6306  SCIP* scip /**< SCIP data structure */
6307  );
6308 
6309 /** check if the reoptimization process should be restarted
6310  *
6311  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6312  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6313  *
6314  * @pre This method can be called if @p scip is in one of the following stages:
6315  * - \ref SCIP_STAGE_TRANSFORMED
6316  * - \ref SCIP_STAGE_SOLVING
6317  */
6318 extern
6320  SCIP* scip, /**< SCIP data structure */
6321  SCIP_NODE* node, /**< current node of the branch and bound tree (or NULL) */
6322  SCIP_Bool* restart /**< pointer to store of the reoptimitation process should be restarted */
6323  );
6324 
6325 /** save bound change based on dual information in the reoptimization tree
6326  *
6327  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6328  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6329  *
6330  * @pre This method can be called if @p scip is in one of the following stages:
6331  * - \ref SCIP_STAGE_SOLVING
6332  * - \ref SCIP_STAGE_SOLVED
6333  */
6334 extern
6336  SCIP* scip, /**< SCIP data structure */
6337  SCIP_NODE* node, /**< node of the search tree */
6338  SCIP_VAR* var, /**< variable whose bound changed */
6339  SCIP_Real newbound, /**< new bound of the variable */
6340  SCIP_Real oldbound /**< old bound of the variable */
6341  );
6342 
6343 /** returns the optimal solution of the last iteration or NULL of none exists */
6344 extern
6346  SCIP* scip /**< SCIP data structure */
6347  );
6348 
6349 /** returns the objective coefficent of a given variable in a previous iteration
6350  *
6351  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6352  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6353  *
6354  * @pre This method can be called if @p scip is in one of the following stages:
6355  * - \ref SCIP_STAGE_PRESOLVING
6356  * - \ref SCIP_STAGE_SOLVING
6357  */
6358 extern
6360  SCIP* scip, /**< SCIP data structure */
6361  SCIP_VAR* var, /**< variable */
6362  int run, /**< number of the run */
6363  SCIP_Real* objcoef /**< pointer to store the objective coefficient */
6364  );
6365 
6366 /** returns whether we are in the restarting phase
6367  *
6368  * @return TRUE, if we are in the restarting phase; FALSE, otherwise
6369  *
6370  * @pre This method can be called if @p scip is in one of the following stages:
6371  * - \ref SCIP_STAGE_INITPRESOLVE
6372  * - \ref SCIP_STAGE_PRESOLVING
6373  * - \ref SCIP_STAGE_EXITPRESOLVE
6374  * - \ref SCIP_STAGE_PRESOLVED
6375  * - \ref SCIP_STAGE_INITSOLVE
6376  * - \ref SCIP_STAGE_SOLVING
6377  * - \ref SCIP_STAGE_SOLVED
6378  * - \ref SCIP_STAGE_EXITSOLVE
6379  * - \ref SCIP_STAGE_FREETRANS
6380  */
6381 extern
6383  SCIP* scip /**< SCIP data structure */
6384  );
6385 
6386 /**@} */
6387 
6388 
6389 
6390 
6391 /*
6392  * variable methods
6393  */
6394 
6395 /**@name Variable Methods */
6396 /**@{ */
6397 
6398 /** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded;
6399  * an integer variable with bounds zero and one is automatically converted into a binary variable;
6400  *
6401  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
6402  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
6403  * original objective function value of variables created during the solving process has to be multiplied by
6404  * -1, too.
6405  *
6406  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6407  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6408  *
6409  * @pre This method can be called if @p scip is in one of the following stages:
6410  * - \ref SCIP_STAGE_PROBLEM
6411  * - \ref SCIP_STAGE_TRANSFORMING
6412  * - \ref SCIP_STAGE_INITPRESOLVE
6413  * - \ref SCIP_STAGE_PRESOLVING
6414  * - \ref SCIP_STAGE_EXITPRESOLVE
6415  * - \ref SCIP_STAGE_PRESOLVED
6416  * - \ref SCIP_STAGE_SOLVING
6417  *
6418  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
6419  */
6420 extern
6422  SCIP* scip, /**< SCIP data structure */
6423  SCIP_VAR** var, /**< pointer to variable object */
6424  const char* name, /**< name of variable, or NULL for automatic name creation */
6425  SCIP_Real lb, /**< lower bound of variable */
6426  SCIP_Real ub, /**< upper bound of variable */
6427  SCIP_Real obj, /**< objective function value */
6428  SCIP_VARTYPE vartype, /**< type of variable */
6429  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
6430  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
6431  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
6432  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
6433  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
6434  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
6435  SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */
6436  );
6437 
6438 /** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set
6439  * afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(),
6440  * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE
6441  * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.;
6442  * if variable is of integral type, fractional bounds are automatically rounded;
6443  * an integer variable with bounds zero and one is automatically converted into a binary variable;
6444  *
6445  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
6446  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
6447  * original objective function value of variables created during the solving process has to be multiplied by
6448  * -1, too.
6449  *
6450  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6451  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6452  *
6453  * @pre This method can be called if @p scip is in one of the following stages:
6454  * - \ref SCIP_STAGE_PROBLEM
6455  * - \ref SCIP_STAGE_TRANSFORMING
6456  * - \ref SCIP_STAGE_INITPRESOLVE
6457  * - \ref SCIP_STAGE_PRESOLVING
6458  * - \ref SCIP_STAGE_EXITPRESOLVE
6459  * - \ref SCIP_STAGE_PRESOLVED
6460  * - \ref SCIP_STAGE_SOLVING
6461  *
6462  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
6463  */
6464 extern
6466  SCIP* scip, /**< SCIP data structure */
6467  SCIP_VAR** var, /**< pointer to variable object */
6468  const char* name, /**< name of variable, or NULL for automatic name creation */
6469  SCIP_Real lb, /**< lower bound of variable */
6470  SCIP_Real ub, /**< upper bound of variable */
6471  SCIP_Real obj, /**< objective function value */
6472  SCIP_VARTYPE vartype /**< type of variable */
6473  );
6474 
6475 /** outputs the variable name to the file stream
6476  *
6477  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6478  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6479  *
6480  * @pre This method can be called if @p scip is in one of the following stages:
6481  * - \ref SCIP_STAGE_PROBLEM
6482  * - \ref SCIP_STAGE_TRANSFORMING
6483  * - \ref SCIP_STAGE_TRANSFORMED
6484  * - \ref SCIP_STAGE_INITPRESOLVE
6485  * - \ref SCIP_STAGE_PRESOLVING
6486  * - \ref SCIP_STAGE_EXITPRESOLVE
6487  * - \ref SCIP_STAGE_PRESOLVED
6488  * - \ref SCIP_STAGE_INITSOLVE
6489  * - \ref SCIP_STAGE_SOLVING
6490  * - \ref SCIP_STAGE_SOLVED
6491  * - \ref SCIP_STAGE_EXITSOLVE
6492  * - \ref SCIP_STAGE_FREETRANS
6493  */
6494 extern
6496  SCIP* scip, /**< SCIP data structure */
6497  FILE* file, /**< output file, or NULL for stdout */
6498  SCIP_VAR* var, /**< variable to output */
6499  SCIP_Bool type /**< should the variable type be also posted */
6500  );
6501 
6502 /** print the given list of variables to output stream separated by the given delimiter character;
6503  *
6504  * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
6505  *
6506  * the method SCIPparseVarsList() can parse such a string
6507  *
6508  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6509  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6510  *
6511  * @pre This method can be called if @p scip is in one of the following stages:
6512  * - \ref SCIP_STAGE_PROBLEM
6513  * - \ref SCIP_STAGE_TRANSFORMING
6514  * - \ref SCIP_STAGE_TRANSFORMED
6515  * - \ref SCIP_STAGE_INITPRESOLVE
6516  * - \ref SCIP_STAGE_PRESOLVING
6517  * - \ref SCIP_STAGE_EXITPRESOLVE
6518  * - \ref SCIP_STAGE_PRESOLVED
6519  * - \ref SCIP_STAGE_INITSOLVE
6520  * - \ref SCIP_STAGE_SOLVING
6521  * - \ref SCIP_STAGE_SOLVED
6522  * - \ref SCIP_STAGE_EXITSOLVE
6523  * - \ref SCIP_STAGE_FREETRANS
6524  *
6525  * @note The printing process is done via the message handler system.
6526  */
6527 extern
6529  SCIP* scip, /**< SCIP data structure */
6530  FILE* file, /**< output file, or NULL for stdout */
6531  SCIP_VAR** vars, /**< variable array to output */
6532  int nvars, /**< number of variables */
6533  SCIP_Bool type, /**< should the variable type be also posted */
6534  char delimiter /**< character which is used for delimitation */
6535  );
6536 
6537 /** print the given variables and coefficients as linear sum in the following form
6538  * c1 <x1> + c2 <x2> ... + cn <xn>
6539  *
6540  * This string can be parsed by the method SCIPparseVarsLinearsum().
6541  *
6542  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6543  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6544  *
6545  * @pre This method can be called if @p scip is in one of the following stages:
6546  * - \ref SCIP_STAGE_PROBLEM
6547  * - \ref SCIP_STAGE_TRANSFORMING
6548  * - \ref SCIP_STAGE_TRANSFORMED
6549  * - \ref SCIP_STAGE_INITPRESOLVE
6550  * - \ref SCIP_STAGE_PRESOLVING
6551  * - \ref SCIP_STAGE_EXITPRESOLVE
6552  * - \ref SCIP_STAGE_PRESOLVED
6553  * - \ref SCIP_STAGE_INITSOLVE
6554  * - \ref SCIP_STAGE_SOLVING
6555  * - \ref SCIP_STAGE_SOLVED
6556  * - \ref SCIP_STAGE_EXITSOLVE
6557  * - \ref SCIP_STAGE_FREETRANS
6558  *
6559  * @note The printing process is done via the message handler system.
6560  */
6561 extern
6563  SCIP* scip, /**< SCIP data structure */
6564  FILE* file, /**< output file, or NULL for stdout */
6565  SCIP_VAR** vars, /**< variable array to output */
6566  SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
6567  int nvars, /**< number of variables */
6568  SCIP_Bool type /**< should the variable type be also posted */
6569  );
6570 
6571 /** print the given monomials as polynomial in the following form
6572  * c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...
6573  *
6574  * This string can be parsed by the method SCIPparseVarsPolynomial().
6575  *
6576  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6577  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6578  *
6579  * @pre This method can be called if @p scip is in one of the following stages:
6580  * - \ref SCIP_STAGE_PROBLEM
6581  * - \ref SCIP_STAGE_TRANSFORMING
6582  * - \ref SCIP_STAGE_TRANSFORMED
6583  * - \ref SCIP_STAGE_INITPRESOLVE
6584  * - \ref SCIP_STAGE_PRESOLVING
6585  * - \ref SCIP_STAGE_EXITPRESOLVE
6586  * - \ref SCIP_STAGE_PRESOLVED
6587  * - \ref SCIP_STAGE_INITSOLVE
6588  * - \ref SCIP_STAGE_SOLVING
6589  * - \ref SCIP_STAGE_SOLVED
6590  * - \ref SCIP_STAGE_EXITSOLVE
6591  * - \ref SCIP_STAGE_FREETRANS
6592  *
6593  * @note The printing process is done via the message handler system.
6594  */
6595 extern
6597  SCIP* scip, /**< SCIP data structure */
6598  FILE* file, /**< output file, or NULL for stdout */
6599  SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */
6600  SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */
6601  SCIP_Real* monomialcoefs, /**< array with monomial coefficients */
6602  int* monomialnvars, /**< array with number of variables for each monomial */
6603  int nmonomials, /**< number of monomials */
6604  SCIP_Bool type /**< should the variable type be also posted */
6605  );
6606 
6607 /** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
6608  * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
6609  * variable with bounds zero and one is automatically converted into a binary variable
6610  *
6611  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6612  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6613  *
6614  * @pre This method can be called if @p scip is in one of the following stages:
6615  * - \ref SCIP_STAGE_PROBLEM
6616  * - \ref SCIP_STAGE_TRANSFORMING
6617  * - \ref SCIP_STAGE_INITPRESOLVE
6618  * - \ref SCIP_STAGE_PRESOLVING
6619  * - \ref SCIP_STAGE_EXITPRESOLVE
6620  * - \ref SCIP_STAGE_PRESOLVED
6621  * - \ref SCIP_STAGE_SOLVING
6622  */
6623 extern
6625  SCIP* scip, /**< SCIP data structure */
6626  SCIP_VAR** var, /**< pointer to store the problem variable */
6627  const char* str, /**< string to parse */
6628  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
6629  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
6630  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
6631  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
6632  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
6633  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
6634  SCIP_VARDATA* vardata, /**< user data for this specific variable */
6635  char** endptr, /**< pointer to store the final string position if successful */
6636  SCIP_Bool* success /**< pointer store if the paring process was successful */
6637  );
6638 
6639 /** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
6640  * exits and returns the position where the parsing stopped
6641  *
6642  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6643  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6644  *
6645  * @pre This method can be called if @p scip is in one of the following stages:
6646  * - \ref SCIP_STAGE_PROBLEM
6647  * - \ref SCIP_STAGE_TRANSFORMING
6648  * - \ref SCIP_STAGE_INITPRESOLVE
6649  * - \ref SCIP_STAGE_PRESOLVING
6650  * - \ref SCIP_STAGE_EXITPRESOLVE
6651  * - \ref SCIP_STAGE_PRESOLVED
6652  * - \ref SCIP_STAGE_SOLVING
6653  */
6654 extern
6656  SCIP* scip, /**< SCIP data structure */
6657  const char* str, /**< string to parse */
6658  SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */
6659  char** endptr /**< pointer to store the final string position if successful */
6660  );
6661 
6662 /** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
6663  * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
6664  *
6665  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6666  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6667  *
6668  * @pre This method can be called if @p scip is in one of the following stages:
6669  * - \ref SCIP_STAGE_PROBLEM
6670  * - \ref SCIP_STAGE_TRANSFORMING
6671  * - \ref SCIP_STAGE_INITPRESOLVE
6672  * - \ref SCIP_STAGE_PRESOLVING
6673  * - \ref SCIP_STAGE_EXITPRESOLVE
6674  * - \ref SCIP_STAGE_PRESOLVED
6675  * - \ref SCIP_STAGE_SOLVING
6676  *
6677  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
6678  *
6679  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
6680  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
6681  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
6682  * memory functions).
6683  */
6684 extern
6686  SCIP* scip, /**< SCIP data structure */
6687  const char* str, /**< string to parse */
6688  SCIP_VAR** vars, /**< array to store the parsed variable */
6689  int* nvars, /**< pointer to store number of parsed variables */
6690  int varssize, /**< size of the variable array */
6691  int* requiredsize, /**< pointer to store the required array size for the active variables */
6692  char** endptr, /**< pointer to store the final string position if successful */
6693  char delimiter, /**< character which is used for delimitation */
6694  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
6695  );
6696 
6697 /** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
6698  * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
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 if @p scip is in one of the following stages:
6704  * - \ref SCIP_STAGE_PROBLEM
6705  * - \ref SCIP_STAGE_TRANSFORMING
6706  * - \ref SCIP_STAGE_INITPRESOLVE
6707  * - \ref SCIP_STAGE_PRESOLVING
6708  * - \ref SCIP_STAGE_EXITPRESOLVE
6709  * - \ref SCIP_STAGE_PRESOLVED
6710  * - \ref SCIP_STAGE_SOLVING
6711  *
6712  * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
6713  *
6714  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
6715  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
6716  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
6717  * memory functions).
6718  */
6719 extern
6721  SCIP* scip, /**< SCIP data structure */
6722  const char* str, /**< string to parse */
6723  SCIP_VAR** vars, /**< array to store the parsed variables */
6724  SCIP_Real* vals, /**< array to store the parsed coefficients */
6725  int* nvars, /**< pointer to store number of parsed variables */
6726  int varssize, /**< size of the variable array */
6727  int* requiredsize, /**< pointer to store the required array size for the active variables */
6728  char** endptr, /**< pointer to store the final string position if successful */
6729  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
6730  );
6731 
6732 /** parse the given string as polynomial of variables and coefficients
6733  * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
6734  * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
6735  *
6736  * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
6737  * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
6738  * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
6739  * they use buffer memory that is intended for short term use only.
6740  *
6741  * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
6742  * are recognized.
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_TRANSFORMING
6750  * - \ref SCIP_STAGE_INITPRESOLVE
6751  * - \ref SCIP_STAGE_PRESOLVING
6752  * - \ref SCIP_STAGE_EXITPRESOLVE
6753  * - \ref SCIP_STAGE_PRESOLVED
6754  * - \ref SCIP_STAGE_SOLVING
6755  */
6756 extern
6758  SCIP* scip, /**< SCIP data structure */
6759  const char* str, /**< string to parse */
6760  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
6761  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
6762  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
6763  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
6764  int* nmonomials, /**< pointer to store number of parsed monomials */
6765  char** endptr, /**< pointer to store the final string position if successful */
6766  SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
6767  );
6768 
6769 /** frees memory allocated when parsing a polynomial from a string
6770  *
6771  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6772  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6773  *
6774  * @pre This method can be called if @p scip is in one of the following stages:
6775  * - \ref SCIP_STAGE_PROBLEM
6776  * - \ref SCIP_STAGE_TRANSFORMING
6777  * - \ref SCIP_STAGE_INITPRESOLVE
6778  * - \ref SCIP_STAGE_PRESOLVING
6779  * - \ref SCIP_STAGE_EXITPRESOLVE
6780  * - \ref SCIP_STAGE_PRESOLVED
6781  * - \ref SCIP_STAGE_SOLVING
6782  */
6783 extern
6785  SCIP* scip, /**< SCIP data structure */
6786  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
6787  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
6788  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
6789  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
6790  int nmonomials /**< pointer to store number of parsed monomials */
6791  );
6792 
6793 /** increases usage counter of variable
6794  *
6795  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6796  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6797  *
6798  * @pre This method can be called if @p scip is in one of the following stages:
6799  * - \ref SCIP_STAGE_PROBLEM
6800  * - \ref SCIP_STAGE_TRANSFORMING
6801  * - \ref SCIP_STAGE_TRANSFORMED
6802  * - \ref SCIP_STAGE_INITPRESOLVE
6803  * - \ref SCIP_STAGE_PRESOLVING
6804  * - \ref SCIP_STAGE_EXITPRESOLVE
6805  * - \ref SCIP_STAGE_PRESOLVED
6806  * - \ref SCIP_STAGE_INITSOLVE
6807  * - \ref SCIP_STAGE_SOLVING
6808  * - \ref SCIP_STAGE_SOLVED
6809  * - \ref SCIP_STAGE_EXITSOLVE
6810  */
6811 extern
6813  SCIP* scip, /**< SCIP data structure */
6814  SCIP_VAR* var /**< variable to capture */
6815  );
6816 
6817 /** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
6818  *
6819  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6820  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6821  *
6822  * @pre This method can be called if @p scip is in one of the following stages:
6823  * - \ref SCIP_STAGE_PROBLEM
6824  * - \ref SCIP_STAGE_TRANSFORMING
6825  * - \ref SCIP_STAGE_TRANSFORMED
6826  * - \ref SCIP_STAGE_INITPRESOLVE
6827  * - \ref SCIP_STAGE_PRESOLVING
6828  * - \ref SCIP_STAGE_EXITPRESOLVE
6829  * - \ref SCIP_STAGE_PRESOLVED
6830  * - \ref SCIP_STAGE_INITSOLVE
6831  * - \ref SCIP_STAGE_SOLVING
6832  * - \ref SCIP_STAGE_SOLVED
6833  * - \ref SCIP_STAGE_EXITSOLVE
6834  * - \ref SCIP_STAGE_FREETRANS
6835  *
6836  * @note the pointer of the variable will be NULLed
6837  */
6838 extern
6840  SCIP* scip, /**< SCIP data structure */
6841  SCIP_VAR** var /**< pointer to variable */
6842  );
6843 
6844 /** changes the name of a variable
6845  *
6846  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6847  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6848  *
6849  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM
6850  *
6851  * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h
6852  */
6853 extern
6855  SCIP* scip, /**< SCIP data structure */
6856  SCIP_VAR* var, /**< variable */
6857  const char* name /**< new name of constraint */
6858  );
6859 
6860 /** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
6861  * a new transformed variable for this variable is created
6862  *
6863  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6864  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6865  *
6866  * @pre This method can be called if @p scip is in one of the following stages:
6867  * - \ref SCIP_STAGE_TRANSFORMING
6868  * - \ref SCIP_STAGE_TRANSFORMED
6869  * - \ref SCIP_STAGE_INITPRESOLVE
6870  * - \ref SCIP_STAGE_PRESOLVING
6871  * - \ref SCIP_STAGE_EXITPRESOLVE
6872  * - \ref SCIP_STAGE_PRESOLVED
6873  * - \ref SCIP_STAGE_INITSOLVE
6874  * - \ref SCIP_STAGE_SOLVING
6875  */
6876 extern
6878  SCIP* scip, /**< SCIP data structure */
6879  SCIP_VAR* var, /**< variable to get/create transformed variable for */
6880  SCIP_VAR** transvar /**< pointer to store the transformed variable */
6881  );
6882 
6883 /** gets and captures transformed variables for an array of variables;
6884  * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
6885  * it is possible to call this method with vars == transvars
6886  *
6887  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6888  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6889  *
6890  * @pre This method can be called if @p scip is in one of the following stages:
6891  * - \ref SCIP_STAGE_TRANSFORMING
6892  * - \ref SCIP_STAGE_TRANSFORMED
6893  * - \ref SCIP_STAGE_INITPRESOLVE
6894  * - \ref SCIP_STAGE_PRESOLVING
6895  * - \ref SCIP_STAGE_EXITPRESOLVE
6896  * - \ref SCIP_STAGE_PRESOLVED
6897  * - \ref SCIP_STAGE_INITSOLVE
6898  * - \ref SCIP_STAGE_SOLVING
6899  */
6900 extern
6902  SCIP* scip, /**< SCIP data structure */
6903  int nvars, /**< number of variables to get/create transformed variables for */
6904  SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */
6905  SCIP_VAR** transvars /**< array to store the transformed variables */
6906  );
6907 
6908 /** gets corresponding transformed variable of a given variable;
6909  * returns NULL as transvar, if transformed variable is not yet existing
6910  *
6911  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6912  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6913  *
6914  * @pre This method can be called if @p scip is in one of the following stages:
6915  * - \ref SCIP_STAGE_TRANSFORMING
6916  * - \ref SCIP_STAGE_TRANSFORMED
6917  * - \ref SCIP_STAGE_INITPRESOLVE
6918  * - \ref SCIP_STAGE_PRESOLVING
6919  * - \ref SCIP_STAGE_EXITPRESOLVE
6920  * - \ref SCIP_STAGE_PRESOLVED
6921  * - \ref SCIP_STAGE_INITSOLVE
6922  * - \ref SCIP_STAGE_SOLVING
6923  * - \ref SCIP_STAGE_SOLVED
6924  * - \ref SCIP_STAGE_EXITSOLVE
6925  * - \ref SCIP_STAGE_FREETRANS
6926  */
6927 extern
6929  SCIP* scip, /**< SCIP data structure */
6930  SCIP_VAR* var, /**< variable to get transformed variable for */
6931  SCIP_VAR** transvar /**< pointer to store the transformed variable */
6932  );
6933 
6934 /** gets corresponding transformed variables for an array of variables;
6935  * stores NULL in a transvars slot, if the transformed variable is not yet existing;
6936  * it is possible to call this method with vars == transvars, but remember that variables that are not
6937  * yet transformed will be replaced with NULL
6938  *
6939  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6940  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6941  *
6942  * @pre This method can be called if @p scip is in one of the following stages:
6943  * - \ref SCIP_STAGE_TRANSFORMING
6944  * - \ref SCIP_STAGE_TRANSFORMED
6945  * - \ref SCIP_STAGE_INITPRESOLVE
6946  * - \ref SCIP_STAGE_PRESOLVING
6947  * - \ref SCIP_STAGE_EXITPRESOLVE
6948  * - \ref SCIP_STAGE_PRESOLVED
6949  * - \ref SCIP_STAGE_INITSOLVE
6950  * - \ref SCIP_STAGE_SOLVING
6951  * - \ref SCIP_STAGE_SOLVED
6952  * - \ref SCIP_STAGE_EXITSOLVE
6953  * - \ref SCIP_STAGE_FREETRANS
6954  */
6955 extern
6957  SCIP* scip, /**< SCIP data structure */
6958  int nvars, /**< number of variables to get transformed variables for */
6959  SCIP_VAR** vars, /**< array with variables to get transformed variables for */
6960  SCIP_VAR** transvars /**< array to store the transformed variables */
6961  );
6962 
6963 /** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing
6964  *
6965  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6966  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6967  *
6968  * @pre This method can be called if @p scip is in one of the following stages:
6969  * - \ref SCIP_STAGE_PROBLEM
6970  * - \ref SCIP_STAGE_TRANSFORMING
6971  * - \ref SCIP_STAGE_TRANSFORMED
6972  * - \ref SCIP_STAGE_INITPRESOLVE
6973  * - \ref SCIP_STAGE_PRESOLVING
6974  * - \ref SCIP_STAGE_EXITPRESOLVE
6975  * - \ref SCIP_STAGE_PRESOLVED
6976  * - \ref SCIP_STAGE_INITSOLVE
6977  * - \ref SCIP_STAGE_SOLVING
6978  * - \ref SCIP_STAGE_SOLVED
6979  * - \ref SCIP_STAGE_EXITSOLVE
6980  * - \ref SCIP_STAGE_FREETRANS
6981  */
6982 extern
6984  SCIP* scip, /**< SCIP data structure */
6985  SCIP_VAR* var, /**< variable to get negated variable for */
6986  SCIP_VAR** negvar /**< pointer to store the negated variable */
6987  );
6988 
6989 /** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing;
6990  * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
6991  *
6992  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6993  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6994  *
6995  * @pre This method can be called if @p scip is in one of the following stages:
6996  * - \ref SCIP_STAGE_PROBLEM
6997  * - \ref SCIP_STAGE_TRANSFORMING
6998  * - \ref SCIP_STAGE_TRANSFORMED
6999  * - \ref SCIP_STAGE_INITPRESOLVE
7000  * - \ref SCIP_STAGE_PRESOLVING
7001  * - \ref SCIP_STAGE_EXITPRESOLVE
7002  * - \ref SCIP_STAGE_PRESOLVED
7003  * - \ref SCIP_STAGE_INITSOLVE
7004  * - \ref SCIP_STAGE_SOLVING
7005  * - \ref SCIP_STAGE_SOLVED
7006  * - \ref SCIP_STAGE_EXITSOLVE
7007  * - \ref SCIP_STAGE_FREETRANS
7008  */
7009 extern
7011  SCIP* scip, /**< SCIP data structure */
7012  int nvars, /**< number of variables to get negated variables for */
7013  SCIP_VAR** vars, /**< array of variables to get negated variables for */
7014  SCIP_VAR** negvars /**< array to store the negated variables */
7015  );
7016 
7017 /** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
7018  * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
7019  *
7020  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7021  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7022  *
7023  * @pre This method can be called if @p scip is in one of the following stages:
7024  * - \ref SCIP_STAGE_PROBLEM
7025  * - \ref SCIP_STAGE_TRANSFORMED
7026  * - \ref SCIP_STAGE_INITPRESOLVE
7027  * - \ref SCIP_STAGE_PRESOLVING
7028  * - \ref SCIP_STAGE_EXITPRESOLVE
7029  * - \ref SCIP_STAGE_PRESOLVED
7030  * - \ref SCIP_STAGE_INITSOLVE
7031  * - \ref SCIP_STAGE_SOLVING
7032  * - \ref SCIP_STAGE_SOLVED
7033  * - \ref SCIP_STAGE_EXITSOLVE
7034  */
7035 extern
7037  SCIP* scip, /**< SCIP data structure */
7038  SCIP_VAR* var, /**< binary variable to get binary representative for */
7039  SCIP_VAR** repvar, /**< pointer to store the binary representative */
7040  SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
7041  );
7042 
7043 /** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
7044  * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
7045  *
7046  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7047  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7048  *
7049  * @pre This method can be called if @p scip is in one of the following stages:
7050  * - \ref SCIP_STAGE_PROBLEM
7051  * - \ref SCIP_STAGE_TRANSFORMED
7052  * - \ref SCIP_STAGE_INITPRESOLVE
7053  * - \ref SCIP_STAGE_PRESOLVING
7054  * - \ref SCIP_STAGE_EXITPRESOLVE
7055  * - \ref SCIP_STAGE_PRESOLVED
7056  * - \ref SCIP_STAGE_INITSOLVE
7057  * - \ref SCIP_STAGE_SOLVING
7058  * - \ref SCIP_STAGE_SOLVED
7059  * - \ref SCIP_STAGE_EXITSOLVE
7060  */
7061 extern
7063  SCIP* scip, /**< SCIP data structure */
7064  int nvars, /**< number of binary variables to get representatives for */
7065  SCIP_VAR** vars, /**< binary variables to get binary representatives for */
7066  SCIP_VAR** repvars, /**< array to store the binary representatives */
7067  SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
7068  );
7069 
7070 /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
7071  *
7072  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7073  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7074  *
7075  * @pre This method can be called if @p scip is in one of the following stages:
7076  * - \ref SCIP_STAGE_INITPRESOLVE
7077  * - \ref SCIP_STAGE_PRESOLVING
7078  * - \ref SCIP_STAGE_EXITPRESOLVE
7079  * - \ref SCIP_STAGE_PRESOLVED
7080  * - \ref SCIP_STAGE_INITSOLVE
7081  * - \ref SCIP_STAGE_SOLVING
7082  * - \ref SCIP_STAGE_SOLVED
7083  */
7084 extern
7086  SCIP* scip, /**< SCIP data structure */
7087  SCIP_VAR* var /**< problem variable */
7088  );
7089 
7090 /** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
7091  * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
7092  *
7093  * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
7094  * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
7095  * representation is stored in the variable array, scalar array and constant.
7096  *
7097  * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
7098  * allocated (e.g., by a C++ 'new' or SCIP functions).
7099  *
7100  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7101  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7102  *
7103  * @pre This method can be called if @p scip is in one of the following stages:
7104  * - \ref SCIP_STAGE_TRANSFORMED
7105  * - \ref SCIP_STAGE_INITPRESOLVE
7106  * - \ref SCIP_STAGE_PRESOLVING
7107  * - \ref SCIP_STAGE_EXITPRESOLVE
7108  * - \ref SCIP_STAGE_PRESOLVED
7109  * - \ref SCIP_STAGE_INITSOLVE
7110  * - \ref SCIP_STAGE_SOLVING
7111  * - \ref SCIP_STAGE_SOLVED
7112  * - \ref SCIP_STAGE_EXITSOLVE
7113  * - \ref SCIP_STAGE_FREETRANS
7114  *
7115  * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
7116  * given entries are overwritten.
7117  *
7118  * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
7119  * the method with the linear sum 1.0*x + 0.0.
7120  */
7121 extern
7123  SCIP* scip, /**< SCIP data structure */
7124  SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
7125  * overwritten by the variable array y_1, ..., y_m in the linear sum
7126  * w.r.t. active variables */
7127  SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
7128  * scalars b_1, ..., b_m in the linear sum of the active variables */
7129  int* nvars, /**< pointer to number of variables in the linear sum which will be
7130  * overwritten by the number of variables in the linear sum corresponding
7131  * to the active variables */
7132  int varssize, /**< available slots in vars and scalars array which is needed to check if
7133  * the array are large enough for the linear sum w.r.t. active
7134  * variables */
7135  SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
7136  * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
7137  * d w.r.t. the active variables */
7138  int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
7139  * active variables */
7140  SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
7141  );
7142 
7143 /** transforms given variable, scalar and constant to the corresponding active, fixed, or
7144  * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
7145  * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
7146  * with only one active variable (this can happen due to fixings after the multi-aggregation),
7147  * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
7148  *
7149  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7150  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7151  *
7152  * @pre This method can be called if @p scip is in one of the following stages:
7153  * - \ref SCIP_STAGE_TRANSFORMED
7154  * - \ref SCIP_STAGE_INITPRESOLVE
7155  * - \ref SCIP_STAGE_PRESOLVING
7156  * - \ref SCIP_STAGE_EXITPRESOLVE
7157  * - \ref SCIP_STAGE_PRESOLVED
7158  * - \ref SCIP_STAGE_INITSOLVE
7159  * - \ref SCIP_STAGE_SOLVING
7160  * - \ref SCIP_STAGE_SOLVED
7161  * - \ref SCIP_STAGE_EXITSOLVE
7162  * - \ref SCIP_STAGE_FREETRANS
7163  */
7164 extern
7166  SCIP* scip, /**< SCIP data structure */
7167  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
7168  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
7169  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
7170  );
7171 
7172 /** return for given variables all their active counterparts; all active variables will be pairwise different
7173  * @note It does not hold that the first output variable is the active variable for the first input variable.
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_TRANSFORMED
7180  * - \ref SCIP_STAGE_INITPRESOLVE
7181  * - \ref SCIP_STAGE_PRESOLVING
7182  * - \ref SCIP_STAGE_EXITPRESOLVE
7183  * - \ref SCIP_STAGE_PRESOLVED
7184  * - \ref SCIP_STAGE_INITSOLVE
7185  * - \ref SCIP_STAGE_SOLVING
7186  * - \ref SCIP_STAGE_SOLVED
7187  * - \ref SCIP_STAGE_EXITSOLVE
7188  * - \ref SCIP_STAGE_FREETRANS
7189  */
7190 extern
7192  SCIP* scip, /**< SCIP data structure */
7193  SCIP_VAR** vars, /**< variable array with given variables and as output all active
7194  * variables, if enough slots exist */
7195  int* nvars, /**< number of given variables, and as output number of active variables,
7196  * if enough slots exist */
7197  int varssize, /**< available slots in vars array */
7198  int* requiredsize /**< pointer to store the required array size for the active variables */
7199  );
7200 
7201 /** returns the reduced costs of the variable in the current node's LP relaxation;
7202  * the current node has to have a feasible LP.
7203  *
7204  * returns SCIP_INVALID if the variable is active but not in the current LP;
7205  * returns 0 if the variable has been aggregated out or fixed in presolving.
7206  *
7207  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7208  */
7209 extern
7211  SCIP* scip, /**< SCIP data structure */
7212  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
7213  );
7214 
7215 /** returns the implied reduced costs of the variable in the current node's LP relaxation;
7216  * the current node has to have a feasible LP.
7217  *
7218  * returns SCIP_INVALID if the variable is active but not in the current LP;
7219  * returns 0 if the variable has been aggregated out or fixed in presolving.
7220  *
7221  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7222  */
7223 extern
7225  SCIP* scip, /**< SCIP data structure */
7226  SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */
7227  SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */
7228  );
7229 
7230 /** returns the Farkas coefficient of the variable in the current node's LP relaxation;
7231  * the current node has to have an infeasible LP.
7232  *
7233  * returns SCIP_INVALID if the variable is active but not in the current LP;
7234  * returns 0 if the variable has been aggregated out or fixed in presolving.
7235  *
7236  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7237  */
7238 extern
7240  SCIP* scip, /**< SCIP data structure */
7241  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
7242  );
7243 
7244 /** gets solution value for variable in current node
7245  *
7246  * @return solution value for variable in current node
7247  *
7248  * @pre This method can be called if @p scip is in one of the following stages:
7249  * - \ref SCIP_STAGE_PRESOLVED
7250  * - \ref SCIP_STAGE_SOLVING
7251  */
7252 extern
7254  SCIP* scip, /**< SCIP data structure */
7255  SCIP_VAR* var /**< variable to get solution value for */
7256  );
7257 
7258 /** gets solution values of multiple variables in current node
7259  *
7260  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7261  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7262  *
7263  * @pre This method can be called if @p scip is in one of the following stages:
7264  * - \ref SCIP_STAGE_PRESOLVED
7265  * - \ref SCIP_STAGE_SOLVING
7266  */
7267 extern
7269  SCIP* scip, /**< SCIP data structure */
7270  int nvars, /**< number of variables to get solution value for */
7271  SCIP_VAR** vars, /**< array with variables to get value for */
7272  SCIP_Real* vals /**< array to store solution values of variables */
7273  );
7274 
7275 /** sets the solution value of all variables in the global relaxation solution to zero
7276  *
7277  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7278  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7279  *
7280  * @pre This method can be called if @p scip is in one of the following stages:
7281  * - \ref SCIP_STAGE_PRESOLVED
7282  * - \ref SCIP_STAGE_SOLVING
7283  */
7284 extern
7286  SCIP* scip /**< SCIP data structure */
7287  );
7288 
7289 /** sets the value of the given variable in the global relaxation solution;
7290  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
7291  * You can use SCIPclearRelaxSolVals() to set all values to zero, initially;
7292  * after setting all solution values, you have to call SCIPmarkRelaxSolValid()
7293  * to inform SCIP that the stored solution is valid
7294  *
7295  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7296  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7297  *
7298  * @pre This method can be called if @p scip is in one of the following stages:
7299  * - \ref SCIP_STAGE_PRESOLVED
7300  * - \ref SCIP_STAGE_SOLVING
7301  */
7302 extern
7304  SCIP* scip, /**< SCIP data structure */
7305  SCIP_VAR* var, /**< variable to set value for */
7306  SCIP_Real val /**< solution value of variable */
7307  );
7308 
7309 /** sets the values of the given variables in the global relaxation solution;
7310  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
7311  * the solution is automatically cleared, s.t. all other variables get value 0.0
7312  *
7313  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7314  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7315  *
7316  * @pre This method can be called if @p scip is in one of the following stages:
7317  * - \ref SCIP_STAGE_PRESOLVED
7318  * - \ref SCIP_STAGE_SOLVING
7319  */
7320 extern
7322  SCIP* scip, /**< SCIP data structure */
7323  int nvars, /**< number of variables to set relaxation solution value for */
7324  SCIP_VAR** vars, /**< array with variables to set value for */
7325  SCIP_Real* vals /**< array with solution values of variables */
7326  );
7327 
7328 /** sets the values of the variables in the global relaxation solution to the values
7329  * in the given primal solution; the relaxation solution can be filled by the relaxation hanlders
7330  * and might be used by heuristics and for separation
7331  *
7332  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7333  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7334  *
7335  * @pre This method can be called if @p scip is in one of the following stages:
7336  * - \ref SCIP_STAGE_PRESOLVED
7337  * - \ref SCIP_STAGE_SOLVING
7338  */
7339 extern
7341  SCIP* scip, /**< SCIP data structure */
7342  SCIP_SOL* sol /**< primal relaxation solution */
7343  );
7344 
7345 /** returns whether the relaxation solution is valid
7346  *
7347  * @return TRUE, if the relaxation solution is valid; FALSE, otherwise
7348  *
7349  * @pre This method can be called if @p scip is in one of the following stages:
7350  * - \ref SCIP_STAGE_PRESOLVED
7351  * - \ref SCIP_STAGE_SOLVING
7352  */
7353 extern
7355  SCIP* scip /**< SCIP data structure */
7356  );
7357 
7358 /** informs SCIP, that the relaxation solution is valid
7359  *
7360  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7361  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7362  *
7363  * @pre This method can be called if @p scip is in one of the following stages:
7364  * - \ref SCIP_STAGE_PRESOLVED
7365  * - \ref SCIP_STAGE_SOLVING
7366  */
7367 extern
7369  SCIP* scip /**< SCIP data structure */
7370  );
7371 
7372 /** informs SCIP, that the relaxation solution is invalid
7373  *
7374  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7375  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7376  *
7377  * @pre This method can be called if @p scip is in one of the following stages:
7378  * - \ref SCIP_STAGE_PRESOLVED
7379  * - \ref SCIP_STAGE_SOLVING
7380  */
7381 extern
7383  SCIP* scip /**< SCIP data structure */
7384  );
7385 
7386 /** gets the relaxation solution value of the given variable
7387  *
7388  * @return the relaxation solution value of the given variable
7389  *
7390  * @pre This method can be called if @p scip is in one of the following stages:
7391  * - \ref SCIP_STAGE_PRESOLVED
7392  * - \ref SCIP_STAGE_SOLVING
7393  */
7394 extern
7396  SCIP* scip, /**< SCIP data structure */
7397  SCIP_VAR* var /**< variable to get value for */
7398  );
7399 
7400 /** gets the relaxation solution objective value
7401  *
7402  * @return the objective value of the relaxation solution
7403  *
7404  * @pre This method can be called if @p scip is in one of the following stages:
7405  * - \ref SCIP_STAGE_PRESOLVED
7406  * - \ref SCIP_STAGE_SOLVING
7407  */
7408 extern
7410  SCIP* scip /**< SCIP data structure */
7411  );
7412 
7413 /** start strong branching - call before any strong branching
7414  *
7415  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7416  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7417  *
7418  * @pre This method can be called if @p scip is in one of the following stages:
7419  * - \ref SCIP_STAGE_PRESOLVED
7420  * - \ref SCIP_STAGE_SOLVING
7421  *
7422  * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
7423  * which allow to perform propagation but also creates some overhead
7424  */
7425 extern
7427  SCIP* scip, /**< SCIP data structure */
7428  SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
7429  );
7430 
7431 /** end strong branching - call after any strong branching
7432  *
7433  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7434  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7435  *
7436  * @pre This method can be called if @p scip is in one of the following stages:
7437  * - \ref SCIP_STAGE_PRESOLVED
7438  * - \ref SCIP_STAGE_SOLVING
7439  */
7440 extern
7442  SCIP* scip /**< SCIP data structure */
7443  );
7444 
7445 /** gets strong branching information on column variable with fractional value
7446  *
7447  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7448  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7449  *
7450  * @pre This method can be called if @p scip is in one of the following stages:
7451  * - \ref SCIP_STAGE_PRESOLVED
7452  * - \ref SCIP_STAGE_SOLVING
7453  */
7454 extern
7456  SCIP* scip, /**< SCIP data structure */
7457  SCIP_VAR* var, /**< variable to get strong branching values for */
7458  int itlim, /**< iteration limit for strong branchings */
7459  SCIP_Real* down, /**< stores dual bound after branching column down */
7460  SCIP_Real* up, /**< stores dual bound after branching column up */
7461  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
7462  * otherwise, it can only be used as an estimate value */
7463  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
7464  * otherwise, it can only be used as an estimate value */
7465  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
7466  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
7467  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
7468  * infeasible downwards branch, or NULL */
7469  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
7470  * infeasible upwards branch, or NULL */
7471  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
7472  * solving process should be stopped (e.g., due to a time limit) */
7473  );
7474 
7475 /** gets strong branching information with previous domain propagation on column variable
7476  *
7477  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
7478  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
7479  * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
7480  * enabled in the SCIPstartStrongbranch() call.
7481  *
7482  * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
7483  * can be specified by the parameter @p maxproprounds.
7484  *
7485  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7486  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7487  *
7488  * @pre This method can be called if @p scip is in one of the following stages:
7489  * - \ref SCIP_STAGE_PRESOLVED
7490  * - \ref SCIP_STAGE_SOLVING
7491  *
7492  * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
7493  * they are updated w.r.t. the strong branching LP solution.
7494  */
7495 extern
7497  SCIP* scip, /**< SCIP data structure */
7498  SCIP_VAR* var, /**< variable to get strong branching values for */
7499  SCIP_Real solval, /**< value of the variable in the current LP solution */
7500  SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
7501  int itlim, /**< iteration limit for strong branchings */
7502  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
7503  * settings) */
7504  SCIP_Real* down, /**< stores dual bound after branching column down */
7505  SCIP_Real* up, /**< stores dual bound after branching column up */
7506  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
7507  * otherwise, it can only be used as an estimate value */
7508  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
7509  * otherwise, it can only be used as an estimate value */
7510  SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
7511  SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */
7512  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
7513  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
7514  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
7515  * infeasible downwards branch, or NULL */
7516  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
7517  * infeasible upwards branch, or NULL */
7518  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
7519  * solving process should be stopped (e.g., due to a time limit) */
7520  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
7521  SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
7522  );
7523 
7524 /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
7525  * is (val -1.0) and the up brach ins (val +1.0)
7526  *
7527  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7528  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7529  *
7530  * @pre This method can be called if @p scip is in one of the following stages:
7531  * - \ref SCIP_STAGE_PRESOLVED
7532  * - \ref SCIP_STAGE_SOLVING
7533  *
7534  * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
7535  * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
7536  */
7537 extern
7539  SCIP* scip, /**< SCIP data structure */
7540  SCIP_VAR* var, /**< variable to get strong branching values for */
7541  int itlim, /**< iteration limit for strong branchings */
7542  SCIP_Real* down, /**< stores dual bound after branching column down */
7543  SCIP_Real* up, /**< stores dual bound after branching column up */
7544  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
7545  * otherwise, it can only be used as an estimate value */
7546  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
7547  * otherwise, it can only be used as an estimate value */
7548  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
7549  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
7550  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
7551  * infeasible downwards branch, or NULL */
7552  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
7553  * infeasible upwards branch, or NULL */
7554  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
7555  * solving process should be stopped (e.g., due to a time limit) */
7556  );
7557 
7558 /** gets strong branching information on column variables with fractional values
7559  *
7560  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7561  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7562  *
7563  * @pre This method can be called if @p scip is in one of the following stages:
7564  * - \ref SCIP_STAGE_PRESOLVED
7565  * - \ref SCIP_STAGE_SOLVING
7566  */
7567 extern
7569  SCIP* scip, /**< SCIP data structure */
7570  SCIP_VAR** vars, /**< variables to get strong branching values for */
7571  int nvars, /**< number of variables */
7572  int itlim, /**< iteration limit for strong branchings */
7573  SCIP_Real* down, /**< stores dual bounds after branching variables down */
7574  SCIP_Real* up, /**< stores dual bounds after branching variables up */
7575  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
7576  * otherwise, they can only be used as an estimate value */
7577  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
7578  * otherwise, they can only be used as an estimate value */
7579  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
7580  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
7581  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
7582  * infeasible downward branches, or NULL */
7583  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
7584  * infeasible upward branches, or NULL */
7585  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
7586  * solving process should be stopped (e.g., due to a time limit) */
7587  );
7588 
7589 /** gets strong branching information on column variables with integral values
7590  *
7591  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7592  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7593  *
7594  * @pre This method can be called if @p scip is in one of the following stages:
7595  * - \ref SCIP_STAGE_PRESOLVED
7596  * - \ref SCIP_STAGE_SOLVING
7597  */
7598 extern
7600  SCIP* scip, /**< SCIP data structure */
7601  SCIP_VAR** vars, /**< variables to get strong branching values for */
7602  int nvars, /**< number of variables */
7603  int itlim, /**< iteration limit for strong branchings */
7604  SCIP_Real* down, /**< stores dual bounds after branching variables down */
7605  SCIP_Real* up, /**< stores dual bounds after branching variables up */
7606  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
7607  * otherwise, they can only be used as an estimate value */
7608  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
7609  * otherwise, they can only be used as an estimate value */
7610  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
7611  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
7612  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
7613  * infeasible downward branches, or NULL */
7614  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
7615  * infeasible upward branches, or NULL */
7616  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
7617  * solving process should be stopped (e.g., due to a time limit) */
7618  );
7619 
7620 /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
7621  * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
7622  * keep in mind, that the returned old values may have nothing to do with the current LP solution
7623  *
7624  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7625  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7626  *
7627  * @pre This method can be called if @p scip is in one of the following stages:
7628  * - \ref SCIP_STAGE_SOLVING
7629  * - \ref SCIP_STAGE_SOLVED
7630  */
7631 extern
7633  SCIP* scip, /**< SCIP data structure */
7634  SCIP_VAR* var, /**< variable to get last strong branching values for */
7635  SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
7636  SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
7637  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
7638  * otherwise, it can only be used as an estimate value */
7639  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
7640  * otherwise, it can only be used as an estimate value */
7641  SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */
7642  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
7643  );
7644 
7645 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
7646  * given variable, or -1 if strong branching was never applied to the variable in current run
7647  *
7648  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7649  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7650  *
7651  * @pre This method can be called if @p scip is in one of the following stages:
7652  * - \ref SCIP_STAGE_TRANSFORMING
7653  * - \ref SCIP_STAGE_TRANSFORMED
7654  * - \ref SCIP_STAGE_INITPRESOLVE
7655  * - \ref SCIP_STAGE_PRESOLVING
7656  * - \ref SCIP_STAGE_EXITPRESOLVE
7657  * - \ref SCIP_STAGE_PRESOLVED
7658  * - \ref SCIP_STAGE_INITSOLVE
7659  * - \ref SCIP_STAGE_SOLVING
7660  * - \ref SCIP_STAGE_SOLVED
7661  * - \ref SCIP_STAGE_EXITSOLVE
7662  */
7663 extern
7665  SCIP* scip, /**< SCIP data structure */
7666  SCIP_VAR* var /**< variable to get last strong branching node for */
7667  );
7668 
7669 /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
7670  * the LP where the strong branching on this variable was applied;
7671  * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
7672  *
7673  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7674  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7675  *
7676  * @pre This method can be called if @p scip is in one of the following stages:
7677  * - \ref SCIP_STAGE_TRANSFORMING
7678  * - \ref SCIP_STAGE_TRANSFORMED
7679  * - \ref SCIP_STAGE_INITPRESOLVE
7680  * - \ref SCIP_STAGE_PRESOLVING
7681  * - \ref SCIP_STAGE_EXITPRESOLVE
7682  * - \ref SCIP_STAGE_PRESOLVED
7683  * - \ref SCIP_STAGE_INITSOLVE
7684  * - \ref SCIP_STAGE_SOLVING
7685  * - \ref SCIP_STAGE_SOLVED
7686  * - \ref SCIP_STAGE_EXITSOLVE
7687  */
7688 extern
7690  SCIP* scip, /**< SCIP data structure */
7691  SCIP_VAR* var /**< variable to get strong branching LP age for */
7692  );
7693 
7694 /** gets number of times, strong branching was applied in current run on the given variable
7695  *
7696  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7697  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7698  *
7699  * @pre This method can be called if @p scip is in one of the following stages:
7700  * - \ref SCIP_STAGE_TRANSFORMING
7701  * - \ref SCIP_STAGE_TRANSFORMED
7702  * - \ref SCIP_STAGE_INITPRESOLVE
7703  * - \ref SCIP_STAGE_PRESOLVING
7704  * - \ref SCIP_STAGE_EXITPRESOLVE
7705  * - \ref SCIP_STAGE_PRESOLVED
7706  * - \ref SCIP_STAGE_INITSOLVE
7707  * - \ref SCIP_STAGE_SOLVING
7708  * - \ref SCIP_STAGE_SOLVED
7709  * - \ref SCIP_STAGE_EXITSOLVE
7710  */
7711 extern
7713  SCIP* scip, /**< SCIP data structure */
7714  SCIP_VAR* var /**< variable to get last strong branching node for */
7715  );
7716 
7717 /** adds given values to lock numbers of variable for rounding
7718  *
7719  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7720  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7721  *
7722  * @pre This method can be called if @p scip is in one of the following stages:
7723  * - \ref SCIP_STAGE_PROBLEM
7724  * - \ref SCIP_STAGE_TRANSFORMING
7725  * - \ref SCIP_STAGE_TRANSFORMED
7726  * - \ref SCIP_STAGE_INITPRESOLVE
7727  * - \ref SCIP_STAGE_PRESOLVING
7728  * - \ref SCIP_STAGE_EXITPRESOLVE
7729  * - \ref SCIP_STAGE_PRESOLVED
7730  * - \ref SCIP_STAGE_INITSOLVE
7731  * - \ref SCIP_STAGE_SOLVING
7732  * - \ref SCIP_STAGE_EXITSOLVE
7733  * - \ref SCIP_STAGE_FREETRANS
7734  */
7735 extern
7737  SCIP* scip, /**< SCIP data structure */
7738  SCIP_VAR* var, /**< problem variable */
7739  int nlocksdown, /**< modification in number of rounding down locks */
7740  int nlocksup /**< modification in number of rounding up locks */
7741  );
7742 
7743 /** locks rounding of variable with respect to the lock status of the constraint and its negation;
7744  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
7745  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
7746  * added or removed
7747  *
7748  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7749  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7750  *
7751  * @pre This method can be called if @p scip is in one of the following stages:
7752  * - \ref SCIP_STAGE_PROBLEM
7753  * - \ref SCIP_STAGE_TRANSFORMING
7754  * - \ref SCIP_STAGE_INITPRESOLVE
7755  * - \ref SCIP_STAGE_PRESOLVING
7756  * - \ref SCIP_STAGE_EXITPRESOLVE
7757  * - \ref SCIP_STAGE_INITSOLVE
7758  * - \ref SCIP_STAGE_SOLVING
7759  * - \ref SCIP_STAGE_EXITSOLVE
7760  * - \ref SCIP_STAGE_FREETRANS
7761  */
7762 extern
7764  SCIP* scip, /**< SCIP data structure */
7765  SCIP_VAR* var, /**< problem variable */
7766  SCIP_CONS* cons, /**< constraint */
7767  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
7768  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
7769  );
7770 
7771 /** unlocks rounding of variable with respect to the lock status of the constraint and its negation;
7772  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
7773  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
7774  * added or removed
7775  *
7776  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7777  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7778  *
7779  * @pre This method can be called if @p scip is in one of the following stages:
7780  * - \ref SCIP_STAGE_PROBLEM
7781  * - \ref SCIP_STAGE_TRANSFORMING
7782  * - \ref SCIP_STAGE_INITPRESOLVE
7783  * - \ref SCIP_STAGE_PRESOLVING
7784  * - \ref SCIP_STAGE_EXITPRESOLVE
7785  * - \ref SCIP_STAGE_INITSOLVE
7786  * - \ref SCIP_STAGE_SOLVING
7787  * - \ref SCIP_STAGE_EXITSOLVE
7788  * - \ref SCIP_STAGE_FREETRANS
7789  */
7790 extern
7792  SCIP* scip, /**< SCIP data structure */
7793  SCIP_VAR* var, /**< problem variable */
7794  SCIP_CONS* cons, /**< constraint */
7795  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
7796  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
7797  );
7798 
7799 /** changes variable's objective value
7800  *
7801  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7802  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7803  *
7804  * @pre This method can be called if @p scip is in one of the following stages:
7805  * - \ref SCIP_STAGE_PROBLEM
7806  * - \ref SCIP_STAGE_TRANSFORMING
7807  * - \ref SCIP_STAGE_PRESOLVING
7808  */
7809 extern
7811  SCIP* scip, /**< SCIP data structure */
7812  SCIP_VAR* var, /**< variable to change the objective value for */
7813  SCIP_Real newobj /**< new objective value */
7814  );
7815 
7816 /** adds value to variable's objective value
7817  *
7818  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7819  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7820  *
7821  * @pre This method can be called if @p scip is in one of the following stages:
7822  * - \ref SCIP_STAGE_PROBLEM
7823  * - \ref SCIP_STAGE_TRANSFORMING
7824  * - \ref SCIP_STAGE_PRESOLVING
7825  */
7826 extern
7828  SCIP* scip, /**< SCIP data structure */
7829  SCIP_VAR* var, /**< variable to change the objective value for */
7830  SCIP_Real addobj /**< additional objective value */
7831  );
7832 
7833 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
7834  * does not change the bounds of the variable
7835  *
7836  * @return adjusted lower bound for the given variable; the bound of the variable is not changed
7837  *
7838  * @pre This method can be called if @p scip is in one of the following stages:
7839  * - \ref SCIP_STAGE_PROBLEM
7840  * - \ref SCIP_STAGE_TRANSFORMING
7841  * - \ref SCIP_STAGE_TRANSFORMED
7842  * - \ref SCIP_STAGE_INITPRESOLVE
7843  * - \ref SCIP_STAGE_PRESOLVING
7844  * - \ref SCIP_STAGE_EXITPRESOLVE
7845  * - \ref SCIP_STAGE_PRESOLVED
7846  * - \ref SCIP_STAGE_INITSOLVE
7847  * - \ref SCIP_STAGE_SOLVING
7848  * - \ref SCIP_STAGE_SOLVED
7849  * - \ref SCIP_STAGE_EXITSOLVE
7850  * - \ref SCIP_STAGE_FREETRANS
7851  */
7852 extern
7854  SCIP* scip, /**< SCIP data structure */
7855  SCIP_VAR* var, /**< variable to adjust the bound for */
7856  SCIP_Real lb /**< lower bound value to adjust */
7857  );
7858 
7859 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
7860  * does not change the bounds of the variable
7861  *
7862  * @return adjusted upper bound for the given variable; the bound of the variable is not changed
7863  *
7864  * @pre This method can be called if @p scip is in one of the following stages:
7865  * - \ref SCIP_STAGE_PROBLEM
7866  * - \ref SCIP_STAGE_TRANSFORMING
7867  * - \ref SCIP_STAGE_TRANSFORMED
7868  * - \ref SCIP_STAGE_INITPRESOLVE
7869  * - \ref SCIP_STAGE_PRESOLVING
7870  * - \ref SCIP_STAGE_EXITPRESOLVE
7871  * - \ref SCIP_STAGE_PRESOLVED
7872  * - \ref SCIP_STAGE_INITSOLVE
7873  * - \ref SCIP_STAGE_SOLVING
7874  * - \ref SCIP_STAGE_SOLVED
7875  * - \ref SCIP_STAGE_EXITSOLVE
7876  * - \ref SCIP_STAGE_FREETRANS
7877  */
7878 extern
7880  SCIP* scip, /**< SCIP data structure */
7881  SCIP_VAR* var, /**< variable to adjust the bound for */
7882  SCIP_Real ub /**< upper bound value to adjust */
7883  );
7884 
7885 /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
7886  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
7887  * that in conflict analysis, this change is treated like a branching decision
7888  *
7889  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7890  * SCIPgetVars()) gets resorted.
7891  *
7892  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7893  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7894  *
7895  * @pre This method can be called if @p scip is in one of the following stages:
7896  * - \ref SCIP_STAGE_PROBLEM
7897  * - \ref SCIP_STAGE_TRANSFORMING
7898  * - \ref SCIP_STAGE_PRESOLVING
7899  * - \ref SCIP_STAGE_SOLVING
7900  *
7901  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7902  */
7903 extern
7905  SCIP* scip, /**< SCIP data structure */
7906  SCIP_VAR* var, /**< variable to change the bound for */
7907  SCIP_Real newbound /**< new value for bound */
7908  );
7909 
7910 /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
7911  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
7912  * that in conflict analysis, this change is treated like a branching decision
7913  *
7914  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7915  * SCIPgetVars()) gets resorted.
7916  *
7917  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7918  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7919  *
7920  * @pre This method can be called if @p scip is in one of the following stages:
7921  * - \ref SCIP_STAGE_PROBLEM
7922  * - \ref SCIP_STAGE_TRANSFORMING
7923  * - \ref SCIP_STAGE_PRESOLVING
7924  * - \ref SCIP_STAGE_SOLVING
7925  *
7926  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7927  */
7928 extern
7930  SCIP* scip, /**< SCIP data structure */
7931  SCIP_VAR* var, /**< variable to change the bound for */
7932  SCIP_Real newbound /**< new value for bound */
7933  );
7934 
7935 /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
7936  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
7937  * decision
7938  *
7939  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7940  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7941  *
7942  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7943  */
7944 extern
7946  SCIP* scip, /**< SCIP data structure */
7947  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
7948  SCIP_VAR* var, /**< variable to change the bound for */
7949  SCIP_Real newbound /**< new value for bound */
7950  );
7951 
7952 /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
7953  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
7954  * decision
7955  *
7956  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7957  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7958  *
7959  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7960  */
7961 extern
7963  SCIP* scip, /**< SCIP data structure */
7964  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
7965  SCIP_VAR* var, /**< variable to change the bound for */
7966  SCIP_Real newbound /**< new value for bound */
7967  );
7968 
7969 /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
7970  * if the global bound is better than the local bound
7971  *
7972  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7973  * SCIPgetVars()) gets resorted.
7974  *
7975  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7976  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7977  *
7978  * @pre This method can be called if @p scip is in one of the following stages:
7979  * - \ref SCIP_STAGE_PROBLEM
7980  * - \ref SCIP_STAGE_TRANSFORMING
7981  * - \ref SCIP_STAGE_PRESOLVING
7982  * - \ref SCIP_STAGE_SOLVING
7983  *
7984  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7985  */
7986 extern
7988  SCIP* scip, /**< SCIP data structure */
7989  SCIP_VAR* var, /**< variable to change the bound for */
7990  SCIP_Real newbound /**< new value for bound */
7991  );
7992 
7993 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
7994  * if the global bound is better than the local bound
7995  *
7996  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7997  * SCIPgetVars()) gets resorted.
7998  *
7999  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8000  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8001  *
8002  * @pre This method can be called if @p scip is in one of the following stages:
8003  * - \ref SCIP_STAGE_PROBLEM
8004  * - \ref SCIP_STAGE_TRANSFORMING
8005  * - \ref SCIP_STAGE_PRESOLVING
8006  * - \ref SCIP_STAGE_SOLVING
8007  *
8008  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8009  */
8010 extern
8012  SCIP* scip, /**< SCIP data structure */
8013  SCIP_VAR* var, /**< variable to change the bound for */
8014  SCIP_Real newbound /**< new value for bound */
8015  );
8016 
8017 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
8018  *
8019  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
8020  * to be put into the LP explicitly.
8021  *
8022  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8023  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8024  *
8025  * @pre This method can be called if @p scip is in one of the following stages:
8026  * - \ref SCIP_STAGE_PROBLEM
8027  * - \ref SCIP_STAGE_TRANSFORMING
8028  * - \ref SCIP_STAGE_TRANSFORMED
8029  * - \ref SCIP_STAGE_PRESOLVING
8030  * - \ref SCIP_STAGE_SOLVING
8031  *
8032  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
8033  */
8034 extern
8036  SCIP* scip, /**< SCIP data structure */
8037  SCIP_VAR* var, /**< problem variable */
8038  SCIP_Real lazylb /**< the lazy lower bound to be set */
8039  );
8040 
8041 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
8042  *
8043  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
8044  * to be put into the LP explicitly.
8045  *
8046  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8047  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8048  *
8049  * @pre This method can be called if @p scip is in one of the following stages:
8050  * - \ref SCIP_STAGE_PROBLEM
8051  * - \ref SCIP_STAGE_TRANSFORMING
8052  * - \ref SCIP_STAGE_TRANSFORMED
8053  * - \ref SCIP_STAGE_PRESOLVING
8054  * - \ref SCIP_STAGE_SOLVING
8055  *
8056  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
8057  */
8058 extern
8060  SCIP* scip, /**< SCIP data structure */
8061  SCIP_VAR* var, /**< problem variable */
8062  SCIP_Real lazyub /**< the lazy lower bound to be set */
8063  );
8064 
8065 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8066  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8067  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
8068  * is treated like a branching decision
8069  *
8070  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8071  * SCIPgetVars()) gets resorted.
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_PROBLEM
8078  * - \ref SCIP_STAGE_PRESOLVING
8079  * - \ref SCIP_STAGE_SOLVING
8080  *
8081  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8082  */
8083 extern
8085  SCIP* scip, /**< SCIP data structure */
8086  SCIP_VAR* var, /**< variable to change the bound for */
8087  SCIP_Real newbound, /**< new value for bound */
8088  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8089  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
8090  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8091  );
8092 
8093 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
8094  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8095  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
8096  * is treated like a branching decision
8097  *
8098  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8099  * SCIPgetVars()) gets resorted.
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_PROBLEM
8106  * - \ref SCIP_STAGE_PRESOLVING
8107  * - \ref SCIP_STAGE_SOLVING
8108  *
8109  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8110  */
8111 extern
8113  SCIP* scip, /**< SCIP data structure */
8114  SCIP_VAR* var, /**< variable to change the bound for */
8115  SCIP_Real newbound, /**< new value for bound */
8116  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8117  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
8118  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8119  );
8120 
8121 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
8122  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
8123  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
8124  *
8125  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
8126  * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
8127  * SCIPinferVarUbCons
8128  *
8129  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
8130  * SCIPgetVars()) gets resorted.
8131  *
8132  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
8133  */
8134 extern
8136  SCIP* scip, /**< SCIP data structure */
8137  SCIP_VAR* var, /**< variable to change the bound for */
8138  SCIP_Real fixedval, /**< new value for fixation */
8139  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
8140  int inferinfo, /**< user information for inference to help resolving the conflict */
8141  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8142  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8143  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8144  );
8145 
8146 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8147  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8148  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
8149  * for the deduction of the bound change
8150  *
8151  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8152  * SCIPgetVars()) gets resorted.
8153  *
8154  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8155  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8156  *
8157  * @pre This method can be called if @p scip is in one of the following stages:
8158  * - \ref SCIP_STAGE_PROBLEM
8159  * - \ref SCIP_STAGE_PRESOLVING
8160  * - \ref SCIP_STAGE_SOLVING
8161  *
8162  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8163  */
8164 extern
8166  SCIP* scip, /**< SCIP data structure */
8167  SCIP_VAR* var, /**< variable to change the bound for */
8168  SCIP_Real newbound, /**< new value for bound */
8169  SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
8170  int inferinfo, /**< user information for inference to help resolving the conflict */
8171  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8172  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8173  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8174  );
8175 
8176 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
8177  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8178  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
8179  * for the deduction of the bound change
8180  *
8181  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8182  * SCIPgetVars()) gets resorted.
8183  *
8184  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8185  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8186  *
8187  * @pre This method can be called if @p scip is in one of the following stages:
8188  * - \ref SCIP_STAGE_PROBLEM
8189  * - \ref SCIP_STAGE_PRESOLVING
8190  * - \ref SCIP_STAGE_SOLVING
8191  *
8192  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8193  */
8194 extern
8196  SCIP* scip, /**< SCIP data structure */
8197  SCIP_VAR* var, /**< variable to change the bound for */
8198  SCIP_Real newbound, /**< new value for bound */
8199  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
8200  int inferinfo, /**< user information for inference to help resolving the conflict */
8201  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8202  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8203  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8204  );
8205 
8206 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
8207  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
8208  * deduction of the fixing
8209  *
8210  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8211  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8212  *
8213  * @pre This method can be called if @p scip is in one of the following stages:
8214  * - \ref SCIP_STAGE_PROBLEM
8215  * - \ref SCIP_STAGE_PRESOLVING
8216  * - \ref SCIP_STAGE_SOLVING
8217  */
8218 extern
8220  SCIP* scip, /**< SCIP data structure */
8221  SCIP_VAR* var, /**< binary variable to fix */
8222  SCIP_Bool fixedval, /**< value to fix binary variable to */
8223  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
8224  int inferinfo, /**< user information for inference to help resolving the conflict */
8225  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
8226  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
8227  );
8228 
8229 /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
8230  * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
8231  * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
8232  *
8233  * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
8234  * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
8235  * SCIPinferVarUbProp
8236  *
8237  * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
8238  * SCIPgetVars()) gets resorted.
8239  *
8240  * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
8241  */
8242 extern
8244  SCIP* scip, /**< SCIP data structure */
8245  SCIP_VAR* var, /**< variable to change the bound for */
8246  SCIP_Real fixedval, /**< new value for fixation */
8247  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
8248  int inferinfo, /**< user information for inference to help resolving the conflict */
8249  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8250  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8251  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8252  );
8253 
8254 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8255  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8256  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
8257  * for the deduction of the bound change
8258  *
8259  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8260  * SCIPgetVars()) gets resorted.
8261  *
8262  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8263  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8264  *
8265  * @pre This method can be called if @p scip is in one of the following stages:
8266  * - \ref SCIP_STAGE_PROBLEM
8267  * - \ref SCIP_STAGE_PRESOLVING
8268  * - \ref SCIP_STAGE_SOLVING
8269  *
8270  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8271  */
8272 extern
8274  SCIP* scip, /**< SCIP data structure */
8275  SCIP_VAR* var, /**< variable to change the bound for */
8276  SCIP_Real newbound, /**< new value for bound */
8277  SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
8278  int inferinfo, /**< user information for inference to help resolving the conflict */
8279  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8280  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8281  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8282  );
8283 
8284 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
8285  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
8286  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
8287  * for the deduction of the bound change
8288  *
8289  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8290  * SCIPgetVars()) gets resorted.
8291  *
8292  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8293  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8294  *
8295  * @pre This method can be called if @p scip is in one of the following stages:
8296  * - \ref SCIP_STAGE_PROBLEM
8297  * - \ref SCIP_STAGE_PRESOLVING
8298  * - \ref SCIP_STAGE_SOLVING
8299  *
8300  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8301  */
8302 extern
8304  SCIP* scip, /**< SCIP data structure */
8305  SCIP_VAR* var, /**< variable to change the bound for */
8306  SCIP_Real newbound, /**< new value for bound */
8307  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
8308  int inferinfo, /**< user information for inference to help resolving the conflict */
8309  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8310  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
8311  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8312  );
8313 
8314 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
8315  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
8316  * deduction of the fixing
8317  *
8318  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8319  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8320  *
8321  * @pre This method can be called if @p scip is in one of the following stages:
8322  * - \ref SCIP_STAGE_PROBLEM
8323  * - \ref SCIP_STAGE_PRESOLVING
8324  * - \ref SCIP_STAGE_PRESOLVED
8325  * - \ref SCIP_STAGE_SOLVING
8326  */
8327 extern
8329  SCIP* scip, /**< SCIP data structure */
8330  SCIP_VAR* var, /**< binary variable to fix */
8331  SCIP_Bool fixedval, /**< value to fix binary variable to */
8332  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
8333  int inferinfo, /**< user information for inference to help resolving the conflict */
8334  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
8335  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
8336  );
8337 
8338 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
8339  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
8340  * also tightens the local bound, if the global bound is better than the local bound
8341  *
8342  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8343  * SCIPgetVars()) gets resorted.
8344  *
8345  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8346  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8347  *
8348  * @pre This method can be called if @p scip is in one of the following stages:
8349  * - \ref SCIP_STAGE_PROBLEM
8350  * - \ref SCIP_STAGE_TRANSFORMING
8351  * - \ref SCIP_STAGE_PRESOLVING
8352  * - \ref SCIP_STAGE_SOLVING
8353  *
8354  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8355  */
8356 extern
8358  SCIP* scip, /**< SCIP data structure */
8359  SCIP_VAR* var, /**< variable to change the bound for */
8360  SCIP_Real newbound, /**< new value for bound */
8361  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8362  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
8363  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8364  );
8365 
8366 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
8367  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
8368  * also tightens the local bound, if the global bound is better than the local bound
8369  *
8370  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
8371  * SCIPgetVars()) gets resorted.
8372  *
8373  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8374  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8375  *
8376  * @pre This method can be called if @p scip is in one of the following stages:
8377  * - \ref SCIP_STAGE_PROBLEM
8378  * - \ref SCIP_STAGE_TRANSFORMING
8379  * - \ref SCIP_STAGE_PRESOLVING
8380  * - \ref SCIP_STAGE_SOLVING
8381  *
8382  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
8383  */
8384 extern
8386  SCIP* scip, /**< SCIP data structure */
8387  SCIP_VAR* var, /**< variable to change the bound for */
8388  SCIP_Real newbound, /**< new value for bound */
8389  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
8390  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
8391  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
8392  );
8393 
8394 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
8395  *
8396  * 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
8397  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
8398  *
8399  * @return the global lower bound computed by adding the global bounds from all aggregation variables
8400  */
8401 extern
8403  SCIP* scip, /**< SCIP data structure */
8404  SCIP_VAR* var /**< variable to compute the bound for */
8405  );
8406 
8407 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
8408  *
8409  * 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
8410  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
8411  *
8412  * @return the global upper bound computed by adding the global bounds from all aggregation variables
8413  */
8414 extern
8416  SCIP* scip, /**< SCIP data structure */
8417  SCIP_VAR* var /**< variable to compute the bound for */
8418  );
8419 
8420 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
8421  *
8422  * 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
8423  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
8424  *
8425  * @return the local lower bound computed by adding the global bounds from all aggregation variables
8426  */
8427 extern
8429  SCIP* scip, /**< SCIP data structure */
8430  SCIP_VAR* var /**< variable to compute the bound for */
8431  );
8432 
8433 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
8434  *
8435  * 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
8436  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
8437  *
8438  * @return the local upper bound computed by adding the global bounds from all aggregation variables
8439  */
8440 extern
8442  SCIP* scip, /**< SCIP data structure */
8443  SCIP_VAR* var /**< variable to compute the bound for */
8444  );
8445 
8446 /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
8447  * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
8448  * not updated if bounds of aggregation variables are changing
8449  *
8450  * calling this function for a non-multi-aggregated variable is not allowed
8451  */
8452 extern
8454  SCIP* scip, /**< SCIP data structure */
8455  SCIP_VAR* var /**< variable to compute the bound for */
8456  );
8457 
8458 /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
8459  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
8460  * not updated if bounds of aggregation variables are changing
8461  *
8462  * calling this function for a non-multi-aggregated variable is not allowed
8463  */
8464 extern
8466  SCIP* scip, /**< SCIP data structure */
8467  SCIP_VAR* var /**< variable to compute the bound for */
8468  );
8469 
8470 /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
8471  * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
8472  * not updated if bounds of aggregation variables are changing
8473  *
8474  * calling this function for a non-multi-aggregated variable is not allowed
8475  */
8476 extern
8478  SCIP* scip, /**< SCIP data structure */
8479  SCIP_VAR* var /**< variable to compute the bound for */
8480  );
8481 
8482 /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
8483  * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
8484  * not updated if bounds of aggregation variables are changing
8485  *
8486  * calling this function for a non-multi-aggregated variable is not allowed
8487  */
8488 extern
8490  SCIP* scip, /**< SCIP data structure */
8491  SCIP_VAR* var /**< variable to compute the bound for */
8492  );
8493 
8494 #ifdef NDEBUG
8495 
8496 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
8497  * speed up the algorithms.
8498  */
8499 
8500 #define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
8501 #define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
8502 #define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
8503 #define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
8504 
8505 #endif
8506 
8507 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
8508  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
8509  * available
8510  *
8511  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8512  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8513  *
8514  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8515  */
8516 extern
8518  SCIP* scip, /**< SCIP data structure */
8519  SCIP_VAR* var, /**< active problem variable */
8520  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
8521  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
8522  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
8523  );
8524 
8525 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
8526  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
8527  *
8528  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8529  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8530  *
8531  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8532  */
8533 extern
8535  SCIP* scip, /**< SCIP data structure */
8536  SCIP_VAR* var, /**< active problem variable */
8537  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
8538  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
8539  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
8540  );
8541 
8542 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
8543  * if z is binary, the corresponding valid implication for z is also added;
8544  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
8545  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
8546  * improves the global bounds of the variable and the vlb variable if possible
8547  *
8548  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8549  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8550  *
8551  * @pre This method can be called if @p scip is in one of the following stages:
8552  * - \ref SCIP_STAGE_PRESOLVING
8553  * - \ref SCIP_STAGE_PRESOLVED
8554  * - \ref SCIP_STAGE_SOLVING
8555  */
8556 extern
8558  SCIP* scip, /**< SCIP data structure */
8559  SCIP_VAR* var, /**< problem variable */
8560  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
8561  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
8562  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
8563  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
8564  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
8565  );
8566 
8567 
8568 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
8569  * if z is binary, the corresponding valid implication for z is also added;
8570  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
8571  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
8572  * improves the global bounds of the variable and the vlb variable if possible
8573  *
8574  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8575  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8576  *
8577  * @pre This method can be called if @p scip is in one of the following stages:
8578  * - \ref SCIP_STAGE_PRESOLVING
8579  * - \ref SCIP_STAGE_PRESOLVED
8580  * - \ref SCIP_STAGE_SOLVING
8581  */
8582 extern
8584  SCIP* scip, /**< SCIP data structure */
8585  SCIP_VAR* var, /**< problem variable */
8586  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
8587  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
8588  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
8589  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
8590  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
8591  );
8592 
8593 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
8594  * also adds the corresponding implication or variable bound to the implied variable;
8595  * if the implication is conflicting, the variable is fixed to the opposite value;
8596  * if the variable is already fixed to the given value, the implication is performed immediately;
8597  * if the implication is redundant with respect to the variables' global bounds, it is ignored
8598  *
8599  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8600  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8601  *
8602  * @pre This method can be called if @p scip is in one of the following stages:
8603  * - \ref SCIP_STAGE_TRANSFORMED
8604  * - \ref SCIP_STAGE_PRESOLVING
8605  * - \ref SCIP_STAGE_PRESOLVED
8606  * - \ref SCIP_STAGE_SOLVING
8607  */
8608 extern
8610  SCIP* scip, /**< SCIP data structure */
8611  SCIP_VAR* var, /**< problem variable */
8612  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
8613  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
8614  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
8615  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
8616  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
8617  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
8618  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
8619  );
8620 
8621 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
8622  * if a variable appears twice in the same clique, the corresponding implications are performed
8623  *
8624  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8625  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8626  *
8627  * @pre This method can be called if @p scip is in one of the following stages:
8628  * - \ref SCIP_STAGE_TRANSFORMED
8629  * - \ref SCIP_STAGE_PRESOLVING
8630  * - \ref SCIP_STAGE_PRESOLVED
8631  * - \ref SCIP_STAGE_SOLVING
8632  */
8633 extern
8635  SCIP* scip, /**< SCIP data structure */
8636  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
8637  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
8638  int nvars, /**< number of variables in the clique */
8639  SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
8640  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
8641  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
8642  );
8643 
8644 /** calculates a partition of the given set of binary variables into cliques;
8645  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
8646  * were assigned to the same clique;
8647  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
8648  * the preceding variables was assigned to clique i-1;
8649  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
8650  *
8651  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8652  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8653  *
8654  * @pre This method can be called if @p scip is in one of the following stages:
8655  * - \ref SCIP_STAGE_INITPRESOLVE
8656  * - \ref SCIP_STAGE_PRESOLVING
8657  * - \ref SCIP_STAGE_EXITPRESOLVE
8658  * - \ref SCIP_STAGE_PRESOLVED
8659  * - \ref SCIP_STAGE_SOLVING
8660  */
8661 extern
8663  SCIP*const scip, /**< SCIP data structure */
8664  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
8665  int const nvars, /**< number of variables in the clique */
8666  int*const cliquepartition, /**< array of length nvars to store the clique partition */
8667  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
8668  );
8669 
8670 /** calculates a partition of the given set of binary variables into negated cliques;
8671  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
8672  * were assigned to the same negated clique;
8673  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
8674  * the preceding variables was assigned to clique i-1;
8675  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
8676  *
8677  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8678  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8679  *
8680  * @pre This method can be called if @p scip is in one of the following stages:
8681  * - \ref SCIP_STAGE_INITPRESOLVE
8682  * - \ref SCIP_STAGE_PRESOLVING
8683  * - \ref SCIP_STAGE_EXITPRESOLVE
8684  * - \ref SCIP_STAGE_PRESOLVED
8685  * - \ref SCIP_STAGE_SOLVING
8686  */
8687 extern
8689  SCIP*const scip, /**< SCIP data structure */
8690  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
8691  int const nvars, /**< number of variables in the clique */
8692  int*const cliquepartition, /**< array of length nvars to store the clique partition */
8693  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
8694  );
8695 
8696 /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
8697  * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
8698  *
8699  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
8700  *
8701  * @pre This method can be called if @p scip is in one of the following stages:
8702  * - \ref SCIP_STAGE_TRANSFORMED
8703  * - \ref SCIP_STAGE_INITPRESOLVE
8704  * - \ref SCIP_STAGE_PRESOLVING
8705  * - \ref SCIP_STAGE_EXITPRESOLVE
8706  * - \ref SCIP_STAGE_PRESOLVED
8707  * - \ref SCIP_STAGE_INITSOLVE
8708  * - \ref SCIP_STAGE_SOLVING
8709  * - \ref SCIP_STAGE_SOLVED
8710  * - \ref SCIP_STAGE_EXITSOLVE
8711  */
8712 extern
8714  SCIP* scip, /**< SCIP data structure */
8715  SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
8716  );
8717 
8718 /** gets the number of cliques in the clique table
8719  *
8720  * @return number of cliques in the clique table
8721  *
8722  * @pre This method can be called if @p scip is in one of the following stages:
8723  * - \ref SCIP_STAGE_TRANSFORMED
8724  * - \ref SCIP_STAGE_INITPRESOLVE
8725  * - \ref SCIP_STAGE_PRESOLVING
8726  * - \ref SCIP_STAGE_EXITPRESOLVE
8727  * - \ref SCIP_STAGE_PRESOLVED
8728  * - \ref SCIP_STAGE_INITSOLVE
8729  * - \ref SCIP_STAGE_SOLVING
8730  * - \ref SCIP_STAGE_SOLVED
8731  * - \ref SCIP_STAGE_EXITSOLVE
8732  */
8733 extern
8734 int SCIPgetNCliques(
8735  SCIP* scip /**< SCIP data structure */
8736  );
8737 
8738 /** gets the array of cliques in the clique table
8739  *
8740  * @return array of cliques in the clique table
8741  *
8742  * @pre This method can be called if @p scip is in one of the following stages:
8743  * - \ref SCIP_STAGE_TRANSFORMED
8744  * - \ref SCIP_STAGE_INITPRESOLVE
8745  * - \ref SCIP_STAGE_PRESOLVING
8746  * - \ref SCIP_STAGE_EXITPRESOLVE
8747  * - \ref SCIP_STAGE_PRESOLVED
8748  * - \ref SCIP_STAGE_INITSOLVE
8749  * - \ref SCIP_STAGE_SOLVING
8750  * - \ref SCIP_STAGE_SOLVED
8751  * - \ref SCIP_STAGE_EXITSOLVE
8752  */
8753 extern
8755  SCIP* scip /**< SCIP data structure */
8756  );
8757 
8758 /** returns whether there is a clique that contains both given variable/value pairs;
8759  * the variables must be active binary variables;
8760  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
8761  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
8762  *
8763  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
8764  *
8765  * @pre This method can be called if @p scip is in one of the following stages:
8766  * - \ref SCIP_STAGE_TRANSFORMED
8767  * - \ref SCIP_STAGE_INITPRESOLVE
8768  * - \ref SCIP_STAGE_PRESOLVING
8769  * - \ref SCIP_STAGE_EXITPRESOLVE
8770  * - \ref SCIP_STAGE_PRESOLVED
8771  * - \ref SCIP_STAGE_INITSOLVE
8772  * - \ref SCIP_STAGE_SOLVING
8773  * - \ref SCIP_STAGE_SOLVED
8774  * - \ref SCIP_STAGE_EXITSOLVE
8775  *
8776  * @note a variable with it's negated variable are NOT! in a clique
8777  * @note a variable with itself are in a clique
8778  */
8779 extern
8781  SCIP* scip, /**< SCIP data structure */
8782  SCIP_VAR* var1, /**< first variable */
8783  SCIP_Bool value1, /**< value of first variable */
8784  SCIP_VAR* var2, /**< second variable */
8785  SCIP_Bool value2, /**< value of second variable */
8786  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
8787  );
8788 
8789 /** writes the clique graph to a gml file
8790  *
8791  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8792  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8793  *
8794  * @pre This method can be called if @p scip is in one of the following stages:
8795  * - \ref SCIP_STAGE_TRANSFORMED
8796  * - \ref SCIP_STAGE_INITPRESOLVE
8797  * - \ref SCIP_STAGE_PRESOLVING
8798  * - \ref SCIP_STAGE_EXITPRESOLVE
8799  * - \ref SCIP_STAGE_PRESOLVED
8800  * - \ref SCIP_STAGE_INITSOLVE
8801  * - \ref SCIP_STAGE_SOLVING
8802  * - \ref SCIP_STAGE_SOLVED
8803  * - \ref SCIP_STAGE_EXITSOLVE
8804  *
8805  * @note there can be duplicated arcs in the output file
8806  *
8807  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
8808  * between such nodes are written.
8809  */
8810 extern
8812  SCIP* scip, /**< SCIP data structure */
8813  const char* fname, /**< name of file */
8814  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
8815  );
8816 
8817 /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
8818  * This is an advanced method which should be used with care.
8819  *
8820  * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
8821  *
8822  * @pre This method can be called if @p scip is in one of the following stages:
8823  * - \ref SCIP_STAGE_TRANSFORMED
8824  * - \ref SCIP_STAGE_INITPRESOLVE
8825  * - \ref SCIP_STAGE_PRESOLVING
8826  * - \ref SCIP_STAGE_EXITPRESOLVE
8827  * - \ref SCIP_STAGE_PRESOLVED
8828  * - \ref SCIP_STAGE_INITSOLVE
8829  * - \ref SCIP_STAGE_SOLVING
8830  * - \ref SCIP_STAGE_SOLVED
8831  * - \ref SCIP_STAGE_EXITSOLVE
8832  */
8833 extern
8835  SCIP* scip, /**< SCIP data structure */
8836  SCIP_VAR* var /**< variable to remove from global structures */
8837  );
8838 
8839 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
8840  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
8841  *
8842  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8843  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8844  *
8845  * @pre This method can be called if @p scip is in one of the following stages:
8846  * - \ref SCIP_STAGE_PROBLEM
8847  * - \ref SCIP_STAGE_TRANSFORMING
8848  * - \ref SCIP_STAGE_TRANSFORMED
8849  * - \ref SCIP_STAGE_INITPRESOLVE
8850  * - \ref SCIP_STAGE_PRESOLVING
8851  * - \ref SCIP_STAGE_EXITPRESOLVE
8852  * - \ref SCIP_STAGE_PRESOLVED
8853  * - \ref SCIP_STAGE_SOLVING
8854  */
8855 extern
8857  SCIP* scip, /**< SCIP data structure */
8858  SCIP_VAR* var, /**< problem variable */
8859  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
8860  );
8861 
8862 /** scales the branch factor of the variable with the given value
8863  *
8864  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8865  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8866  *
8867  * @pre This method can be called if @p scip is in one of the following stages:
8868  * - \ref SCIP_STAGE_PROBLEM
8869  * - \ref SCIP_STAGE_TRANSFORMING
8870  * - \ref SCIP_STAGE_TRANSFORMED
8871  * - \ref SCIP_STAGE_INITPRESOLVE
8872  * - \ref SCIP_STAGE_PRESOLVING
8873  * - \ref SCIP_STAGE_EXITPRESOLVE
8874  * - \ref SCIP_STAGE_PRESOLVED
8875  * - \ref SCIP_STAGE_SOLVING
8876  */
8877 extern
8879  SCIP* scip, /**< SCIP data structure */
8880  SCIP_VAR* var, /**< problem variable */
8881  SCIP_Real scale /**< factor to scale variable's branching factor with */
8882  );
8883 
8884 /** adds the given value to the branch factor of the variable
8885  *
8886  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8887  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8888  *
8889  * @pre This method can be called if @p scip is in one of the following stages:
8890  * - \ref SCIP_STAGE_PROBLEM
8891  * - \ref SCIP_STAGE_TRANSFORMING
8892  * - \ref SCIP_STAGE_TRANSFORMED
8893  * - \ref SCIP_STAGE_INITPRESOLVE
8894  * - \ref SCIP_STAGE_PRESOLVING
8895  * - \ref SCIP_STAGE_EXITPRESOLVE
8896  * - \ref SCIP_STAGE_PRESOLVED
8897  * - \ref SCIP_STAGE_SOLVING
8898  */
8899 extern
8901  SCIP* scip, /**< SCIP data structure */
8902  SCIP_VAR* var, /**< problem variable */
8903  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
8904  );
8905 
8906 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
8907  * with lower priority in selection of branching variable
8908  *
8909  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8910  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8911  *
8912  * @pre This method can be called if @p scip is in one of the following stages:
8913  * - \ref SCIP_STAGE_PROBLEM
8914  * - \ref SCIP_STAGE_TRANSFORMING
8915  * - \ref SCIP_STAGE_TRANSFORMED
8916  * - \ref SCIP_STAGE_INITPRESOLVE
8917  * - \ref SCIP_STAGE_PRESOLVING
8918  * - \ref SCIP_STAGE_EXITPRESOLVE
8919  * - \ref SCIP_STAGE_PRESOLVED
8920  * - \ref SCIP_STAGE_SOLVING
8921  *
8922  * @note the default branching priority is 0
8923  */
8924 extern
8926  SCIP* scip, /**< SCIP data structure */
8927  SCIP_VAR* var, /**< problem variable */
8928  int branchpriority /**< branch priority of the variable */
8929  );
8930 
8931 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
8932  *
8933  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8934  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8935  *
8936  * @pre This method can be called if @p scip is in one of the following stages:
8937  * - \ref SCIP_STAGE_PROBLEM
8938  * - \ref SCIP_STAGE_TRANSFORMING
8939  * - \ref SCIP_STAGE_TRANSFORMED
8940  * - \ref SCIP_STAGE_INITPRESOLVE
8941  * - \ref SCIP_STAGE_PRESOLVING
8942  * - \ref SCIP_STAGE_EXITPRESOLVE
8943  * - \ref SCIP_STAGE_PRESOLVED
8944  * - \ref SCIP_STAGE_SOLVING
8945  */
8946 extern
8948  SCIP* scip, /**< SCIP data structure */
8949  SCIP_VAR* var, /**< problem variable */
8950  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
8951  );
8952 
8953 /** adds the given value to the branch priority of the variable
8954  *
8955  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8956  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8957  *
8958  * @pre This method can be called if @p scip is in one of the following stages:
8959  * - \ref SCIP_STAGE_PROBLEM
8960  * - \ref SCIP_STAGE_TRANSFORMING
8961  * - \ref SCIP_STAGE_TRANSFORMED
8962  * - \ref SCIP_STAGE_INITPRESOLVE
8963  * - \ref SCIP_STAGE_PRESOLVING
8964  * - \ref SCIP_STAGE_EXITPRESOLVE
8965  * - \ref SCIP_STAGE_PRESOLVED
8966  * - \ref SCIP_STAGE_SOLVING
8967  */
8968 extern
8970  SCIP* scip, /**< SCIP data structure */
8971  SCIP_VAR* var, /**< problem variable */
8972  int addpriority /**< value to add to the branch priority of the variable */
8973  );
8974 
8975 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
8976  * branch)
8977  *
8978  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8979  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8980  *
8981  * @pre This method can be called if @p scip is in one of the following stages:
8982  * - \ref SCIP_STAGE_PROBLEM
8983  * - \ref SCIP_STAGE_TRANSFORMING
8984  * - \ref SCIP_STAGE_TRANSFORMED
8985  * - \ref SCIP_STAGE_INITPRESOLVE
8986  * - \ref SCIP_STAGE_PRESOLVING
8987  * - \ref SCIP_STAGE_EXITPRESOLVE
8988  * - \ref SCIP_STAGE_PRESOLVED
8989  * - \ref SCIP_STAGE_SOLVING
8990  */
8991 extern
8993  SCIP* scip, /**< SCIP data structure */
8994  SCIP_VAR* var, /**< problem variable */
8995  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
8996  );
8997 
8998 /** changes type of variable in the problem;
8999  *
9000  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
9001  *
9002  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9003  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9004  *
9005  * @pre This method can be called if @p scip is in one of the following stages:
9006  * - \ref SCIP_STAGE_PROBLEM
9007  * - \ref SCIP_STAGE_TRANSFORMING
9008  * - \ref SCIP_STAGE_PRESOLVING
9009  *
9010  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
9011  * corresponding transformed variable is changed; the type of the original variable does not change
9012  *
9013  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
9014  * adjusted w.r.t. to integrality information
9015  */
9016 extern
9018  SCIP* scip, /**< SCIP data structure */
9019  SCIP_VAR* var, /**< variable to change the bound for */
9020  SCIP_VARTYPE vartype, /**< new type of variable */
9021  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
9022  * integrality condition of the new variable type) */
9023  );
9024 
9025 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
9026  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
9027  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
9028  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
9029  *
9030  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9031  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9032  *
9033  * @pre This method can be called if @p scip is in one of the following stages:
9034  * - \ref SCIP_STAGE_PROBLEM
9035  * - \ref SCIP_STAGE_PRESOLVING
9036  * - \ref SCIP_STAGE_SOLVING
9037  */
9038 extern
9040  SCIP* scip, /**< SCIP data structure */
9041  SCIP_VAR* var, /**< variable to fix */
9042  SCIP_Real fixedval, /**< value to fix variable to */
9043  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
9044  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
9045  );
9046 
9047 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
9048  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
9049  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
9050  * In the first step, the equality is transformed into an equality with active problem variables
9051  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
9052  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
9053  * infeasibility) otherwise.
9054  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
9055  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
9056  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
9057  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
9058  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
9059  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
9060  *
9061  * The output flags have the following meaning:
9062  * - infeasible: the problem is infeasible
9063  * - redundant: the equality can be deleted from the constraint set
9064  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
9065  *
9066  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9067  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9068  *
9069  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
9070  */
9071 extern
9073  SCIP* scip, /**< SCIP data structure */
9074  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
9075  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
9076  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
9077  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
9078  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
9079  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
9080  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
9081  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
9082  );
9083 
9084 /** converts variable into multi-aggregated variable; this changes the variable array returned from
9085  * SCIPgetVars() and SCIPgetVarsData();
9086  *
9087  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
9088  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
9089  * implies integrality on the aggregated variable.
9090  *
9091  * The output flags have the following meaning:
9092  * - infeasible: the problem is infeasible
9093  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
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 only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
9099  */
9100 extern
9102  SCIP* scip, /**< SCIP data structure */
9103  SCIP_VAR* var, /**< variable x to aggregate */
9104  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9105  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9106  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9107  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
9108  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
9109  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
9110  );
9111 
9112 /** returns whether aggregation of variables is not allowed */
9113 extern
9115  SCIP* scip /**< SCIP data structure */
9116  );
9117 
9118 /** returns whether multi-aggregation is disabled */
9119 extern
9121  SCIP* scip /**< SCIP data structure */
9122  );
9123 
9124 /** returns whether variable is not allowed to be multi-aggregated */
9125 extern
9127  SCIP* scip, /**< SCIP data structure */
9128  SCIP_VAR* var /**< variable x to aggregate */
9129  );
9130 
9131 /** returns whether dual reductions propagation methods and presolvers is allowed */
9132 extern
9134  SCIP* scip /**< SCIP data structure */
9135  );
9136 
9137 /** returns whether propagation w.r.t. current objective is allowed */
9138 extern
9140  SCIP* scip /**< SCIP data structure */
9141  );
9142 
9143 /** marks the variable that it must not be multi-aggregated
9144  *
9145  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9146  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9147  *
9148  * @pre This method can be called if @p scip is in one of the following stages:
9149  * - \ref SCIP_STAGE_INIT
9150  * - \ref SCIP_STAGE_PROBLEM
9151  * - \ref SCIP_STAGE_TRANSFORMING
9152  * - \ref SCIP_STAGE_TRANSFORMED
9153  * - \ref SCIP_STAGE_INITPRESOLVE
9154  * - \ref SCIP_STAGE_PRESOLVING
9155  * - \ref SCIP_STAGE_EXITPRESOLVE
9156  *
9157  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
9158  * multi-aggregated that this is will be the case.
9159  */
9160 extern
9162  SCIP* scip, /**< SCIP data structure */
9163  SCIP_VAR* var /**< variable to delete */
9164  );
9165 
9166 /** enables the collection of statistics for a variable
9167  *
9168  * @pre This method can be called if @p scip is in one of the following stages:
9169  * - \ref SCIP_STAGE_PROBLEM
9170  * - \ref SCIP_STAGE_INITPRESOLVE
9171  * - \ref SCIP_STAGE_PRESOLVING
9172  * - \ref SCIP_STAGE_EXITPRESOLVE
9173  * - \ref SCIP_STAGE_SOLVING
9174  * - \ref SCIP_STAGE_SOLVED
9175  */
9176 extern
9178  SCIP* scip /**< SCIP data structure */
9179  );
9180 
9181 /** disables the collection of any statistic for a variable
9182  *
9183  * @pre This method can be called if @p scip is in one of the following stages:
9184  * - \ref SCIP_STAGE_PROBLEM
9185  * - \ref SCIP_STAGE_INITPRESOLVE
9186  * - \ref SCIP_STAGE_PRESOLVING
9187  * - \ref SCIP_STAGE_EXITPRESOLVE
9188  * - \ref SCIP_STAGE_SOLVING
9189  * - \ref SCIP_STAGE_SOLVED
9190  */
9191 extern
9193  SCIP* scip /**< SCIP data structure */
9194  );
9195 
9196 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
9197  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
9198  * the update is ignored, if the objective value difference is infinite
9199  *
9200  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9201  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9202  *
9203  * @pre This method can be called if @p scip is in one of the following stages:
9204  * - \ref SCIP_STAGE_SOLVING
9205  * - \ref SCIP_STAGE_SOLVED
9206  */
9207 extern
9209  SCIP* scip, /**< SCIP data structure */
9210  SCIP_VAR* var, /**< problem variable */
9211  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
9212  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
9213  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
9214  );
9215 
9216 /** gets the variable's pseudo cost value for the given change of the variable's LP value
9217  *
9218  * @return the variable's pseudo cost value for the given change of the variable's LP value
9219  *
9220  * @pre This method can be called if @p scip is in one of the following stages:
9221  * - \ref SCIP_STAGE_INITPRESOLVE
9222  * - \ref SCIP_STAGE_PRESOLVING
9223  * - \ref SCIP_STAGE_EXITPRESOLVE
9224  * - \ref SCIP_STAGE_PRESOLVED
9225  * - \ref SCIP_STAGE_INITSOLVE
9226  * - \ref SCIP_STAGE_SOLVING
9227  * - \ref SCIP_STAGE_SOLVED
9228  */
9229 extern
9231  SCIP* scip, /**< SCIP data structure */
9232  SCIP_VAR* var, /**< problem variable */
9233  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
9234  );
9235 
9236 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
9237  * only using the pseudo cost information of the current run
9238  *
9239  * @return the variable's pseudo cost value for the given change of the variable's LP value,
9240  * only using the pseudo cost information of the current run
9241  *
9242  * @pre This method can be called if @p scip is in one of the following stages:
9243  * - \ref SCIP_STAGE_INITPRESOLVE
9244  * - \ref SCIP_STAGE_PRESOLVING
9245  * - \ref SCIP_STAGE_EXITPRESOLVE
9246  * - \ref SCIP_STAGE_PRESOLVED
9247  * - \ref SCIP_STAGE_INITSOLVE
9248  * - \ref SCIP_STAGE_SOLVING
9249  * - \ref SCIP_STAGE_SOLVED
9250  */
9251 extern
9253  SCIP* scip, /**< SCIP data structure */
9254  SCIP_VAR* var, /**< problem variable */
9255  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
9256  );
9257 
9258 /** gets the variable's pseudo cost value for the given direction
9259  *
9260  * @return the variable's pseudo cost value for the given direction
9261  *
9262  * @pre This method can be called if @p scip is in one of the following stages:
9263  * - \ref SCIP_STAGE_INITPRESOLVE
9264  * - \ref SCIP_STAGE_PRESOLVING
9265  * - \ref SCIP_STAGE_EXITPRESOLVE
9266  * - \ref SCIP_STAGE_PRESOLVED
9267  * - \ref SCIP_STAGE_INITSOLVE
9268  * - \ref SCIP_STAGE_SOLVING
9269  * - \ref SCIP_STAGE_SOLVED
9270  */
9271 extern
9273  SCIP* scip, /**< SCIP data structure */
9274  SCIP_VAR* var, /**< problem variable */
9275  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9276  );
9277 
9278 /** gets the variable's pseudo cost value for the given direction,
9279  * only using the pseudo cost information of the current run
9280  *
9281  * @return the variable's pseudo cost value for the given direction,
9282  * only using the pseudo cost information of the current run
9283  *
9284  * @pre This method can be called if @p scip is in one of the following stages:
9285  * - \ref SCIP_STAGE_INITPRESOLVE
9286  * - \ref SCIP_STAGE_PRESOLVING
9287  * - \ref SCIP_STAGE_EXITPRESOLVE
9288  * - \ref SCIP_STAGE_PRESOLVED
9289  * - \ref SCIP_STAGE_INITSOLVE
9290  * - \ref SCIP_STAGE_SOLVING
9291  * - \ref SCIP_STAGE_SOLVED
9292  */
9293 extern
9295  SCIP* scip, /**< SCIP data structure */
9296  SCIP_VAR* var, /**< problem variable */
9297  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9298  );
9299 
9300 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
9301  *
9302  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
9303  *
9304  * @pre This method can be called if @p scip is in one of the following stages:
9305  * - \ref SCIP_STAGE_INITPRESOLVE
9306  * - \ref SCIP_STAGE_PRESOLVING
9307  * - \ref SCIP_STAGE_EXITPRESOLVE
9308  * - \ref SCIP_STAGE_PRESOLVED
9309  * - \ref SCIP_STAGE_INITSOLVE
9310  * - \ref SCIP_STAGE_SOLVING
9311  * - \ref SCIP_STAGE_SOLVED
9312  */
9313 extern
9315  SCIP* scip, /**< SCIP data structure */
9316  SCIP_VAR* var, /**< problem variable */
9317  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9318  );
9319 
9320 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
9321  * only using the pseudo cost information of the current run
9322  *
9323  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
9324  * only using the pseudo cost information of the current run
9325  *
9326  * @pre This method can be called if @p scip is in one of the following stages:
9327  * - \ref SCIP_STAGE_INITPRESOLVE
9328  * - \ref SCIP_STAGE_PRESOLVING
9329  * - \ref SCIP_STAGE_EXITPRESOLVE
9330  * - \ref SCIP_STAGE_PRESOLVED
9331  * - \ref SCIP_STAGE_INITSOLVE
9332  * - \ref SCIP_STAGE_SOLVING
9333  * - \ref SCIP_STAGE_SOLVED
9334  */
9335 extern
9337  SCIP* scip, /**< SCIP data structure */
9338  SCIP_VAR* var, /**< problem variable */
9339  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9340  );
9341 
9342 /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
9343  *
9344  * @return returns the (corrected) variance of pseudo code information collected so far.
9345  *
9346  * @pre This method can be called if @p scip is in one of the following stages:
9347  * - \ref SCIP_STAGE_INITPRESOLVE
9348  * - \ref SCIP_STAGE_PRESOLVING
9349  * - \ref SCIP_STAGE_EXITPRESOLVE
9350  * - \ref SCIP_STAGE_PRESOLVED
9351  * - \ref SCIP_STAGE_INITSOLVE
9352  * - \ref SCIP_STAGE_SOLVING
9353  * - \ref SCIP_STAGE_SOLVED
9354  */
9355 extern
9357  SCIP* scip, /**< SCIP data structure */
9358  SCIP_VAR* var, /**< problem variable */
9359  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
9360  SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
9361  );
9362 
9363 /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
9364  *
9365  * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
9366  * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
9367  * of 2 * clevel - 1.
9368  *
9369  * @return value of confidence bound for this variable
9370  */
9371 extern
9373  SCIP* scip, /**< SCIP data structure */
9374  SCIP_VAR* var, /**< variable in question */
9375  SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
9376  SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
9377  SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
9378  );
9379 
9380 /** check if variable pseudo-costs have a significant difference in location. The significance depends on
9381  * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
9382  * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
9383  * unknown location means of the underlying pseudo-cost distributions of x and y.
9384  *
9385  * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
9386  * better than x (despite the current information), meaning that y can be expected to yield branching
9387  * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
9388  * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
9389  * than y.
9390  *
9391  * @note The order of x and y matters for the one-sided hypothesis
9392  *
9393  * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
9394  * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
9395  *
9396  * @return TRUE if the hypothesis can be safely rejected at the given confidence level
9397  */
9398 extern
9400  SCIP* scip, /**< SCIP data structure */
9401  SCIP_VAR* varx, /**< variable x */
9402  SCIP_Real fracx, /**< the fractionality of variable x */
9403  SCIP_VAR* vary, /**< variable y */
9404  SCIP_Real fracy, /**< the fractionality of variable y */
9405  SCIP_BRANCHDIR dir, /**< branching direction */
9406  SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
9407  SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
9408  );
9409 
9410 /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
9411  * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
9412  * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
9413  * of at least \p threshold.
9414  *
9415  * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
9416  * the estimated probability to exceed \p threshold is less than 25 %.
9417  *
9418  * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
9419  * of confidence.
9420  *
9421  * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
9422  * at the given confidence level \p clevel.
9423  */
9424 extern
9426  SCIP* scip, /**< SCIP data structure */
9427  SCIP_VAR* var, /**< variable x */
9428  SCIP_Real frac, /**< the fractionality of variable x */
9429  SCIP_Real threshold, /**< the threshold to test against */
9430  SCIP_BRANCHDIR dir, /**< branching direction */
9431  SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
9432  );
9433 
9434 /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
9435  * Error is calculated at a specific confidence level
9436  *
9437  * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
9438  */
9439 extern
9441  SCIP* scip, /**< SCIP data structure */
9442  SCIP_VAR* var, /**< variable in question */
9443  SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
9444  SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
9445  );
9446 
9447 /** gets the variable's pseudo cost score value for the given LP solution value
9448  *
9449  * @return the variable's pseudo cost score value for the given LP solution value
9450  *
9451  * @pre This method can be called if @p scip is in one of the following stages:
9452  * - \ref SCIP_STAGE_INITPRESOLVE
9453  * - \ref SCIP_STAGE_PRESOLVING
9454  * - \ref SCIP_STAGE_EXITPRESOLVE
9455  * - \ref SCIP_STAGE_PRESOLVED
9456  * - \ref SCIP_STAGE_INITSOLVE
9457  * - \ref SCIP_STAGE_SOLVING
9458  * - \ref SCIP_STAGE_SOLVED
9459  */
9460 extern
9462  SCIP* scip, /**< SCIP data structure */
9463  SCIP_VAR* var, /**< problem variable */
9464  SCIP_Real solval /**< variable's LP solution value */
9465  );
9466 
9467 /** gets the variable's pseudo cost score value for the given LP solution value,
9468  * only using the pseudo cost information of the current run
9469  *
9470  * @return the variable's pseudo cost score value for the given LP solution value,
9471  * only using the pseudo cost information of the current run
9472  *
9473  * @pre This method can be called if @p scip is in one of the following stages:
9474  * - \ref SCIP_STAGE_INITPRESOLVE
9475  * - \ref SCIP_STAGE_PRESOLVING
9476  * - \ref SCIP_STAGE_EXITPRESOLVE
9477  * - \ref SCIP_STAGE_PRESOLVED
9478  * - \ref SCIP_STAGE_INITSOLVE
9479  * - \ref SCIP_STAGE_SOLVING
9480  * - \ref SCIP_STAGE_SOLVED
9481  */
9482 extern
9484  SCIP* scip, /**< SCIP data structure */
9485  SCIP_VAR* var, /**< problem variable */
9486  SCIP_Real solval /**< variable's LP solution value */
9487  );
9488 
9489 /** returns the variable's VSIDS value
9490  *
9491  * @return the variable's VSIDS value
9492  *
9493  * @pre This method can be called if @p scip is in one of the following stages:
9494  * - \ref SCIP_STAGE_INITPRESOLVE
9495  * - \ref SCIP_STAGE_PRESOLVING
9496  * - \ref SCIP_STAGE_EXITPRESOLVE
9497  * - \ref SCIP_STAGE_PRESOLVED
9498  * - \ref SCIP_STAGE_INITSOLVE
9499  * - \ref SCIP_STAGE_SOLVING
9500  * - \ref SCIP_STAGE_SOLVED
9501  */
9502 extern
9504  SCIP* scip, /**< SCIP data structure */
9505  SCIP_VAR* var, /**< problem variable */
9506  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9507  );
9508 
9509 /** returns the variable's VSIDS value only using conflicts of the current run
9510  *
9511  * @return the variable's VSIDS value only using conflicts of the current run
9512  *
9513  * @pre This method can be called if @p scip is in one of the following stages:
9514  * - \ref SCIP_STAGE_INITPRESOLVE
9515  * - \ref SCIP_STAGE_PRESOLVING
9516  * - \ref SCIP_STAGE_EXITPRESOLVE
9517  * - \ref SCIP_STAGE_PRESOLVED
9518  * - \ref SCIP_STAGE_INITSOLVE
9519  * - \ref SCIP_STAGE_SOLVING
9520  * - \ref SCIP_STAGE_SOLVED
9521  */
9522 extern
9524  SCIP* scip, /**< SCIP data structure */
9525  SCIP_VAR* var, /**< problem variable */
9526  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9527  );
9528 
9529 /** returns the variable's conflict score value
9530  *
9531  * @return the variable's conflict score value
9532  *
9533  * @pre This method can be called if @p scip is in one of the following stages:
9534  * - \ref SCIP_STAGE_INITPRESOLVE
9535  * - \ref SCIP_STAGE_PRESOLVING
9536  * - \ref SCIP_STAGE_EXITPRESOLVE
9537  * - \ref SCIP_STAGE_PRESOLVED
9538  * - \ref SCIP_STAGE_INITSOLVE
9539  * - \ref SCIP_STAGE_SOLVING
9540  * - \ref SCIP_STAGE_SOLVED
9541  */
9542 extern
9544  SCIP* scip, /**< SCIP data structure */
9545  SCIP_VAR* var /**< problem variable */
9546  );
9547 
9548 /** returns the variable's conflict score value only using conflicts of the current run
9549  *
9550  * @return the variable's conflict score value only using conflicts of the current run
9551  *
9552  * @pre This method can be called if @p scip is in one of the following stages:
9553  * - \ref SCIP_STAGE_INITPRESOLVE
9554  * - \ref SCIP_STAGE_PRESOLVING
9555  * - \ref SCIP_STAGE_EXITPRESOLVE
9556  * - \ref SCIP_STAGE_PRESOLVED
9557  * - \ref SCIP_STAGE_INITSOLVE
9558  * - \ref SCIP_STAGE_SOLVING
9559  * - \ref SCIP_STAGE_SOLVED
9560  */
9561 extern
9563  SCIP* scip, /**< SCIP data structure */
9564  SCIP_VAR* var /**< problem variable */
9565  );
9566 
9567 /** returns the variable's conflict length score
9568  *
9569  * @return the variable's conflict length score
9570  *
9571  * @pre This method can be called if @p scip is in one of the following stages:
9572  * - \ref SCIP_STAGE_INITPRESOLVE
9573  * - \ref SCIP_STAGE_PRESOLVING
9574  * - \ref SCIP_STAGE_EXITPRESOLVE
9575  * - \ref SCIP_STAGE_PRESOLVED
9576  * - \ref SCIP_STAGE_INITSOLVE
9577  * - \ref SCIP_STAGE_SOLVING
9578  * - \ref SCIP_STAGE_SOLVED
9579  */
9580 extern
9582  SCIP* scip, /**< SCIP data structure */
9583  SCIP_VAR* var /**< problem variable */
9584  );
9585 
9586 /** returns the variable's conflict length score only using conflicts of the current run
9587  *
9588  * @return the variable's conflict length score only using conflicts of the current run
9589  *
9590  * @pre This method can be called if @p scip is in one of the following stages:
9591  * - \ref SCIP_STAGE_INITPRESOLVE
9592  * - \ref SCIP_STAGE_PRESOLVING
9593  * - \ref SCIP_STAGE_EXITPRESOLVE
9594  * - \ref SCIP_STAGE_PRESOLVED
9595  * - \ref SCIP_STAGE_INITSOLVE
9596  * - \ref SCIP_STAGE_SOLVING
9597  * - \ref SCIP_STAGE_SOLVED
9598  */
9599 extern
9601  SCIP* scip, /**< SCIP data structure */
9602  SCIP_VAR* var /**< problem variable */
9603  );
9604 
9605 /** returns the variable's average conflict length
9606  *
9607  * @return the variable's average conflict length
9608  *
9609  * @pre This method can be called if @p scip is in one of the following stages:
9610  * - \ref SCIP_STAGE_INITPRESOLVE
9611  * - \ref SCIP_STAGE_PRESOLVING
9612  * - \ref SCIP_STAGE_EXITPRESOLVE
9613  * - \ref SCIP_STAGE_PRESOLVED
9614  * - \ref SCIP_STAGE_INITSOLVE
9615  * - \ref SCIP_STAGE_SOLVING
9616  * - \ref SCIP_STAGE_SOLVED
9617  */
9618 extern
9620  SCIP* scip, /**< SCIP data structure */
9621  SCIP_VAR* var, /**< problem variable */
9622  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9623  );
9624 
9625 /** returns the variable's average conflict length only using conflicts of the current run
9626  *
9627  * @return the variable's average conflict length only using conflicts of the current run
9628  *
9629  * @pre This method can be called if @p scip is in one of the following stages:
9630  * - \ref SCIP_STAGE_INITPRESOLVE
9631  * - \ref SCIP_STAGE_PRESOLVING
9632  * - \ref SCIP_STAGE_EXITPRESOLVE
9633  * - \ref SCIP_STAGE_PRESOLVED
9634  * - \ref SCIP_STAGE_INITSOLVE
9635  * - \ref SCIP_STAGE_SOLVING
9636  * - \ref SCIP_STAGE_SOLVED
9637  */
9638 extern
9640  SCIP* scip, /**< SCIP data structure */
9641  SCIP_VAR* var, /**< problem variable */
9642  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9643  );
9644 
9645 /** returns the average number of inferences found after branching on the variable in given direction;
9646  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
9647  * over all variables for branching in the given direction is returned
9648  *
9649  * @return the average number of inferences found after branching on the variable in given direction
9650  *
9651  * @pre This method can be called if @p scip is in one of the following stages:
9652  * - \ref SCIP_STAGE_INITPRESOLVE
9653  * - \ref SCIP_STAGE_PRESOLVING
9654  * - \ref SCIP_STAGE_EXITPRESOLVE
9655  * - \ref SCIP_STAGE_PRESOLVED
9656  * - \ref SCIP_STAGE_INITSOLVE
9657  * - \ref SCIP_STAGE_SOLVING
9658  * - \ref SCIP_STAGE_SOLVED
9659  */
9660 extern
9662  SCIP* scip, /**< SCIP data structure */
9663  SCIP_VAR* var, /**< problem variable */
9664  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9665  );
9666 
9667 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
9668  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
9669  * over all variables for branching in the given direction is returned
9670  *
9671  * @return the average number of inferences found after branching on the variable in given direction in the current run
9672  *
9673  * @pre This method can be called if @p scip is in one of the following stages:
9674  * - \ref SCIP_STAGE_INITPRESOLVE
9675  * - \ref SCIP_STAGE_PRESOLVING
9676  * - \ref SCIP_STAGE_EXITPRESOLVE
9677  * - \ref SCIP_STAGE_PRESOLVED
9678  * - \ref SCIP_STAGE_INITSOLVE
9679  * - \ref SCIP_STAGE_SOLVING
9680  * - \ref SCIP_STAGE_SOLVED
9681  */
9682 extern
9684  SCIP* scip, /**< SCIP data structure */
9685  SCIP_VAR* var, /**< problem variable */
9686  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9687  );
9688 
9689 /** returns the variable's average inference score value
9690  *
9691  * @return the variable's average inference score value
9692  *
9693  * @pre This method can be called if @p scip is in one of the following stages:
9694  * - \ref SCIP_STAGE_INITPRESOLVE
9695  * - \ref SCIP_STAGE_PRESOLVING
9696  * - \ref SCIP_STAGE_EXITPRESOLVE
9697  * - \ref SCIP_STAGE_PRESOLVED
9698  * - \ref SCIP_STAGE_INITSOLVE
9699  * - \ref SCIP_STAGE_SOLVING
9700  * - \ref SCIP_STAGE_SOLVED
9701  */
9702 extern
9704  SCIP* scip, /**< SCIP data structure */
9705  SCIP_VAR* var /**< problem variable */
9706  );
9707 
9708 /** returns the variable's average inference score value only using inferences of the current run
9709  *
9710  * @return the variable's average inference score value only using inferences of the current run
9711  *
9712  * @pre This method can be called if @p scip is in one of the following stages:
9713  * - \ref SCIP_STAGE_INITPRESOLVE
9714  * - \ref SCIP_STAGE_PRESOLVING
9715  * - \ref SCIP_STAGE_EXITPRESOLVE
9716  * - \ref SCIP_STAGE_PRESOLVED
9717  * - \ref SCIP_STAGE_INITSOLVE
9718  * - \ref SCIP_STAGE_SOLVING
9719  * - \ref SCIP_STAGE_SOLVED
9720  */
9721 extern
9723  SCIP* scip, /**< SCIP data structure */
9724  SCIP_VAR* var /**< problem variable */
9725  );
9726 
9727 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
9728  * of a variable to the given values
9729  *
9730  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9731  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9732  *
9733  * @pre This method can be called if @p scip is in one of the following stages:
9734  * - \ref SCIP_STAGE_TRANSFORMED
9735  * - \ref SCIP_STAGE_INITPRESOLVE
9736  * - \ref SCIP_STAGE_PRESOLVING
9737  * - \ref SCIP_STAGE_EXITPRESOLVE
9738  * - \ref SCIP_STAGE_PRESOLVED
9739  * - \ref SCIP_STAGE_INITSOLVE
9740  * - \ref SCIP_STAGE_SOLVING
9741  */
9742 extern
9744  SCIP* scip, /**< SCIP data structure */
9745  SCIP_VAR* var, /**< variable which should be initialized */
9746  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
9747  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
9748  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
9749  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
9750  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
9751  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
9752  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
9753  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
9754  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
9755  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
9756  );
9757 
9758 /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
9759  * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
9760  *
9761  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9762  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9763  *
9764  * @pre This method can be called if @p scip is in one of the following stages:
9765  * - \ref SCIP_STAGE_TRANSFORMED
9766  * - \ref SCIP_STAGE_INITPRESOLVE
9767  * - \ref SCIP_STAGE_PRESOLVING
9768  * - \ref SCIP_STAGE_EXITPRESOLVE
9769  * - \ref SCIP_STAGE_PRESOLVED
9770  * - \ref SCIP_STAGE_INITSOLVE
9771  * - \ref SCIP_STAGE_SOLVING
9772  */
9773 extern
9775  SCIP* scip, /**< SCIP data structure */
9776  SCIP_VAR* var, /**< variable which should be initialized */
9777  SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
9778  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
9779  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
9780  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
9781  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
9782  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
9783  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
9784  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
9785  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
9786  );
9787 
9788 /** returns the average number of cutoffs found after branching on the variable in given direction;
9789  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
9790  * over all variables for branching in the given direction is returned
9791  *
9792  * @return the average number of cutoffs found after branching on the variable in given direction
9793  *
9794  * @pre This method can be called if @p scip is in one of the following stages:
9795  * - \ref SCIP_STAGE_INITPRESOLVE
9796  * - \ref SCIP_STAGE_PRESOLVING
9797  * - \ref SCIP_STAGE_EXITPRESOLVE
9798  * - \ref SCIP_STAGE_PRESOLVED
9799  * - \ref SCIP_STAGE_INITSOLVE
9800  * - \ref SCIP_STAGE_SOLVING
9801  * - \ref SCIP_STAGE_SOLVED
9802  */
9803 extern
9805  SCIP* scip, /**< SCIP data structure */
9806  SCIP_VAR* var, /**< problem variable */
9807  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9808  );
9809 
9810 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
9811  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
9812  * over all variables for branching in the given direction is returned
9813  *
9814  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
9815  *
9816  * @pre This method can be called if @p scip is in one of the following stages:
9817  * - \ref SCIP_STAGE_INITPRESOLVE
9818  * - \ref SCIP_STAGE_PRESOLVING
9819  * - \ref SCIP_STAGE_EXITPRESOLVE
9820  * - \ref SCIP_STAGE_PRESOLVED
9821  * - \ref SCIP_STAGE_INITSOLVE
9822  * - \ref SCIP_STAGE_SOLVING
9823  * - \ref SCIP_STAGE_SOLVED
9824  */
9825 extern
9827  SCIP* scip, /**< SCIP data structure */
9828  SCIP_VAR* var, /**< problem variable */
9829  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9830  );
9831 
9832 /** returns the variable's average cutoff score value
9833  *
9834  * @return the variable's average cutoff score value
9835  *
9836  * @pre This method can be called if @p scip is in one of the following stages:
9837  * - \ref SCIP_STAGE_INITPRESOLVE
9838  * - \ref SCIP_STAGE_PRESOLVING
9839  * - \ref SCIP_STAGE_EXITPRESOLVE
9840  * - \ref SCIP_STAGE_PRESOLVED
9841  * - \ref SCIP_STAGE_INITSOLVE
9842  * - \ref SCIP_STAGE_SOLVING
9843  * - \ref SCIP_STAGE_SOLVED
9844  */
9845 extern
9847  SCIP* scip, /**< SCIP data structure */
9848  SCIP_VAR* var /**< problem variable */
9849  );
9850 
9851 /** returns the variable's average cutoff score value, only using cutoffs of the current run
9852  *
9853  * @return the variable's average cutoff score value, only using cutoffs of the current run
9854  *
9855  * @pre This method can be called if @p scip is in one of the following stages:
9856  * - \ref SCIP_STAGE_INITPRESOLVE
9857  * - \ref SCIP_STAGE_PRESOLVING
9858  * - \ref SCIP_STAGE_EXITPRESOLVE
9859  * - \ref SCIP_STAGE_PRESOLVED
9860  * - \ref SCIP_STAGE_INITSOLVE
9861  * - \ref SCIP_STAGE_SOLVING
9862  * - \ref SCIP_STAGE_SOLVED
9863  */
9864 extern
9866  SCIP* scip, /**< SCIP data structure */
9867  SCIP_VAR* var /**< problem variable */
9868  );
9869 
9870 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
9871  * factor
9872  *
9873  * @return the variable's average inference/cutoff score value
9874  *
9875  * @pre This method can be called if @p scip is in one of the following stages:
9876  * - \ref SCIP_STAGE_INITPRESOLVE
9877  * - \ref SCIP_STAGE_PRESOLVING
9878  * - \ref SCIP_STAGE_EXITPRESOLVE
9879  * - \ref SCIP_STAGE_PRESOLVED
9880  * - \ref SCIP_STAGE_INITSOLVE
9881  * - \ref SCIP_STAGE_SOLVING
9882  * - \ref SCIP_STAGE_SOLVED
9883  */
9884 extern
9886  SCIP* scip, /**< SCIP data structure */
9887  SCIP_VAR* var, /**< problem variable */
9888  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
9889  );
9890 
9891 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
9892  * factor, only using inferences and cutoffs of the current run
9893  *
9894  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
9895  *
9896  * @pre This method can be called if @p scip is in one of the following stages:
9897  * - \ref SCIP_STAGE_INITPRESOLVE
9898  * - \ref SCIP_STAGE_PRESOLVING
9899  * - \ref SCIP_STAGE_EXITPRESOLVE
9900  * - \ref SCIP_STAGE_PRESOLVED
9901  * - \ref SCIP_STAGE_INITSOLVE
9902  * - \ref SCIP_STAGE_SOLVING
9903  * - \ref SCIP_STAGE_SOLVED
9904  */
9905 extern
9907  SCIP* scip, /**< SCIP data structure */
9908  SCIP_VAR* var, /**< problem variable */
9909  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
9910  );
9911 
9912 /** outputs variable information to file stream via the message system
9913  *
9914  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9915  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9916  *
9917  * @pre This method can be called if @p scip is in one of the following stages:
9918  * - \ref SCIP_STAGE_PROBLEM
9919  * - \ref SCIP_STAGE_TRANSFORMING
9920  * - \ref SCIP_STAGE_TRANSFORMED
9921  * - \ref SCIP_STAGE_INITPRESOLVE
9922  * - \ref SCIP_STAGE_PRESOLVING
9923  * - \ref SCIP_STAGE_EXITPRESOLVE
9924  * - \ref SCIP_STAGE_PRESOLVED
9925  * - \ref SCIP_STAGE_INITSOLVE
9926  * - \ref SCIP_STAGE_SOLVING
9927  * - \ref SCIP_STAGE_SOLVED
9928  * - \ref SCIP_STAGE_EXITSOLVE
9929  * - \ref SCIP_STAGE_FREETRANS
9930  *
9931  * @note If the message handler is set to a NULL pointer nothing will be printed
9932  */
9933 extern
9935  SCIP* scip, /**< SCIP data structure */
9936  SCIP_VAR* var, /**< problem variable */
9937  FILE* file /**< output file (or NULL for standard output) */
9938  );
9939 
9940 /**@} */
9941 
9942 
9943 
9944 
9945 /*
9946  * conflict analysis methods
9947  */
9948 
9949 /**@name Conflict Analysis Methods */
9950 /**@{ */
9951 
9952 /** return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
9953  * conflict analysis since it will not be applied
9954  *
9955  * @return return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
9956  * conflict analysis since it will not be applied
9957  *
9958  * @pre This method can be called if SCIP is in one of the following stages:
9959  * - \ref SCIP_STAGE_INITPRESOLVE
9960  * - \ref SCIP_STAGE_PRESOLVING
9961  * - \ref SCIP_STAGE_EXITPRESOLVE
9962  * - \ref SCIP_STAGE_SOLVING
9963  *
9964  * @note SCIP stage does not get changed
9965  */
9966 extern
9968  SCIP* scip /**< SCIP data structure */
9969  );
9970 
9971 /** initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you
9972  * enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
9973  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
9974  *
9975  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9976  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9977  *
9978  * @pre This method can be called if SCIP is in one of the following stages:
9979  * - \ref SCIP_STAGE_PRESOLVING
9980  * - \ref SCIP_STAGE_SOLVING
9981  *
9982  * @note SCIP stage does not get changed
9983  */
9984 extern
9986  SCIP* scip /**< SCIP data structure */
9987  );
9988 
9989 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
9990  * this method should be called in one of the following two cases:
9991  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound
9992  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
9993  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called
9994  * for each lower bound, whose current assignment led to the deduction of the given conflict bound.
9995  *
9996  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9997  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9998  *
9999  * @pre This method can be called if SCIP is in one of the following stages:
10000  * - \ref SCIP_STAGE_PRESOLVING
10001  * - \ref SCIP_STAGE_SOLVING
10002  *
10003  * @note SCIP stage does not get changed
10004  */
10005 extern
10007  SCIP* scip, /**< SCIP data structure */
10008  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
10009  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10010  * conflicting bound was valid, NULL for current local bound */
10011  );
10012 
10013 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
10014  * with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough
10015  * to explain a certain bound change;
10016  * this method should be called in one of the following two cases:
10017  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound
10018  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10019  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called
10020  * for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.
10021  *
10022  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10023  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10024  *
10025  * @pre This method can be called if SCIP is in one of the following stages:
10026  * - \ref SCIP_STAGE_PRESOLVING
10027  * - \ref SCIP_STAGE_SOLVING
10028  *
10029  * @note SCIP stage does not get changed
10030  */
10031 extern
10033  SCIP* scip, /**< SCIP data structure */
10034  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
10035  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10036  * conflicting bound was valid, NULL for current local bound */
10037  SCIP_Real relaxedlb /**< the relaxed lower bound */
10038  );
10039 
10040 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
10041  * this method should be called in one of the following two cases:
10042  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that
10043  * led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10044  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for
10045  * each upper bound, whose current assignment led to the deduction of the given conflict bound.
10046  *
10047  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10048  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10049  *
10050  * @pre This method can be called if SCIP is in one of the following stages:
10051  * - \ref SCIP_STAGE_PRESOLVING
10052  * - \ref SCIP_STAGE_SOLVING
10053  *
10054  * @note SCIP stage does not get changed
10055  */
10056 extern
10058  SCIP* scip, /**< SCIP data structure */
10059  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10060  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10061  * conflicting bound was valid, NULL for current local bound */
10062  );
10063 
10064 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
10065  * with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough
10066  * to explain a certain bound change;
10067  * this method should be called in one of the following two cases:
10068  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper
10069  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10070  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be
10071  * called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict
10072  * bound.
10073  *
10074  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10075  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10076  *
10077  * @pre This method can be called if SCIP is in one of the following stages:
10078  * - \ref SCIP_STAGE_PRESOLVING
10079  * - \ref SCIP_STAGE_SOLVING
10080  *
10081  * @note SCIP stage does not get changed
10082  */
10083 extern
10085  SCIP* scip, /**< SCIP data structure */
10086  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10087  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10088  * conflicting bound was valid, NULL for current local bound */
10089  SCIP_Real relaxedub /**< the relaxed upper bound */
10090  );
10091 
10092 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate
10093  * storage; this method should be called in one of the following two cases:
10094  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound
10095  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10096  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called
10097  * for each bound, whose current assignment led to the deduction of the given conflict bound.
10098  *
10099  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10100  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10101  *
10102  * @pre This method can be called if SCIP is in one of the following stages:
10103  * - \ref SCIP_STAGE_PRESOLVING
10104  * - \ref SCIP_STAGE_SOLVING
10105  *
10106  * @note SCIP stage does not get changed
10107  */
10108 extern
10110  SCIP* scip, /**< SCIP data structure */
10111  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10112  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10113  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
10114  * conflicting bound was valid, NULL for current local bound */
10115  );
10116 
10117 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis'
10118  * candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one
10119  * which would be enough to explain a certain bound change;
10120  * this method should be called in one of the following two cases:
10121  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed)
10122  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10123  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be
10124  * called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.
10125  *
10126  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10127  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10128  *
10129  * @pre This method can be called if SCIP is in one of the following stages:
10130  * - \ref SCIP_STAGE_PRESOLVING
10131  * - \ref SCIP_STAGE_SOLVING
10132  *
10133  * @note SCIP stage does not get changed
10134  */
10135 extern
10137  SCIP* scip, /**< SCIP data structure */
10138  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10139  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10140  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10141  * conflicting bound was valid, NULL for current local bound */
10142  SCIP_Real relaxedbd /**< the relaxed bound */
10143  );
10144 
10145 /** adds changed bound of fixed binary variable to the conflict analysis' candidate storage;
10146  * this method should be called in one of the following two cases:
10147  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary
10148  * variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
10149  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called
10150  * for each binary variable, whose current fixing led to the deduction of the given conflict bound.
10151  *
10152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10154  *
10155  * @pre This method can be called if SCIP is in one of the following stages:
10156  * - \ref SCIP_STAGE_PRESOLVING
10157  * - \ref SCIP_STAGE_SOLVING
10158  *
10159  * @note SCIP stage does not get changed
10160  */
10161 extern
10163  SCIP* scip, /**< SCIP data structure */
10164  SCIP_VAR* var /**< binary variable whose changed bound should be added to conflict queue */
10165  );
10166 
10167 /** checks if the given variable is already part of the current conflict set or queued for resolving with the same or
10168  * even stronger bound
10169  *
10170  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10171  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10172  *
10173  * @pre This method can be called if SCIP is in one of the following stages:
10174  * - \ref SCIP_STAGE_PRESOLVING
10175  * - \ref SCIP_STAGE_SOLVING
10176  *
10177  * @note SCIP stage does not get changed
10178  */
10179 extern
10181  SCIP* scip, /**< SCIP data structure */
10182  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
10183  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
10184  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
10185  * conflicting bound was valid, NULL for current local bound */
10186  SCIP_Bool* used /**< pointer to store if the variable is already used */
10187  );
10188 
10189 /** returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
10190  * bound
10191  *
10192  * @return returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
10193  * bound
10194  *
10195  * @pre This method can be called if SCIP is in one of the following stages:
10196  * - \ref SCIP_STAGE_PRESOLVING
10197  * - \ref SCIP_STAGE_SOLVING
10198  *
10199  * @note SCIP stage does not get changed
10200  */
10201 extern
10203  SCIP* scip, /**< SCIP data structure */
10204  SCIP_VAR* var /**< problem variable */
10205  );
10206 
10207 /** returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
10208  * upper bound
10209  *
10210  * @return returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
10211  * upper bound
10212  *
10213  * @pre This method can be called if SCIP is in one of the following stages:
10214  * - \ref SCIP_STAGE_PRESOLVING
10215  * - \ref SCIP_STAGE_SOLVING
10216  *
10217  * @note SCIP stage does not get changed
10218  */
10219 extern
10221  SCIP* scip, /**< SCIP data structure */
10222  SCIP_VAR* var /**< problem variable */
10223  );
10224 
10225 /** analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to
10226  * SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
10227  * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict
10228  * handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth
10229  * level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
10230  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is
10231  * valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons()
10232  * instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used
10233  *
10234  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10235  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10236  *
10237  * @pre This method can be called if SCIP is in one of the following stages:
10238  * - \ref SCIP_STAGE_PRESOLVING
10239  * - \ref SCIP_STAGE_SOLVING
10240  *
10241  * @note SCIP stage does not get changed
10242  */
10243 extern
10245  SCIP* scip, /**< SCIP data structure */
10246  int validdepth, /**< minimal depth level at which the initial conflict set is valid */
10247  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
10248  );
10249 
10250 /** analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(),
10251  * SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or
10252  * SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the
10253  * resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint
10254  * that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(),
10255  * SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(),
10256  * SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())
10257  *
10258  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10259  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10260  *
10261  * @pre This method can be called if SCIP is in one of the following stages:
10262  * - \ref SCIP_STAGE_PRESOLVING
10263  * - \ref SCIP_STAGE_SOLVING
10264  *
10265  * @note SCIP stage does not get changed
10266  */
10267 extern
10269  SCIP* scip, /**< SCIP data structure */
10270  SCIP_CONS* cons, /**< constraint that detected the conflict */
10271  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
10272  );
10273 
10274 /**@} */
10275 
10276 
10277 
10278 
10279 /*
10280  * constraint methods
10281  */
10282 
10283 /**@name Constraint Methods */
10284 /**@{ */
10285 
10286 /** creates and captures a constraint of the given constraint handler
10287  *
10288  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
10289  * be declared feasible even if it violates this particular constraint. This constellation should only be
10290  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
10291  * to the variable's local bounds.
10292  *
10293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10295  *
10296  * @pre This method can be called if @p scip is in one of the following stages:
10297  * - \ref SCIP_STAGE_PROBLEM
10298  * - \ref SCIP_STAGE_TRANSFORMING
10299  * - \ref SCIP_STAGE_INITPRESOLVE
10300  * - \ref SCIP_STAGE_PRESOLVING
10301  * - \ref SCIP_STAGE_EXITPRESOLVE
10302  * - \ref SCIP_STAGE_PRESOLVED
10303  * - \ref SCIP_STAGE_INITSOLVE
10304  * - \ref SCIP_STAGE_SOLVING
10305  * - \ref SCIP_STAGE_EXITSOLVE
10306  *
10307  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
10308  */
10309 extern
10311  SCIP* scip, /**< SCIP data structure */
10312  SCIP_CONS** cons, /**< pointer to constraint */
10313  const char* name, /**< name of constraint */
10314  SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
10315  SCIP_CONSDATA* consdata, /**< data for this specific constraint */
10316  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
10317  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
10318  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
10319  * Usually set to TRUE. */
10320  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
10321  * TRUE for model constraints, FALSE for additional, redundant constraints. */
10322  SCIP_Bool check, /**< should the constraint be checked for feasibility?
10323  * TRUE for model constraints, FALSE for additional, redundant constraints. */
10324  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
10325  * Usually set to TRUE. */
10326  SCIP_Bool local, /**< is constraint only valid locally?
10327  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
10328  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
10329  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
10330  * adds coefficients to this constraint. */
10331  SCIP_Bool dynamic, /**< is constraint subject to aging?
10332  * Usually set to FALSE. Set to TRUE for own cuts which
10333  * are separated as constraints. */
10334  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
10335  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
10336  SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
10337  * if it may be moved to a more global node?
10338  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
10339  );
10340 
10341 /** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
10342  * creates and captures;
10343  *
10344  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10345  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10346  *
10347  * @pre This method can be called if @p scip is in one of the following stages:
10348  * - \ref SCIP_STAGE_PROBLEM
10349  * - \ref SCIP_STAGE_TRANSFORMING
10350  * - \ref SCIP_STAGE_INITPRESOLVE
10351  * - \ref SCIP_STAGE_PRESOLVING
10352  * - \ref SCIP_STAGE_EXITPRESOLVE
10353  * - \ref SCIP_STAGE_PRESOLVED
10354  * - \ref SCIP_STAGE_SOLVING
10355  * - \ref SCIP_STAGE_EXITSOLVE
10356  *
10357  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
10358  * be declared feasible even if it violates this particular constraint. This constellation should only be
10359  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
10360  * to the variable's local bounds.
10361  */
10362 extern
10364  SCIP* scip, /**< SCIP data structure */
10365  SCIP_CONS** cons, /**< pointer to store constraint */
10366  const char* str, /**< string to parse for constraint */
10367  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
10368  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
10369  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
10370  * Usually set to TRUE. */
10371  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
10372  * TRUE for model constraints, FALSE for additional, redundant constraints. */
10373  SCIP_Bool check, /**< should the constraint be checked for feasibility?
10374  * TRUE for model constraints, FALSE for additional, redundant constraints. */
10375  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
10376  * Usually set to TRUE. */
10377  SCIP_Bool local, /**< is constraint only valid locally?
10378  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
10379  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
10380  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
10381  * adds coefficients to this constraint. */
10382  SCIP_Bool dynamic, /**< is constraint subject to aging?
10383  * Usually set to FALSE. Set to TRUE for own cuts which
10384  * are separated as constraints. */
10385  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
10386  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
10387  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
10388  * if it may be moved to a more global node?
10389  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
10390  SCIP_Bool* success /**< pointer to store if the paring process was successful */
10391  );
10392 
10393 /** increases usage counter of constraint
10394  *
10395  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10396  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10397  *
10398  * @pre This method can be called if @p scip is in one of the following stages:
10399  * - \ref SCIP_STAGE_PROBLEM
10400  * - \ref SCIP_STAGE_TRANSFORMING
10401  * - \ref SCIP_STAGE_TRANSFORMED
10402  * - \ref SCIP_STAGE_INITPRESOLVE
10403  * - \ref SCIP_STAGE_PRESOLVING
10404  * - \ref SCIP_STAGE_EXITPRESOLVE
10405  * - \ref SCIP_STAGE_PRESOLVED
10406  * - \ref SCIP_STAGE_INITSOLVE
10407  * - \ref SCIP_STAGE_SOLVING
10408  * - \ref SCIP_STAGE_SOLVED
10409  */
10410 extern
10412  SCIP* scip, /**< SCIP data structure */
10413  SCIP_CONS* cons /**< constraint to capture */
10414  );
10415 
10416 /** decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
10417  *
10418  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10419  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10420  *
10421  * @pre This method can be called if @p scip is in one of the following stages:
10422  * - \ref SCIP_STAGE_PROBLEM
10423  * - \ref SCIP_STAGE_TRANSFORMING
10424  * - \ref SCIP_STAGE_TRANSFORMED
10425  * - \ref SCIP_STAGE_INITPRESOLVE
10426  * - \ref SCIP_STAGE_PRESOLVING
10427  * - \ref SCIP_STAGE_EXITPRESOLVE
10428  * - \ref SCIP_STAGE_PRESOLVED
10429  * - \ref SCIP_STAGE_INITSOLVE
10430  * - \ref SCIP_STAGE_SOLVING
10431  * - \ref SCIP_STAGE_SOLVED
10432  * - \ref SCIP_STAGE_EXITSOLVE
10433  * - \ref SCIP_STAGE_FREETRANS
10434  *
10435  * @note the pointer of the constraint will be NULLed
10436  */
10437 extern
10439  SCIP* scip, /**< SCIP data structure */
10440  SCIP_CONS** cons /**< pointer to constraint */
10441  );
10442 
10443 /** change constraint name
10444  *
10445  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10446  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10447  *
10448  * @pre This method can be called if @p scip is in one of the following stages:
10449  * - \ref SCIP_STAGE_PROBLEM
10450  *
10451  * @note to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h
10452  */
10453 extern
10455  SCIP* scip, /**< SCIP data structure */
10456  SCIP_CONS* cons, /**< constraint */
10457  const char* name /**< new name of constraint */
10458  );
10459 
10460 /** sets the initial flag of the given constraint
10461  *
10462  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10463  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10464  *
10465  * @pre This method can be called if @p scip is in one of the following stages:
10466  * - \ref SCIP_STAGE_PROBLEM
10467  * - \ref SCIP_STAGE_TRANSFORMING
10468  * - \ref SCIP_STAGE_PRESOLVING
10469  * - \ref SCIP_STAGE_PRESOLVED
10470  * - \ref SCIP_STAGE_SOLVING
10471  */
10472 extern
10474  SCIP* scip, /**< SCIP data structure */
10475  SCIP_CONS* cons, /**< constraint */
10476  SCIP_Bool initial /**< new value */
10477  );
10478 
10479 /** sets the separate flag of the given constraint
10480  *
10481  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10482  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10483  *
10484  * @pre This method can be called if @p scip is in one of the following stages:
10485  * - \ref SCIP_STAGE_PROBLEM
10486  * - \ref SCIP_STAGE_TRANSFORMING
10487  * - \ref SCIP_STAGE_PRESOLVING
10488  * - \ref SCIP_STAGE_PRESOLVED
10489  * - \ref SCIP_STAGE_SOLVING
10490  */
10491 extern
10493  SCIP* scip, /**< SCIP data structure */
10494  SCIP_CONS* cons, /**< constraint */
10495  SCIP_Bool separate /**< new value */
10496  );
10497 
10498 /** sets the enforce flag of the given constraint
10499  *
10500  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10501  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10502  *
10503  * @pre This method can be called if @p scip is in one of the following stages:
10504  * - \ref SCIP_STAGE_PROBLEM
10505  * - \ref SCIP_STAGE_TRANSFORMING
10506  * - \ref SCIP_STAGE_PRESOLVING
10507  * - \ref SCIP_STAGE_PRESOLVED
10508  * - \ref SCIP_STAGE_SOLVING
10509  */
10510 extern
10512  SCIP* scip, /**< SCIP data structure */
10513  SCIP_CONS* cons, /**< constraint */
10514  SCIP_Bool enforce /**< new value */
10515  );
10516 
10517 /** sets the check flag of the given constraint
10518  *
10519  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10520  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10521  *
10522  * @pre This method can be called if @p scip is in one of the following stages:
10523  * - \ref SCIP_STAGE_PROBLEM
10524  * - \ref SCIP_STAGE_TRANSFORMING
10525  * - \ref SCIP_STAGE_PRESOLVING
10526  * - \ref SCIP_STAGE_PRESOLVED
10527  * - \ref SCIP_STAGE_SOLVING
10528  */
10529 extern
10531  SCIP* scip, /**< SCIP data structure */
10532  SCIP_CONS* cons, /**< constraint */
10533  SCIP_Bool check /**< new value */
10534  );
10535 
10536 /** sets the propagate flag of the given constraint
10537  *
10538  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10539  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10540  *
10541  * @pre This method can be called if @p scip is in one of the following stages:
10542  * - \ref SCIP_STAGE_PROBLEM
10543  * - \ref SCIP_STAGE_TRANSFORMING
10544  * - \ref SCIP_STAGE_PRESOLVING
10545  * - \ref SCIP_STAGE_PRESOLVED
10546  * - \ref SCIP_STAGE_SOLVING
10547  */
10548 extern
10550  SCIP* scip, /**< SCIP data structure */
10551  SCIP_CONS* cons, /**< constraint */
10552  SCIP_Bool propagate /**< new value */
10553  );
10554 
10555 /** sets the local flag of the given constraint
10556  *
10557  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10558  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10559  *
10560  * @pre This method can be called if @p scip is in one of the following stages:
10561  * - \ref SCIP_STAGE_PROBLEM
10562  * - \ref SCIP_STAGE_TRANSFORMING
10563  * - \ref SCIP_STAGE_INITPRESOLVE
10564  * - \ref SCIP_STAGE_PRESOLVING
10565  * - \ref SCIP_STAGE_PRESOLVED
10566  * - \ref SCIP_STAGE_INITSOLVE
10567  * - \ref SCIP_STAGE_SOLVING
10568  */
10569 extern
10571  SCIP* scip, /**< SCIP data structure */
10572  SCIP_CONS* cons, /**< constraint */
10573  SCIP_Bool local /**< new value */
10574  );
10575 
10576 /** sets the modifiable flag of the given constraint
10577  *
10578  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10579  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10580  *
10581  * @pre This method can be called if @p scip is in one of the following stages:
10582  * - \ref SCIP_STAGE_PROBLEM
10583  * - \ref SCIP_STAGE_TRANSFORMING
10584  * - \ref SCIP_STAGE_PRESOLVING
10585  * - \ref SCIP_STAGE_PRESOLVED
10586  * - \ref SCIP_STAGE_SOLVING
10587  * - \ref SCIP_STAGE_EXITSOLVE
10588  */
10589 extern
10591  SCIP* scip, /**< SCIP data structure */
10592  SCIP_CONS* cons, /**< constraint */
10593  SCIP_Bool modifiable /**< new value */
10594  );
10595 
10596 /** sets the dynamic flag of the given constraint
10597  *
10598  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10599  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10600  *
10601  * @pre This method can be called if @p scip is in one of the following stages:
10602  * - \ref SCIP_STAGE_PROBLEM
10603  * - \ref SCIP_STAGE_TRANSFORMING
10604  * - \ref SCIP_STAGE_PRESOLVING
10605  * - \ref SCIP_STAGE_PRESOLVED
10606  * - \ref SCIP_STAGE_SOLVING
10607  */
10608 extern
10610  SCIP* scip, /**< SCIP data structure */
10611  SCIP_CONS* cons, /**< constraint */
10612  SCIP_Bool dynamic /**< new value */
10613  );
10614 
10615 /** sets the removable flag of the given constraint
10616  *
10617  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10618  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10619  *
10620  * @pre This method can be called if @p scip is in one of the following stages:
10621  * - \ref SCIP_STAGE_PROBLEM
10622  * - \ref SCIP_STAGE_TRANSFORMING
10623  * - \ref SCIP_STAGE_PRESOLVING
10624  * - \ref SCIP_STAGE_PRESOLVED
10625  * - \ref SCIP_STAGE_SOLVING
10626  */
10627 extern
10629  SCIP* scip, /**< SCIP data structure */
10630  SCIP_CONS* cons, /**< constraint */
10631  SCIP_Bool removable /**< new value */
10632  );
10633 
10634 /** sets the stickingatnode flag of the given constraint
10635  *
10636  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10637  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10638  *
10639  * @pre This method can be called if @p scip is in one of the following stages:
10640  * - \ref SCIP_STAGE_PROBLEM
10641  * - \ref SCIP_STAGE_TRANSFORMING
10642  * - \ref SCIP_STAGE_PRESOLVING
10643  * - \ref SCIP_STAGE_PRESOLVED
10644  * - \ref SCIP_STAGE_SOLVING
10645  */
10646 extern
10648  SCIP* scip, /**< SCIP data structure */
10649  SCIP_CONS* cons, /**< constraint */
10650  SCIP_Bool stickingatnode /**< new value */
10651  );
10652 
10653 /** updates the flags of the first constraint according to the ones of the second constraint
10654  *
10655  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10656  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10657  *
10658  * @pre This method can be called if @p scip is in one of the following stages:
10659  * - \ref SCIP_STAGE_PROBLEM
10660  * - \ref SCIP_STAGE_TRANSFORMING
10661  * - \ref SCIP_STAGE_PRESOLVING
10662  * - \ref SCIP_STAGE_PRESOLVED
10663  * - \ref SCIP_STAGE_SOLVING
10664  */
10665 extern
10667  SCIP* scip, /**< SCIP data structure */
10668  SCIP_CONS* cons0, /**< constraint that should stay */
10669  SCIP_CONS* cons1 /**< constraint that should be deleted */
10670  );
10671 
10672 /** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
10673  * a new transformed constraint for this constraint is created
10674  *
10675  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10676  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10677  *
10678  * @pre This method can be called if @p scip is in one of the following stages:
10679  * - \ref SCIP_STAGE_TRANSFORMING
10680  * - \ref SCIP_STAGE_TRANSFORMED
10681  * - \ref SCIP_STAGE_INITPRESOLVE
10682  * - \ref SCIP_STAGE_PRESOLVING
10683  * - \ref SCIP_STAGE_EXITPRESOLVE
10684  * - \ref SCIP_STAGE_PRESOLVED
10685  * - \ref SCIP_STAGE_INITSOLVE
10686  * - \ref SCIP_STAGE_SOLVING
10687  */
10688 extern
10690  SCIP* scip, /**< SCIP data structure */
10691  SCIP_CONS* cons, /**< constraint to get/create transformed constraint for */
10692  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
10693  );
10694 
10695 /** gets and captures transformed constraints for an array of constraints;
10696  * if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created;
10697  * it is possible to call this method with conss == transconss
10698  *
10699  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10700  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10701  *
10702  * @pre This method can be called if @p scip is in one of the following stages:
10703  * - \ref SCIP_STAGE_TRANSFORMING
10704  * - \ref SCIP_STAGE_TRANSFORMED
10705  * - \ref SCIP_STAGE_INITPRESOLVE
10706  * - \ref SCIP_STAGE_PRESOLVING
10707  * - \ref SCIP_STAGE_EXITPRESOLVE
10708  * - \ref SCIP_STAGE_PRESOLVED
10709  * - \ref SCIP_STAGE_INITSOLVE
10710  * - \ref SCIP_STAGE_SOLVING
10711  */
10712 extern
10714  SCIP* scip, /**< SCIP data structure */
10715  int nconss, /**< number of constraints to get/create transformed constraints for */
10716  SCIP_CONS** conss, /**< array with constraints to get/create transformed constraints for */
10717  SCIP_CONS** transconss /**< array to store the transformed constraints */
10718  );
10719 
10720 /** gets corresponding transformed constraint of a given constraint;
10721  * returns NULL as transcons, if transformed constraint is not yet existing
10722  *
10723  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10724  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10725  *
10726  * @pre This method can be called if @p scip is in one of the following stages:
10727  * - \ref SCIP_STAGE_TRANSFORMING
10728  * - \ref SCIP_STAGE_TRANSFORMED
10729  * - \ref SCIP_STAGE_INITPRESOLVE
10730  * - \ref SCIP_STAGE_PRESOLVING
10731  * - \ref SCIP_STAGE_EXITPRESOLVE
10732  * - \ref SCIP_STAGE_PRESOLVED
10733  * - \ref SCIP_STAGE_INITSOLVE
10734  * - \ref SCIP_STAGE_SOLVING
10735  * - \ref SCIP_STAGE_SOLVED
10736  * - \ref SCIP_STAGE_EXITSOLVE
10737  * - \ref SCIP_STAGE_FREETRANS
10738  */
10739 extern
10741  SCIP* scip, /**< SCIP data structure */
10742  SCIP_CONS* cons, /**< constraint to get the transformed constraint for */
10743  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
10744  );
10745 
10746 /** gets corresponding transformed constraints for an array of constraints;
10747  * stores NULL in a transconss slot, if the transformed constraint is not yet existing;
10748  * it is possible to call this method with conss == transconss, but remember that constraints that are not
10749  * yet transformed will be replaced with NULL
10750  *
10751  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10752  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10753  *
10754  * @pre This method can be called if @p scip is in one of the following stages:
10755  * - \ref SCIP_STAGE_TRANSFORMING
10756  * - \ref SCIP_STAGE_TRANSFORMED
10757  * - \ref SCIP_STAGE_INITPRESOLVE
10758  * - \ref SCIP_STAGE_PRESOLVING
10759  * - \ref SCIP_STAGE_EXITPRESOLVE
10760  * - \ref SCIP_STAGE_PRESOLVED
10761  * - \ref SCIP_STAGE_INITSOLVE
10762  * - \ref SCIP_STAGE_SOLVING
10763  * - \ref SCIP_STAGE_SOLVED
10764  * - \ref SCIP_STAGE_EXITSOLVE
10765  * - \ref SCIP_STAGE_FREETRANS
10766  */
10767 extern
10769  SCIP* scip, /**< SCIP data structure */
10770  int nconss, /**< number of constraints to get the transformed constraints for */
10771  SCIP_CONS** conss, /**< constraints to get the transformed constraints for */
10772  SCIP_CONS** transconss /**< array to store the transformed constraints */
10773  );
10774 
10775 /** adds given value to age of constraint, but age can never become negative;
10776  * should be called
10777  * - in constraint separation, if no cut was found for this constraint,
10778  * - in constraint enforcing, if constraint was feasible, and
10779  * - in constraint propagation, if no domain reduction was deduced;
10780  *
10781  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10782  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10783  *
10784  * @pre This method can be called if @p scip is in one of the following stages:
10785  * - \ref SCIP_STAGE_TRANSFORMED
10786  * - \ref SCIP_STAGE_PRESOLVING
10787  * - \ref SCIP_STAGE_PRESOLVED
10788  * - \ref SCIP_STAGE_SOLVING
10789  * - \ref SCIP_STAGE_SOLVED
10790  */
10791 extern
10793  SCIP* scip, /**< SCIP data structure */
10794  SCIP_CONS* cons, /**< constraint */
10795  SCIP_Real deltaage /**< value to add to the constraint's age */
10796  );
10797 
10798 /** increases age of constraint by 1.0;
10799  * should be called
10800  * - in constraint separation, if no cut was found for this constraint,
10801  * - in constraint enforcing, if constraint was feasible, and
10802  * - in constraint propagation, if no domain reduction was deduced;
10803  *
10804  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10805  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10806  *
10807  * @pre This method can be called if @p scip is in one of the following stages:
10808  * - \ref SCIP_STAGE_TRANSFORMED
10809  * - \ref SCIP_STAGE_PRESOLVING
10810  * - \ref SCIP_STAGE_PRESOLVED
10811  * - \ref SCIP_STAGE_SOLVING
10812  * - \ref SCIP_STAGE_SOLVED
10813  */
10814 extern
10816  SCIP* scip, /**< SCIP data structure */
10817  SCIP_CONS* cons /**< constraint */
10818  );
10819 
10820 /** resets age of constraint to zero;
10821  * should be called
10822  * - in constraint separation, if a cut was found for this constraint,
10823  * - in constraint enforcing, if the constraint was violated, and
10824  * - in constraint propagation, if a domain reduction was deduced;
10825  *
10826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10828  *
10829  * @pre This method can be called if @p scip is in one of the following stages:
10830  * - \ref SCIP_STAGE_TRANSFORMED
10831  * - \ref SCIP_STAGE_PRESOLVING
10832  * - \ref SCIP_STAGE_PRESOLVED
10833  * - \ref SCIP_STAGE_SOLVING
10834  * - \ref SCIP_STAGE_SOLVED
10835  */
10836 extern
10838  SCIP* scip, /**< SCIP data structure */
10839  SCIP_CONS* cons /**< constraint */
10840  );
10841 
10842 /** enables constraint's separation, propagation, and enforcing capabilities
10843  *
10844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10846  *
10847  * @pre This method can be called if @p scip is in one of the following stages:
10848  * - \ref SCIP_STAGE_TRANSFORMED
10849  * - \ref SCIP_STAGE_PRESOLVING
10850  * - \ref SCIP_STAGE_PRESOLVED
10851  * - \ref SCIP_STAGE_INITSOLVE
10852  * - \ref SCIP_STAGE_SOLVING
10853  * - \ref SCIP_STAGE_SOLVED
10854  */
10855 extern
10857  SCIP* scip, /**< SCIP data structure */
10858  SCIP_CONS* cons /**< constraint */
10859  );
10860 
10861 /** disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated,
10862  * separated, and enforced anymore until it is enabled again with a call to SCIPenableCons();
10863  * in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and
10864  * does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor
10865  * automatically disabled again on entering the node again;
10866  * note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint
10867  * is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree,
10868  * and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using
10869  * an appropriate event handler that watches the corresponding variables' domain changes)
10870  *
10871  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10872  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10873  *
10874  * @pre This method can be called if @p scip is in one of the following stages:
10875  * - \ref SCIP_STAGE_TRANSFORMED
10876  * - \ref SCIP_STAGE_INITPRESOLVE
10877  * - \ref SCIP_STAGE_PRESOLVING
10878  * - \ref SCIP_STAGE_PRESOLVED
10879  * - \ref SCIP_STAGE_INITSOLVE
10880  * - \ref SCIP_STAGE_SOLVING
10881  * - \ref SCIP_STAGE_SOLVED
10882  */
10883 extern
10885  SCIP* scip, /**< SCIP data structure */
10886  SCIP_CONS* cons /**< constraint */
10887  );
10888 
10889 /** enables constraint's separation capabilities
10890  *
10891  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10892  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10893  *
10894  * @pre This method can be called if @p scip is in one of the following stages:
10895  * - \ref SCIP_STAGE_TRANSFORMED
10896  * - \ref SCIP_STAGE_PRESOLVING
10897  * - \ref SCIP_STAGE_PRESOLVED
10898  * - \ref SCIP_STAGE_INITSOLVE
10899  * - \ref SCIP_STAGE_SOLVING
10900  * - \ref SCIP_STAGE_SOLVED
10901  */
10902 extern
10904  SCIP* scip, /**< SCIP data structure */
10905  SCIP_CONS* cons /**< constraint */
10906  );
10907 
10908 /** disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation
10909  * is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
10910  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
10911  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
10912  *
10913  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10914  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10915  *
10916  * @pre This method can be called if @p scip is in one of the following stages:
10917  * - \ref SCIP_STAGE_TRANSFORMED
10918  * - \ref SCIP_STAGE_PRESOLVING
10919  * - \ref SCIP_STAGE_PRESOLVED
10920  * - \ref SCIP_STAGE_INITSOLVE
10921  * - \ref SCIP_STAGE_SOLVING
10922  * - \ref SCIP_STAGE_SOLVED
10923  */
10924 extern
10926  SCIP* scip, /**< SCIP data structure */
10927  SCIP_CONS* cons /**< constraint */
10928  );
10929 
10930 /** enables constraint's propagation capabilities
10931  *
10932  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10933  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10934  *
10935  * @pre This method can be called if @p scip is in one of the following stages:
10936  * - \ref SCIP_STAGE_TRANSFORMED
10937  * - \ref SCIP_STAGE_INITPRESOLVE
10938  * - \ref SCIP_STAGE_PRESOLVING
10939  * - \ref SCIP_STAGE_EXITPRESOLVE
10940  * - \ref SCIP_STAGE_PRESOLVED
10941  * - \ref SCIP_STAGE_INITSOLVE
10942  * - \ref SCIP_STAGE_SOLVING
10943  * - \ref SCIP_STAGE_SOLVED
10944  */
10945 extern
10947  SCIP* scip, /**< SCIP data structure */
10948  SCIP_CONS* cons /**< constraint */
10949  );
10950 
10951 /** disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation
10952  * is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
10953  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
10954  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
10955  *
10956  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10957  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10958  *
10959  * @pre This method can be called if @p scip is in one of the following stages:
10960  * - \ref SCIP_STAGE_TRANSFORMED
10961  * - \ref SCIP_STAGE_INITPRESOLVE
10962  * - \ref SCIP_STAGE_PRESOLVING
10963  * - \ref SCIP_STAGE_EXITPRESOLVE
10964  * - \ref SCIP_STAGE_PRESOLVED
10965  * - \ref SCIP_STAGE_INITSOLVE
10966  * - \ref SCIP_STAGE_SOLVING
10967  * - \ref SCIP_STAGE_SOLVED
10968  */
10969 extern
10971  SCIP* scip, /**< SCIP data structure */
10972  SCIP_CONS* cons /**< constraint */
10973  );
10974 
10975 
10976 /** marks constraint to be propagated
10977  *
10978  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10979  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10980  *
10981  * @pre This method can be called if @p scip is in one of the following stages:
10982  * - \ref SCIP_STAGE_TRANSFORMED
10983  * - \ref SCIP_STAGE_PRESOLVING
10984  * - \ref SCIP_STAGE_EXITPRESOLVE
10985  * - \ref SCIP_STAGE_PRESOLVED
10986  * - \ref SCIP_STAGE_INITSOLVE
10987  * - \ref SCIP_STAGE_SOLVING
10988  * - \ref SCIP_STAGE_SOLVED
10989  *
10990  * @note if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation
10991  */
10992 extern
10994  SCIP* scip, /**< SCIP data structure */
10995  SCIP_CONS* cons /**< constraint */
10996  );
10997 
10998 /** unmarks the constraint to be propagated
10999  *
11000  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11001  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11002  *
11003  * @pre This method can be called if @p scip is in one of the following stages:
11004  * - \ref SCIP_STAGE_TRANSFORMED
11005  * - \ref SCIP_STAGE_PRESOLVING
11006  * - \ref SCIP_STAGE_EXITPRESOLVE
11007  * - \ref SCIP_STAGE_PRESOLVED
11008  * - \ref SCIP_STAGE_INITSOLVE
11009  * - \ref SCIP_STAGE_SOLVING
11010  * - \ref SCIP_STAGE_SOLVED
11011  */
11012 extern
11014  SCIP* scip, /**< SCIP data structure */
11015  SCIP_CONS* cons /**< constraint */
11016  );
11017 
11018 /** adds given values to lock status of the constraint and updates the rounding locks of the involved variables
11019  *
11020  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11021  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11022  *
11023  * @pre This method can be called if @p scip is in one of the following stages:
11024  * - \ref SCIP_STAGE_PROBLEM
11025  * - \ref SCIP_STAGE_TRANSFORMING
11026  * - \ref SCIP_STAGE_INITPRESOLVE
11027  * - \ref SCIP_STAGE_PRESOLVING
11028  * - \ref SCIP_STAGE_EXITPRESOLVE
11029  * - \ref SCIP_STAGE_INITSOLVE
11030  * - \ref SCIP_STAGE_SOLVING
11031  * - \ref SCIP_STAGE_EXITSOLVE
11032  * - \ref SCIP_STAGE_FREETRANS
11033  */
11034 extern
11036  SCIP* scip, /**< SCIP data structure */
11037  SCIP_CONS* cons, /**< constraint */
11038  int nlockspos, /**< increase in number of rounding locks for constraint */
11039  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
11040  );
11041 
11042 /** checks single constraint for feasibility of the given solution
11043  *
11044  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11045  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11046  *
11047  * @pre This method can be called if @p scip is in one of the following stages:
11048  * - \ref SCIP_STAGE_TRANSFORMED
11049  * - \ref SCIP_STAGE_INITPRESOLVE
11050  * - \ref SCIP_STAGE_PRESOLVING
11051  * - \ref SCIP_STAGE_EXITPRESOLVE
11052  * - \ref SCIP_STAGE_PRESOLVED
11053  * - \ref SCIP_STAGE_INITSOLVE
11054  * - \ref SCIP_STAGE_SOLVING
11055  * - \ref SCIP_STAGE_SOLVED
11056  */
11057 extern
11059  SCIP* scip, /**< SCIP data structure */
11060  SCIP_CONS* cons, /**< constraint to check */
11061  SCIP_SOL* sol, /**< primal CIP solution */
11062  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
11063  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
11064  SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
11065  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11066  );
11067 
11068 /** enforces single constraint for a given pseudo solution
11069  *
11070  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11071  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11072  *
11073  * @pre This method can be called if @p scip is in one of the following stages:
11074  * - \ref SCIP_STAGE_SOLVING
11075  *
11076  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11077  * added to SCIP beforehand.
11078  */
11079 extern
11081  SCIP* scip, /**< SCIP data structure */
11082  SCIP_CONS* cons, /**< constraint to enforce */
11083  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
11084  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
11085  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11086  );
11087 
11088 /** enforces single constraint for a given LP solution
11089  *
11090  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11091  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11092  *
11093  * @pre This method can be called if @p scip is in one of the following stages:
11094  * - \ref SCIP_STAGE_SOLVING
11095  *
11096  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11097  * added to SCIP beforehand.
11098  */
11099 extern
11101  SCIP* scip, /**< SCIP data structure */
11102  SCIP_CONS* cons, /**< constraint to enforce */
11103  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
11104  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11105  );
11106 
11107 /** calls LP initialization method for single constraint
11108  *
11109  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11110  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11111  *
11112  * @pre This method can be called if @p scip is in one of the following stages:
11113  * - \ref SCIP_STAGE_SOLVING
11114  *
11115  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11116  * added to SCIP beforehand.
11117  */
11118 extern
11120  SCIP* scip, /**< SCIP data structure */
11121  SCIP_CONS* cons /**< constraint to initialize */
11122  );
11123 
11124 /** calls separation method of single constraint for LP solution
11125  *
11126  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11127  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11128  *
11129  * @pre This method can be called if @p scip is in one of the following stages:
11130  * - \ref SCIP_STAGE_SOLVING
11131  *
11132  * @note This is an advanced method and should be used with caution.
11133  */
11134 extern
11136  SCIP* scip, /**< SCIP data structure */
11137  SCIP_CONS* cons, /**< constraint to separate */
11138  SCIP_RESULT* result /**< pointer to store the result of the separation call */
11139  );
11140 
11141 /** calls separation method of single constraint for given primal solution
11142  *
11143  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11144  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11145  *
11146  * @pre This method can be called if @p scip is in one of the following stages:
11147  * - \ref SCIP_STAGE_SOLVING
11148  *
11149  * @note This is an advanced method and should be used with caution.
11150  */
11151 extern
11153  SCIP* scip, /**< SCIP data structure */
11154  SCIP_CONS* cons, /**< constraint to separate */
11155  SCIP_SOL* sol, /**< primal solution that should be separated*/
11156  SCIP_RESULT* result /**< pointer to store the result of the separation call */
11157  );
11158 
11159 /** calls domain propagation method of single constraint
11160  *
11161  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11162  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11163  *
11164  * @pre This method can be called if @p scip is in one of the following stages:
11165  * - \ref SCIP_STAGE_PRESOLVING
11166  * - \ref SCIP_STAGE_SOLVING
11167  *
11168  * @note This is an advanced method and should be used with caution.
11169  */
11170 extern
11172  SCIP* scip, /**< SCIP data structure */
11173  SCIP_CONS* cons, /**< constraint to propagate */
11174  SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
11175  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11176  );
11177 
11178 /** resolves propagation conflict of single constraint
11179  *
11180  *
11181  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11182  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11183  *
11184  * @pre This method can be called if @p scip is in one of the following stages:
11185  * - \ref SCIP_STAGE_PRESOLVING
11186  * - \ref SCIP_STAGE_SOLVING
11187  *
11188  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11189  * added to SCIP beforehand.
11190  */
11191 extern
11193  SCIP* scip, /**< SCIP data structure */
11194  SCIP_CONS* cons, /**< constraint to resolve conflict for */
11195  SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
11196  int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
11197  SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
11198  SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
11199  SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
11200  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11201  );
11202 
11203 /** presolves of single constraint
11204  *
11205  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11206  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11207  *
11208  * @pre This method can be called if @p scip is in one of the following stages:
11209  * - \ref SCIP_STAGE_PRESOLVING
11210  *
11211  * @note This is an advanced method and should be used with caution.
11212  */
11213 extern
11215  SCIP* scip, /**< SCIP data structure */
11216  SCIP_CONS* cons, /**< constraint to presolve */
11217  int nrounds, /**< number of presolving rounds already done */
11218  SCIP_PRESOLTIMING presoltiming, /**< presolving timing(s) to be performed */
11219  int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
11220  int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
11221  int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
11222  int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
11223  int nnewholes, /**< number of domain holes added since the last call to the presolving method */
11224  int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
11225  int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
11226  int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
11227  int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
11228  int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
11229  int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
11230  int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
11231  int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
11232  int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
11233  int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
11234  int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
11235  int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
11236  int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
11237  int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
11238  int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
11239  SCIP_RESULT* result /**< pointer to store the result of the callback method */
11240  );
11241 
11242 /** calls constraint activation notification method of single constraint
11243  *
11244  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11245  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11246  *
11247  * @pre This method can be called if @p scip is in one of the following stages:
11248  * - \ref SCIP_STAGE_TRANSFORMING
11249  *
11250  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11251  * added to SCIP beforehand.
11252  */
11253 extern
11255  SCIP* scip, /**< SCIP data structure */
11256  SCIP_CONS* cons /**< constraint to notify */
11257  );
11258 
11259 /** calls constraint deactivation notification method of single constraint
11260  *
11261  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11262  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11263  *
11264  * @pre This method can be called if @p scip is in one of the following stages:
11265  * - \ref SCIP_STAGE_PRESOLVING
11266  * - \ref SCIP_STAGE_SOLVING
11267  *
11268  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
11269  * added to SCIP beforehand.
11270  */
11271 extern
11273  SCIP* scip, /**< SCIP data structure */
11274  SCIP_CONS* cons /**< constraint to notify */
11275  );
11276 
11277 /** outputs constraint information to file stream via the message handler system
11278  *
11279  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11280  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11281  *
11282  * @pre This method can be called if @p scip is in one of the following stages:
11283  * - \ref SCIP_STAGE_PROBLEM
11284  * - \ref SCIP_STAGE_TRANSFORMING
11285  * - \ref SCIP_STAGE_TRANSFORMED
11286  * - \ref SCIP_STAGE_INITPRESOLVE
11287  * - \ref SCIP_STAGE_PRESOLVING
11288  * - \ref SCIP_STAGE_EXITPRESOLVE
11289  * - \ref SCIP_STAGE_PRESOLVED
11290  * - \ref SCIP_STAGE_INITSOLVE
11291  * - \ref SCIP_STAGE_SOLVING
11292  * - \ref SCIP_STAGE_SOLVED
11293  * - \ref SCIP_STAGE_EXITSOLVE
11294  * - \ref SCIP_STAGE_FREETRANS
11295  *
11296  * @note If the message handler is set to a NULL pointer nothing will be printed.
11297  * @note The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a
11298  * newline character.
11299  */
11300 extern
11302  SCIP* scip, /**< SCIP data structure */
11303  SCIP_CONS* cons, /**< constraint */
11304  FILE* file /**< output file (or NULL for standard output) */
11305  );
11306 
11307 /** method to collect the variables of a constraint
11308  *
11309  * If the number of variables is greater than the available slots in the variable array, nothing happens except that
11310  * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
11311  * a constraint has in its scope.
11312  *
11313  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11314  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11315  *
11316  * @pre This method can be called if @p scip is in one of the following stages:
11317  * - \ref SCIP_STAGE_PROBLEM
11318  * - \ref SCIP_STAGE_TRANSFORMING
11319  * - \ref SCIP_STAGE_TRANSFORMED
11320  * - \ref SCIP_STAGE_INITPRESOLVE
11321  * - \ref SCIP_STAGE_PRESOLVING
11322  * - \ref SCIP_STAGE_EXITPRESOLVE
11323  * - \ref SCIP_STAGE_PRESOLVED
11324  * - \ref SCIP_STAGE_INITSOLVE
11325  * - \ref SCIP_STAGE_SOLVING
11326  * - \ref SCIP_STAGE_SOLVED
11327  * - \ref SCIP_STAGE_EXITSOLVE
11328  * - \ref SCIP_STAGE_FREETRANS
11329  *
11330  * @note The success pointer indicates if all variables were copied into the vars arrray.
11331  *
11332  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
11333  * set to FALSE.
11334  */
11335 extern
11337  SCIP* scip, /**< SCIP data structure */
11338  SCIP_CONS* cons, /**< constraint for which the variables are wanted */
11339  SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
11340  int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
11341  SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
11342  );
11343 
11344 /** method to collect the number of variables of a constraint
11345  *
11346  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11347  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11348  *
11349  * @pre This method can be called if @p scip is in one of the following stages:
11350  * - \ref SCIP_STAGE_PROBLEM
11351  * - \ref SCIP_STAGE_TRANSFORMING
11352  * - \ref SCIP_STAGE_TRANSFORMED
11353  * - \ref SCIP_STAGE_INITPRESOLVE
11354  * - \ref SCIP_STAGE_PRESOLVING
11355  * - \ref SCIP_STAGE_EXITPRESOLVE
11356  * - \ref SCIP_STAGE_PRESOLVED
11357  * - \ref SCIP_STAGE_INITSOLVE
11358  * - \ref SCIP_STAGE_SOLVING
11359  * - \ref SCIP_STAGE_SOLVED
11360  * - \ref SCIP_STAGE_EXITSOLVE
11361  * - \ref SCIP_STAGE_FREETRANS
11362  *
11363  * @note The success pointer indicates if the contraint handler was able to return the number of variables
11364  *
11365  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
11366  * set to FALSE
11367  */
11368 extern
11370  SCIP* scip, /**< SCIP data structure */
11371  SCIP_CONS* cons, /**< constraint for which the number of variables is wanted */
11372  int* nvars, /**< pointer to store the number of variables */
11373  SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
11374  );
11375 
11376 /**@} */
11377 
11378 
11379 
11380 
11381 /*
11382  * LP methods
11383  */
11384 
11385 /**@name LP Methods */
11386 /**@{ */
11387 
11388 /** returns, whether the LP was or is to be solved in the current node
11389  *
11390  * @return whether the LP was or is to be solved in the current node.
11391  *
11392  * @pre This method can be called if @p scip is in one of the following stages:
11393  * - \ref SCIP_STAGE_SOLVING
11394  *
11395  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11396  */
11397 extern
11399  SCIP* scip /**< SCIP data structure */
11400  );
11401 
11402 /** returns, whether the LP of the current node is already constructed
11403  *
11404  * @return whether the LP of the current node is already constructed.
11405  *
11406  * @pre This method can be called if @p scip is in one of the following stages:
11407  * - \ref SCIP_STAGE_SOLVING
11408  *
11409  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11410  */
11411 extern
11413  SCIP* scip /**< SCIP data structure */
11414  );
11415 
11416 /** makes sure that the LP of the current node is loaded and may be accessed through the LP information methods
11417  *
11418  * @warning Contructing the LP might change the amount of variables known in the transformed problem and therefore also
11419  * the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to
11420  * call one of the later method after this one
11421  *
11422  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11423  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11424  *
11425  * @pre This method can be called if @p scip is in one of the following stages:
11426  * - \ref SCIP_STAGE_SOLVING
11427  *
11428  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11429  */
11430 extern
11432  SCIP* scip, /**< SCIP data structure */
11433  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
11434  );
11435 
11436 /** makes sure that the LP of the current node is flushed
11437  *
11438  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11439  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11440  *
11441  * @pre This method can be called if @p scip is in one of the following stages:
11442  * - \ref SCIP_STAGE_SOLVING
11443  *
11444  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11445  */
11446 extern
11448  SCIP* scip /**< SCIP data structure */
11449  );
11450 
11451 /** gets solution status of current LP
11452  *
11453  * @return the solution status of current LP.
11454  *
11455  * @pre This method can be called if @p scip is in one of the following stages:
11456  * - \ref SCIP_STAGE_SOLVING
11457  *
11458  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11459  */
11460 extern
11462  SCIP* scip /**< SCIP data structure */
11463  );
11464 
11465 /** returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
11466  *
11467  * @return whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.
11468  *
11469  * @pre This method can be called if @p scip is in one of the following stages:
11470  * - \ref SCIP_STAGE_SOLVING
11471  *
11472  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11473  */
11474 extern
11476  SCIP* scip /**< SCIP data structure */
11477  );
11478 
11479 /** gets objective value of current LP (which is the sum of column and loose objective value)
11480  *
11481  * @return the objective value of current LP (which is the sum of column and loose objective value).
11482  *
11483  * @pre This method can be called if @p scip is in one of the following stages:
11484  * - \ref SCIP_STAGE_SOLVING
11485  *
11486  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
11487  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by
11488  * SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
11489  *
11490  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11491  */
11492 extern
11494  SCIP* scip /**< SCIP data structure */
11495  );
11496 
11497 /** gets part of objective value of current LP that results from COLUMN variables only
11498  *
11499  * @return the part of objective value of current LP that results from COLUMN variables only.
11500  *
11501  * @pre This method can be called if @p scip is in one of the following stages:
11502  * - \ref SCIP_STAGE_SOLVING
11503  *
11504  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11505  */
11506 extern
11508  SCIP* scip /**< SCIP data structure */
11509  );
11510 
11511 /** gets part of objective value of current LP that results from LOOSE variables only
11512  *
11513  * @return part of objective value of current LP that results from LOOSE variables only.
11514  *
11515  * @pre This method can be called if @p scip is in one of the following stages:
11516  * - \ref SCIP_STAGE_SOLVING
11517  *
11518  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11519  */
11520 extern
11522  SCIP* scip /**< SCIP data structure */
11523  );
11524 
11525 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
11526  * function) global bound
11527  *
11528  * @return the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
11529  * function) global bound.
11530  *
11531  * @pre This method can be called if @p scip is in one of the following stages:
11532  * - \ref SCIP_STAGE_INITPRESOLVE
11533  * - \ref SCIP_STAGE_PRESOLVING
11534  * - \ref SCIP_STAGE_EXITPRESOLVE
11535  * - \ref SCIP_STAGE_PRESOLVED
11536  * - \ref SCIP_STAGE_INITSOLVE
11537  * - \ref SCIP_STAGE_SOLVING
11538  *
11539  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11540  */
11541 extern
11543  SCIP* scip /**< SCIP data structure */
11544  );
11545 
11546 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
11547  * objective function) local bound
11548  *
11549  * @return the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
11550  * objective function) local bound.
11551  *
11552  * @pre This method can be called if @p scip is in one of the following stages:
11553  * - \ref SCIP_STAGE_INITPRESOLVE
11554  * - \ref SCIP_STAGE_PRESOLVING
11555  * - \ref SCIP_STAGE_EXITPRESOLVE
11556  * - \ref SCIP_STAGE_PRESOLVED
11557  * - \ref SCIP_STAGE_INITSOLVE
11558  * - \ref SCIP_STAGE_SOLVING
11559  *
11560  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11561  */
11562 extern
11564  SCIP* scip /**< SCIP data structure */
11565  );
11566 
11567 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
11568  *
11569  * @return whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.
11570  *
11571  * @pre This method can be called if @p scip is in one of the following stages:
11572  * - \ref SCIP_STAGE_SOLVING
11573  *
11574  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11575  */
11576 extern
11578  SCIP* scip /**< SCIP data structure */
11579  );
11580 
11581 /** gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved
11582  *
11583  * @return the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved.
11584  *
11585  * @pre This method can be called if @p scip is in one of the following stages:
11586  * - \ref SCIP_STAGE_INITPRESOLVE
11587  * - \ref SCIP_STAGE_PRESOLVING
11588  * - \ref SCIP_STAGE_EXITPRESOLVE
11589  * - \ref SCIP_STAGE_SOLVING
11590  *
11591  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11592  */
11593 extern
11595  SCIP* scip /**< SCIP data structure */
11596  );
11597 
11598 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
11599  * returns SCIP_INVALID if the root node LP was not (yet) solved
11600  *
11601  * @return the part of the objective value of the root node LP that results from COLUMN variables only;
11602  * or SCIP_INVALID if the root node LP was not (yet) solved.
11603  *
11604  * @pre This method can be called if @p scip is in one of the following stages:
11605  * - \ref SCIP_STAGE_INITPRESOLVE
11606  * - \ref SCIP_STAGE_PRESOLVING
11607  * - \ref SCIP_STAGE_EXITPRESOLVE
11608  * - \ref SCIP_STAGE_SOLVING
11609  *
11610  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11611  */
11612 extern
11614  SCIP* scip /**< SCIP data structure */
11615  );
11616 
11617 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
11618  * returns SCIP_INVALID if the root node LP was not (yet) solved
11619  *
11620  * @return the part of the objective value of the root node LP that results from LOOSE variables only;
11621  * or SCIP_INVALID if the root node LP was not (yet) solved.
11622  *
11623  * @pre This method can be called if @p scip is in one of the following stages:
11624  * - \ref SCIP_STAGE_INITPRESOLVE
11625  * - \ref SCIP_STAGE_PRESOLVING
11626  * - \ref SCIP_STAGE_EXITPRESOLVE
11627  * - \ref SCIP_STAGE_SOLVING
11628  *
11629  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11630  */
11631 extern
11633  SCIP* scip /**< SCIP data structure */
11634  );
11635 
11636 /** gets current LP columns along with the current number of LP columns
11637  *
11638  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11639  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11640  *
11641  * @pre This method can be called if @p scip is in one of the following stages:
11642  * - \ref SCIP_STAGE_SOLVING
11643  *
11644  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11645  */
11646 extern
11648  SCIP* scip, /**< SCIP data structure */
11649  SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */
11650  int* ncols /**< pointer to store the number of LP columns, or NULL */
11651  );
11652 
11653 /** gets current LP columns
11654  *
11655  * @return the current LP columns.
11656  *
11657  * @pre This method can be called if @p scip is in one of the following stages:
11658  * - \ref SCIP_STAGE_SOLVING
11659  *
11660  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11661  */
11662 extern
11664  SCIP* scip /**< SCIP data structure */
11665  );
11666 
11667 /** gets current number of LP columns
11668  *
11669  * @return the current number of LP columns.
11670  *
11671  * @pre This method can be called if @p scip is in one of the following stages:
11672  * - \ref SCIP_STAGE_SOLVING
11673  *
11674  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11675  */
11676 extern
11677 int SCIPgetNLPCols(
11678  SCIP* scip /**< SCIP data structure */
11679  );
11680 
11681 /** gets current LP rows along with the current number of LP rows
11682  *
11683  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11684  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11685  *
11686  * @pre This method can be called if @p scip is in one of the following stages:
11687  * - \ref SCIP_STAGE_SOLVING
11688  *
11689  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11690  */
11691 extern
11693  SCIP* scip, /**< SCIP data structure */
11694  SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */
11695  int* nrows /**< pointer to store the number of LP rows, or NULL */
11696  );
11697 
11698 /** gets current LP rows
11699  *
11700  * @return the current LP rows.
11701  *
11702  * @pre This method can be called if @p scip is in one of the following stages:
11703  * - \ref SCIP_STAGE_SOLVING
11704  *
11705  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11706  */
11707 extern
11709  SCIP* scip /**< SCIP data structure */
11710  );
11711 
11712 /** gets current number of LP rows
11713  *
11714  * @return the current number of LP rows.
11715  *
11716  * @pre This method can be called if @p scip is in one of the following stages:
11717  * - \ref SCIP_STAGE_SOLVING
11718  *
11719  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11720  */
11721 extern
11722 int SCIPgetNLPRows(
11723  SCIP* scip /**< SCIP data structure */
11724  );
11725 
11726 /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
11727  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
11728  *
11729  * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
11730  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.
11731  *
11732  * @pre This method can be called if @p scip is in one of the following stages:
11733  * - \ref SCIP_STAGE_SOLVING
11734  *
11735  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11736  */
11737 extern
11739  SCIP* scip /**< SCIP data structure */
11740  );
11741 
11742 /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
11743  *
11744  * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis.
11745  *
11746  * @pre This method can be called if @p scip is in one of the following stages:
11747  * - \ref SCIP_STAGE_SOLVING
11748  *
11749  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11750  */
11751 extern
11753  SCIP* scip /**< SCIP data structure */
11754  );
11755 
11756 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
11757  *
11758  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11759  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11760  *
11761  * @pre This method can be called if @p scip is in one of the following stages:
11762  * - \ref SCIP_STAGE_SOLVING
11763  *
11764  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11765  */
11766 extern
11768  SCIP* scip, /**< SCIP data structure */
11769  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
11770  );
11771 
11772 /** gets a row from the inverse basis matrix B^-1
11773  *
11774  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11775  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11776  *
11777  * @pre This method can be called if @p scip is in one of the following stages:
11778  * - \ref SCIP_STAGE_SOLVING
11779  *
11780  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11781  */
11782 extern
11784  SCIP* scip, /**< SCIP data structure */
11785  int r, /**< row number */
11786  SCIP_Real* coefs, /**< array to store the coefficients of the row */
11787  int* inds, /**< array to store the non-zero indices, or NULL */
11788  int* ninds /**< pointer to store the number of non-zero indices, or NULL
11789  * (-1: if we do not store sparsity informations) */
11790  );
11791 
11792 /** gets a column from the inverse basis matrix B^-1
11793  *
11794  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11795  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11796  *
11797  * @pre This method can be called if @p scip is in one of the following stages:
11798  * - \ref SCIP_STAGE_SOLVING
11799  *
11800  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11801  */
11802 extern
11804  SCIP* scip, /**< SCIP data structure */
11805  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
11806  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
11807  * to get the array which links the B^-1 column numbers to the row and
11808  * column numbers of the LP! c must be between 0 and nrows-1, since the
11809  * basis has the size nrows * nrows */
11810  SCIP_Real* coefs, /**< array to store the coefficients of the column */
11811  int* inds, /**< array to store the non-zero indices, or NULL */
11812  int* ninds /**< pointer to store the number of non-zero indices, or NULL
11813  * (-1: if we do not store sparsity informations) */
11814  );
11815 
11816 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
11817  *
11818  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11819  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11820  *
11821  * @pre This method can be called if @p scip is in one of the following stages:
11822  * - \ref SCIP_STAGE_SOLVING
11823  *
11824  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11825  */
11826 extern
11828  SCIP* scip, /**< SCIP data structure */
11829  int r, /**< row number */
11830  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */
11831  SCIP_Real* coefs, /**< array to store the coefficients of the row */
11832  int* inds, /**< array to store the non-zero indices, or NULL */
11833  int* ninds /**< pointer to store the number of non-zero indices, or NULL
11834  * (-1: if we do not store sparsity informations) */
11835  );
11836 
11837 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
11838  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
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  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11847  */
11848 extern
11850  SCIP* scip, /**< SCIP data structure */
11851  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
11852  SCIP_Real* coefs, /**< array to store the coefficients of the column */
11853  int* inds, /**< array to store the non-zero indices, or NULL */
11854  int* ninds /**< pointer to store the number of non-zero indices, or NULL
11855  * (-1: if we do not store sparsity informations) */
11856  );
11857 
11858 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
11859  * LP row are swapped in the summation
11860  *
11861  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11862  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11863  *
11864  * @pre This method can be called if @p scip is in one of the following stages:
11865  * - \ref SCIP_STAGE_SOLVING
11866  *
11867  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11868  */
11869 extern
11871  SCIP* scip, /**< SCIP data structure */
11872  SCIP_Real* weights, /**< row weights in row summation */
11873  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
11874  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
11875  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
11876  );
11877 
11878 /** calculates a MIR cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these
11879  * rows cannot participate in a MIR cut.
11880  *
11881  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11882  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11883  *
11884  * @pre This method can be called if @p scip is in one of the following stages:
11885  * - \ref SCIP_STAGE_SOLVING
11886  *
11887  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11888  */
11889 extern
11891  SCIP* scip, /**< SCIP data structure */
11892  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
11893  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
11894  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
11895  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
11896  SCIP_Bool fixintegralrhs, /**< should complementation tried to be adjusted such that rhs gets fractional? */
11897  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
11898  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
11899  * NULL for using closest bound for all variables */
11900  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
11901  * NULL for using closest bound for all variables */
11902  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
11903  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
11904  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
11905  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
11906  SCIP_Real* weights, /**< row weights in row summation; some weights might be set to zero */
11907  SCIP_Real maxweight, /**< largest magnitude of weights; set to -1.0 if sparsity information is
11908  * unknown */
11909  int* weightinds, /**< sparsity pattern of weights; size nrowinds; NULL if sparsity info is
11910  * unknown */
11911  int nweightinds, /**< number of nonzeros in weights; -1 if rowinds is NULL */
11912  int rowlensum, /**< total number of non-zeros in used rows (row associated with nonzero weight coefficient); -1 if unknown */
11913  int* sidetypes, /**< specify row side type (-1 = lhs, 0 = unkown, 1 = rhs) or NULL for automatic choices */
11914  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
11915  SCIP_Real* mksetcoefs, /**< array to store mixed knapsack set coefficients: size nvars; or NULL */
11916  SCIP_Bool* mksetcoefsvalid, /**< pointer to store whether mixed knapsack set coefficients are valid; or NULL */
11917  SCIP_Real* mircoef, /**< array to store MIR coefficients: must be of size SCIPgetNVars() */
11918  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the MIR row */
11919  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
11920  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid MIR cut */
11921  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
11922  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
11923  );
11924 
11925 /** 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
11926  * rows cannot participate in a MIR cut.
11927  *
11928  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11929  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11930  *
11931  * @pre This method can be called if @p scip is in one of the following stages:
11932  * - \ref SCIP_STAGE_SOLVING
11933  *
11934  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11935  */
11936 extern
11938  SCIP* scip, /**< SCIP data structure */
11939  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
11940  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
11941  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
11942  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
11943  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
11944  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce strong CG cut for */
11945  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce strong CG cut for */
11946  SCIP_Real* weights, /**< row weights in row summation; some weights might be set to zero */
11947  int* inds, /**< indices of non-zero entries in weights array, or NULL */
11948  int ninds, /**< number of indices of non-zero entries in weights array, -1 if inds is
11949  * NULL */
11950  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
11951  SCIP_Real* mircoef, /**< array to store strong CG coefficients: must be of size SCIPgetNVars() */
11952  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the strong CG row */
11953  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
11954  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid strong CG cut */
11955  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
11956  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
11957  );
11958 
11959 /** writes current LP to a file
11960  *
11961  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11962  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11963  *
11964  * @pre This method can be called if @p scip is in one of the following stages:
11965  * - \ref SCIP_STAGE_SOLVING
11966  *
11967  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11968  */
11969 extern
11971  SCIP* scip, /**< SCIP data structure */
11972  const char* filename /**< file name */
11973  );
11974 
11975 /** writes MIP relaxation of the current branch-and-bound node to a file
11976  *
11977  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11978  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11979  *
11980  * @pre This method can be called if @p scip is in one of the following stages:
11981  * - \ref SCIP_STAGE_SOLVING
11982  *
11983  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11984  */
11985 extern
11987  SCIP* scip, /**< SCIP data structure */
11988  const char* filename, /**< file name */
11989  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
11990  * troubles with reserved symbols? */
11991  SCIP_Bool origobj, /**< should the original objective function be used? */
11992  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
11993  );
11994 
11995 /** gets the LP interface of SCIP;
11996  * with the LPI you can use all of the methods defined in lpi/lpi.h;
11997  *
11998  * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely
11999  * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution
12000  * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in
12001  * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make
12002  * sure, the internal solution status is recovered completely at the end of your method. This can be achieved
12003  * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it
12004  * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the
12005  * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.
12006  *
12007  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
12008  *
12009  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12010  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12011  *
12012  * @pre This method can be called if @p scip is in one of the following stages:
12013  * - \ref SCIP_STAGE_TRANSFORMED
12014  * - \ref SCIP_STAGE_INITPRESOLVE
12015  * - \ref SCIP_STAGE_PRESOLVING
12016  * - \ref SCIP_STAGE_EXITPRESOLVE
12017  * - \ref SCIP_STAGE_PRESOLVED
12018  * - \ref SCIP_STAGE_INITSOLVE
12019  * - \ref SCIP_STAGE_SOLVING
12020  * - \ref SCIP_STAGE_SOLVED
12021  * - \ref SCIP_STAGE_EXITSOLVE
12022  *
12023  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12024  */
12025 extern
12027  SCIP* scip, /**< SCIP data structure */
12028  SCIP_LPI** lpi /**< pointer to store the LP interface */
12029  );
12030 
12031 /** Displays quality information about the current LP solution. An LP solution need to be available. Information printed
12032  * is subject to what the LP solver supports
12033  *
12034  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12035  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12036  *
12037  * @pre This method can be called if @p scip is in one of the following stages:
12038  * - \ref SCIP_STAGE_INIT
12039  * - \ref SCIP_STAGE_PROBLEM
12040  * - \ref SCIP_STAGE_TRANSFORMED
12041  * - \ref SCIP_STAGE_INITPRESOLVE
12042  * - \ref SCIP_STAGE_PRESOLVING
12043  * - \ref SCIP_STAGE_EXITPRESOLVE
12044  * - \ref SCIP_STAGE_PRESOLVED
12045  * - \ref SCIP_STAGE_SOLVING
12046  * - \ref SCIP_STAGE_SOLVED
12047  * - \ref SCIP_STAGE_FREE
12048  *
12049  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12050  *
12051  * @note The printing process is done via the message handler system.
12052  */
12053 extern
12055  SCIP* scip, /**< SCIP data structure */
12056  FILE* file /**< output file (or NULL for standard output) */
12057  );
12058 
12059 /** compute relative interior point to current LP
12060  * @see SCIPlpComputeRelIntPoint
12061  *
12062  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12063  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12064  *
12065  * @pre This method can be called if @p scip is in one of the following stages:
12066  * - \ref SCIP_STAGE_TRANSFORMED
12067  * - \ref SCIP_STAGE_INITPRESOLVE
12068  * - \ref SCIP_STAGE_PRESOLVING
12069  * - \ref SCIP_STAGE_EXITPRESOLVE
12070  * - \ref SCIP_STAGE_PRESOLVED
12071  * - \ref SCIP_STAGE_SOLVING
12072  * - \ref SCIP_STAGE_SOLVED
12073  *
12074  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
12075  */
12076 extern
12078  SCIP* scip, /**< SCIP data structure */
12079  SCIP_Bool relaxrows, /**< should the rows be relaxed */
12080  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
12081  SCIP_Real timelimit, /**< time limit for LP solver */
12082  int iterlimit, /**< iteration limit for LP solver */
12083  SCIP_SOL** point /**< relative interior point on exit */
12084  );
12085 
12086 /**@} */
12087 
12088 
12089 
12090 /*
12091  * LP column methods
12092  */
12093 
12094 /**@name LP Column Methods */
12095 /**@{ */
12096 
12097 /** returns the reduced costs of a column in the last (feasible) LP
12098  *
12099  * @return the reduced costs of a column in the last (feasible) LP
12100  *
12101  * @pre this method can be called in one of the following stages of the SCIP solving process:
12102  * - \ref SCIP_STAGE_SOLVING
12103  */
12104 extern
12106  SCIP* scip, /**< SCIP data structure */
12107  SCIP_COL* col /**< LP column */
12108  );
12109 
12110 /** returns the Farkas coefficient of a column in the last (infeasible) LP
12111  *
12112  * @return the Farkas coefficient of a column in the last (infeasible) LP
12113  *
12114  * @pre this method can be called in one of the following stages of the SCIP solving process:
12115  * - \ref SCIP_STAGE_SOLVING
12116  */
12117 extern
12119  SCIP* scip, /**< SCIP data structure */
12120  SCIP_COL* col /**< LP column */
12121  );
12122 
12123 /** marks a column to be not removable from the LP in the current node
12124  *
12125  * @pre this method can be called in the following stage of the SCIP solving process:
12126  * - \ref SCIP_STAGE_SOLVING
12127  */
12128 extern
12130  SCIP* scip, /**< SCIP data structure */
12131  SCIP_COL* col /**< LP column */
12132  );
12133 
12134 /**@} */
12135 
12136 
12137 
12138 
12139 /*
12140  * LP row methods
12141  */
12142 
12143 /**@name LP Row Methods */
12144 /**@{ */
12145 
12146 /** creates and captures an LP row from a constraint handler
12147  *
12148  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12149  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12150  *
12151  * @pre this method can be called in one of the following stages of the SCIP solving process:
12152  * - \ref SCIP_STAGE_INITSOLVE
12153  * - \ref SCIP_STAGE_SOLVING
12154  */
12155 extern
12157  SCIP* scip, /**< SCIP data structure */
12158  SCIP_ROW** row, /**< pointer to row */
12159  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
12160  const char* name, /**< name of row */
12161  int len, /**< number of nonzeros in the row */
12162  SCIP_COL** cols, /**< array with columns of row entries */
12163  SCIP_Real* vals, /**< array with coefficients of row entries */
12164  SCIP_Real lhs, /**< left hand side of row */
12165  SCIP_Real rhs, /**< right hand side of row */
12166  SCIP_Bool local, /**< is row only valid locally? */
12167  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12168  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12169  );
12170 
12171 /** creates and captures an LP row from a separator
12172  *
12173  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12174  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12175  *
12176  * @pre this method can be called in one of the following stages of the SCIP solving process:
12177  * - \ref SCIP_STAGE_INITSOLVE
12178  * - \ref SCIP_STAGE_SOLVING
12179  */
12180 extern
12182  SCIP* scip, /**< SCIP data structure */
12183  SCIP_ROW** row, /**< pointer to row */
12184  SCIP_SEPA* sepa, /**< separator that creates the row */
12185  const char* name, /**< name of row */
12186  int len, /**< number of nonzeros in the row */
12187  SCIP_COL** cols, /**< array with columns of row entries */
12188  SCIP_Real* vals, /**< array with coefficients of row entries */
12189  SCIP_Real lhs, /**< left hand side of row */
12190  SCIP_Real rhs, /**< right hand side of row */
12191  SCIP_Bool local, /**< is row only valid locally? */
12192  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12193  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12194  );
12195 
12196 /** creates and captures an LP row from an unspecified source
12197  *
12198  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12199  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12200  *
12201  * @pre this method can be called in one of the following stages of the SCIP solving process:
12202  * - \ref SCIP_STAGE_INITSOLVE
12203  * - \ref SCIP_STAGE_SOLVING
12204  */
12205 extern
12207  SCIP* scip, /**< SCIP data structure */
12208  SCIP_ROW** row, /**< pointer to row */
12209  const char* name, /**< name of row */
12210  int len, /**< number of nonzeros in the row */
12211  SCIP_COL** cols, /**< array with columns of row entries */
12212  SCIP_Real* vals, /**< array with coefficients of row entries */
12213  SCIP_Real lhs, /**< left hand side of row */
12214  SCIP_Real rhs, /**< right hand side of row */
12215  SCIP_Bool local, /**< is row only valid locally? */
12216  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12217  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12218  );
12219 
12220 /** creates and captures an LP row
12221  *
12222  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12223  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12224  *
12225  * @pre this method can be called in one of the following stages of the SCIP solving process:
12226  * - \ref SCIP_STAGE_INITSOLVE
12227  * - \ref SCIP_STAGE_SOLVING
12228  *
12229  * @deprecated Please use SCIPcreateRowCons() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order
12230  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().
12231  */
12232 extern
12234  SCIP* scip, /**< SCIP data structure */
12235  SCIP_ROW** row, /**< pointer to row */
12236  const char* name, /**< name of row */
12237  int len, /**< number of nonzeros in the row */
12238  SCIP_COL** cols, /**< array with columns of row entries */
12239  SCIP_Real* vals, /**< array with coefficients of row entries */
12240  SCIP_Real lhs, /**< left hand side of row */
12241  SCIP_Real rhs, /**< right hand side of row */
12242  SCIP_Bool local, /**< is row only valid locally? */
12243  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12244  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12245  );
12246 
12247 /** creates and captures an LP row without any coefficients from a constraint handler
12248  *
12249  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12250  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12251  *
12252  * @pre this method can be called in one of the following stages of the SCIP solving process:
12253  * - \ref SCIP_STAGE_INITSOLVE
12254  * - \ref SCIP_STAGE_SOLVING
12255  */
12256 extern
12258  SCIP* scip, /**< SCIP data structure */
12259  SCIP_ROW** row, /**< pointer to row */
12260  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
12261  const char* name, /**< name of row */
12262  SCIP_Real lhs, /**< left hand side of row */
12263  SCIP_Real rhs, /**< right hand side of row */
12264  SCIP_Bool local, /**< is row only valid locally? */
12265  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12266  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12267  );
12268 
12269 /** creates and captures an LP row without any coefficients from a separator
12270  *
12271  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12272  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12273  *
12274  * @pre this method can be called in one of the following stages of the SCIP solving process:
12275  * - \ref SCIP_STAGE_INITSOLVE
12276  * - \ref SCIP_STAGE_SOLVING
12277  */
12278 extern
12280  SCIP* scip, /**< SCIP data structure */
12281  SCIP_ROW** row, /**< pointer to row */
12282  SCIP_SEPA* sepa, /**< separator that creates the row */
12283  const char* name, /**< name of row */
12284  SCIP_Real lhs, /**< left hand side of row */
12285  SCIP_Real rhs, /**< right hand side of row */
12286  SCIP_Bool local, /**< is row only valid locally? */
12287  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12288  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12289  );
12290 
12291 /** creates and captures an LP row without any coefficients from an unspecified source
12292  *
12293  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12294  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12295  *
12296  * @pre this method can be called in one of the following stages of the SCIP solving process:
12297  * - \ref SCIP_STAGE_INITSOLVE
12298  * - \ref SCIP_STAGE_SOLVING
12299  */
12300 extern
12302  SCIP* scip, /**< SCIP data structure */
12303  SCIP_ROW** row, /**< pointer to row */
12304  const char* name, /**< name of row */
12305  SCIP_Real lhs, /**< left hand side of row */
12306  SCIP_Real rhs, /**< right hand side of row */
12307  SCIP_Bool local, /**< is row only valid locally? */
12308  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12309  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12310  );
12311 
12312 /** creates and captures an LP row without any coefficients
12313  *
12314  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12315  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12316  *
12317  * @pre this method can be called in one of the following stages of the SCIP solving process:
12318  * - \ref SCIP_STAGE_INITSOLVE
12319  * - \ref SCIP_STAGE_SOLVING
12320  *
12321  * @deprecated Please use SCIPcreateEmptyRowCons() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order
12322  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().
12323  */
12324 extern
12326  SCIP* scip, /**< SCIP data structure */
12327  SCIP_ROW** row, /**< pointer to row */
12328  const char* name, /**< name of row */
12329  SCIP_Real lhs, /**< left hand side of row */
12330  SCIP_Real rhs, /**< right hand side of row */
12331  SCIP_Bool local, /**< is row only valid locally? */
12332  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
12333  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
12334  );
12335 
12336 /** increases usage counter of LP row
12337  *
12338  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12339  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12340  *
12341  * @pre this method can be called in one of the following stages of the SCIP solving process:
12342  * - \ref SCIP_STAGE_INITSOLVE
12343  * - \ref SCIP_STAGE_SOLVING
12344  */
12345 extern
12347  SCIP* scip, /**< SCIP data structure */
12348  SCIP_ROW* row /**< row to capture */
12349  );
12350 
12351 /** decreases usage counter of LP row, and frees memory if necessary
12352  *
12353  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12354  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12355  *
12356  * @pre this method can be called in one of the following stages of the SCIP solving process:
12357  * - \ref SCIP_STAGE_INITSOLVE
12358  * - \ref SCIP_STAGE_SOLVING
12359  * - \ref SCIP_STAGE_EXITSOLVE
12360  */
12361 extern
12363  SCIP* scip, /**< SCIP data structure */
12364  SCIP_ROW** row /**< pointer to LP row */
12365  );
12366 
12367 /** changes left hand side of LP row
12368  *
12369  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12370  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12371  *
12372  * @pre this method can be called in one of the following stages of the SCIP solving process:
12373  * - \ref SCIP_STAGE_INITSOLVE
12374  * - \ref SCIP_STAGE_SOLVING
12375  */
12376 extern
12378  SCIP* scip, /**< SCIP data structure */
12379  SCIP_ROW* row, /**< LP row */
12380  SCIP_Real lhs /**< new left hand side */
12381  );
12382 
12383 /** changes right hand side of LP row
12384  *
12385  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12386  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12387  *
12388  * @pre this method can be called in one of the following stages of the SCIP solving process:
12389  * - \ref SCIP_STAGE_INITSOLVE
12390  * - \ref SCIP_STAGE_SOLVING
12391  */
12392 extern
12394  SCIP* scip, /**< SCIP data structure */
12395  SCIP_ROW* row, /**< LP row */
12396  SCIP_Real rhs /**< new right hand side */
12397  );
12398 
12399 /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
12400  * after all additions were applied, SCIPflushRowExtensions() must be called;
12401  * while the caching of row extensions is activated, information methods of the row give invalid results;
12402  * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase
12403  * the performance
12404  *
12405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12407  *
12408  * @pre this method can be called in one of the following stages of the SCIP solving process:
12409  * - \ref SCIP_STAGE_INITSOLVE
12410  * - \ref SCIP_STAGE_SOLVING
12411  */
12412 extern
12414  SCIP* scip, /**< SCIP data structure */
12415  SCIP_ROW* row /**< LP row */
12416  );
12417 
12418 /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with
12419  * equal columns into a single coefficient
12420  *
12421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12423  *
12424  * @pre this method can be called in one of the following stages of the SCIP solving process:
12425  * - \ref SCIP_STAGE_INITSOLVE
12426  * - \ref SCIP_STAGE_SOLVING
12427  */
12428 extern
12430  SCIP* scip, /**< SCIP data structure */
12431  SCIP_ROW* row /**< LP row */
12432  );
12433 
12434 /** resolves variable to columns and adds them with the coefficient to the row
12435  *
12436  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12437  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12438  *
12439  * @pre this method can be called in one of the following stages of the SCIP solving process:
12440  * - \ref SCIP_STAGE_INITSOLVE
12441  * - \ref SCIP_STAGE_SOLVING
12442  *
12443  * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables,
12444  * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP.
12445  * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution
12446  * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but
12447  * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the
12448  * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was
12449  * violated, the linear relaxation might not be violated anymore.)
12450  */
12451 extern
12453  SCIP* scip, /**< SCIP data structure */
12454  SCIP_ROW* row, /**< LP row */
12455  SCIP_VAR* var, /**< problem variable */
12456  SCIP_Real val /**< value of coefficient */
12457  );
12458 
12459 /** resolves variables to columns and adds them with the coefficients to the row;
12460  * this method caches the row extensions and flushes them afterwards to gain better performance
12461  *
12462  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12463  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12464  *
12465  * @pre this method can be called in one of the following stages of the SCIP solving process:
12466  * - \ref SCIP_STAGE_INITSOLVE
12467  * - \ref SCIP_STAGE_SOLVING
12468  */
12469 extern
12471  SCIP* scip, /**< SCIP data structure */
12472  SCIP_ROW* row, /**< LP row */
12473  int nvars, /**< number of variables to add to the row */
12474  SCIP_VAR** vars, /**< problem variables to add */
12475  SCIP_Real* vals /**< values of coefficients */
12476  );
12477 
12478 /** resolves variables to columns and adds them with the same single coefficient to the row;
12479  * this method caches the row extensions and flushes them afterwards to gain better performance
12480  *
12481  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12482  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12483  *
12484  * @pre this method can be called in one of the following stages of the SCIP solving process:
12485  * - \ref SCIP_STAGE_INITSOLVE
12486  * - \ref SCIP_STAGE_SOLVING
12487  */
12488 extern
12490  SCIP* scip, /**< SCIP data structure */
12491  SCIP_ROW* row, /**< LP row */
12492  int nvars, /**< number of variables to add to the row */
12493  SCIP_VAR** vars, /**< problem variables to add */
12494  SCIP_Real val /**< unique value of all coefficients */
12495  );
12496 
12497 /** tries to find a value, such that all row coefficients, if scaled with this value become integral
12498  *
12499  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12500  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12501  *
12502  * @pre this method can be called in one of the following stages of the SCIP solving process:
12503  * - \ref SCIP_STAGE_INITSOLVE
12504  * - \ref SCIP_STAGE_SOLVING
12505  */
12506 extern
12508  SCIP* scip, /**< SCIP data structure */
12509  SCIP_ROW* row, /**< LP row */
12510  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
12511  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
12512  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
12513  SCIP_Real maxscale, /**< maximal allowed scalar */
12514  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
12515  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
12516  SCIP_Bool* success /**< stores whether returned value is valid */
12517  );
12518 
12519 /** tries to scale row, s.t. all coefficients (of integer variables) become integral
12520  *
12521  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12522  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12523  *
12524  * @pre this method can be called in one of the following stages of the SCIP solving process:
12525  * - \ref SCIP_STAGE_INITSOLVE
12526  * - \ref SCIP_STAGE_SOLVING
12527  */
12528 extern
12530  SCIP* scip, /**< SCIP data structure */
12531  SCIP_ROW* row, /**< LP row */
12532  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
12533  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
12534  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
12535  SCIP_Real maxscale, /**< maximal value to scale row with */
12536  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
12537  SCIP_Bool* success /**< stores whether row could be made rational */
12538  );
12539 
12540 /** marks a row to be not removable from the LP in the current node
12541  *
12542  * @pre this method can be called in the following stage of the SCIP solving process:
12543  * - \ref SCIP_STAGE_SOLVING
12544  */
12545 extern
12547  SCIP* scip, /**< SCIP data structure */
12548  SCIP_ROW* row /**< LP row */
12549  );
12550 
12551 /** returns minimal absolute value of row vector's non-zero coefficients
12552  *
12553  * @return minimal absolute value of row vector's non-zero coefficients
12554  *
12555  * @pre this method can be called in one of the following stages of the SCIP solving process:
12556  * - \ref SCIP_STAGE_INITSOLVE
12557  * - \ref SCIP_STAGE_SOLVING
12558  */
12559 extern
12561  SCIP* scip, /**< SCIP data structure */
12562  SCIP_ROW* row /**< LP row */
12563  );
12564 
12565 /** returns maximal absolute value of row vector's non-zero coefficients
12566  *
12567  * @return maximal absolute value of row vector's non-zero coefficients
12568  *
12569  * @pre this method can be called in one of the following stages of the SCIP solving process:
12570  * - \ref SCIP_STAGE_INITSOLVE
12571  * - \ref SCIP_STAGE_SOLVING
12572  */
12573 extern
12575  SCIP* scip, /**< SCIP data structure */
12576  SCIP_ROW* row /**< LP row */
12577  );
12578 
12579 /** returns the minimal activity of a row w.r.t. the column's bounds
12580  *
12581  * @return the minimal activity of a row w.r.t. the column's bounds
12582  *
12583  * @pre this method can be called in one of the following stages of the SCIP solving process:
12584  * - \ref SCIP_STAGE_SOLVING
12585  */
12586 extern
12588  SCIP* scip, /**< SCIP data structure */
12589  SCIP_ROW* row /**< LP row */
12590  );
12591 
12592 /** returns the maximal activity of a row w.r.t. the column's bounds
12593  *
12594  * @return the maximal activity of a row w.r.t. the column's bounds
12595  *
12596  * @pre this method can be called in one of the following stages of the SCIP solving process:
12597  * - \ref SCIP_STAGE_SOLVING
12598  */
12599 extern
12601  SCIP* scip, /**< SCIP data structure */
12602  SCIP_ROW* row /**< LP row */
12603  );
12604 
12605 /** recalculates the activity of a row in the last LP solution
12606  *
12607  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12608  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12609  *
12610  * @pre this method can be called in one of the following stages of the SCIP solving process:
12611  * - \ref SCIP_STAGE_SOLVING
12612  */
12613 extern
12615  SCIP* scip, /**< SCIP data structure */
12616  SCIP_ROW* row /**< LP row */
12617  );
12618 
12619 /** returns the activity of a row in the last LP solution
12620  *
12621  * @return activity of a row in the last LP solution
12622  *
12623  * @pre this method can be called in one of the following stages of the SCIP solving process:
12624  * - \ref SCIP_STAGE_SOLVING
12625  */
12626 extern
12628  SCIP* scip, /**< SCIP data structure */
12629  SCIP_ROW* row /**< LP row */
12630  );
12631 
12632 /** returns the feasibility of a row in the last LP solution
12633  *
12634  * @return the feasibility of a row in the last LP solution: negative value means infeasibility
12635  *
12636  * @pre this method can be called in one of the following stages of the SCIP solving process:
12637  * - \ref SCIP_STAGE_SOLVING
12638  */
12639 extern
12641  SCIP* scip, /**< SCIP data structure */
12642  SCIP_ROW* row /**< LP row */
12643  );
12644 
12645 /** recalculates the activity of a row for the current pseudo solution
12646  *
12647  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12648  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12649  *
12650  * @pre this method can be called in one of the following stages of the SCIP solving process:
12651  * - \ref SCIP_STAGE_SOLVING
12652  */
12653 extern
12655  SCIP* scip, /**< SCIP data structure */
12656  SCIP_ROW* row /**< LP row */
12657  );
12658 
12659 /** returns the activity of a row for the current pseudo solution
12660  *
12661  * @return the activity of a row for the current pseudo solution
12662  *
12663  * @pre this method can be called in one of the following stages of the SCIP solving process:
12664  * - \ref SCIP_STAGE_SOLVING
12665  */
12666 extern
12668  SCIP* scip, /**< SCIP data structure */
12669  SCIP_ROW* row /**< LP row */
12670  );
12671 
12672 /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
12673  *
12674  * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility
12675  *
12676  * @pre this method can be called in one of the following stages of the SCIP solving process:
12677  * - \ref SCIP_STAGE_SOLVING
12678  */
12679 extern
12681  SCIP* scip, /**< SCIP data structure */
12682  SCIP_ROW* row /**< LP row */
12683  );
12684 
12685 /** recalculates the activity of a row in the last LP or pseudo solution
12686  *
12687  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12688  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12689  *
12690  * @pre this method can be called in one of the following stages of the SCIP solving process:
12691  * - \ref SCIP_STAGE_SOLVING
12692  */
12693 extern
12695  SCIP* scip, /**< SCIP data structure */
12696  SCIP_ROW* row /**< LP row */
12697  );
12698 
12699 /** returns the activity of a row in the last LP or pseudo solution
12700  *
12701  * @return the activity of a row in the last LP or pseudo solution
12702  *
12703  * @pre this method can be called in one of the following stages of the SCIP solving process:
12704  * - \ref SCIP_STAGE_SOLVING
12705  */
12706 extern
12708  SCIP* scip, /**< SCIP data structure */
12709  SCIP_ROW* row /**< LP row */
12710  );
12711 
12712 /** returns the feasibility of a row in the last LP or pseudo solution
12713  *
12714  * @return the feasibility of a row in the last LP or pseudo solution
12715  *
12716  * @pre this method can be called in one of the following stages of the SCIP solving process:
12717  * - \ref SCIP_STAGE_SOLVING
12718  */
12719 extern
12721  SCIP* scip, /**< SCIP data structure */
12722  SCIP_ROW* row /**< LP row */
12723  );
12724 
12725 /** returns the activity of a row for the given primal solution
12726  *
12727  * @return the activitiy of a row for the given primal solution
12728  *
12729  * @pre this method can be called in one of the following stages of the SCIP solving process:
12730  * - \ref SCIP_STAGE_SOLVING
12731  */
12732 extern
12734  SCIP* scip, /**< SCIP data structure */
12735  SCIP_ROW* row, /**< LP row */
12736  SCIP_SOL* sol /**< primal CIP solution */
12737  );
12738 
12739 /** returns the feasibility of a row for the given primal solution
12740  *
12741  * @return the feasibility of a row for the given primal solution
12742  *
12743  * @pre this method can be called in one of the following stages of the SCIP solving process:
12744  * - \ref SCIP_STAGE_SOLVING
12745  */
12746 extern
12748  SCIP* scip, /**< SCIP data structure */
12749  SCIP_ROW* row, /**< LP row */
12750  SCIP_SOL* sol /**< primal CIP solution */
12751  );
12752 
12753 /** output row to file stream via the message handler system
12754  *
12755  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12756  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12757  *
12758  * @pre this method can be called in one of the following stages of the SCIP solving process:
12759  * - \ref SCIP_STAGE_INITSOLVE
12760  * - \ref SCIP_STAGE_SOLVING
12761  * - \ref SCIP_STAGE_SOLVED
12762  * - \ref SCIP_STAGE_EXITSOLVE
12763  */
12764 extern
12766  SCIP* scip, /**< SCIP data structure */
12767  SCIP_ROW* row, /**< LP row */
12768  FILE* file /**< output file (or NULL for standard output) */
12769  );
12770 
12771 /**@} */
12772 
12773 
12774 /*
12775  * NLP methods
12776  */
12777 
12778 /**@name NLP Methods */
12779 /**@{ */
12780 
12781 /** returns whether the NLP relaxation has been enabled
12782  *
12783  * If the NLP relaxation is enabled, then SCIP will construct the NLP relaxation when the solving process is about to begin.
12784  * To check whether an NLP is existing, use SCIPisNLPConstructed().
12785  *
12786  * @pre This method can be called if SCIP is in one of the following stages:
12787  * - \ref SCIP_STAGE_INITPRESOLVE
12788  * - \ref SCIP_STAGE_PRESOLVING
12789  * - \ref SCIP_STAGE_EXITPRESOLVE
12790  * - \ref SCIP_STAGE_PRESOLVED
12791  * - \ref SCIP_STAGE_INITSOLVE
12792  * - \ref SCIP_STAGE_SOLVING
12793  *
12794  * @see SCIPenableNLP
12795  */
12796 extern
12798  SCIP* scip /**< SCIP data structure */
12799  );
12800 
12801 /** marks that there are constraints that are representable by nonlinear rows
12802  *
12803  * This method should be called by a constraint handler if it has constraints that have a representation as nonlinear rows.
12804  *
12805  * The function should be called before the branch-and-bound process is initialized, e.g., when presolve is exiting.
12806  *
12807  * @pre This method can be called if SCIP is in one of the following stages:
12808  * - \ref SCIP_STAGE_INITPRESOLVE
12809  * - \ref SCIP_STAGE_PRESOLVING
12810  * - \ref SCIP_STAGE_EXITPRESOLVE
12811  * - \ref SCIP_STAGE_PRESOLVED
12812  * - \ref SCIP_STAGE_INITSOLVE
12813  * - \ref SCIP_STAGE_SOLVING
12814  */
12815 extern
12816 void SCIPenableNLP(
12817  SCIP* scip /**< SCIP data structure */
12818  );
12819 
12820 /** returns, whether an NLP has been constructed
12821  *
12822  * @pre This method can be called if SCIP is in one of the following stages:
12823  * - \ref SCIP_STAGE_INITSOLVE
12824  * - \ref SCIP_STAGE_SOLVING
12825  */
12826 extern
12828  SCIP* scip /**< SCIP data structure */
12829  );
12830 
12831 /** returns whether the NLP has a continuous variable in a nonlinear term
12832  *
12833  * @pre This method can be called if SCIP is in one of the following stages:
12834  * - \ref SCIP_STAGE_INITSOLVE
12835  * - \ref SCIP_STAGE_SOLVING
12836  */
12837 extern
12839  SCIP* scip /**< SCIP data structure */
12840  );
12841 
12842 /** gets current NLP variables along with the current number of NLP variables
12843  *
12844  * @pre This method can be called if SCIP is in one of the following stages:
12845  * - \ref SCIP_STAGE_INITSOLVE
12846  * - \ref SCIP_STAGE_SOLVING
12847  */
12848 extern
12850  SCIP* scip, /**< SCIP data structure */
12851  SCIP_VAR*** vars, /**< pointer to store the array of NLP variables, or NULL */
12852  int* nvars /**< pointer to store the number of NLP variables, or NULL */
12853  );
12854 
12855 /** gets array with variables of the NLP
12856  *
12857  * @pre This method can be called if SCIP is in one of the following stages:
12858  * - \ref SCIP_STAGE_INITSOLVE
12859  * - \ref SCIP_STAGE_SOLVING
12860  */
12861 extern
12863  SCIP* scip /**< SCIP data structure */
12864  );
12865 
12866 /** gets current number of variables in NLP
12867  *
12868  * @pre This method can be called if SCIP is in one of the following stages:
12869  * - \ref SCIP_STAGE_INITSOLVE
12870  * - \ref SCIP_STAGE_SOLVING
12871  */
12872 extern
12873 int SCIPgetNNLPVars(
12874  SCIP* scip /**< SCIP data structure */
12875  );
12876 
12877 /** computes for each variables the number of NLP rows in which the variable appears in a nonlinear var
12878  *
12879  * @pre This method can be called if SCIP is in one of the following stages:
12880  * - \ref SCIP_STAGE_INITSOLVE
12881  * - \ref SCIP_STAGE_SOLVING
12882  */
12883 extern
12885  SCIP* scip, /**< SCIP data structure */
12886  int* nlcount /**< an array of length at least SCIPnlpGetNVars() to store nonlinearity counts of variables */
12887  );
12888 
12889 /** returns dual solution values associated with lower bounds of NLP variables
12890  *
12891  * @pre This method can be called if SCIP is in one of the following stages:
12892  * - \ref SCIP_STAGE_INITSOLVE
12893  * - \ref SCIP_STAGE_SOLVING
12894  */
12895 extern
12897  SCIP* scip /**< SCIP data structure */
12898  );
12899 
12900 /** returns dual solution values associated with upper bounds of NLP variables
12901  *
12902  * @pre This method can be called if SCIP is in one of the following stages:
12903  * - \ref SCIP_STAGE_INITSOLVE
12904  * - \ref SCIP_STAGE_SOLVING
12905  */
12906 extern
12908  SCIP* scip /**< SCIP data structure */
12909  );
12910 
12911 /** gets current NLP nonlinear rows along with the current number of NLP nonlinear rows
12912  *
12913  * @pre This method can be called if SCIP is in one of the following stages:
12914  * - \ref SCIP_STAGE_INITSOLVE
12915  * - \ref SCIP_STAGE_SOLVING
12916  */
12917 extern
12919  SCIP* scip, /**< SCIP data structure */
12920  SCIP_NLROW*** nlrows, /**< pointer to store the array of NLP nonlinear rows, or NULL */
12921  int* nnlrows /**< pointer to store the number of NLP nonlinear rows, or NULL */
12922  );
12923 
12924 /** gets array with nonlinear rows of the NLP
12925  *
12926  * @pre This method can be called if SCIP is in one of the following stages:
12927  * - \ref SCIP_STAGE_INITSOLVE
12928  * - \ref SCIP_STAGE_SOLVING
12929  */
12930 extern
12932  SCIP* scip /**< SCIP data structure */
12933  );
12934 
12935 /** gets current number of nonlinear rows in NLP
12936  *
12937  * @pre This method can be called if SCIP is in one of the following stages:
12938  * - \ref SCIP_STAGE_INITSOLVE
12939  * - \ref SCIP_STAGE_SOLVING
12940  */
12941 extern
12942 int SCIPgetNNLPNlRows(
12943  SCIP* scip /**< SCIP data structure */
12944  );
12945 
12946 /** adds a nonlinear row to the NLP. This row is captured by the NLP.
12947  *
12948  * @pre This method can be called if SCIP is in one of the following stages:
12949  * - \ref SCIP_STAGE_INITSOLVE
12950  * - \ref SCIP_STAGE_SOLVING
12951  */
12952 extern
12954  SCIP* scip, /**< SCIP data structure */
12955  SCIP_NLROW* nlrow /**< nonlinear row to add to NLP */
12956  );
12957 
12958 /** makes sure that the NLP of the current node is flushed
12959  *
12960  * @pre This method can be called if SCIP is in one of the following stages:
12961  * - \ref SCIP_STAGE_INITSOLVE
12962  * - \ref SCIP_STAGE_SOLVING
12963  */
12964 extern
12966  SCIP* scip /**< SCIP data structure */
12967  );
12968 
12969 /** sets or clears initial primal guess for NLP solution (start point for NLP solver)
12970  *
12971  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12972  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12973  *
12974  * @pre This method can be called if SCIP is in one of the following stages:
12975  * - \ref SCIP_STAGE_INITSOLVE
12976  * - \ref SCIP_STAGE_SOLVING
12977  */
12978 extern
12980  SCIP* scip, /**< SCIP data structure */
12981  SCIP_Real* initialguess /**< values of initial guess (corresponding to variables from SCIPgetNLPVarsData), or NULL to use no start point */
12982  );
12983 
12984 /** sets initial primal guess for NLP solution (start point for NLP solver)
12985  *
12986  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12987  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12988  *
12989  * @pre This method can be called if SCIP is in one of the following stages:
12990  * - \ref SCIP_STAGE_INITSOLVE
12991  * - \ref SCIP_STAGE_SOLVING
12992  */
12993 extern
12995  SCIP* scip, /**< SCIP data structure */
12996  SCIP_SOL* sol /**< solution which values should be taken as initial guess, or NULL for LP solution */
12997  );
12998 
12999 /** solves the current NLP
13000  *
13001  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13002  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13003  *
13004  * @pre This method can be called if SCIP is in one of the following stages:
13005  * - \ref SCIP_STAGE_INITSOLVE
13006  * - \ref SCIP_STAGE_SOLVING
13007  */
13008 extern
13010  SCIP* scip /**< SCIP data structure */
13011  );
13012 
13013 /** gets solution status of current NLP
13014  *
13015  * @pre This method can be called if SCIP is in one of the following stages:
13016  * - \ref SCIP_STAGE_INITSOLVE
13017  * - \ref SCIP_STAGE_SOLVING
13018  */
13019 extern
13021  SCIP* scip /**< SCIP data structure */
13022  );
13023 
13024 /** gets termination status of last NLP solve
13025  *
13026  * @pre This method can be called if SCIP is in one of the following stages:
13027  * - \ref SCIP_STAGE_INITSOLVE
13028  * - \ref SCIP_STAGE_SOLVING
13029  */
13030 extern
13032  SCIP* scip /**< SCIP data structure */
13033  );
13034 
13035 /** gives statistics (number of iterations, solving time, ...) of last NLP solve
13036  *
13037  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13038  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13039  *
13040  * @pre This method can be called if SCIP is in one of the following stages:
13041  * - \ref SCIP_STAGE_INITSOLVE
13042  * - \ref SCIP_STAGE_SOLVING
13043  */
13044 extern
13046  SCIP* scip, /**< SCIP data structure */
13047  SCIP_NLPSTATISTICS* statistics /**< pointer to store statistics */
13048  );
13049 
13050 /** gets objective value of current NLP
13051  *
13052  * @pre This method can be called if SCIP is in one of the following stages:
13053  * - \ref SCIP_STAGE_INITSOLVE
13054  * - \ref SCIP_STAGE_SOLVING
13055  */
13056 extern
13058  SCIP* scip /**< SCIP data structure */
13059  );
13060 
13061 /** indicates whether a feasible solution for the current NLP is available
13062  * thus, returns whether the solution status <= feasible
13063  *
13064  * @pre This method can be called if SCIP is in one of the following stages:
13065  * - \ref SCIP_STAGE_INITSOLVE
13066  * - \ref SCIP_STAGE_SOLVING
13067  */
13068 extern
13070  SCIP* scip /**< SCIP data structure */
13071  );
13072 
13073 /** gets fractional variables of last NLP solution along with solution values and fractionalities
13074  *
13075  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13076  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13077  *
13078  * @pre This method can be called if SCIP is in one of the following stages:
13079  * - \ref SCIP_STAGE_INITSOLVE
13080  * - \ref SCIP_STAGE_SOLVING
13081  */
13082 extern
13084  SCIP* scip, /**< SCIP data structure */
13085  SCIP_VAR*** fracvars, /**< pointer to store the array of NLP fractional variables, or NULL */
13086  SCIP_Real** fracvarssol, /**< pointer to store the array of NLP fractional variables solution values, or NULL */
13087  SCIP_Real** fracvarsfrac, /**< pointer to store the array of NLP fractional variables fractionalities, or NULL */
13088  int* nfracvars, /**< pointer to store the number of NLP fractional variables , or NULL */
13089  int* npriofracvars /**< pointer to store the number of NLP fractional variables with maximal branching priority, or NULL */
13090  );
13091 
13092 /** gets integer parameter of NLP
13093  *
13094  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13095  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13096  *
13097  * @pre This method can be called if SCIP is in one of the following stages:
13098  * - \ref SCIP_STAGE_INITSOLVE
13099  * - \ref SCIP_STAGE_SOLVING
13100  */
13101 extern
13103  SCIP* scip, /**< SCIP data structure */
13104  SCIP_NLPPARAM type, /**< parameter number */
13105  int* ival /**< pointer to store the parameter value */
13106  );
13107 
13108 /** sets integer parameter of NLP
13109  *
13110  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13111  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13112  *
13113  * @pre This method can be called if SCIP is in one of the following stages:
13114  * - \ref SCIP_STAGE_INITSOLVE
13115  * - \ref SCIP_STAGE_SOLVING
13116  */
13117 extern
13119  SCIP* scip, /**< SCIP data structure */
13120  SCIP_NLPPARAM type, /**< parameter number */
13121  int ival /**< parameter value */
13122  );
13123 
13124 /** gets floating point parameter of NLP
13125  *
13126  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13127  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13128  *
13129  * @pre This method can be called if SCIP is in one of the following stages:
13130  * - \ref SCIP_STAGE_INITSOLVE
13131  * - \ref SCIP_STAGE_SOLVING
13132  */
13133 extern
13135  SCIP* scip, /**< SCIP data structure */
13136  SCIP_NLPPARAM type, /**< parameter number */
13137  SCIP_Real* dval /**< pointer to store the parameter value */
13138  );
13139 
13140 /** sets floating point parameter of NLP
13141  *
13142  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13143  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13144  *
13145  * @pre This method can be called if SCIP is in one of the following stages:
13146  * - \ref SCIP_STAGE_INITSOLVE
13147  * - \ref SCIP_STAGE_SOLVING
13148  */
13149 extern
13151  SCIP* scip, /**< SCIP data structure */
13152  SCIP_NLPPARAM type, /**< parameter number */
13153  SCIP_Real dval /**< parameter value */
13154  );
13155 
13156 /** gets string parameter of NLP
13157  *
13158  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13159  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13160  *
13161  * @pre This method can be called if SCIP is in one of the following stages:
13162  * - \ref SCIP_STAGE_INITSOLVE
13163  * - \ref SCIP_STAGE_SOLVING
13164  */
13165 extern
13167  SCIP* scip, /**< SCIP data structure */
13168  SCIP_NLPPARAM type, /**< parameter number */
13169  const char** sval /**< pointer to store the parameter value */
13170  );
13171 
13172 /** sets string parameter of NLP
13173  *
13174  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13175  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13176  *
13177  * @pre This method can be called if SCIP is in one of the following stages:
13178  * - \ref SCIP_STAGE_INITSOLVE
13179  * - \ref SCIP_STAGE_SOLVING
13180  */
13181 extern
13183  SCIP* scip, /**< SCIP data structure */
13184  SCIP_NLPPARAM type, /**< parameter number */
13185  const char* sval /**< parameter value */
13186  );
13187 
13188 /** writes current NLP to a file
13189  *
13190  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13191  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13192  *
13193  * @pre This method can be called if SCIP is in one of the following stages:
13194  * - \ref SCIP_STAGE_INITSOLVE
13195  * - \ref SCIP_STAGE_SOLVING
13196  */
13197 extern
13199  SCIP* scip, /**< SCIP data structure */
13200  const char* filename /**< file name */
13201  );
13202 
13203 /** gets the NLP interface and problem used by the SCIP NLP;
13204  * with the NLPI and its problem you can use all of the methods defined in nlpi/nlpi.h;
13205  *
13206  * @warning You have to make sure, that the full internal state of the NLPI does not change or is recovered completely
13207  * after the end of the method that uses the NLPI. In particular, if you manipulate the NLP or its solution
13208  * (e.g. by calling one of the SCIPnlpiAdd...() or the SCIPnlpiSolve() method), you have to check in advance
13209  * whether the NLP is currently solved. If this is the case, you have to make sure, the internal solution
13210  * status is recovered completely at the end of your method. Additionally you have to resolve the NLP with
13211  * SCIPnlpiSolve() in order to reinstall the internal solution status.
13212  *
13213  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
13214  *
13215  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13216  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13217  *
13218  * @pre This method can be called if SCIP is in one of the following stages:
13219  * - \ref SCIP_STAGE_INITSOLVE
13220  * - \ref SCIP_STAGE_SOLVING
13221  */
13222 extern
13224  SCIP* scip, /**< SCIP data structure */
13225  SCIP_NLPI** nlpi, /**< pointer to store the NLP solver interface */
13226  SCIP_NLPIPROBLEM** nlpiproblem /**< pointer to store the NLP solver interface problem */
13227  );
13228 
13229 /**@} */
13230 
13231 
13232 /*
13233  * NLP diving methods
13234  */
13235 
13236 /**@name NLP Diving Methods */
13237 /**@{ */
13238 
13239 /** initiates NLP diving making methods SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), SCIPchgVarsBoundsDiveNLP(), and SCIPsolveDiveNLP() available
13240  *
13241  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13242  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13243  *
13244  * @pre This method can be called if SCIP is in one of the following stages:
13245  * - \ref SCIP_STAGE_INITSOLVE
13246  * - \ref SCIP_STAGE_SOLVING
13247  */
13248 extern
13250  SCIP* scip /**< SCIP data structure */
13251  );
13252 
13253 /** ends NLP diving
13254  *
13255  * Resets changes made by SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), and SCIPchgVarsBoundsDiveNLP().
13256  *
13257  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13258  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13259  *
13260  * @pre This method can be called if SCIP is in one of the following stages:
13261  * - \ref SCIP_STAGE_INITSOLVE
13262  * - \ref SCIP_STAGE_SOLVING
13263  */
13264 extern
13266  SCIP* scip /**< SCIP data structure */
13267  );
13268 
13269 /** changes linear objective coefficient of a variable in diving NLP
13270  *
13271  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13272  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13273  *
13274  * @pre This method can be called if SCIP is in one of the following stages:
13275  * - \ref SCIP_STAGE_INITSOLVE
13276  * - \ref SCIP_STAGE_SOLVING
13277  */
13278 extern
13280  SCIP* scip, /**< SCIP data structure */
13281  SCIP_VAR* var, /**< variable which coefficient to change */
13282  SCIP_Real coef /**< new value for coefficient */
13283  );
13284 
13285 /** changes bounds of a variable in diving NLP
13286  *
13287  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13288  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13289  *
13290  * @pre This method can be called if SCIP is in one of the following stages:
13291  * - \ref SCIP_STAGE_INITSOLVE
13292  * - \ref SCIP_STAGE_SOLVING
13293  */
13294 extern
13296  SCIP* scip, /**< SCIP data structure */
13297  SCIP_VAR* var, /**< variable which bounds to change */
13298  SCIP_Real lb, /**< new lower bound */
13299  SCIP_Real ub /**< new upper bound */
13300  );
13301 
13302 /** changes bounds of a set of variables in diving NLP
13303  *
13304  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13305  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13306  *
13307  * @pre This method can be called if SCIP is in one of the following stages:
13308  * - \ref SCIP_STAGE_INITSOLVE
13309  * - \ref SCIP_STAGE_SOLVING
13310  */
13311 extern
13313  SCIP* scip, /**< SCIP data structure */
13314  int nvars, /**< number of variables which bounds to changes */
13315  SCIP_VAR** vars, /**< variables which bounds to change */
13316  SCIP_Real* lbs, /**< new lower bounds */
13317  SCIP_Real* ubs /**< new upper bounds */
13318  );
13319 
13320 /** solves diving NLP
13321  *
13322  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13323  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13324  *
13325  * @pre This method can be called if SCIP is in one of the following stages:
13326  * - \ref SCIP_STAGE_INITSOLVE
13327  * - \ref SCIP_STAGE_SOLVING
13328  */
13329 extern
13331  SCIP* scip /**< SCIP data structure */
13332  );
13333 
13334 /**@} */
13335 
13336 
13337 /*
13338  * NLP nonlinear row methods
13339  */
13340 
13341 /**@name NLP Nonlinear Row Methods */
13342 /**@{ */
13343 
13344 /** creates and captures an NLP row
13345  *
13346  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13347  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13348  *
13349  * @pre This method can be called if SCIP is in one of the following stages:
13350  * - \ref SCIP_STAGE_PRESOLVED
13351  * - \ref SCIP_STAGE_INITSOLVE
13352  * - \ref SCIP_STAGE_SOLVING
13353  */
13354 extern
13356  SCIP* scip, /**< SCIP data structure */
13357  SCIP_NLROW** nlrow, /**< buffer to store pointer to nonlinear row */
13358  const char* name, /**< name of nonlinear row */
13359  SCIP_Real constant, /**< constant */
13360  int nlinvars, /**< number of linear variables */
13361  SCIP_VAR** linvars, /**< linear variables, or NULL if nlinvars == 0 */
13362  SCIP_Real* lincoefs, /**< linear coefficients, or NULL if nlinvars == 0 */
13363  int nquadvars, /**< number of variables in quadratic term */
13364  SCIP_VAR** quadvars, /**< variables in quadratic terms, or NULL if nquadvars == 0 */
13365  int nquadelems, /**< number of elements in quadratic term */
13366  SCIP_QUADELEM* quadelems, /**< elements (i.e., monomials) in quadratic term, or NULL if nquadelems == 0 */
13367  SCIP_EXPRTREE* expression, /**< nonlinear expression, or NULL */
13368  SCIP_Real lhs, /**< left hand side */
13369  SCIP_Real rhs /**< right hand side */
13370  );
13371 
13372 /** creates and captures an NLP nonlinear row without any coefficients
13373  *
13374  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13375  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13376  *
13377  * @pre This method can be called if SCIP is in one of the following stages:
13378  * - \ref SCIP_STAGE_PRESOLVED
13379  * - \ref SCIP_STAGE_INITSOLVE
13380  * - \ref SCIP_STAGE_SOLVING
13381  */
13382 extern
13384  SCIP* scip, /**< SCIP data structure */
13385  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
13386  const char* name, /**< name of nonlinear row */
13387  SCIP_Real lhs, /**< left hand side */
13388  SCIP_Real rhs /**< right hand side */
13389  );
13390 
13391 /** creates and captures an NLP row from a linear row
13392  *
13393  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13394  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13395  *
13396  * @pre This method can be called if SCIP is in one of the following stages:
13397  * - \ref SCIP_STAGE_PRESOLVED
13398  * - \ref SCIP_STAGE_INITSOLVE
13399  * - \ref SCIP_STAGE_SOLVING
13400  */
13401 extern
13403  SCIP* scip, /**< SCIP data structure */
13404  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
13405  SCIP_ROW* row /**< the linear row to copy */
13406  );
13407 
13408 /** increases usage counter of NLP nonlinear row
13409  *
13410  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13411  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13412  *
13413  * @pre This method can be called if SCIP is in one of the following stages:
13414  * - \ref SCIP_STAGE_PRESOLVED
13415  * - \ref SCIP_STAGE_INITSOLVE
13416  * - \ref SCIP_STAGE_SOLVING
13417  */
13418 extern
13420  SCIP* scip, /**< SCIP data structure */
13421  SCIP_NLROW* nlrow /**< nonlinear row to capture */
13422  );
13423 
13424 /** decreases usage counter of NLP nonlinear row, and frees memory if necessary
13425  *
13426  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13427  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13428  *
13429  * @pre This method can be called if SCIP is in one of the following stages:
13430  * - \ref SCIP_STAGE_PRESOLVED
13431  * - \ref SCIP_STAGE_INITSOLVE
13432  * - \ref SCIP_STAGE_SOLVING
13433  * - \ref SCIP_STAGE_EXITSOLVE
13434  */
13435 extern
13437  SCIP* scip, /**< SCIP data structure */
13438  SCIP_NLROW** nlrow /**< pointer to nonlinear row */
13439  );
13440 
13441 /** changes left hand side of NLP nonlinear row
13442  *
13443  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13444  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13445  *
13446  * @pre This method can be called if SCIP is in one of the following stages:
13447  * - \ref SCIP_STAGE_PRESOLVED
13448  * - \ref SCIP_STAGE_INITSOLVE
13449  * - \ref SCIP_STAGE_SOLVING
13450  */
13451 extern
13453  SCIP* scip, /**< SCIP data structure */
13454  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13455  SCIP_Real lhs /**< new left hand side */
13456  );
13457 
13458 /** changes right hand side of NLP nonlinear row
13459  *
13460  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13461  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13462  *
13463  * @pre This method can be called if SCIP is in one of the following stages:
13464  * - \ref SCIP_STAGE_PRESOLVED
13465  * - \ref SCIP_STAGE_INITSOLVE
13466  * - \ref SCIP_STAGE_SOLVING
13467  */
13468 extern
13470  SCIP* scip, /**< SCIP data structure */
13471  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13472  SCIP_Real rhs /**< new right hand side */
13473  );
13474 
13475 /** changes constant of NLP nonlinear row
13476  *
13477  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13478  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13479  *
13480  * @pre This method can be called if SCIP is in one of the following stages:
13481  * - \ref SCIP_STAGE_PRESOLVED
13482  * - \ref SCIP_STAGE_INITSOLVE
13483  * - \ref SCIP_STAGE_SOLVING
13484  */
13485 extern
13487  SCIP* scip, /**< SCIP data structure */
13488  SCIP_NLROW* nlrow, /**< NLP row */
13489  SCIP_Real constant /**< new value for constant */
13490  );
13491 
13492 /** adds variable with a linear coefficient to the nonlinear row
13493  *
13494  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13495  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13496  *
13497  * @pre This method can be called if SCIP is in one of the following stages:
13498  * - \ref SCIP_STAGE_PRESOLVED
13499  * - \ref SCIP_STAGE_INITSOLVE
13500  * - \ref SCIP_STAGE_SOLVING
13501  */
13502 extern
13504  SCIP* scip, /**< SCIP data structure */
13505  SCIP_NLROW* nlrow, /**< NLP row */
13506  SCIP_VAR* var, /**< problem variable */
13507  SCIP_Real val /**< value of coefficient in linear part of row */
13508  );
13509 
13510 /** adds variables with linear coefficients to the row
13511  *
13512  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13513  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13514  *
13515  * @pre This method can be called if SCIP is in one of the following stages:
13516  * - \ref SCIP_STAGE_PRESOLVED
13517  * - \ref SCIP_STAGE_INITSOLVE
13518  * - \ref SCIP_STAGE_SOLVING
13519  */
13520 extern
13522  SCIP* scip, /**< SCIP data structure */
13523  SCIP_NLROW* nlrow, /**< NLP row */
13524  int nvars, /**< number of variables to add to the row */
13525  SCIP_VAR** vars, /**< problem variables to add */
13526  SCIP_Real* vals /**< values of coefficients in linear part of row */
13527  );
13528 
13529 /** changes linear coefficient of a variables in a row
13530  *
13531  * Setting the coefficient to 0.0 means that it is removed from the row
13532  * the variable does not need to exists before.
13533  *
13534  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13535  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13536  *
13537  * @pre This method can be called if SCIP is in one of the following stages:
13538  * - \ref SCIP_STAGE_PRESOLVED
13539  * - \ref SCIP_STAGE_INITSOLVE
13540  * - \ref SCIP_STAGE_SOLVING
13541  */
13542 extern
13544  SCIP* scip, /**< SCIP data structure */
13545  SCIP_NLROW* nlrow, /**< NLP row */
13546  SCIP_VAR* var, /**< variable */
13547  SCIP_Real coef /**< new value of coefficient */
13548  );
13549 
13550 /** adds quadratic variable to the nonlinear row
13551  *
13552  * After adding a quadratic variable, it can be used to add quadratic elements.
13553  *
13554  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13555  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13556  *
13557  * @pre This method can be called if SCIP is in one of the following stages:
13558  * - \ref SCIP_STAGE_PRESOLVED
13559  * - \ref SCIP_STAGE_INITSOLVE
13560  * - \ref SCIP_STAGE_SOLVING
13561  */
13562 extern
13564  SCIP* scip, /**< SCIP data structure */
13565  SCIP_NLROW* nlrow, /**< NLP row */
13566  SCIP_VAR* var /**< problem variable */
13567  );
13568 
13569 /** adds quadratic variables to the nonlinear row
13570  *
13571  * After adding quadratic variables, they can be used to add quadratic elements.
13572  *
13573  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13574  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13575  *
13576  * @pre This method can be called if SCIP is in one of the following stages:
13577  * - \ref SCIP_STAGE_PRESOLVED
13578  * - \ref SCIP_STAGE_INITSOLVE
13579  * - \ref SCIP_STAGE_SOLVING
13580  */
13581 extern
13583  SCIP* scip, /**< SCIP data structure */
13584  SCIP_NLROW* nlrow, /**< NLP row */
13585  int nvars, /**< number of problem variables */
13586  SCIP_VAR** vars /**< problem variables */
13587  );
13588 
13589 /** add a quadratic element to the nonlinear row
13590  *
13591  * Variable indices of the quadratic element need to be relative to quadratic variables array of row.
13592  *
13593  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13594  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13595  *
13596  * @pre This method can be called if SCIP is in one of the following stages:
13597  * - \ref SCIP_STAGE_PRESOLVED
13598  * - \ref SCIP_STAGE_INITSOLVE
13599  * - \ref SCIP_STAGE_SOLVING
13600  */
13601 extern
13603  SCIP* scip, /**< SCIP data structure */
13604  SCIP_NLROW* nlrow, /**< NLP row */
13605  SCIP_QUADELEM quadelem /**< quadratic element */
13606  );
13607 
13608 /** adds quadratic elements to the nonlinear row
13609  *
13610  * Variable indices of the quadratic elements need to be relative to quadratic variables array of row.
13611  *
13612  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13613  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13614  *
13615  * @pre This method can be called if SCIP is in one of the following stages:
13616  * - \ref SCIP_STAGE_PRESOLVED
13617  * - \ref SCIP_STAGE_INITSOLVE
13618  * - \ref SCIP_STAGE_SOLVING
13619  */
13620 extern
13622  SCIP* scip, /**< SCIP data structure */
13623  SCIP_NLROW* nlrow, /**< NLP row */
13624  int nquadelems, /**< number of quadratic elements */
13625  SCIP_QUADELEM* quadelems /**< quadratic elements */
13626  );
13627 
13628 /** changes coefficient in quadratic part of a row
13629  *
13630  * Setting the coefficient in the quadelement to 0.0 means that it is removed from the row
13631  * the element does not need to exists before.
13632  *
13633  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13634  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13635  *
13636  * @pre This method can be called if SCIP is in one of the following stages:
13637  * - \ref SCIP_STAGE_PRESOLVED
13638  * - \ref SCIP_STAGE_INITSOLVE
13639  * - \ref SCIP_STAGE_SOLVING
13640  */
13641 extern
13643  SCIP* scip, /**< SCIP data structure */
13644  SCIP_NLROW* nlrow, /**< NLP row */
13645  SCIP_QUADELEM quadelement /**< new quadratic element, or update for existing one */
13646  );
13647 
13648 /** sets or deletes expression tree in the nonlinear row
13649  *
13650  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13651  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13652  *
13653  * @pre This method can be called if SCIP is in one of the following stages:
13654  * - \ref SCIP_STAGE_PRESOLVED
13655  * - \ref SCIP_STAGE_INITSOLVE
13656  * - \ref SCIP_STAGE_SOLVING
13657  */
13658 extern
13660  SCIP* scip, /**< SCIP data structure */
13661  SCIP_NLROW* nlrow, /**< NLP row */
13662  SCIP_EXPRTREE* exprtree /**< expression tree, or NULL */
13663  );
13664 
13665 /** sets a parameter of expression tree in the nonlinear row
13666  *
13667  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13668  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13669  *
13670  * @pre This method can be called if SCIP is in one of the following stages:
13671  * - \ref SCIP_STAGE_PRESOLVED
13672  * - \ref SCIP_STAGE_INITSOLVE
13673  * - \ref SCIP_STAGE_SOLVING
13674  */
13675 extern
13677  SCIP* scip, /**< SCIP data structure */
13678  SCIP_NLROW* nlrow, /**< NLP row */
13679  int paramidx, /**< index of parameter in expression tree */
13680  SCIP_Real paramval /**< new value of parameter in expression tree */
13681  );
13682 
13683 /** sets parameters of expression tree in the nonlinear row
13684  *
13685  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13686  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13687  *
13688  * @pre This method can be called if SCIP is in one of the following stages:
13689  * - \ref SCIP_STAGE_PRESOLVED
13690  * - \ref SCIP_STAGE_INITSOLVE
13691  * - \ref SCIP_STAGE_SOLVING
13692  */
13693 extern
13695  SCIP* scip, /**< SCIP data structure */
13696  SCIP_NLROW* nlrow, /**< NLP row */
13697  SCIP_Real* paramvals /**< new values of parameter in expression tree */
13698  );
13699 
13700 /** recalculates the activity of a nonlinear row in the last NLP solution
13701  *
13702  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13703  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13704  *
13705  * @pre This method can be called if SCIP is in one of the following stages:
13706  * - \ref SCIP_STAGE_PRESOLVED
13707  * - \ref SCIP_STAGE_INITSOLVE
13708  * - \ref SCIP_STAGE_SOLVING
13709  */
13710 extern
13712  SCIP* scip, /**< SCIP data structure */
13713  SCIP_NLROW* nlrow /**< NLP nonlinear row */
13714  );
13715 
13716 /** returns the activity of a nonlinear row in the last NLP solution
13717  *
13718  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13719  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13720  *
13721  * @pre This method can be called if SCIP is in one of the following stages:
13722  * - \ref SCIP_STAGE_INITSOLVE
13723  * - \ref SCIP_STAGE_SOLVING
13724  */
13725 extern
13727  SCIP* scip, /**< SCIP data structure */
13728  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13729  SCIP_Real* activity /**< pointer to store activity value */
13730  );
13731 
13732 /** gives the feasibility of a nonlinear row in the last NLP solution: negative value means infeasibility
13733  *
13734  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13735  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13736  *
13737  * @pre This method can be called if SCIP is in one of the following stages:
13738  * - \ref SCIP_STAGE_INITSOLVE
13739  * - \ref SCIP_STAGE_SOLVING
13740  */
13741 extern
13743  SCIP* scip, /**< SCIP data structure */
13744  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13745  SCIP_Real* feasibility /**< pointer to store feasibility value */
13746  );
13747 
13748 /** recalculates the activity of a nonlinear row for the current pseudo solution
13749  *
13750  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13751  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13752  *
13753  * @pre This method can be called if SCIP is in one of the following stages:
13754  * - \ref SCIP_STAGE_INITSOLVE
13755  * - \ref SCIP_STAGE_SOLVING
13756  */
13757 extern
13759  SCIP* scip, /**< SCIP data structure */
13760  SCIP_NLROW* nlrow /**< NLP nonlinear row */
13761  );
13762 
13763 /** gives the activity of a nonlinear row for the current pseudo solution
13764  *
13765  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13766  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13767  *
13768  * @pre This method can be called if SCIP is in one of the following stages:
13769  * - \ref SCIP_STAGE_INITSOLVE
13770  * - \ref SCIP_STAGE_SOLVING
13771  */
13772 extern
13774  SCIP* scip, /**< SCIP data structure */
13775  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13776  SCIP_Real* pseudoactivity /**< pointer to store pseudo activity value */
13777  );
13778 
13779 /** gives the feasibility of a nonlinear row for the current pseudo solution: negative value means infeasibility
13780  *
13781  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13782  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13783  *
13784  * @pre This method can be called if SCIP is in one of the following stages:
13785  * - \ref SCIP_STAGE_INITSOLVE
13786  * - \ref SCIP_STAGE_SOLVING
13787  */
13788 extern
13790  SCIP* scip, /**< SCIP data structure */
13791  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13792  SCIP_Real* pseudofeasibility /**< pointer to store pseudo feasibility value */
13793  );
13794 
13795 /** recalculates the activity of a nonlinear row in the last NLP or pseudo solution
13796  *
13797  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13798  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13799  *
13800  * @pre This method can be called if SCIP is in one of the following stages:
13801  * - \ref SCIP_STAGE_INITSOLVE
13802  * - \ref SCIP_STAGE_SOLVING
13803  */
13804 extern
13806  SCIP* scip, /**< SCIP data structure */
13807  SCIP_NLROW* nlrow /**< NLP nonlinear row */
13808  );
13809 
13810 /** gives the activity of a nonlinear row in the last NLP or pseudo solution
13811  *
13812  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13813  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13814  *
13815  * @pre This method can be called if SCIP is in one of the following stages:
13816  * - \ref SCIP_STAGE_INITSOLVE
13817  * - \ref SCIP_STAGE_SOLVING
13818  */
13819 extern
13821  SCIP* scip, /**< SCIP data structure */
13822  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13823  SCIP_Real* activity /**< pointer to store activity value */
13824  );
13825 
13826 /** gives the feasibility of a nonlinear row in the last NLP or pseudo solution
13827  *
13828  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13829  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13830  *
13831  * @pre This method can be called if SCIP is in one of the following stages:
13832  * - \ref SCIP_STAGE_INITSOLVE
13833  * - \ref SCIP_STAGE_SOLVING
13834  */
13835 extern
13837  SCIP* scip, /**< SCIP data structure */
13838  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13839  SCIP_Real* feasibility /**< pointer to store feasibility value */
13840  );
13841 
13842 /** gives the activity of a nonlinear row for the given primal solution or NLP solution or pseudo solution
13843  *
13844  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13845  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13846  *
13847  * @pre This method can be called if SCIP is in one of the following stages:
13848  * - \ref SCIP_STAGE_INITSOLVE
13849  * - \ref SCIP_STAGE_SOLVING
13850  */
13851 extern
13853  SCIP* scip, /**< SCIP data structure */
13854  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13855  SCIP_SOL* sol, /**< primal CIP solution, or NULL for NLP solution of pseudo solution */
13856  SCIP_Real* activity /**< pointer to store activity value */
13857  );
13858 
13859 /** gives the feasibility of a nonlinear row for the given primal solution
13860  *
13861  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13862  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13863  *
13864  * @pre This method can be called if SCIP is in one of the following stages:
13865  * - \ref SCIP_STAGE_INITSOLVE
13866  * - \ref SCIP_STAGE_SOLVING
13867  */
13868 extern
13870  SCIP* scip, /**< SCIP data structure */
13871  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13872  SCIP_SOL* sol, /**< primal CIP solution */
13873  SCIP_Real* feasibility /**< pointer to store feasibility value */
13874  );
13875 
13876 /** gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds
13877  *
13878  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13879  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13880  *
13881  * @pre This method can be called if SCIP is in one of the following stages:
13882  * - \ref SCIP_STAGE_PRESOLVED
13883  * - \ref SCIP_STAGE_INITSOLVE
13884  * - \ref SCIP_STAGE_SOLVING
13885  */
13886 extern
13888  SCIP* scip, /**< SCIP data structure */
13889  SCIP_NLROW* nlrow, /**< NLP row */
13890  SCIP_Real* minactivity, /**< buffer to store minimal activity, or NULL */
13891  SCIP_Real* maxactivity /**< buffer to store maximal activity, or NULL */
13892  );
13893 
13894 /** output nonlinear row to file stream
13895  *
13896  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13897  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13898  *
13899  * @pre This method can be called if SCIP is in one of the following stages:
13900  * - \ref SCIP_STAGE_PRESOLVED
13901  * - \ref SCIP_STAGE_INITSOLVE
13902  * - \ref SCIP_STAGE_SOLVING
13903  */
13904 extern
13906  SCIP* scip, /**< SCIP data structure */
13907  SCIP_NLROW* nlrow, /**< NLP row */
13908  FILE* file /**< output file (or NULL for standard output) */
13909  );
13910 
13911 /**@} */
13912 
13913 /**@name Expression tree methods */
13914 /**@{ */
13915 
13916 /** replaces array of variables in expression tree by corresponding transformed variables
13917  *
13918  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13919  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13920  *
13921  * @pre This method can be called if @p scip is in one of the following stages:
13922  * - \ref SCIP_STAGE_TRANSFORMING
13923  * - \ref SCIP_STAGE_TRANSFORMED
13924  * - \ref SCIP_STAGE_INITPRESOLVE
13925  * - \ref SCIP_STAGE_PRESOLVING
13926  * - \ref SCIP_STAGE_EXITPRESOLVE
13927  * - \ref SCIP_STAGE_PRESOLVED
13928  * - \ref SCIP_STAGE_INITSOLVE
13929  * - \ref SCIP_STAGE_SOLVING
13930  * - \ref SCIP_STAGE_SOLVED
13931  * - \ref SCIP_STAGE_EXITSOLVE
13932  * - \ref SCIP_STAGE_FREETRANS
13933  *
13934  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13935  */
13936 extern
13938  SCIP* scip, /**< SCIP data structure */
13939  SCIP_EXPRTREE* tree /**< expression tree */
13940  );
13941 
13942 /** evaluates an expression tree for a primal solution or LP solution
13943  *
13944  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13945  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13946  *
13947  * @pre This method can be called if @p scip is in one of the following stages:
13948  * - \ref SCIP_STAGE_PROBLEM
13949  * - \ref SCIP_STAGE_TRANSFORMING
13950  * - \ref SCIP_STAGE_TRANSFORMED
13951  * - \ref SCIP_STAGE_INITPRESOLVE
13952  * - \ref SCIP_STAGE_PRESOLVING
13953  * - \ref SCIP_STAGE_EXITPRESOLVE
13954  * - \ref SCIP_STAGE_PRESOLVED
13955  * - \ref SCIP_STAGE_INITSOLVE
13956  * - \ref SCIP_STAGE_SOLVING
13957  * - \ref SCIP_STAGE_SOLVED
13958  * - \ref SCIP_STAGE_EXITSOLVE
13959  * - \ref SCIP_STAGE_FREETRANS
13960  *
13961  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13962  */
13963 extern
13965  SCIP* scip, /**< SCIP data structure */
13966  SCIP_EXPRTREE* tree, /**< expression tree */
13967  SCIP_SOL* sol, /**< a solution, or NULL for current LP solution */
13968  SCIP_Real* val /**< buffer to store value */
13969  );
13970 
13971 /** evaluates an expression tree w.r.t. current global bounds
13972  *
13973  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13974  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13975  *
13976  * @pre This method can be called if @p scip is in one of the following stages:
13977  * - \ref SCIP_STAGE_PROBLEM
13978  * - \ref SCIP_STAGE_TRANSFORMING
13979  * - \ref SCIP_STAGE_TRANSFORMED
13980  * - \ref SCIP_STAGE_INITPRESOLVE
13981  * - \ref SCIP_STAGE_PRESOLVING
13982  * - \ref SCIP_STAGE_EXITPRESOLVE
13983  * - \ref SCIP_STAGE_PRESOLVED
13984  * - \ref SCIP_STAGE_INITSOLVE
13985  * - \ref SCIP_STAGE_SOLVING
13986  * - \ref SCIP_STAGE_SOLVED
13987  * - \ref SCIP_STAGE_EXITSOLVE
13988  * - \ref SCIP_STAGE_FREETRANS
13989  *
13990  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13991  */
13992 extern
13994  SCIP* scip, /**< SCIP data structure */
13995  SCIP_EXPRTREE* tree, /**< expression tree */
13996  SCIP_Real infinity, /**< value to use for infinity */
13997  SCIP_INTERVAL* val /**< buffer to store result */
13998  );
13999 
14000 /** evaluates an expression tree w.r.t. current local bounds
14001  *
14002  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14003  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14004  *
14005  * @pre This method can be called if @p scip is in one of the following stages:
14006  * - \ref SCIP_STAGE_PROBLEM
14007  * - \ref SCIP_STAGE_TRANSFORMING
14008  * - \ref SCIP_STAGE_TRANSFORMED
14009  * - \ref SCIP_STAGE_INITPRESOLVE
14010  * - \ref SCIP_STAGE_PRESOLVING
14011  * - \ref SCIP_STAGE_EXITPRESOLVE
14012  * - \ref SCIP_STAGE_PRESOLVED
14013  * - \ref SCIP_STAGE_INITSOLVE
14014  * - \ref SCIP_STAGE_SOLVING
14015  * - \ref SCIP_STAGE_SOLVED
14016  * - \ref SCIP_STAGE_EXITSOLVE
14017  * - \ref SCIP_STAGE_FREETRANS
14018  *
14019  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14020  */
14021 extern
14023  SCIP* scip, /**< SCIP data structure */
14024  SCIP_EXPRTREE* tree, /**< expression tree */
14025  SCIP_Real infinity, /**< value to use for infinity */
14026  SCIP_INTERVAL* val /**< buffer to store result */
14027  );
14028 
14029 /**@} */
14030 
14031 
14032 
14033 
14034 /*
14035  * nonlinear methods
14036  */
14037 
14038 /**@name Nonlinear Methods */
14039 /**@{ */
14040 
14041 
14042 /** computes coefficients of linearization of a square term in a reference point */
14043 extern
14045  SCIP* scip, /**< SCIP data structure */
14046  SCIP_Real sqrcoef, /**< coefficient of square term */
14047  SCIP_Real refpoint, /**< point where to linearize */
14048  SCIP_Bool isint, /**< whether corresponding variable is a discrete variable, and thus linearization could be moved */
14049  SCIP_Real* lincoef, /**< buffer to add coefficient of linearization */
14050  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14051  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14052  );
14053 
14054 /** computes coefficients of secant of a square term */
14055 extern
14056 void SCIPaddSquareSecant(
14057  SCIP* scip, /**< SCIP data structure */
14058  SCIP_Real sqrcoef, /**< coefficient of square term */
14059  SCIP_Real lb, /**< lower bound on variable */
14060  SCIP_Real ub, /**< upper bound on variable */
14061  SCIP_Real refpoint, /**< point for which to compute value of linearization */
14062  SCIP_Real* lincoef, /**< buffer to add coefficient of secant */
14063  SCIP_Real* linconstant, /**< buffer to add constant of secant */
14064  SCIP_Bool* success /**< buffer to set to FALSE if secant has failed due to large numbers or unboundedness */
14065  );
14066 
14067 /** computes coefficients of linearization of a bilinear term in a reference point */
14068 extern
14070  SCIP* scip, /**< SCIP data structure */
14071  SCIP_Real bilincoef, /**< coefficient of bilinear term */
14072  SCIP_Real refpointx, /**< point where to linearize first variable */
14073  SCIP_Real refpointy, /**< point where to linearize second variable */
14074  SCIP_Real* lincoefx, /**< buffer to add coefficient of first variable in linearization */
14075  SCIP_Real* lincoefy, /**< buffer to add coefficient of second variable in linearization */
14076  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14077  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14078  );
14079 
14080 /** computes coefficients of McCormick under- or overestimation of a bilinear term */
14081 extern
14083  SCIP* scip, /**< SCIP data structure */
14084  SCIP_Real bilincoef, /**< coefficient of bilinear term */
14085  SCIP_Real lbx, /**< lower bound on first variable */
14086  SCIP_Real ubx, /**< upper bound on first variable */
14087  SCIP_Real refpointx, /**< reference point for first variable */
14088  SCIP_Real lby, /**< lower bound on second variable */
14089  SCIP_Real uby, /**< upper bound on second variable */
14090  SCIP_Real refpointy, /**< reference point for second variable */
14091  SCIP_Bool overestimate, /**< whether to compute an overestimator instead of an underestimator */
14092  SCIP_Real* lincoefx, /**< buffer to add coefficient of first variable in linearization */
14093  SCIP_Real* lincoefy, /**< buffer to add coefficient of second variable in linearization */
14094  SCIP_Real* linconstant, /**< buffer to add constant of linearization */
14095  SCIP_Bool* success /**< buffer to set to FALSE if linearization has failed due to large numbers */
14096  );
14097 
14098 /**@} */
14099 
14100 
14101 
14102 
14103 /*
14104  * cutting plane methods
14105  */
14106 
14107 /**@name Cutting Plane Methods */
14108 /**@{ */
14109 
14110 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
14111  * e = -feasibility/norm
14112  *
14113  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
14114  * e = -feasibility/norm
14115  *
14116  * @pre This method can be called if @p scip is in one of the following stages:
14117  * - \ref SCIP_STAGE_SOLVING
14118  */
14119 extern
14121  SCIP* scip, /**< SCIP data structure */
14122  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
14123  SCIP_ROW* cut /**< separated cut */
14124  );
14125 
14126 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
14127  * than the minimal cut efficacy
14128  *
14129  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
14130  * than the minimal cut efficacy, otherwise FALSE
14131  *
14132  * @pre This method can be called if @p scip is in one of the following stages:
14133  * - \ref SCIP_STAGE_SOLVING
14134  */
14135 extern
14137  SCIP* scip, /**< SCIP data structure */
14138  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
14139  SCIP_ROW* cut /**< separated cut */
14140  );
14141 
14142 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
14143  *
14144  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
14145  */
14146 extern
14148  SCIP* scip, /**< SCIP data structure */
14149  SCIP_Real efficacy /**< efficacy of the cut */
14150  );
14151 
14152 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
14153  *
14154  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
14155  */
14156 extern
14158  SCIP* scip, /**< SCIP data structure */
14159  SCIP_Real* vals, /**< array of values */
14160  int nvals /**< number of values */
14161  );
14162 
14163 /** indicates whether a cut is applicable
14164  *
14165  * If the cut has only one variable and this method returns FALSE, it may
14166  * still be possible that the cut can be added to the LP (as a row instead
14167  * of a boundchange), but it will be a very weak cut. The user is asked
14168  * to avoid such cuts.
14169  *
14170  * @pre This method can be called if @p scip is in one of the following stages:
14171  * - \ref SCIP_STAGE_SOLVING
14172  *
14173  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
14174  */
14175 extern
14177  SCIP* scip, /**< SCIP data structure */
14178  SCIP_ROW* cut /**< separated cut */
14179  );
14180 
14181 /** adds cut to separation storage
14182  *
14183  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14184  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14185  *
14186  * @pre This method can be called if @p scip is in one of the following stages:
14187  * - \ref SCIP_STAGE_SOLVING
14188  */
14189 extern
14191  SCIP* scip, /**< SCIP data structure */
14192  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
14193  SCIP_ROW* cut, /**< separated cut */
14194  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
14195  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
14196  );
14197 
14198 /** if not already existing, adds row to global cut pool
14199  *
14200  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14201  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14202  *
14203  * @pre This method can be called if @p scip is in one of the following stages:
14204  * - \ref SCIP_STAGE_SOLVING
14205  */
14206 extern
14208  SCIP* scip, /**< SCIP data structure */
14209  SCIP_ROW* row /**< cutting plane to add */
14210  );
14211 
14212 /** removes the row from the global cut pool
14213  *
14214  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14215  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14216  *
14217  * @pre This method can be called if @p scip is in one of the following stages:
14218  * - \ref SCIP_STAGE_SOLVING
14219  */
14220 extern
14222  SCIP* scip, /**< SCIP data structure */
14223  SCIP_ROW* row /**< cutting plane to add */
14224  );
14225 
14226 /** gets current cuts in the global cut pool
14227  *
14228  * @return the current cuts in the global cut pool
14229  *
14230  * @pre This method can be called if @p scip is in one of the following stages:
14231  * - \ref SCIP_STAGE_SOLVING
14232  * - \ref SCIP_STAGE_SOLVED
14233  * - \ref SCIP_STAGE_EXITSOLVE
14234  */
14235 extern
14237  SCIP* scip /**< SCIP data structure */
14238  );
14239 
14240 /** gets current number of rows in the global cut pool
14241  *
14242  * @return the current number of rows in the global cut pool
14243  *
14244  * @pre This method can be called if @p scip is in one of the following stages:
14245  * - \ref SCIP_STAGE_SOLVING
14246  * - \ref SCIP_STAGE_SOLVED
14247  * - \ref SCIP_STAGE_EXITSOLVE
14248  */
14249 extern
14250 int SCIPgetNPoolCuts(
14251  SCIP* scip /**< SCIP data structure */
14252  );
14253 
14254 /** gets the global cut pool used by SCIP
14255  *
14256  * @return the global cut pool used by SCIP
14257  *
14258  * @pre This method can be called if @p scip is in one of the following stages:
14259  * - \ref SCIP_STAGE_SOLVING
14260  * - \ref SCIP_STAGE_SOLVED
14261  * - \ref SCIP_STAGE_EXITSOLVE
14262  */
14263 extern
14265  SCIP* scip /**< SCIP data structure */
14266  );
14267 
14268 /** creates a cut pool
14269  *
14270  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14271  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14272  *
14273  * @pre This method can be called if @p scip is in one of the following stages:
14274  * - \ref SCIP_STAGE_TRANSFORMING
14275  * - \ref SCIP_STAGE_TRANSFORMED
14276  * - \ref SCIP_STAGE_INITPRESOLVE
14277  * - \ref SCIP_STAGE_PRESOLVING
14278  * - \ref SCIP_STAGE_EXITPRESOLVE
14279  * - \ref SCIP_STAGE_PRESOLVED
14280  * - \ref SCIP_STAGE_INITSOLVE
14281  * - \ref SCIP_STAGE_SOLVING
14282  */
14283 extern
14285  SCIP* scip, /**< SCIP data structure */
14286  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
14287  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
14288  );
14289 
14290 /** frees a cut pool
14291  *
14292  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14293  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14294  *
14295  * @pre This method can be called if @p scip is in one of the following stages:
14296  * - \ref SCIP_STAGE_TRANSFORMING
14297  * - \ref SCIP_STAGE_TRANSFORMED
14298  * - \ref SCIP_STAGE_INITPRESOLVE
14299  * - \ref SCIP_STAGE_PRESOLVING
14300  * - \ref SCIP_STAGE_EXITPRESOLVE
14301  * - \ref SCIP_STAGE_PRESOLVED
14302  * - \ref SCIP_STAGE_INITSOLVE
14303  * - \ref SCIP_STAGE_SOLVING
14304  * - \ref SCIP_STAGE_SOLVED
14305  * - \ref SCIP_STAGE_EXITSOLVE
14306  * - \ref SCIP_STAGE_FREETRANS
14307  */
14308 extern
14310  SCIP* scip, /**< SCIP data structure */
14311  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
14312  );
14313 
14314 /** if not already existing, adds row to a cut pool and captures it
14315  *
14316  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14317  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14318  *
14319  * @pre This method can be called if @p scip is in one of the following stages:
14320  * - \ref SCIP_STAGE_INITSOLVE
14321  * - \ref SCIP_STAGE_SOLVING
14322  */
14323 extern
14325  SCIP* scip, /**< SCIP data structure */
14326  SCIP_CUTPOOL* cutpool, /**< cut pool */
14327  SCIP_ROW* row /**< cutting plane to add */
14328  );
14329 
14330 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
14331  *
14332  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14333  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14334  *
14335  * @pre This method can be called if @p scip is in one of the following stages:
14336  * - \ref SCIP_STAGE_INITSOLVE
14337  * - \ref SCIP_STAGE_SOLVING
14338  */
14339 extern
14341  SCIP* scip, /**< SCIP data structure */
14342  SCIP_CUTPOOL* cutpool, /**< cut pool */
14343  SCIP_ROW* row /**< cutting plane to add */
14344  );
14345 
14346 /** removes the LP row from a cut pool
14347  *
14348  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14349  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14350  *
14351  * @pre This method can be called if @p scip is in one of the following stages:
14352  * - \ref SCIP_STAGE_INITSOLVE
14353  * - \ref SCIP_STAGE_SOLVING
14354  * - \ref SCIP_STAGE_SOLVED
14355  */
14356 extern
14358  SCIP* scip, /**< SCIP data structure */
14359  SCIP_CUTPOOL* cutpool, /**< cut pool */
14360  SCIP_ROW* row /**< row to remove */
14361  );
14362 
14363 /** separates cuts from a cut pool
14364  *
14365  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14366  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14367  *
14368  * @pre This method can be called if @p scip is in one of the following stages:
14369  * - \ref SCIP_STAGE_SOLVING
14370  */
14371 extern
14373  SCIP* scip, /**< SCIP data structure */
14374  SCIP_CUTPOOL* cutpool, /**< cut pool */
14375  SCIP_RESULT* result /**< pointer to store the result of the separation call */
14376  );
14377 
14378 /** separates cuts w.r.t. given solution from a cut pool
14379  *
14380  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14381  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14382  *
14383  * @pre This method can be called if @p scip is in one of the following stages:
14384  * - \ref SCIP_STAGE_SOLVING
14385  */
14386 extern
14388  SCIP* scip, /**< SCIP data structure */
14389  SCIP_CUTPOOL* cutpool, /**< cut pool */
14390  SCIP_SOL* sol, /**< solution to be separated */
14391  SCIP_RESULT* result /**< pointer to store the result of the separation call */
14392  );
14393 
14394 /** if not already existing, adds row to the delayed global cut pool
14395  *
14396  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14397  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14398  *
14399  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
14400  */
14401 extern
14403  SCIP* scip, /**< SCIP data structure */
14404  SCIP_ROW* row /**< cutting plane to add */
14405  );
14406 
14407 /** removes the row from the delayed global cut pool
14408  *
14409  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14410  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14411  *
14412  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
14413  */
14414 extern
14416  SCIP* scip, /**< SCIP data structure */
14417  SCIP_ROW* row /**< cutting plane to add */
14418  );
14419 
14420 /** gets current cuts in the delayed global cut pool
14421  *
14422  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14423  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14424  *
14425  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
14426  */
14427 extern
14429  SCIP* scip /**< SCIP data structure */
14430  );
14431 
14432 /** gets current number of rows in the delayed global cut pool
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 @p scip is the stages \ref SCIP_STAGE_SOLVING
14438  */
14439 extern
14441  SCIP* scip /**< SCIP data structure */
14442  );
14443 
14444 /** gets the delayed global cut pool used by SCIP
14445  *
14446  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14447  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14448  *
14449  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
14450  */
14451 extern
14453  SCIP* scip /**< SCIP data structure */
14454  );
14455 
14456 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
14457  * separation methods;
14458  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
14459  * SCIPgetNCuts();
14460  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
14461  * separation storage;
14462  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
14463  * afterwards
14464  *
14465  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14466  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14467  *
14468  * @pre This method can be called if @p scip is in one of the following stages:
14469  * - \ref SCIP_STAGE_SOLVING
14470  */
14471 extern
14473  SCIP* scip, /**< SCIP data structure */
14474  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
14475  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
14476  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
14477  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
14478  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
14479  );
14480 
14481 /** gets the array of cuts currently stored in the separation storage
14482  *
14483  * @return the array of cuts currently stored in the separation storage
14484  *
14485  * @pre This method can be called if @p scip is in one of the following stages:
14486  * - \ref SCIP_STAGE_PRESOLVED
14487  * - \ref SCIP_STAGE_SOLVING
14488  * - \ref SCIP_STAGE_SOLVED
14489  */
14490 extern
14492  SCIP* scip /**< SCIP data structure */
14493  );
14494 
14495 /** get current number of cuts in the separation storage
14496  *
14497  * @return the current number of cuts in the separation storage
14498  *
14499  * @pre This method can be called if @p scip is in one of the following stages:
14500  * - \ref SCIP_STAGE_PRESOLVED
14501  * - \ref SCIP_STAGE_SOLVING
14502  * - \ref SCIP_STAGE_SOLVED
14503  */
14504 extern
14505 int SCIPgetNCuts(
14506  SCIP* scip /**< SCIP data structure */
14507  );
14508 
14509 /** clears the separation storage
14510  *
14511  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14512  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14513  *
14514  * @pre This method can be called if @p scip is in one of the following stages:
14515  * - \ref SCIP_STAGE_SOLVING
14516  */
14517 extern
14519  SCIP* scip /**< SCIP data structure */
14520  );
14521 
14522 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
14523  *
14524  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14525  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14526  *
14527  * @pre This method can be called if @p scip is in one of the following stages:
14528  * - \ref SCIP_STAGE_SOLVING
14529  */
14530 extern
14532  SCIP* scip /**< SCIP data structure */
14533  );
14534 
14535 /** returns current factor on cut infeasibility to limit feasibility tolerance for relaxation solver
14536  *
14537  * Gives value of separating/feastolfac parameter.
14538  *
14539  * @return factor on cut infeasibility to limit feasibility tolerance for relaxation solver
14540  *
14541  * @pre This method can be called if @p scip is in one of the following stages:
14542  * - \ref SCIP_STAGE_SOLVING
14543  */
14544 extern
14546  SCIP* scip /**< SCIP data structure */
14547  );
14548 
14549 /**@} */
14550 
14551 
14552 
14553 
14554 /*
14555  * LP diving methods
14556  */
14557 
14558 /**@name LP Diving Methods */
14559 /**@{ */
14560 
14561 /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
14562  *
14563  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14564  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14565  *
14566  * @pre This method can be called if @p scip is in one of the following stages:
14567  * - \ref SCIP_STAGE_SOLVING
14568  *
14569  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14570  *
14571  * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware
14572  * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from
14573  * numerical troubles during the last LP solve; because of this, most users will want to call this method only if
14574  * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL
14575  */
14576 extern
14578  SCIP* scip /**< SCIP data structure */
14579  );
14580 
14581 /** quits LP diving and resets bounds and objective values of columns to the current node's values
14582  *
14583  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14584  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14585  *
14586  * @pre This method can be called if @p scip is in one of the following stages:
14587  * - \ref SCIP_STAGE_SOLVING
14588  *
14589  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14590  */
14591 extern
14593  SCIP* scip /**< SCIP data structure */
14594  );
14595 
14596 /** changes cutoffbound in current dive
14597  *
14598  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14599  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14600  *
14601  * @pre This method can be called if @p scip is in one of the following stages:
14602  * - \ref SCIP_STAGE_SOLVING
14603  *
14604  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14605  */
14606 extern
14608  SCIP* scip, /**< SCIP data structure */
14609  SCIP_Real newcutoffbound /**< new cutoffbound */
14610  );
14611 
14612 /** changes variable's objective value in current dive
14613  *
14614  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14615  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14616  *
14617  * @pre This method can be called if @p scip is in one of the following stages:
14618  * - \ref SCIP_STAGE_SOLVING
14619  *
14620  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14621  */
14622 extern
14624  SCIP* scip, /**< SCIP data structure */
14625  SCIP_VAR* var, /**< variable to change the objective value for */
14626  SCIP_Real newobj /**< new objective value */
14627  );
14628 
14629 /** changes variable's lower bound in current dive
14630  *
14631  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14632  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14633  *
14634  * @pre This method can be called if @p scip is in one of the following stages:
14635  * - \ref SCIP_STAGE_SOLVING
14636  *
14637  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14638  */
14639 extern
14641  SCIP* scip, /**< SCIP data structure */
14642  SCIP_VAR* var, /**< variable to change the bound for */
14643  SCIP_Real newbound /**< new value for bound */
14644  );
14645 
14646 /** changes variable's upper bound in current dive
14647  *
14648  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14649  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14650  *
14651  * @pre This method can be called if @p scip is in one of the following stages:
14652  * - \ref SCIP_STAGE_SOLVING
14653  *
14654  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14655  */
14656 extern
14658  SCIP* scip, /**< SCIP data structure */
14659  SCIP_VAR* var, /**< variable to change the bound for */
14660  SCIP_Real newbound /**< new value for bound */
14661  );
14662 
14663 /** adds a row to the LP in current dive
14664  *
14665  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14666  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14667  *
14668  * @pre This method can be called if @p scip is in one of the following stages:
14669  * - \ref SCIP_STAGE_SOLVING
14670  *
14671  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14672  */
14673 extern
14675  SCIP* scip, /**< SCIP data structure */
14676  SCIP_ROW* row /**< row to be added */
14677  );
14678 
14679 /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
14680  *
14681  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14682  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14683  *
14684  * @pre This method can be called if @p scip is in one of the following stages:
14685  * - \ref SCIP_STAGE_SOLVING
14686  *
14687  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14688  */
14689 extern
14691  SCIP* scip, /**< SCIP data structure */
14692  SCIP_ROW* row, /**< row to change the lhs for */
14693  SCIP_Real newlhs /**< new value for lhs */
14694  );
14695 
14696 /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
14697  *
14698  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14699  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14700  *
14701  * @pre This method can be called if @p scip is in one of the following stages:
14702  * - \ref SCIP_STAGE_SOLVING
14703  *
14704  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14705  */
14706 extern
14708  SCIP* scip, /**< SCIP data structure */
14709  SCIP_ROW* row, /**< row to change the lhs for */
14710  SCIP_Real newrhs /**< new value for rhs */
14711  );
14712 
14713 /** gets variable's objective value in current dive
14714  *
14715  * @return the variable's objective value in current dive.
14716  *
14717  * @pre This method can be called if @p scip is in one of the following stages:
14718  * - \ref SCIP_STAGE_SOLVING
14719  *
14720  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14721  */
14722 extern
14724  SCIP* scip, /**< SCIP data structure */
14725  SCIP_VAR* var /**< variable to get the bound for */
14726  );
14727 
14728 /** gets variable's lower bound in current dive
14729  *
14730  * @return the variable's lower bound in current dive.
14731  *
14732  * @pre This method can be called if @p scip is in one of the following stages:
14733  * - \ref SCIP_STAGE_SOLVING
14734  *
14735  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14736  */
14737 extern
14739  SCIP* scip, /**< SCIP data structure */
14740  SCIP_VAR* var /**< variable to get the bound for */
14741  );
14742 
14743 /** gets variable's upper bound in current dive
14744  *
14745  * @return the variable's upper bound in current dive.
14746  *
14747  * @pre This method can be called if @p scip is in one of the following stages:
14748  * - \ref SCIP_STAGE_SOLVING
14749  *
14750  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14751  */
14752 extern
14754  SCIP* scip, /**< SCIP data structure */
14755  SCIP_VAR* var /**< variable to get the bound for */
14756  );
14757 /** solves the LP of the current dive; no separation or pricing is applied
14758  *
14759  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14760  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14761  *
14762  * @pre This method can be called if @p scip is in one of the following stages:
14763  * - \ref SCIP_STAGE_SOLVING
14764  *
14765  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14766  *
14767  * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL,
14768  * compare the explanation of SCIPstartDive()
14769  */
14770 extern
14772  SCIP* scip, /**< SCIP data structure */
14773  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
14774  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
14775  SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective
14776  * limit was reached (or NULL, if not needed) */
14777  );
14778 
14779 /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving
14780  * or probing mode
14781  *
14782  * @return the number of the node in the current branch and bound run, where the last LP was solved in diving
14783  * or probing mode.
14784  *
14785  * @pre This method can be called if @p scip is in one of the following stages:
14786  * - \ref SCIP_STAGE_TRANSFORMING
14787  * - \ref SCIP_STAGE_TRANSFORMED
14788  * - \ref SCIP_STAGE_INITPRESOLVE
14789  * - \ref SCIP_STAGE_PRESOLVING
14790  * - \ref SCIP_STAGE_EXITPRESOLVE
14791  * - \ref SCIP_STAGE_PRESOLVED
14792  * - \ref SCIP_STAGE_INITSOLVE
14793  * - \ref SCIP_STAGE_SOLVING
14794  * - \ref SCIP_STAGE_SOLVED
14795  * - \ref SCIP_STAGE_EXITSOLVE
14796  * - \ref SCIP_STAGE_FREETRANS
14797  *
14798  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14799  */
14800 extern
14802  SCIP* scip /**< SCIP data structure */
14803  );
14804 
14805 /** returns whether we are in diving mode
14806  *
14807  * @return whether we are in diving mode.
14808  *
14809  * @pre This method can be called if @p scip is in one of the following stages:
14810  * - \ref SCIP_STAGE_TRANSFORMING
14811  * - \ref SCIP_STAGE_TRANSFORMED
14812  * - \ref SCIP_STAGE_INITPRESOLVE
14813  * - \ref SCIP_STAGE_PRESOLVING
14814  * - \ref SCIP_STAGE_EXITPRESOLVE
14815  * - \ref SCIP_STAGE_PRESOLVED
14816  * - \ref SCIP_STAGE_INITSOLVE
14817  * - \ref SCIP_STAGE_SOLVING
14818  * - \ref SCIP_STAGE_SOLVED
14819  * - \ref SCIP_STAGE_EXITSOLVE
14820  * - \ref SCIP_STAGE_FREETRANS
14821  *
14822  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14823  */
14824 extern
14826  SCIP* scip /**< SCIP data structure */
14827  );
14828 
14829 /**@} */
14830 
14831 
14832 
14833 
14834 /*
14835  * probing methods
14836  */
14837 
14838 /**@name Probing Methods */
14839 /**@{ */
14840 
14841 /** returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped
14842  * via SCIPendProbing()
14843  *
14844  * @return TRUE, if SCIP is currently in probing mode, otherwise FALSE
14845  *
14846  * @pre This method can be called if @p scip is in one of the following stages:
14847  * - \ref SCIP_STAGE_TRANSFORMED
14848  * - \ref SCIP_STAGE_INITPRESOLVE
14849  * - \ref SCIP_STAGE_PRESOLVING
14850  * - \ref SCIP_STAGE_EXITPRESOLVE
14851  * - \ref SCIP_STAGE_PRESOLVED
14852  * - \ref SCIP_STAGE_INITSOLVE
14853  * - \ref SCIP_STAGE_SOLVING
14854  * - \ref SCIP_STAGE_SOLVED
14855  * - \ref SCIP_STAGE_EXITSOLVE
14856  */
14857 extern
14859  SCIP* scip /**< SCIP data structure */
14860  );
14861 
14862 /** initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),
14863  * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available
14864  *
14865  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14866  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14867  *
14868  * @pre This method can be called if @p scip is in one of the following stages:
14869  * - \ref SCIP_STAGE_PRESOLVING
14870  * - \ref SCIP_STAGE_SOLVING
14871  *
14872  * @note The collection of variable statistics is turned off during probing. If these statistics should be collected
14873  * during probing use the method SCIPenableVarHistory() to turn the collection explicitly on.
14874  */
14875 extern
14877  SCIP* scip /**< SCIP data structure */
14878  );
14879 
14880 /** creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path
14881  * with a call to SCIPbacktrackProbing();
14882  * using a sub node for each set of probing bound changes can improve conflict analysis
14883  *
14884  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14885  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14886  *
14887  * @pre This method can be called if @p scip is in one of the following stages:
14888  * - \ref SCIP_STAGE_PRESOLVING
14889  * - \ref SCIP_STAGE_SOLVING
14890  */
14891 extern
14893  SCIP* scip /**< SCIP data structure */
14894  );
14895 
14896 /** returns the current probing depth
14897  *
14898  * @return the probing depth, i.e. the number of probing sub nodes existing in the probing path
14899  *
14900  * @pre This method can be called if @p scip is in one of the following stages:
14901  * - \ref SCIP_STAGE_PRESOLVING
14902  * - \ref SCIP_STAGE_SOLVING
14903  */
14904 extern
14906  SCIP* scip /**< SCIP data structure */
14907  );
14908 
14909 /** undoes all changes to the problem applied in probing up to the given probing depth;
14910  * the changes of the probing node of the given probing depth are the last ones that remain active;
14911  * changes that were applied before calling SCIPnewProbingNode() cannot be undone
14912  *
14913  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14914  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14915  *
14916  * @pre This method can be called if @p scip is in one of the following stages:
14917  * - \ref SCIP_STAGE_PRESOLVING
14918  * - \ref SCIP_STAGE_SOLVING
14919  */
14920 extern
14922  SCIP* scip, /**< SCIP data structure */
14923  int probingdepth /**< probing depth of the node in the probing path that should be reactivated */
14924  );
14925 
14926 /** quits probing and resets bounds and constraints to the focus node's environment
14927  *
14928  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14929  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14930  *
14931  * @pre This method can be called if @p scip is in one of the following stages:
14932  * - \ref SCIP_STAGE_PRESOLVING
14933  * - \ref SCIP_STAGE_SOLVING
14934  */
14935 extern
14937  SCIP* scip /**< SCIP data structure */
14938  );
14939 
14940 /** injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to
14941  * SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
14942  *
14943  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14944  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14945  *
14946  * @pre This method can be called if @p scip is in one of the following stages:
14947  * - \ref SCIP_STAGE_PRESOLVING
14948  * - \ref SCIP_STAGE_SOLVING
14949  */
14950 extern
14952  SCIP* scip, /**< SCIP data structure */
14953  SCIP_VAR* var, /**< variable to change the bound for */
14954  SCIP_Real newbound /**< new value for bound */
14955  );
14956 
14957 /** injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to
14958  * SCIPchgVarUb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
14959  *
14960  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14961  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14962  *
14963  * @pre This method can be called if @p scip is in one of the following stages:
14964  * - \ref SCIP_STAGE_PRESOLVING
14965  * - \ref SCIP_STAGE_SOLVING
14966  */
14967 extern
14969  SCIP* scip, /**< SCIP data structure */
14970  SCIP_VAR* var, /**< variable to change the bound for */
14971  SCIP_Real newbound /**< new value for bound */
14972  );
14973 
14974 /** gets variable's objective value in current probing
14975  *
14976  * @return the variable's objective value in current probing.
14977  *
14978  * @pre This method can be called if @p scip is in one of the following stages:
14979  * - \ref SCIP_STAGE_SOLVING
14980  *
14981  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14982  */
14983 extern
14985  SCIP* scip, /**< SCIP data structure */
14986  SCIP_VAR* var /**< variable to get the bound for */
14987  );
14988 
14989 /** injects a change of variable's bounds into current probing node to fix the variable to the specified value;
14990  * the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated
14991  * like deductions instead of branching decisions
14992  *
14993  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14994  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14995  *
14996  * @pre This method can be called if @p scip is in one of the following stages:
14997  * - \ref SCIP_STAGE_PRESOLVING
14998  * - \ref SCIP_STAGE_SOLVING
14999  */
15000 extern
15002  SCIP* scip, /**< SCIP data structure */
15003  SCIP_VAR* var, /**< variable to change the bound for */
15004  SCIP_Real fixedval /**< value to fix variable to */
15005  );
15006 
15007 /** changes (column) variable's objective value during probing mode
15008  *
15009  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15010  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15011  *
15012  * @pre This method can be called if @p scip is in one of the following stages:
15013  * - \ref SCIP_STAGE_PRESOLVING
15014  * - \ref SCIP_STAGE_SOLVING
15015  *
15016  * @pre The variable needs to be a column variable.
15017  */
15018 extern
15020  SCIP* scip, /**< SCIP data structure */
15021  SCIP_VAR* var, /**< variable to change the objective for */
15022  SCIP_Real newobj /**< new objective function value */
15023  );
15024 
15025 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
15026  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
15027  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
15028  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
15029  *
15030  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15031  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15032  *
15033  * @pre This method can be called if @p scip is in one of the following stages:
15034  * - \ref SCIP_STAGE_PRESOLVING
15035  * - \ref SCIP_STAGE_SOLVING
15036  */
15037 extern
15039  SCIP* scip, /**< SCIP data structure */
15040  int maxproprounds, /**< maximal number of propagation rounds (-1: no limit, 0: parameter settings) */
15041  SCIP_Bool* cutoff, /**< pointer to store whether the probing node can be cut off */
15042  SCIP_Longint* ndomredsfound /**< pointer to store the number of domain reductions found, or NULL */
15043  );
15044 
15045 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
15046  * only propagations of the binary variables fixed at the current probing node that are triggered by the implication
15047  * graph and the clique table are applied;
15048  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
15049  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
15050  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
15051  *
15052  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15053  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15054  *
15055  * @pre This method can be called if @p scip is in one of the following stages:
15056  * - \ref SCIP_STAGE_PRESOLVING
15057  * - \ref SCIP_STAGE_SOLVING
15058  */
15059 extern
15061  SCIP* scip, /**< SCIP data structure */
15062  SCIP_Bool* cutoff /**< pointer to store whether the probing node can be cut off */
15063  );
15064 
15065 /** solves the LP at the current probing node (cannot be applied at preprocessing stage);
15066  * no separation or pricing is applied
15067  *
15068  * The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()).
15069  *
15070  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15071  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15072  *
15073  * @pre This method can be called if @p scip is in one of the following stages:
15074  * - \ref SCIP_STAGE_SOLVING
15075  */
15076 extern
15078  SCIP* scip, /**< SCIP data structure */
15079  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
15080  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
15081  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
15082  * limit was reached (or NULL, if not needed) */
15083  );
15084 
15085 /** solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing
15086  * until the LP is solved to optimality; no separation is applied
15087  *
15088  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See \ref
15089  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15090  *
15091  * @pre This method can be called if @p scip is in one of the following stages:
15092  * - \ref SCIP_STAGE_SOLVING
15093  */
15094 extern
15096  SCIP* scip, /**< SCIP data structure */
15097  SCIP_Bool pretendroot, /**< should the pricers be called as if we are at the root node? */
15098  SCIP_Bool displayinfo, /**< should info lines be displayed after each pricing round? */
15099  int maxpricerounds, /**< maximal number of pricing rounds (-1: no limit);
15100  * a finite limit means that the LP might not be solved to optimality! */
15101  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
15102  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
15103  * limit was reached (or NULL, if not needed) */
15104 
15105  );
15106 
15107 /** adds a row to the LP in the current probing node
15108  *
15109  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15110  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15111  *
15112  * @pre This method can be called if @p scip is in one of the following stages:
15113  * - \ref SCIP_STAGE_SOLVING
15114  *
15115  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15116  */
15117 extern
15119  SCIP* scip, /**< SCIP data structure */
15120  SCIP_ROW* row /**< row to be added */
15121  );
15122 
15123 /** applies the cuts in the separation storage to the LP and clears the storage afterwards;
15124  * this method can only be applied during probing; the user should resolve the probing LP afterwards
15125  * in order to get a new solution
15126  *
15127  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15128  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15129  *
15130  * @pre This method can be called if @p scip is in one of the following stages:
15131  * - \ref SCIP_STAGE_SOLVING
15132  */
15133 extern
15135  SCIP* scip, /**< SCIP data structure */
15136  SCIP_Bool* cutoff /**< pointer to store whether an empty domain was created */
15137  );
15138 
15139 /** stores the candidate score and preferred rounding direction for a candidate variable */
15140 extern
15142  SCIP* scip, /**< SCIP data structure */
15143  SCIP_DIVESET* diveset, /**< general diving settings */
15144  SCIP_DIVETYPE divetype, /**< represents different methods for a dive set to explore the next children */
15145  SCIP_VAR* divecand, /**< the candidate for which the branching direction is requested */
15146  SCIP_Real divecandsol, /**< LP solution value of the candidate */
15147  SCIP_Real divecandfrac, /**< fractionality of the candidate */
15148  SCIP_Real* candscore, /**< pointer to store the candidate score */
15149  SCIP_Bool* roundup /**< pointer to store whether preferred direction for diving is upwards */
15150  );
15151 
15152 /** update diveset LP statistics, should be called after every LP solved by this diving heuristic */
15153 extern
15155  SCIP* scip, /**< SCIP data structure */
15156  SCIP_DIVESET* diveset, /**< diving settings */
15157  SCIP_Longint niterstoadd /**< additional number of LP iterations to be added */
15158  );
15159 
15160 /** update diveset statistics and global diveset statistics */
15161 extern
15163  SCIP* scip, /**< SCIP data structure */
15164  SCIP_DIVESET* diveset, /**< diveset to be reset */
15165  int nprobingnodes, /**< the number of probing nodes explored this time */
15166  int nbacktracks, /**< the number of backtracks during probing this time */
15167  SCIP_Longint nsolsfound, /**< the number of solutions found */
15168  SCIP_Longint nbestsolsfound, /**< the number of best solutions found */
15169  SCIP_Bool leavewassol /**< was a solution found at the leaf? */
15170  );
15171 
15172 /** enforces a probing/diving solution by suggesting bound changes that maximize the score w.r.t. the current diving settings
15173  *
15174  * the process is guided by the enforcement priorities of the constraint handlers and the scoring mechanism provided by
15175  * the dive set.
15176  * Constraint handlers may suggest diving bound changes in decreasing order of their enforcement priority, based on the
15177  * solution values in the solution @p sol and the current local bounds of the variables. A diving bound change
15178  * is a triple (variable,branching direction,value) and is used inside SCIPperformGenericDivingAlgorithm().
15179  *
15180  * After a successful call, SCIP holds two arrays of suggested dive bound changes, one for the preferred child
15181  * and one for the alternative.
15182  *
15183  * @see SCIPgetDiveBoundChangeData() for retrieving the dive bound change suggestions.
15184  *
15185  * The method stops after the first constraint handler was successful
15186  *
15187  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15188  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15189  *
15190  * @pre This method can be called if @p scip is in one of the following stages:
15191  * - \ref SCIP_STAGE_SOLVING
15192  *
15193  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15194  */
15195 extern
15197  SCIP* scip, /**< SCIP data structure */
15198  SCIP_DIVESET* diveset, /**< diving settings to control scoring */
15199  SCIP_SOL* sol, /**< current solution of diving mode */
15200  SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */
15201  SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */
15202  );
15203 
15204 /** adds a diving bound change to the diving bound change storage of SCIP together with the information if this is a
15205  * bound change for the preferred direction or not
15206  *
15207  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15208  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15209  *
15210  * @pre This method can be called if @p scip is in one of the following stages:
15211  * - \ref SCIP_STAGE_SOLVING
15212  *
15213  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15214  */
15215 extern
15217  SCIP* scip, /**< SCIP data structure */
15218  SCIP_VAR* var, /**< variable to apply the bound change to */
15219  SCIP_BRANCHDIR dir, /**< direction of the bound change */
15220  SCIP_Real value, /**< value to adjust this variable bound to */
15221  SCIP_Bool preferred /**< is this a bound change for the preferred child? */
15222  );
15223 
15224 /** get the dive bound change data for the preferred or the alternative direction
15225  *
15226  * @pre This method can be called if @p scip is in one of the following stages:
15227  * - \ref SCIP_STAGE_SOLVING
15228  *
15229  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15230  */
15231 extern
15233  SCIP* scip, /**< SCIP data structure */
15234  SCIP_VAR*** variables, /**< pointer to store variables for the specified direction */
15235  SCIP_BRANCHDIR** directions, /**< pointer to store the branching directions */
15236  SCIP_Real** values, /**< pointer to store bound change values */
15237  int* ndivebdchgs, /**< pointer to store the number of dive bound changes */
15238  SCIP_Bool preferred /**< should the dive bound changes for the preferred child be output? */
15239  );
15240 
15241 /** clear the dive bound change data structures
15242  *
15243  * @pre This method can be called if @p scip is in one of the following stages:
15244  * - \ref SCIP_STAGE_SOLVING
15245  *
15246  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15247  */
15248 extern
15250  SCIP* scip /**< SCIP data structure */
15251  );
15252 
15253 /**@} */
15254 
15255 /*
15256  * branching methods
15257  */
15258 
15259 /**@name Branching Methods */
15260 /**@{ */
15261 
15262 /** gets branching candidates for LP solution branching (fractional variables) along with solution values,
15263  * fractionalities, and number of branching candidates; The number of branching candidates does NOT
15264  * account for fractional implicit integer variables which should not be used for branching decisions.
15265  *
15266  * Fractional implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1
15267  *
15268  * branching rules should always select the branching candidate among the first npriolpcands of the candidate
15269  * list
15270  *
15271  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15272  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15273  *
15274  * @pre This method can be called if @p scip is in one of the following stages:
15275  * - \ref SCIP_STAGE_SOLVING
15276  *
15277  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15278  */
15279 extern
15281  SCIP* scip, /**< SCIP data structure */
15282  SCIP_VAR*** lpcands, /**< pointer to store the array of LP branching candidates, or NULL */
15283  SCIP_Real** lpcandssol, /**< pointer to store the array of LP candidate solution values, or NULL */
15284  SCIP_Real** lpcandsfrac, /**< pointer to store the array of LP candidate fractionalities, or NULL */
15285  int* nlpcands, /**< pointer to store the number of LP branching candidates, or NULL */
15286  int* npriolpcands, /**< pointer to store the number of candidates with maximal priority, or NULL */
15287  int* nfracimplvars /**< pointer to store the number of fractional implicit integer variables, or NULL */
15288  );
15289 
15290 /** gets number of branching candidates for LP solution branching (number of fractional variables)
15291  *
15292  * @return the number of branching candidates for LP solution branching (number of fractional variables).
15293  *
15294  * @pre This method can be called if @p scip is in one of the following stages:
15295  * - \ref SCIP_STAGE_SOLVING
15296  *
15297  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15298  */
15299 extern
15301  SCIP* scip /**< SCIP data structure */
15302  );
15303 
15304 /** gets number of branching candidates with maximal priority for LP solution branching
15305  *
15306  * @return the number of branching candidates with maximal priority for LP solution branching.
15307  *
15308  * @pre This method can be called if @p scip is in one of the following stages:
15309  * - \ref SCIP_STAGE_SOLVING
15310  *
15311  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15312  */
15313 extern
15315  SCIP* scip /**< SCIP data structure */
15316  );
15317 
15318 /** gets external branching candidates along with solution values, scores, and number of branching candidates;
15319  * these branching candidates can be used by relaxations or nonlinear constraint handlers;
15320  * branching rules should always select the branching candidate among the first nprioexterncands of the candidate
15321  * list
15322  *
15323  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15324  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15325  *
15326  * @pre This method can be called if @p scip is in one of the following stages:
15327  * - \ref SCIP_STAGE_SOLVING
15328  *
15329  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15330  *
15331  * @note Candidate variables with maximal priority are ordered: binaries first, then integers, implicit integers and
15332  * continuous last.
15333  */
15334 extern
15336  SCIP* scip, /**< SCIP data structure */
15337  SCIP_VAR*** externcands, /**< pointer to store the array of extern branching candidates, or NULL */
15338  SCIP_Real** externcandssol, /**< pointer to store the array of extern candidate solution values, or NULL */
15339  SCIP_Real** externcandsscore, /**< pointer to store the array of extern candidate scores, or NULL */
15340  int* nexterncands, /**< pointer to store the number of extern branching candidates, or NULL */
15341  int* nprioexterncands, /**< pointer to store the number of candidates with maximal priority, or NULL */
15342  int* nprioexternbins, /**< pointer to store the number of binary candidates with maximal priority, or NULL */
15343  int* nprioexternints, /**< pointer to store the number of integer candidates with maximal priority, or NULL */
15344  int* nprioexternimpls /**< pointer to store the number of implicit integer candidates with maximal priority,
15345  * or NULL */
15346  );
15347 
15348 /** gets number of external branching candidates
15349  *
15350  * @return the number of external branching candidates.
15351  *
15352  * @pre This method can be called if @p scip is in one of the following stages:
15353  * - \ref SCIP_STAGE_SOLVING
15354  *
15355  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15356  */
15357 extern
15359  SCIP* scip /**< SCIP data structure */
15360  );
15361 
15362 /** gets number of external branching candidates with maximal branch priority
15363  *
15364  * @return the number of external branching candidates with maximal branch priority.
15365  *
15366  * @pre This method can be called if @p scip is in one of the following stages:
15367  * - \ref SCIP_STAGE_SOLVING
15368  *
15369  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15370  */
15371 extern
15373  SCIP* scip /**< SCIP data structure */
15374  );
15375 
15376 /** gets number of binary external branching candidates with maximal branch priority
15377  *
15378  * @return the number of binary external branching candidates with maximal branch priority.
15379  *
15380  * @pre This method can be called if @p scip is in one of the following stages:
15381  * - \ref SCIP_STAGE_SOLVING
15382  *
15383  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15384  */
15385 extern
15387  SCIP* scip /**< SCIP data structure */
15388  );
15389 
15390 /** gets number of integer external branching candidates with maximal branch priority
15391  *
15392  * @return the number of integer external branching candidates with maximal branch priority.
15393  *
15394  * @pre This method can be called if @p scip is in one of the following stages:
15395  * - \ref SCIP_STAGE_SOLVING
15396  *
15397  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15398  */
15399 extern
15401  SCIP* scip /**< SCIP data structure */
15402  );
15403 
15404 /** gets number of implicit integer external branching candidates with maximal branch priority
15405  *
15406  * @return the number of implicit integer external branching candidates with maximal branch priority.
15407  *
15408  * @pre This method can be called if @p scip is in one of the following stages:
15409  * - \ref SCIP_STAGE_SOLVING
15410  *
15411  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15412  */
15413 extern
15415  SCIP* scip /**< SCIP data structure */
15416  );
15417 
15418 /** gets number of continuous external branching candidates with maximal branch priority
15419  *
15420  * @return the number of continuous external branching candidates with maximal branch priority.
15421  *
15422  * @pre This method can be called if @p scip is in one of the following stages:
15423  * - \ref SCIP_STAGE_SOLVING
15424  *
15425  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15426  */
15427 extern
15429  SCIP* scip /**< SCIP data structure */
15430  );
15431 
15432 /** insert variable, its score and its solution value into the external branching candidate storage
15433  * the relative difference of the current lower and upper bounds of a continuous variable must be at least epsilon
15434  *
15435  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15436  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15437  *
15438  * @pre This method can be called if @p scip is in one of the following stages:
15439  * - \ref SCIP_STAGE_SOLVING
15440  *
15441  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15442  */
15443 extern
15445  SCIP* scip, /**< SCIP data structure */
15446  SCIP_VAR* var, /**< variable to insert */
15447  SCIP_Real score, /**< score of external candidate, e.g. infeasibility */
15448  SCIP_Real solval /**< value of the variable in the current solution */
15449  );
15450 
15451 /** removes all external candidates from the storage for external branching
15452  *
15453  * @pre This method can be called if @p scip is in one of the following stages:
15454  * - \ref SCIP_STAGE_SOLVING
15455  *
15456  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15457  */
15458 extern
15460  SCIP* scip /**< SCIP data structure */
15461  );
15462 
15463 /** checks whether the given variable is contained in the candidate storage for external branching
15464  *
15465  * @return whether the given variable is contained in the candidate storage for external branching.
15466  *
15467  * @pre This method can be called if @p scip is in one of the following stages:
15468  * - \ref SCIP_STAGE_SOLVING
15469  *
15470  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15471  */
15472 extern
15474  SCIP* scip, /**< SCIP data structure */
15475  SCIP_VAR* var /**< variable to look for */
15476  );
15477 
15478 /** gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates
15479  *
15480  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15481  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15482  *
15483  * @pre This method can be called if @p scip is in one of the following stages:
15484  * - \ref SCIP_STAGE_PRESOLVING
15485  * - \ref SCIP_STAGE_SOLVING
15486  *
15487  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15488  */
15489 extern
15491  SCIP* scip, /**< SCIP data structure */
15492  SCIP_VAR*** pseudocands, /**< pointer to store the array of pseudo branching candidates, or NULL */
15493  int* npseudocands, /**< pointer to store the number of pseudo branching candidates, or NULL */
15494  int* npriopseudocands /**< pointer to store the number of candidates with maximal priority, or NULL */
15495  );
15496 
15497 /** gets number of branching candidates for pseudo solution branching (non-fixed variables)
15498  *
15499  * @return the number branching candidates for pseudo solution branching (non-fixed variables).
15500  *
15501  * @pre This method can be called if @p scip is in one of the following stages:
15502  * - \ref SCIP_STAGE_PRESOLVING
15503  * - \ref SCIP_STAGE_SOLVING
15504  *
15505  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15506  */
15507 extern
15509  SCIP* scip /**< SCIP data structure */
15510  );
15511 
15512 /** gets number of branching candidates with maximal branch priority for pseudo solution branching
15513  *
15514  * @return the number of branching candidates with maximal branch priority for pseudo solution branching.
15515  *
15516  * @pre This method can be called if @p scip is in one of the following stages:
15517  * - \ref SCIP_STAGE_PRESOLVING
15518  * - \ref SCIP_STAGE_SOLVING
15519  *
15520  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15521  */
15522 extern
15524  SCIP* scip /**< SCIP data structure */
15525  );
15526 
15527 /** gets number of binary branching candidates with maximal branch priority for pseudo solution branching
15528  *
15529  * @return the number of binary branching candidates with maximal branch priority for pseudo solution branching.
15530  *
15531  * @pre This method can be called if @p scip is in one of the following stages:
15532  * - \ref SCIP_STAGE_SOLVING
15533  *
15534  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15535  */
15536 extern
15538  SCIP* scip /**< SCIP data structure */
15539  );
15540 
15541 /** gets number of integer branching candidates with maximal branch priority for pseudo solution branching
15542  *
15543  * @return the number of integer branching candidates with maximal branch priority for pseudo solution branching.
15544  *
15545  * @pre This method can be called if @p scip is in one of the following stages:
15546  * - \ref SCIP_STAGE_SOLVING
15547  *
15548  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15549  */
15550 extern
15552  SCIP* scip /**< SCIP data structure */
15553  );
15554 
15555 /** gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching
15556  *
15557  * @return the number of implicit integer branching candidates with maximal branch priority for pseudo solution branching.
15558  *
15559  * @pre This method can be called if @p scip is in one of the following stages:
15560  * - \ref SCIP_STAGE_SOLVING
15561  *
15562  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15563  */
15564 extern
15566  SCIP* scip /**< SCIP data structure */
15567  );
15568 
15569 /** calculates the branching score out of the gain predictions for a binary branching
15570  *
15571  * @return the branching score out of the gain predictions for a binary branching.
15572  *
15573  * @pre This method can be called if @p scip is in one of the following stages:
15574  * - \ref SCIP_STAGE_SOLVING
15575  *
15576  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15577  */
15578 extern
15580  SCIP* scip, /**< SCIP data structure */
15581  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
15582  SCIP_Real downgain, /**< prediction of objective gain for rounding downwards */
15583  SCIP_Real upgain /**< prediction of objective gain for rounding upwards */
15584  );
15585 
15586 /** calculates the branching score out of the gain predictions for a branching with arbitrary many children
15587  *
15588  * @return the branching score out of the gain predictions for a branching with arbitrary many children.
15589  *
15590  * @pre This method can be called if @p scip is in one of the following stages:
15591  * - \ref SCIP_STAGE_SOLVING
15592  *
15593  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15594  */
15595 extern
15597  SCIP* scip, /**< SCIP data structure */
15598  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
15599  int nchildren, /**< number of children that the branching will create */
15600  SCIP_Real* gains /**< prediction of objective gain for each child */
15601  );
15602 
15603 /** computes a branching point for a continuous or discrete variable
15604  *
15605  * @see SCIPbranchGetBranchingPoint
15606  *
15607  * @return the branching point for a continuous or discrete variable.
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, of which the branching point should be computed */
15618  SCIP_Real suggestion /**< suggestion for branching point, or SCIP_INVALID if no suggestion */
15619  );
15620 
15621 /** calculates the node selection priority for moving the given variable's LP value to the given target value;
15622  * this node selection priority can be given to the SCIPcreateChild() call
15623  *
15624  * @return the node selection priority for moving the given variable's LP value to the given target value.
15625  *
15626  * @pre This method can be called if @p scip is in one of the following stages:
15627  * - \ref SCIP_STAGE_SOLVING
15628  *
15629  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15630  */
15631 extern
15633  SCIP* scip, /**< SCIP data structure */
15634  SCIP_VAR* var, /**< variable on which the branching is applied */
15635  SCIP_BRANCHDIR branchdir, /**< type of branching that was performed: upwards, downwards, or fixed;
15636  * fixed should only be used, when both bounds changed
15637  */
15638  SCIP_Real targetvalue /**< new value of the variable in the child node */
15639  );
15640 
15641 /** calculates an estimate for the objective of the best feasible solution contained in the subtree after applying the given
15642  * branching; this estimate can be given to the SCIPcreateChild() call
15643  *
15644  * @return the estimate for the objective of the best feasible solution contained in the subtree after applying the given
15645  * branching.
15646  *
15647  * @pre This method can be called if @p scip is in one of the following stages:
15648  * - \ref SCIP_STAGE_SOLVING
15649  *
15650  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15651  */
15652 extern
15654  SCIP* scip, /**< SCIP data structure */
15655  SCIP_VAR* var, /**< variable on which the branching is applied */
15656  SCIP_Real targetvalue /**< new value of the variable in the child node */
15657  );
15658 
15659 /** creates a child node of the focus node
15660  *
15661  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15662  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15663  *
15664  * @pre This method can be called if @p scip is in one of the following stages:
15665  * - \ref SCIP_STAGE_SOLVING
15666  *
15667  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15668  */
15669 extern
15671  SCIP* scip, /**< SCIP data structure */
15672  SCIP_NODE** node, /**< pointer to node data structure */
15673  SCIP_Real nodeselprio, /**< node selection priority of new node */
15674  SCIP_Real estimate /**< estimate for (transformed) objective value of best feasible solution in subtree */
15675  );
15676 
15677 /** branches on a non-continuous variable v using the current LP or pseudo solution;
15678  * if solution value x' is fractional, two child nodes will be created
15679  * (x <= floor(x'), x >= ceil(x')),
15680  * if solution value is integral, the x' is equal to lower or upper bound of the branching
15681  * variable and the bounds of v are finite, then two child nodes will be created
15682  * (x <= x'', x >= x''+1 with x'' = floor((lb + ub)/2)),
15683  * otherwise (up to) three child nodes will be created
15684  * (x <= x'-1, x == x', x >= x'+1)
15685  *
15686  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15687  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15688  *
15689  * @pre This method can be called if @p scip is in one of the following stages:
15690  * - \ref SCIP_STAGE_SOLVING
15691  *
15692  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15693  */
15694 extern
15696  SCIP* scip, /**< SCIP data structure */
15697  SCIP_VAR* var, /**< variable to branch on */
15698  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
15699  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
15700  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
15701  );
15702 
15703 /** branches a variable x using a given domain hole; two child nodes (x <= left, x >= right) are created
15704  *
15705  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15706  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15707  *
15708  * @pre This method can be called if @p scip is in one of the following stages:
15709  * - \ref SCIP_STAGE_SOLVING
15710  *
15711  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15712  */
15713 extern
15715  SCIP* scip, /**< SCIP data structure */
15716  SCIP_VAR* var, /**< variable to branch on */
15717  SCIP_Real left, /**< left side of the domain hole */
15718  SCIP_Real right, /**< right side of the domain hole */
15719  SCIP_NODE** downchild, /**< pointer to return the left child (x <= left), or NULL */
15720  SCIP_NODE** upchild /**< pointer to return the right child (x >= right), or NULL */
15721  );
15722 
15723 /** branches on a variable x using a given value x';
15724  * for continuous variables with relative domain width larger epsilon, x' must not be one of the bounds;
15725  * two child nodes (x <= x', x >= x') are created;
15726  * for integer variables, if solution value x' is fractional, two child nodes are created
15727  * (x <= floor(x'), x >= ceil(x')),
15728  * if x' is integral, three child nodes are created
15729  * (x <= x'-1, x == x', x >= x'+1)
15730  *
15731  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15732  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15733  *
15734  * @pre This method can be called if @p scip is in one of the following stages:
15735  * - \ref SCIP_STAGE_SOLVING
15736  *
15737  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15738  */
15739 extern
15741  SCIP* scip, /**< SCIP data structure */
15742  SCIP_VAR* var, /**< variable to branch on */
15743  SCIP_Real val, /**< value to branch on */
15744  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
15745  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
15746  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
15747  );
15748 
15749 /** n-ary branching on a variable x using a given value
15750  *
15751  * Branches on variable x such that up to n/2 children are created on each side of the usual branching value.
15752  * The branching value is selected as in SCIPbranchVarVal().
15753  * The parameters minwidth and widthfactor determine the domain width of the branching variable in the child nodes.
15754  * If n is odd, one child with domain width 'width' and having the branching value in the middle is created.
15755  * Otherwise, two children with domain width 'width' and being left and right of the branching value are created.
15756  * Next further nodes to the left and right are created, where width is multiplied by widthfactor with increasing distance
15757  * from the first nodes.
15758  * The initial width is calculated such that n/2 nodes are created to the left and to the right of the branching value.
15759  * If this value is below minwidth, the initial width is set to minwidth, which may result in creating less than n nodes.
15760  *
15761  * Giving a large value for widthfactor results in creating children with small domain when close to the branching value
15762  * and large domain when closer to the current variable bounds. That is, setting widthfactor to a very large value and n to 3
15763  * results in a ternary branching where the branching variable is mostly fixed in the middle child.
15764  * Setting widthfactor to 1.0 results in children where the branching variable always has the same domain width
15765  * (except for one child if the branching value is not in the middle).
15766  *
15767  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15768  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15769  *
15770  * @pre This method can be called if @p scip is in one of the following stages:
15771  * - \ref SCIP_STAGE_SOLVING
15772  *
15773  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15774  */
15775 extern
15777  SCIP* scip, /**< SCIP data structure */
15778  SCIP_VAR* var, /**< variable to branch on */
15779  SCIP_Real val, /**< value to branch on */
15780  int n, /**< attempted number of children to be created, must be >= 2 */
15781  SCIP_Real minwidth, /**< minimal domain width in children */
15782  SCIP_Real widthfactor, /**< multiplier for children domain width with increasing distance from val, must be >= 1.0 */
15783  int* nchildren /**< pointer to store number of created children, or NULL */
15784  );
15785 
15786 /** calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN;
15787  * if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional
15788  * variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority
15789  *
15790  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15791  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15792  *
15793  * @pre This method can be called if @p scip is in one of the following stages:
15794  * - \ref SCIP_STAGE_SOLVING
15795  *
15796  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15797  */
15798 extern
15800  SCIP* scip, /**< SCIP data structure */
15801  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
15802  );
15803 
15804 /** calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN
15805  *
15806  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15807  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15808  *
15809  * @pre This method can be called if @p scip is in one of the following stages:
15810  * - \ref SCIP_STAGE_SOLVING
15811  *
15812  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15813  */
15814 extern
15816  SCIP* scip, /**< SCIP data structure */
15817  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
15818  );
15819 
15820 /** calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN
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_SOLVING
15827  *
15828  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
15829  */
15830 extern
15832  SCIP* scip, /**< SCIP data structure */
15833  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
15834  );
15835 
15836 /**@} */
15837 
15838 
15839 
15840 
15841 /*
15842  * primal solutions
15843  */
15844 
15845 /**@name Primal Solution Methods */
15846 /**@{ */
15847 
15848 /** creates a primal solution, initialized to zero
15849  *
15850  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15851  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15852  *
15853  * @pre This method can be called if SCIP is in one of the following stages:
15854  * - \ref SCIP_STAGE_PROBLEM
15855  * - \ref SCIP_STAGE_TRANSFORMING
15856  * - \ref SCIP_STAGE_TRANSFORMED
15857  * - \ref SCIP_STAGE_INITPRESOLVE
15858  * - \ref SCIP_STAGE_PRESOLVING
15859  * - \ref SCIP_STAGE_EXITPRESOLVE
15860  * - \ref SCIP_STAGE_PRESOLVED
15861  * - \ref SCIP_STAGE_INITSOLVE
15862  * - \ref SCIP_STAGE_SOLVING
15863  */
15864 extern
15866  SCIP* scip, /**< SCIP data structure */
15867  SCIP_SOL** sol, /**< pointer to store the solution */
15868  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15869  );
15870 
15871 /** creates a primal solution, initialized to the current LP solution
15872  *
15873  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15874  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15875  *
15876  * @pre This method can be called if SCIP is in one of the following stages:
15877  * - \ref SCIP_STAGE_SOLVING
15878  */
15879 extern
15881  SCIP* scip, /**< SCIP data structure */
15882  SCIP_SOL** sol, /**< pointer to store the solution */
15883  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15884  );
15885 
15886 /** creates a primal solution, initialized to the current NLP solution
15887  *
15888  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15889  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15890  *
15891  * @pre This method can be called if SCIP is in one of the following stages:
15892  * - \ref SCIP_STAGE_SOLVING
15893  */
15894 extern
15896  SCIP* scip, /**< SCIP data structure */
15897  SCIP_SOL** sol, /**< pointer to store the solution */
15898  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15899  );
15900 
15901 /** creates a primal solution, initialized to the current relaxation solution
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 SCIP is in one of the following stages:
15907  * - \ref SCIP_STAGE_SOLVING
15908  */
15909 extern
15911  SCIP* scip, /**< SCIP data structure */
15912  SCIP_SOL** sol, /**< pointer to store the solution */
15913  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15914  );
15915 
15916 /** creates a primal solution, initialized to the current pseudo solution
15917  *
15918  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15919  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15920  *
15921  * @pre This method can be called if SCIP is in one of the following stages:
15922  * - \ref SCIP_STAGE_SOLVING
15923  */
15924 extern
15926  SCIP* scip, /**< SCIP data structure */
15927  SCIP_SOL** sol, /**< pointer to store the solution */
15928  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15929  );
15930 
15931 /** creates a primal solution, initialized to the current LP or pseudo solution, depending on whether the LP was solved
15932  * at the current node
15933  *
15934  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15935  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15936  *
15937  * @pre This method can be called if SCIP is in one of the following stages:
15938  * - \ref SCIP_STAGE_SOLVING
15939  */
15940 extern
15942  SCIP* scip, /**< SCIP data structure */
15943  SCIP_SOL** sol, /**< pointer to store the solution */
15944  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15945  );
15946 
15947 /** creates a primal solution, initialized to unknown values
15948  *
15949  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15950  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15951  *
15952  * @pre This method can be called if SCIP is in one of the following stages:
15953  * - \ref SCIP_STAGE_TRANSFORMING
15954  * - \ref SCIP_STAGE_TRANSFORMED
15955  * - \ref SCIP_STAGE_INITPRESOLVE
15956  * - \ref SCIP_STAGE_PRESOLVING
15957  * - \ref SCIP_STAGE_EXITPRESOLVE
15958  * - \ref SCIP_STAGE_PRESOLVED
15959  * - \ref SCIP_STAGE_INITSOLVE
15960  * - \ref SCIP_STAGE_SOLVING
15961  */
15962 extern
15964  SCIP* scip, /**< SCIP data structure */
15965  SCIP_SOL** sol, /**< pointer to store the solution */
15966  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15967  );
15968 
15969 /** creates a primal solution living in the original problem space, initialized to zero;
15970  * a solution in original space allows to set original variables to values that would be invalid in the
15971  * transformed problem due to preprocessing fixings or aggregations
15972  *
15973  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15974  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15975  *
15976  * @pre This method can be called if SCIP is in one of the following stages:
15977  * - \ref SCIP_STAGE_PROBLEM
15978  * - \ref SCIP_STAGE_TRANSFORMING
15979  * - \ref SCIP_STAGE_TRANSFORMED
15980  * - \ref SCIP_STAGE_INITPRESOLVE
15981  * - \ref SCIP_STAGE_PRESOLVING
15982  * - \ref SCIP_STAGE_EXITPRESOLVE
15983  * - \ref SCIP_STAGE_PRESOLVED
15984  * - \ref SCIP_STAGE_INITSOLVE
15985  * - \ref SCIP_STAGE_SOLVING
15986  */
15987 extern
15989  SCIP* scip, /**< SCIP data structure */
15990  SCIP_SOL** sol, /**< pointer to store the solution */
15991  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15992  );
15993 
15994 /** creates a copy of a primal solution; note that a copy of a linked solution is also linked and needs to be unlinked
15995  * if it should stay unaffected from changes in the LP or pseudo solution
15996  *
15997  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15998  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15999  *
16000  * @pre This method can be called if SCIP is in one of the following stages:
16001  * - \ref SCIP_STAGE_PROBLEM
16002  * - \ref SCIP_STAGE_TRANSFORMING
16003  * - \ref SCIP_STAGE_TRANSFORMED
16004  * - \ref SCIP_STAGE_INITPRESOLVE
16005  * - \ref SCIP_STAGE_PRESOLVING
16006  * - \ref SCIP_STAGE_EXITPRESOLVE
16007  * - \ref SCIP_STAGE_PRESOLVED
16008  * - \ref SCIP_STAGE_INITSOLVE
16009  * - \ref SCIP_STAGE_SOLVING
16010  */
16011 extern
16013  SCIP* scip, /**< SCIP data structure */
16014  SCIP_SOL** sol, /**< pointer to store the solution */
16015  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
16016  );
16017 
16018 /** creates a copy of a solution in the original primal solution space
16019  *
16020  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16021  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16022  *
16023  * @pre This method can be called if SCIP is in one of the following stages:
16024  * - \ref SCIP_STAGE_PROBLEM
16025  * - \ref SCIP_STAGE_TRANSFORMING
16026  * - \ref SCIP_STAGE_TRANSFORMED
16027  * - \ref SCIP_STAGE_INITPRESOLVE
16028  * - \ref SCIP_STAGE_PRESOLVING
16029  * - \ref SCIP_STAGE_EXITPRESOLVE
16030  * - \ref SCIP_STAGE_PRESOLVED
16031  * - \ref SCIP_STAGE_INITSOLVE
16032  * - \ref SCIP_STAGE_SOLVING
16033  * - \ref SCIP_STAGE_SOLVED
16034  * - \ref SCIP_STAGE_EXITSOLVE
16035  * - \ref SCIP_STAGE_FREETRANS
16036  */
16037 extern
16039  SCIP* scip, /**< SCIP data structure */
16040  SCIP_SOL** sol, /**< pointer to store the solution */
16041  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
16042  );
16043 
16044 /** creates a copy of a primal solution, thereby replacing infinite fixings of variables by finite values;
16045  * the copy is always defined in the original variable space;
16046  * success indicates whether the objective value of the solution was changed by removing infinite values
16047  *
16048  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16049  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16050  *
16051  * @pre This method can be called if SCIP is in one of the following stages:
16052  * - \ref SCIP_STAGE_PROBLEM
16053  * - \ref SCIP_STAGE_TRANSFORMING
16054  * - \ref SCIP_STAGE_TRANSFORMED
16055  * - \ref SCIP_STAGE_INITPRESOLVE
16056  * - \ref SCIP_STAGE_PRESOLVING
16057  * - \ref SCIP_STAGE_EXITPRESOLVE
16058  * - \ref SCIP_STAGE_PRESOLVED
16059  * - \ref SCIP_STAGE_INITSOLVE
16060  * - \ref SCIP_STAGE_SOLVING
16061  * - \ref SCIP_STAGE_SOLVED
16062  * - \ref SCIP_STAGE_EXITSOLVE
16063  */
16064 extern
16066  SCIP* scip, /**< SCIP data structure */
16067  SCIP_SOL** sol, /**< pointer to store the solution */
16068  SCIP_SOL* sourcesol, /**< primal CIP solution to copy */
16069  SCIP_Bool* success /**< does the finite solution have the same objective value? */
16070  );
16071 
16072 /** frees primal CIP solution
16073  *
16074  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16075  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16076  *
16077  * @pre This method can be called if SCIP is in one of the following stages:
16078  * - \ref SCIP_STAGE_PROBLEM
16079  * - \ref SCIP_STAGE_TRANSFORMING
16080  * - \ref SCIP_STAGE_TRANSFORMED
16081  * - \ref SCIP_STAGE_INITPRESOLVE
16082  * - \ref SCIP_STAGE_PRESOLVING
16083  * - \ref SCIP_STAGE_EXITPRESOLVE
16084  * - \ref SCIP_STAGE_PRESOLVED
16085  * - \ref SCIP_STAGE_INITSOLVE
16086  * - \ref SCIP_STAGE_SOLVING
16087  * - \ref SCIP_STAGE_SOLVED
16088  * - \ref SCIP_STAGE_EXITSOLVE
16089  * - \ref SCIP_STAGE_FREETRANS
16090  */
16091 extern
16093  SCIP* scip, /**< SCIP data structure */
16094  SCIP_SOL** sol /**< pointer to the solution */
16095  );
16096 
16097 /** links a primal solution to the current LP solution
16098  *
16099  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16100  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16101  *
16102  * @pre This method can be called if SCIP is in one of the following stages:
16103  * - \ref SCIP_STAGE_SOLVING
16104  */
16105 extern
16107  SCIP* scip, /**< SCIP data structure */
16108  SCIP_SOL* sol /**< primal solution */
16109  );
16110 
16111 /** links a primal solution to the current NLP solution
16112  *
16113  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16114  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16115  *
16116  * @pre This method can be called if SCIP is in one of the following stages:
16117  * - \ref SCIP_STAGE_SOLVING
16118  */
16119 extern
16121  SCIP* scip, /**< SCIP data structure */
16122  SCIP_SOL* sol /**< primal solution */
16123  );
16124 
16125 /** links a primal solution to the current relaxation solution
16126  *
16127  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16128  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16129  *
16130  * @pre This method can be called if SCIP is in one of the following stages:
16131  * - \ref SCIP_STAGE_SOLVING
16132  */
16133 extern
16135  SCIP* scip, /**< SCIP data structure */
16136  SCIP_SOL* sol /**< primal solution */
16137  );
16138 
16139 /** links a primal solution to the current pseudo solution
16140  *
16141  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16142  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16143  *
16144  * @pre This method can be called if SCIP is in one of the following stages:
16145  * - \ref SCIP_STAGE_PRESOLVING
16146  * - \ref SCIP_STAGE_SOLVING
16147  */
16148 extern
16150  SCIP* scip, /**< SCIP data structure */
16151  SCIP_SOL* sol /**< primal solution */
16152  );
16153 
16154 /** links a primal solution to the current LP or pseudo solution
16155  *
16156  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16157  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16158  *
16159  * @pre This method can be called if SCIP is in one of the following stages:
16160  * - \ref SCIP_STAGE_SOLVING
16161  */
16162 extern
16164  SCIP* scip, /**< SCIP data structure */
16165  SCIP_SOL* sol /**< primal solution */
16166  );
16167 
16168 /** clears a primal solution
16169  *
16170  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16171  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16172  *
16173  * @pre This method can be called if SCIP is in one of the following stages:
16174  * - \ref SCIP_STAGE_PROBLEM
16175  * - \ref SCIP_STAGE_TRANSFORMING
16176  * - \ref SCIP_STAGE_TRANSFORMED
16177  * - \ref SCIP_STAGE_INITPRESOLVE
16178  * - \ref SCIP_STAGE_PRESOLVING
16179  * - \ref SCIP_STAGE_EXITPRESOLVE
16180  * - \ref SCIP_STAGE_PRESOLVED
16181  * - \ref SCIP_STAGE_INITSOLVE
16182  * - \ref SCIP_STAGE_SOLVING
16183  * - \ref SCIP_STAGE_SOLVED
16184  * - \ref SCIP_STAGE_EXITSOLVE
16185  * - \ref SCIP_STAGE_FREETRANS
16186  */
16187 extern
16189  SCIP* scip, /**< SCIP data structure */
16190  SCIP_SOL* sol /**< primal solution */
16191  );
16192 
16193 /** stores solution values of variables in solution's own array
16194  *
16195  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16196  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16197  *
16198  * @pre This method can be called if SCIP is in one of the following stages:
16199  * - \ref SCIP_STAGE_TRANSFORMING
16200  * - \ref SCIP_STAGE_TRANSFORMED
16201  * - \ref SCIP_STAGE_PRESOLVING
16202  * - \ref SCIP_STAGE_PRESOLVED
16203  * - \ref SCIP_STAGE_INITSOLVE
16204  * - \ref SCIP_STAGE_SOLVING
16205  * - \ref SCIP_STAGE_SOLVED
16206  * - \ref SCIP_STAGE_EXITSOLVE
16207  * - \ref SCIP_STAGE_FREETRANS
16208  */
16209 extern
16211  SCIP* scip, /**< SCIP data structure */
16212  SCIP_SOL* sol /**< primal solution */
16213  );
16214 
16215 /** sets value of variable in primal CIP solution
16216  *
16217  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16218  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16219  *
16220  * @pre This method can be called if SCIP is in one of the following stages:
16221  * - \ref SCIP_STAGE_PROBLEM
16222  * - \ref SCIP_STAGE_TRANSFORMING
16223  * - \ref SCIP_STAGE_TRANSFORMED
16224  * - \ref SCIP_STAGE_INITPRESOLVE
16225  * - \ref SCIP_STAGE_PRESOLVING
16226  * - \ref SCIP_STAGE_EXITPRESOLVE
16227  * - \ref SCIP_STAGE_PRESOLVED
16228  * - \ref SCIP_STAGE_INITSOLVE
16229  * - \ref SCIP_STAGE_SOLVING
16230  * - \ref SCIP_STAGE_SOLVED
16231  * - \ref SCIP_STAGE_EXITSOLVE
16232  * - \ref SCIP_STAGE_FREETRANS
16233  */
16234 extern
16236  SCIP* scip, /**< SCIP data structure */
16237  SCIP_SOL* sol, /**< primal solution */
16238  SCIP_VAR* var, /**< variable to add to solution */
16239  SCIP_Real val /**< solution value of variable */
16240  );
16241 
16242 /** sets values of multiple variables in primal CIP solution
16243  *
16244  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16245  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16246  *
16247  * @pre This method can be called if SCIP is in one of the following stages:
16248  * - \ref SCIP_STAGE_PROBLEM
16249  * - \ref SCIP_STAGE_TRANSFORMING
16250  * - \ref SCIP_STAGE_TRANSFORMED
16251  * - \ref SCIP_STAGE_INITPRESOLVE
16252  * - \ref SCIP_STAGE_PRESOLVING
16253  * - \ref SCIP_STAGE_EXITPRESOLVE
16254  * - \ref SCIP_STAGE_PRESOLVED
16255  * - \ref SCIP_STAGE_INITSOLVE
16256  * - \ref SCIP_STAGE_SOLVING
16257  * - \ref SCIP_STAGE_SOLVED
16258  * - \ref SCIP_STAGE_EXITSOLVE
16259  * - \ref SCIP_STAGE_FREETRANS
16260  */
16261 extern
16263  SCIP* scip, /**< SCIP data structure */
16264  SCIP_SOL* sol, /**< primal solution */
16265  int nvars, /**< number of variables to set solution value for */
16266  SCIP_VAR** vars, /**< array with variables to add to solution */
16267  SCIP_Real* vals /**< array with solution values of variables */
16268  );
16269 
16270 /** increases value of variable in primal CIP solution
16271  *
16272  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16273  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16274  *
16275  * @pre This method can be called if SCIP is in one of the following stages:
16276  * - \ref SCIP_STAGE_PROBLEM
16277  * - \ref SCIP_STAGE_TRANSFORMING
16278  * - \ref SCIP_STAGE_TRANSFORMED
16279  * - \ref SCIP_STAGE_INITPRESOLVE
16280  * - \ref SCIP_STAGE_PRESOLVING
16281  * - \ref SCIP_STAGE_EXITPRESOLVE
16282  * - \ref SCIP_STAGE_PRESOLVED
16283  * - \ref SCIP_STAGE_INITSOLVE
16284  * - \ref SCIP_STAGE_SOLVING
16285  * - \ref SCIP_STAGE_SOLVED
16286  * - \ref SCIP_STAGE_EXITSOLVE
16287  * - \ref SCIP_STAGE_FREETRANS
16288  */
16289 extern
16291  SCIP* scip, /**< SCIP data structure */
16292  SCIP_SOL* sol, /**< primal solution */
16293  SCIP_VAR* var, /**< variable to increase solution value for */
16294  SCIP_Real incval /**< increment for solution value of variable */
16295  );
16296 
16297 /** returns value of variable in primal CIP solution, or in current LP/pseudo solution
16298  *
16299  * @return value of variable in primal CIP solution, or in current LP/pseudo solution
16300  *
16301  * @pre In case the solution pointer @p sol is @b NULL, that means it is asked for the LP or pseudo solution, this method
16302  * can only be called if @p scip is in the solving stage \ref SCIP_STAGE_SOLVING. In any other case, this method
16303  * can be called if @p scip is in one of the following stages:
16304  * - \ref SCIP_STAGE_PROBLEM
16305  * - \ref SCIP_STAGE_TRANSFORMING
16306  * - \ref SCIP_STAGE_TRANSFORMED
16307  * - \ref SCIP_STAGE_INITPRESOLVE
16308  * - \ref SCIP_STAGE_PRESOLVING
16309  * - \ref SCIP_STAGE_EXITPRESOLVE
16310  * - \ref SCIP_STAGE_PRESOLVED
16311  * - \ref SCIP_STAGE_INITSOLVE
16312  * - \ref SCIP_STAGE_SOLVING
16313  * - \ref SCIP_STAGE_SOLVED
16314  * - \ref SCIP_STAGE_EXITSOLVE
16315  * - \ref SCIP_STAGE_FREETRANS
16316  */
16317 extern
16319  SCIP* scip, /**< SCIP data structure */
16320  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
16321  SCIP_VAR* var /**< variable to get value for */
16322  );
16323 
16324 /** gets values of multiple variables in primal CIP solution
16325  *
16326  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16327  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16328  *
16329  * @pre This method can be called if SCIP is in one of the following stages:
16330  * - \ref SCIP_STAGE_PROBLEM
16331  * - \ref SCIP_STAGE_TRANSFORMING
16332  * - \ref SCIP_STAGE_TRANSFORMED
16333  * - \ref SCIP_STAGE_INITPRESOLVE
16334  * - \ref SCIP_STAGE_PRESOLVING
16335  * - \ref SCIP_STAGE_EXITPRESOLVE
16336  * - \ref SCIP_STAGE_PRESOLVED
16337  * - \ref SCIP_STAGE_INITSOLVE
16338  * - \ref SCIP_STAGE_SOLVING
16339  * - \ref SCIP_STAGE_SOLVED
16340  * - \ref SCIP_STAGE_EXITSOLVE
16341  * - \ref SCIP_STAGE_FREETRANS
16342  */
16343 extern
16345  SCIP* scip, /**< SCIP data structure */
16346  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
16347  int nvars, /**< number of variables to get solution value for */
16348  SCIP_VAR** vars, /**< array with variables to get value for */
16349  SCIP_Real* vals /**< array to store solution values of variables */
16350  );
16351 
16352 /** returns objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
16353  *
16354  * @return objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
16355  *
16356  * @pre This method can be called if SCIP is in one of the following stages:
16357  * - \ref SCIP_STAGE_PROBLEM
16358  * - \ref SCIP_STAGE_TRANSFORMING
16359  * - \ref SCIP_STAGE_TRANSFORMED
16360  * - \ref SCIP_STAGE_INITPRESOLVE
16361  * - \ref SCIP_STAGE_PRESOLVING
16362  * - \ref SCIP_STAGE_EXITPRESOLVE
16363  * - \ref SCIP_STAGE_PRESOLVED
16364  * - \ref SCIP_STAGE_INITSOLVE
16365  * - \ref SCIP_STAGE_SOLVING
16366  * - \ref SCIP_STAGE_SOLVED
16367  * - \ref SCIP_STAGE_EXITSOLVE
16368  * - \ref SCIP_STAGE_FREETRANS
16369  */
16370 extern
16372  SCIP* scip, /**< SCIP data structure */
16373  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
16374  );
16375 
16376 /** returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
16377  *
16378  * @return transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
16379  *
16380  * @pre This method can be called if SCIP is in one of the following stages:
16381  * - \ref SCIP_STAGE_TRANSFORMING
16382  * - \ref SCIP_STAGE_TRANSFORMED
16383  * - \ref SCIP_STAGE_INITPRESOLVE
16384  * - \ref SCIP_STAGE_PRESOLVING
16385  * - \ref SCIP_STAGE_EXITPRESOLVE
16386  * - \ref SCIP_STAGE_PRESOLVED
16387  * - \ref SCIP_STAGE_INITSOLVE
16388  * - \ref SCIP_STAGE_SOLVING
16389  * - \ref SCIP_STAGE_SOLVED
16390  * - \ref SCIP_STAGE_EXITSOLVE
16391  * - \ref SCIP_STAGE_FREETRANS
16392  */
16393 extern
16395  SCIP* scip, /**< SCIP data structure */
16396  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
16397  );
16398 
16399 /** recomputes the objective value of an original solution, e.g., when transferring solutions
16400  * from the solution pool (objective coefficients might have changed in the meantime)
16401  *
16402  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16403  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16404  *
16405  * @pre This method can be called if SCIP is in one of the following stages:
16406  * - \ref SCIP_STAGE_PRESOLVING
16407  * - \ref SCIP_STAGE_SOLVING
16408  *
16409  */
16410 extern
16412  SCIP* scip,
16413  SCIP_SOL* sol
16414  );
16415 
16416 /** maps original space objective value into transformed objective value
16417  *
16418  * @return transformed objective value
16419  *
16420  * @pre This method can be called if SCIP is in one of the following stages:
16421  * - \ref SCIP_STAGE_TRANSFORMING
16422  * - \ref SCIP_STAGE_TRANSFORMED
16423  * - \ref SCIP_STAGE_INITPRESOLVE
16424  * - \ref SCIP_STAGE_PRESOLVING
16425  * - \ref SCIP_STAGE_EXITPRESOLVE
16426  * - \ref SCIP_STAGE_PRESOLVED
16427  * - \ref SCIP_STAGE_INITSOLVE
16428  * - \ref SCIP_STAGE_SOLVING
16429  * - \ref SCIP_STAGE_SOLVED
16430  */
16431 extern
16433  SCIP* scip, /**< SCIP data structure */
16434  SCIP_Real obj /**< original space objective value to transform */
16435  );
16436 
16437 /** maps transformed objective value into original space
16438  *
16439  * @return objective value into original space
16440  *
16441  * @pre This method can be called if SCIP is in one of the following stages:
16442  * - \ref SCIP_STAGE_TRANSFORMING
16443  * - \ref SCIP_STAGE_TRANSFORMED
16444  * - \ref SCIP_STAGE_INITPRESOLVE
16445  * - \ref SCIP_STAGE_PRESOLVING
16446  * - \ref SCIP_STAGE_EXITPRESOLVE
16447  * - \ref SCIP_STAGE_PRESOLVED
16448  * - \ref SCIP_STAGE_INITSOLVE
16449  * - \ref SCIP_STAGE_SOLVING
16450  * - \ref SCIP_STAGE_SOLVED
16451  */
16452 extern
16454  SCIP* scip, /**< SCIP data structure */
16455  SCIP_Real obj /**< transformed objective value to retransform in original space */
16456  );
16457 
16458 /** gets clock time, when this solution was found
16459  *
16460  * @return clock time, when this solution was found
16461  *
16462  * @pre This method can be called if SCIP is in one of the following stages:
16463  * - \ref SCIP_STAGE_TRANSFORMING
16464  * - \ref SCIP_STAGE_TRANSFORMED
16465  * - \ref SCIP_STAGE_INITPRESOLVE
16466  * - \ref SCIP_STAGE_PRESOLVING
16467  * - \ref SCIP_STAGE_EXITPRESOLVE
16468  * - \ref SCIP_STAGE_PRESOLVED
16469  * - \ref SCIP_STAGE_INITSOLVE
16470  * - \ref SCIP_STAGE_SOLVING
16471  * - \ref SCIP_STAGE_SOLVED
16472  * - \ref SCIP_STAGE_EXITSOLVE
16473  * - \ref SCIP_STAGE_FREETRANS
16474  */
16475 extern
16477  SCIP* scip, /**< SCIP data structure */
16478  SCIP_SOL* sol /**< primal solution */
16479  );
16480 
16481 /** gets branch and bound run number, where this solution was found
16482  *
16483  * @return branch and bound run number, where this solution was found
16484  *
16485  * @pre This method can be called if SCIP is in one of the following stages:
16486  * - \ref SCIP_STAGE_TRANSFORMING
16487  * - \ref SCIP_STAGE_TRANSFORMED
16488  * - \ref SCIP_STAGE_INITPRESOLVE
16489  * - \ref SCIP_STAGE_PRESOLVING
16490  * - \ref SCIP_STAGE_EXITPRESOLVE
16491  * - \ref SCIP_STAGE_PRESOLVED
16492  * - \ref SCIP_STAGE_INITSOLVE
16493  * - \ref SCIP_STAGE_SOLVING
16494  * - \ref SCIP_STAGE_SOLVED
16495  * - \ref SCIP_STAGE_EXITSOLVE
16496  * - \ref SCIP_STAGE_FREETRANS
16497  */
16498 extern
16499 int SCIPgetSolRunnum(
16500  SCIP* scip, /**< SCIP data structure */
16501  SCIP_SOL* sol /**< primal solution */
16502  );
16503 
16504 /** gets node number of the specific branch and bound run, where this solution was found
16505  *
16506  * @return node number of the specific branch and bound run, where this solution was found
16507  *
16508  * @pre This method can be called if SCIP is in one of the following stages:
16509  * - \ref SCIP_STAGE_TRANSFORMING
16510  * - \ref SCIP_STAGE_TRANSFORMED
16511  * - \ref SCIP_STAGE_INITPRESOLVE
16512  * - \ref SCIP_STAGE_PRESOLVING
16513  * - \ref SCIP_STAGE_EXITPRESOLVE
16514  * - \ref SCIP_STAGE_PRESOLVED
16515  * - \ref SCIP_STAGE_INITSOLVE
16516  * - \ref SCIP_STAGE_SOLVING
16517  * - \ref SCIP_STAGE_SOLVED
16518  * - \ref SCIP_STAGE_EXITSOLVE
16519  * - \ref SCIP_STAGE_FREETRANS
16520  */
16521 extern
16523  SCIP* scip, /**< SCIP data structure */
16524  SCIP_SOL* sol /**< primal solution */
16525  );
16526 
16527 /** gets heuristic, that found this solution (or NULL if it's from the tree)
16528  *
16529  * @return heuristic, that found this solution (or NULL if it's from the tree)
16530  *
16531  * @pre This method can be called if SCIP is in one of the following stages:
16532  * - \ref SCIP_STAGE_TRANSFORMING
16533  * - \ref SCIP_STAGE_TRANSFORMED
16534  * - \ref SCIP_STAGE_INITPRESOLVE
16535  * - \ref SCIP_STAGE_PRESOLVING
16536  * - \ref SCIP_STAGE_EXITPRESOLVE
16537  * - \ref SCIP_STAGE_PRESOLVED
16538  * - \ref SCIP_STAGE_INITSOLVE
16539  * - \ref SCIP_STAGE_SOLVING
16540  * - \ref SCIP_STAGE_SOLVED
16541  * - \ref SCIP_STAGE_EXITSOLVE
16542  * - \ref SCIP_STAGE_FREETRANS
16543  */
16544 extern
16546  SCIP* scip, /**< SCIP data structure */
16547  SCIP_SOL* sol /**< primal solution */
16548  );
16549 
16550 /** returns whether two given solutions are exactly equal
16551  *
16552  * @return returns whether two given solutions are exactly equal
16553  *
16554  * @pre This method can be called if SCIP is in one of the following stages:
16555  * - \ref SCIP_STAGE_PROBLEM
16556  * - \ref SCIP_STAGE_TRANSFORMING
16557  * - \ref SCIP_STAGE_TRANSFORMED
16558  * - \ref SCIP_STAGE_INITPRESOLVE
16559  * - \ref SCIP_STAGE_PRESOLVING
16560  * - \ref SCIP_STAGE_EXITPRESOLVE
16561  * - \ref SCIP_STAGE_PRESOLVED
16562  * - \ref SCIP_STAGE_INITSOLVE
16563  * - \ref SCIP_STAGE_SOLVING
16564  * - \ref SCIP_STAGE_SOLVED
16565  * - \ref SCIP_STAGE_EXITSOLVE
16566  * - \ref SCIP_STAGE_FREETRANS
16567  */
16568 extern
16570  SCIP* scip, /**< SCIP data structure */
16571  SCIP_SOL* sol1, /**< first primal CIP solution */
16572  SCIP_SOL* sol2 /**< second primal CIP solution */
16573  );
16574 
16575 /** adjusts solution values of implicit integer variables in handed solution. Solution objective value is not
16576  * deteriorated by this method.
16577  *
16578  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16579  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16580  *
16581  * @pre This method can be called if SCIP is in one of the following stages:
16582  * - \ref SCIP_STAGE_SOLVING
16583  */
16584 extern
16586  SCIP* scip, /**< SCIP data structure */
16587  SCIP_SOL* sol, /**< primal CIP solution */
16588  SCIP_Bool uselprows /**< should LP row information be considered for none-objective variables */
16589  );
16590 
16591 /** outputs non-zero variables of solution in original problem space to the given file stream
16592  *
16593  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16594  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16595  *
16596  * @pre In case the solution pointer @p sol is NULL (askinking for the current LP/pseudo solution), this method can be
16597  * called if @p scip is in one of the following stages:
16598  * - \ref SCIP_STAGE_PRESOLVING
16599  * - \ref SCIP_STAGE_EXITPRESOLVE
16600  * - \ref SCIP_STAGE_PRESOLVED
16601  * - \ref SCIP_STAGE_INITSOLVE
16602  * - \ref SCIP_STAGE_SOLVING
16603  * - \ref SCIP_STAGE_SOLVED
16604  * - \ref SCIP_STAGE_EXITSOLVE
16605  *
16606  * @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
16607  * following stages:
16608  * - \ref SCIP_STAGE_PROBLEM
16609  * - \ref SCIP_STAGE_TRANSFORMED
16610  * - \ref SCIP_STAGE_INITPRESOLVE
16611  * - \ref SCIP_STAGE_PRESOLVING
16612  * - \ref SCIP_STAGE_EXITPRESOLVE
16613  * - \ref SCIP_STAGE_PRESOLVED
16614  * - \ref SCIP_STAGE_INITSOLVE
16615  * - \ref SCIP_STAGE_SOLVING
16616  * - \ref SCIP_STAGE_SOLVED
16617  * - \ref SCIP_STAGE_EXITSOLVE
16618  */
16619 extern
16621  SCIP* scip, /**< SCIP data structure */
16622  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
16623  FILE* file, /**< output file (or NULL for standard output) */
16624  SCIP_Bool printzeros /**< should variables set to zero be printed? */
16625  );
16626 
16627 /** outputs non-zero variables of solution in transformed problem space to file stream
16628  *
16629  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16630  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16631  *
16632  * @pre This method can be called if SCIP is in one of the following stages:
16633  * - \ref SCIP_STAGE_TRANSFORMED
16634  * - \ref SCIP_STAGE_INITPRESOLVE
16635  * - \ref SCIP_STAGE_PRESOLVING
16636  * - \ref SCIP_STAGE_EXITPRESOLVE
16637  * - \ref SCIP_STAGE_PRESOLVED
16638  * - \ref SCIP_STAGE_INITSOLVE
16639  * - \ref SCIP_STAGE_SOLVING
16640  * - \ref SCIP_STAGE_SOLVED
16641  * - \ref SCIP_STAGE_EXITSOLVE
16642  */
16643 extern
16645  SCIP* scip, /**< SCIP data structure */
16646  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
16647  FILE* file, /**< output file (or NULL for standard output) */
16648  SCIP_Bool printzeros /**< should variables set to zero be printed? */
16649  );
16650 
16651 /** outputs dual solution from LP solver to file stream
16652  *
16653  * @note This only works if no presolving has been performed, which can be checked by calling method \ref
16654  * SCIPhasPerformedPresolve().
16655  *
16656  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16657  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16658  *
16659  * @pre This method can be called if SCIP is in one of the following stages:
16660  * - \ref SCIP_STAGE_SOLVED
16661  */
16662 extern
16664  SCIP* scip, /**< SCIP data structure */
16665  FILE* file, /**< output file (or NULL for standard output) */
16666  SCIP_Bool printzeros /**< should variables set to zero be printed? */
16667  );
16668 
16669 
16670 /** outputs non-zero variables of solution representing a ray in original problem space to file stream
16671  *
16672  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16673  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16674  *
16675  * @pre This method can be called if SCIP is in one of the following stages:
16676  * - \ref SCIP_STAGE_PROBLEM
16677  * - \ref SCIP_STAGE_TRANSFORMED
16678  * - \ref SCIP_STAGE_INITPRESOLVE
16679  * - \ref SCIP_STAGE_PRESOLVING
16680  * - \ref SCIP_STAGE_EXITPRESOLVE
16681  * - \ref SCIP_STAGE_PRESOLVED
16682  * - \ref SCIP_STAGE_INITSOLVE
16683  * - \ref SCIP_STAGE_SOLVING
16684  * - \ref SCIP_STAGE_SOLVED
16685  * - \ref SCIP_STAGE_EXITSOLVE
16686  */
16687 extern
16689  SCIP* scip, /**< SCIP data structure */
16690  SCIP_SOL* sol, /**< primal solution representing ray */
16691  FILE* file, /**< output file (or NULL for standard output) */
16692  SCIP_Bool printzeros /**< should variables set to zero be printed? */
16693  );
16694 
16695 /** gets number of feasible primal solutions stored in the solution storage in case the problem is transformed;
16696  * in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate
16697  * storage is returned
16698  *
16699  * @return number of feasible primal solutions stored in the solution storage in case the problem is transformed; or
16700  * number of solution in the original solution candidate storage if the problem stage is SCIP_STAGE_PROBLEM
16701  *
16702  * @pre This method can be called if SCIP is in one of the following stages:
16703  * - \ref SCIP_STAGE_PROBLEM
16704  * - \ref SCIP_STAGE_TRANSFORMED
16705  * - \ref SCIP_STAGE_INITPRESOLVE
16706  * - \ref SCIP_STAGE_PRESOLVING
16707  * - \ref SCIP_STAGE_EXITPRESOLVE
16708  * - \ref SCIP_STAGE_PRESOLVED
16709  * - \ref SCIP_STAGE_INITSOLVE
16710  * - \ref SCIP_STAGE_SOLVING
16711  * - \ref SCIP_STAGE_SOLVED
16712  * - \ref SCIP_STAGE_EXITSOLVE
16713  */
16714 extern
16715 int SCIPgetNSols(
16716  SCIP* scip /**< SCIP data structure */
16717  );
16718 
16719 /** gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case
16720  * if the problem stage is in SCIP_STAGE_PROBLEM, it returns the number array of solution candidate stored
16721  *
16722  * @return array of feasible primal solutions
16723  *
16724  * @pre This method can be called if SCIP is in one of the following stages:
16725  * - \ref SCIP_STAGE_PROBLEM
16726  * - \ref SCIP_STAGE_TRANSFORMED
16727  * - \ref SCIP_STAGE_INITPRESOLVE
16728  * - \ref SCIP_STAGE_PRESOLVING
16729  * - \ref SCIP_STAGE_EXITPRESOLVE
16730  * - \ref SCIP_STAGE_PRESOLVED
16731  * - \ref SCIP_STAGE_INITSOLVE
16732  * - \ref SCIP_STAGE_SOLVING
16733  * - \ref SCIP_STAGE_SOLVED
16734  * - \ref SCIP_STAGE_EXITSOLVE
16735  */
16736 extern
16738  SCIP* scip /**< SCIP data structure */
16739  );
16740 
16741 /** gets best feasible primal solution found so far if the problem is transformed; in case the problem is in
16742  * SCIP_STAGE_PROBLEM it returns the best solution candidate, or NULL if no solution has been found or the candidate
16743  * store is empty;
16744  *
16745  * @return best feasible primal solution so far
16746  *
16747  * @pre This method can be called if SCIP is in one of the following stages:
16748  * - \ref SCIP_STAGE_PROBLEM
16749  * - \ref SCIP_STAGE_TRANSFORMED
16750  * - \ref SCIP_STAGE_INITPRESOLVE
16751  * - \ref SCIP_STAGE_PRESOLVING
16752  * - \ref SCIP_STAGE_EXITPRESOLVE
16753  * - \ref SCIP_STAGE_PRESOLVED
16754  * - \ref SCIP_STAGE_INITSOLVE
16755  * - \ref SCIP_STAGE_SOLVING
16756  * - \ref SCIP_STAGE_SOLVED
16757  * - \ref SCIP_STAGE_EXITSOLVE
16758  */
16759 extern
16761  SCIP* scip /**< SCIP data structure */
16762  );
16763 
16764 /** outputs best feasible primal solution found so far to file stream
16765  *
16766  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16767  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16768  *
16769  * @pre This method can be called if SCIP is in one of the following stages:
16770  * - \ref SCIP_STAGE_INIT
16771  * - \ref SCIP_STAGE_PROBLEM
16772  * - \ref SCIP_STAGE_TRANSFORMING
16773  * - \ref SCIP_STAGE_TRANSFORMED
16774  * - \ref SCIP_STAGE_INITPRESOLVE
16775  * - \ref SCIP_STAGE_PRESOLVING
16776  * - \ref SCIP_STAGE_EXITPRESOLVE
16777  * - \ref SCIP_STAGE_PRESOLVED
16778  * - \ref SCIP_STAGE_INITSOLVE
16779  * - \ref SCIP_STAGE_SOLVING
16780  * - \ref SCIP_STAGE_SOLVED
16781  * - \ref SCIP_STAGE_EXITSOLVE
16782  * - \ref SCIP_STAGE_FREE
16783  */
16784 extern
16786  SCIP* scip, /**< SCIP data structure */
16787  FILE* file, /**< output file (or NULL for standard output) */
16788  SCIP_Bool printzeros /**< should variables set to zero be printed? */
16789  );
16790 
16791 /** outputs best feasible primal solution found so far in transformed variables to file stream
16792  *
16793  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16794  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16795  *
16796  * @pre This method can be called if SCIP is in one of the following stages:
16797  * - \ref SCIP_STAGE_INIT
16798  * - \ref SCIP_STAGE_PROBLEM
16799  * - \ref SCIP_STAGE_TRANSFORMING
16800  * - \ref SCIP_STAGE_TRANSFORMED
16801  * - \ref SCIP_STAGE_INITPRESOLVE
16802  * - \ref SCIP_STAGE_PRESOLVING
16803  * - \ref SCIP_STAGE_EXITPRESOLVE
16804  * - \ref SCIP_STAGE_PRESOLVED
16805  * - \ref SCIP_STAGE_INITSOLVE
16806  * - \ref SCIP_STAGE_SOLVING
16807  * - \ref SCIP_STAGE_SOLVED
16808  * - \ref SCIP_STAGE_EXITSOLVE
16809  * - \ref SCIP_STAGE_FREE
16810  */
16811 extern
16813  SCIP* scip, /**< SCIP data structure */
16814  FILE* file, /**< output file (or NULL for standard output) */
16815  SCIP_Bool printzeros /**< should variables set to zero be printed? */
16816  );
16817 
16818 /** try to round given solution
16819  *
16820  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16821  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16822  *
16823  * @pre This method can be called if SCIP is in one of the following stages:
16824  * - \ref SCIP_STAGE_SOLVING
16825  */
16826 extern
16828  SCIP* scip, /**< SCIP data structure */
16829  SCIP_SOL* sol, /**< primal solution */
16830  SCIP_Bool* success /**< pointer to store whether rounding was successful */
16831  );
16832 
16833 /** retransforms solution to original problem space
16834  *
16835  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16836  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16837  *
16838  * @pre This method can be called if SCIP is in one of the following stages:
16839  * - \ref SCIP_STAGE_PROBLEM
16840  * - \ref SCIP_STAGE_TRANSFORMING
16841  * - \ref SCIP_STAGE_TRANSFORMED
16842  * - \ref SCIP_STAGE_INITPRESOLVE
16843  * - \ref SCIP_STAGE_PRESOLVING
16844  * - \ref SCIP_STAGE_EXITPRESOLVE
16845  * - \ref SCIP_STAGE_PRESOLVED
16846  * - \ref SCIP_STAGE_INITSOLVE
16847  * - \ref SCIP_STAGE_SOLVING
16848  * - \ref SCIP_STAGE_SOLVED
16849  * - \ref SCIP_STAGE_EXITSOLVE
16850  * - \ref SCIP_STAGE_FREETRANS
16851  */
16852 extern
16854  SCIP* scip, /**< SCIP data structure */
16855  SCIP_SOL* sol /**< primal CIP solution */
16856  );
16857 
16858 /** reads a given solution file, problem has to be transformed in advance
16859  *
16860  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16861  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16862  *
16863  * @pre This method can be called if SCIP is in one of the following stages:
16864  * - \ref SCIP_STAGE_PROBLEM
16865  * - \ref SCIP_STAGE_TRANSFORMED
16866  * - \ref SCIP_STAGE_INITPRESOLVE
16867  * - \ref SCIP_STAGE_PRESOLVING
16868  * - \ref SCIP_STAGE_EXITPRESOLVE
16869  * - \ref SCIP_STAGE_PRESOLVED
16870  * - \ref SCIP_STAGE_INITSOLVE
16871  * - \ref SCIP_STAGE_SOLVING
16872  */
16873 extern
16875  SCIP* scip, /**< SCIP data structure */
16876  const char* filename /**< name of the input file */
16877  );
16878 
16879 /** adds feasible primal solution to solution storage by copying it
16880  *
16881  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16882  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16883  *
16884  * @pre This method can be called if SCIP is in one of the following stages:
16885  * - \ref SCIP_STAGE_PROBLEM
16886  * - \ref SCIP_STAGE_TRANSFORMED
16887  * - \ref SCIP_STAGE_INITPRESOLVE
16888  * - \ref SCIP_STAGE_PRESOLVING
16889  * - \ref SCIP_STAGE_EXITPRESOLVE
16890  * - \ref SCIP_STAGE_PRESOLVED
16891  * - \ref SCIP_STAGE_SOLVING
16892  * - \ref SCIP_STAGE_FREETRANS
16893  *
16894  * @note Do not call during propagation, use heur_trysol instead.
16895  */
16896 extern
16898  SCIP* scip, /**< SCIP data structure */
16899  SCIP_SOL* sol, /**< primal CIP solution */
16900  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
16901  );
16902 
16903 /** adds primal solution to solution storage, frees the solution afterwards
16904  *
16905  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16906  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16907  *
16908  * @pre This method can be called if SCIP is in one of the following stages:
16909  * - \ref SCIP_STAGE_PROBLEM
16910  * - \ref SCIP_STAGE_TRANSFORMED
16911  * - \ref SCIP_STAGE_INITPRESOLVE
16912  * - \ref SCIP_STAGE_PRESOLVING
16913  * - \ref SCIP_STAGE_EXITPRESOLVE
16914  * - \ref SCIP_STAGE_PRESOLVED
16915  * - \ref SCIP_STAGE_SOLVING
16916  * - \ref SCIP_STAGE_FREETRANS
16917  *
16918  * @note Do not call during propagation, use heur_trysol instead.
16919  */
16920 extern
16922  SCIP* scip, /**< SCIP data structure */
16923  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
16924  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
16925  );
16926 
16927 /** adds current LP/pseudo solution to solution storage
16928  *
16929  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16930  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16931  *
16932  * @pre This method can be called if SCIP is in one of the following stages:
16933  * - \ref SCIP_STAGE_PRESOLVED
16934  * - \ref SCIP_STAGE_SOLVING
16935  */
16936 extern
16938  SCIP* scip, /**< SCIP data structure */
16939  SCIP_HEUR* heur, /**< heuristic that found the solution */
16940  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
16941  );
16942 
16943 /** checks solution for feasibility; if possible, adds it to storage by copying
16944  *
16945  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16946  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16947  *
16948  * @pre This method can be called if SCIP is in one of the following stages:
16949  * - \ref SCIP_STAGE_TRANSFORMED
16950  * - \ref SCIP_STAGE_INITPRESOLVE
16951  * - \ref SCIP_STAGE_PRESOLVING
16952  * - \ref SCIP_STAGE_EXITPRESOLVE
16953  * - \ref SCIP_STAGE_PRESOLVED
16954  * - \ref SCIP_STAGE_SOLVING
16955  *
16956  * @note Do not call during propagation, use heur_trysol instead.
16957  */
16958 extern
16960  SCIP* scip, /**< SCIP data structure */
16961  SCIP_SOL* sol, /**< primal CIP solution */
16962  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
16963  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
16964  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
16965  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
16966  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
16967  );
16968 
16969 /** checks primal solution; if feasible, adds it to storage; solution is freed afterwards
16970  *
16971  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16972  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16973  *
16974  * @pre This method can be called if SCIP is in one of the following stages:
16975  * - \ref SCIP_STAGE_TRANSFORMED
16976  * - \ref SCIP_STAGE_INITPRESOLVE
16977  * - \ref SCIP_STAGE_PRESOLVING
16978  * - \ref SCIP_STAGE_EXITPRESOLVE
16979  * - \ref SCIP_STAGE_PRESOLVED
16980  * - \ref SCIP_STAGE_SOLVING
16981  *
16982  * @note Do not call during propagation, use heur_trysol instead.
16983  */
16984 extern
16986  SCIP* scip, /**< SCIP data structure */
16987  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
16988  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
16989  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
16990  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
16991  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
16992  SCIP_Bool* stored /**< stores whether solution was feasible and good enough to keep */
16993  );
16994 
16995 /** checks current LP/pseudo solution for feasibility; if possible, adds it to storage
16996  *
16997  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16998  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16999  *
17000  * @pre This method can be called if SCIP is in one of the following stages:
17001  * - \ref SCIP_STAGE_PRESOLVED
17002  * - \ref SCIP_STAGE_SOLVING
17003  */
17004 extern
17006  SCIP* scip, /**< SCIP data structure */
17007  SCIP_HEUR* heur, /**< heuristic that found the solution */
17008  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
17009  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
17010  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
17011  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
17012  );
17013 
17014 /** checks solution for feasibility without adding it to the solution store
17015  *
17016  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17017  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17018  *
17019  * @pre This method can be called if SCIP is in one of the following stages:
17020  * - \ref SCIP_STAGE_PROBLEM
17021  * - \ref SCIP_STAGE_TRANSFORMED
17022  * - \ref SCIP_STAGE_INITPRESOLVE
17023  * - \ref SCIP_STAGE_PRESOLVING
17024  * - \ref SCIP_STAGE_EXITPRESOLVE
17025  * - \ref SCIP_STAGE_PRESOLVED
17026  * - \ref SCIP_STAGE_INITSOLVE
17027  * - \ref SCIP_STAGE_SOLVING
17028  * - \ref SCIP_STAGE_SOLVED
17029  */
17030 extern
17032  SCIP* scip, /**< SCIP data structure */
17033  SCIP_SOL* sol, /**< primal CIP solution */
17034  SCIP_Bool printreason, /**< Should all reasons of violations be printed? */
17035  SCIP_Bool checkbounds, /**< Should the bounds of the variables be checked? */
17036  SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
17037  SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
17038  SCIP_Bool* feasible /**< stores whether given solution is feasible */
17039  );
17040 
17041 /** checks solution for feasibility in original problem without adding it to the solution store;
17042  * this method is used to double check a solution in order to validate the presolving process
17043  *
17044  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17045  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17046  *
17047  * @pre This method can be called if SCIP is in one of the following stages:
17048  * - \ref SCIP_STAGE_PROBLEM
17049  * - \ref SCIP_STAGE_TRANSFORMED
17050  * - \ref SCIP_STAGE_INITPRESOLVE
17051  * - \ref SCIP_STAGE_PRESOLVING
17052  * - \ref SCIP_STAGE_EXITPRESOLVE
17053  * - \ref SCIP_STAGE_PRESOLVED
17054  * - \ref SCIP_STAGE_INITSOLVE
17055  * - \ref SCIP_STAGE_SOLVING
17056  * - \ref SCIP_STAGE_SOLVED
17057  */
17058 extern
17060  SCIP* scip, /**< SCIP data structure */
17061  SCIP_SOL* sol, /**< primal CIP solution */
17062  SCIP_Bool* feasible, /**< stores whether given solution is feasible */
17063  SCIP_Bool printreason, /**< should the reason for the violation be printed? */
17064  SCIP_Bool completely /**< should all violations be checked? */
17065  );
17066 
17067 /** return whether a primal ray is stored that proves unboundedness of the LP relaxation
17068  *
17069  * @return return whether a primal ray is stored that proves unboundedness of the LP relaxation
17070  *
17071  * @pre This method can be called if SCIP is in one of the following stages:
17072  * - \ref SCIP_STAGE_SOLVING
17073  * - \ref SCIP_STAGE_SOLVED
17074  */
17075 extern
17077  SCIP* scip /**< SCIP data structure */
17078  );
17079 
17080 /** gets value of given variable in primal ray causing unboundedness of the LP relaxation;
17081  * should only be called if such a ray is stored (check with SCIPhasPrimalRay())
17082  *
17083  * @return value of given variable in primal ray causing unboundedness of the LP relaxation
17084  *
17085  * @pre This method can be called if SCIP is in one of the following stages:
17086  * - \ref SCIP_STAGE_SOLVING
17087  * - \ref SCIP_STAGE_SOLVED
17088  */
17089 extern
17091  SCIP* scip, /**< SCIP data structure */
17092  SCIP_VAR* var /**< variable to get value for */
17093  );
17094 
17095 /**@} */
17096 
17097 
17098 
17099 
17100 /*
17101  * event methods
17102  */
17103 
17104 /**@name Event Methods
17105  *
17106  * Events can only be caught during the operation on the transformed problem.
17107  * Events on variables can only be caught for transformed variables.
17108  * If you want to catch an event for an original variable, you have to get the corresponding transformed variable
17109  * with a call to SCIPgetTransformedVar() and catch the event on the transformed variable.
17110  */
17111 /**@{ */
17112 
17113 /** catches a global (not variable or row dependent) event
17114  *
17115  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17116  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17117  *
17118  * @pre This method can be called if @p scip is in one of the following stages:
17119  * - \ref SCIP_STAGE_TRANSFORMING
17120  * - \ref SCIP_STAGE_TRANSFORMED
17121  * - \ref SCIP_STAGE_INITPRESOLVE
17122  * - \ref SCIP_STAGE_PRESOLVING
17123  * - \ref SCIP_STAGE_EXITPRESOLVE
17124  * - \ref SCIP_STAGE_PRESOLVED
17125  * - \ref SCIP_STAGE_INITSOLVE
17126  * - \ref SCIP_STAGE_SOLVING
17127  * - \ref SCIP_STAGE_SOLVED
17128  * - \ref SCIP_STAGE_EXITSOLVE
17129  * - \ref SCIP_STAGE_FREETRANS
17130  */
17131 extern
17133  SCIP* scip, /**< SCIP data structure */
17134  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
17135  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
17136  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
17137  int* filterpos /**< pointer to store position of event filter entry, or NULL */
17138  );
17139 
17140 /** drops a global event (stops to track event)
17141  *
17142  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17143  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17144  *
17145  * @pre This method can be called if @p scip is in one of the following stages:
17146  * - \ref SCIP_STAGE_TRANSFORMING
17147  * - \ref SCIP_STAGE_TRANSFORMED
17148  * - \ref SCIP_STAGE_INITPRESOLVE
17149  * - \ref SCIP_STAGE_PRESOLVING
17150  * - \ref SCIP_STAGE_EXITPRESOLVE
17151  * - \ref SCIP_STAGE_PRESOLVED
17152  * - \ref SCIP_STAGE_INITSOLVE
17153  * - \ref SCIP_STAGE_SOLVING
17154  * - \ref SCIP_STAGE_SOLVED
17155  * - \ref SCIP_STAGE_EXITSOLVE
17156  * - \ref SCIP_STAGE_FREETRANS
17157  */
17158 extern
17160  SCIP* scip, /**< SCIP data structure */
17161  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
17162  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
17163  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
17164  int filterpos /**< position of event filter entry returned by SCIPcatchEvent(), or -1 */
17165  );
17166 
17167 /** catches an objective value or domain change event on the given transformed variable
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 @p scip is in one of the following stages:
17173  * - \ref SCIP_STAGE_TRANSFORMING
17174  * - \ref SCIP_STAGE_TRANSFORMED
17175  * - \ref SCIP_STAGE_INITPRESOLVE
17176  * - \ref SCIP_STAGE_PRESOLVING
17177  * - \ref SCIP_STAGE_EXITPRESOLVE
17178  * - \ref SCIP_STAGE_PRESOLVED
17179  * - \ref SCIP_STAGE_INITSOLVE
17180  * - \ref SCIP_STAGE_SOLVING
17181  * - \ref SCIP_STAGE_SOLVED
17182  * - \ref SCIP_STAGE_EXITSOLVE
17183  * - \ref SCIP_STAGE_FREETRANS
17184  */
17185 extern
17187  SCIP* scip, /**< SCIP data structure */
17188  SCIP_VAR* var, /**< transformed variable to catch event for */
17189  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
17190  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
17191  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
17192  int* filterpos /**< pointer to store position of event filter entry, or NULL */
17193  );
17194 
17195 /** drops an objective value or domain change event (stops to track event) on the given transformed variable
17196  *
17197  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17198  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17199  *
17200  * @pre This method can be called if @p scip is in one of the following stages:
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_VAR* var, /**< transformed variable to drop event for */
17217  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
17218  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
17219  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
17220  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
17221  );
17222 
17223 /** catches a row coefficient, constant, or side change event on the given row
17224  *
17225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17227  *
17228  * @pre This method can be called if @p scip is in one of the following stages:
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_ROW* row, /**< linear row to catch event for */
17245  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
17246  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
17247  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
17248  int* filterpos /**< pointer to store position of event filter entry, or NULL */
17249  );
17250 
17251 /** drops a row coefficient, constant, or side change event (stops to track event) on the given row
17252  *
17253  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17254  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17255  *
17256  * @pre This method can be called if @p scip is in one of the following stages:
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_ROW* row, /**< linear row to drop event for */
17273  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
17274  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
17275  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
17276  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
17277  );
17278 
17279 /**@} */
17280 
17281 
17282 
17283 
17284 /*
17285  * tree methods
17286  */
17287 
17288 /**@name Tree Methods */
17289 /**@{ */
17290 
17291 /** gets current node in the tree
17292  *
17293  * @return the current node of the search tree
17294  *
17295  * @pre This method can be called if @p scip is in one of the following stages:
17296  * - \ref SCIP_STAGE_INITPRESOLVE
17297  * - \ref SCIP_STAGE_PRESOLVING
17298  * - \ref SCIP_STAGE_EXITPRESOLVE
17299  * - \ref SCIP_STAGE_SOLVING
17300  */
17301 extern
17303  SCIP* scip /**< SCIP data structure */
17304  );
17305 
17306 /** gets the root node of the tree
17307  *
17308  * @return the root node of the search tree
17309  *
17310  * @pre This method can be called if @p scip is in one of the following stages:
17311  * - \ref SCIP_STAGE_INITPRESOLVE
17312  * - \ref SCIP_STAGE_PRESOLVING
17313  * - \ref SCIP_STAGE_EXITPRESOLVE
17314  * - \ref SCIP_STAGE_SOLVING
17315  */
17316 extern
17318  SCIP* scip /**< SCIP data structure */
17319  );
17320 
17321 /** gets the effective root depth, i.e., the depth of the deepest node which is part of all paths from the root node
17322  * to the unprocessed nodes.
17323  *
17324  * @return effective root depth
17325  *
17326  * @pre This method can be called if @p scip is in one of the following stages:
17327  * - \ref SCIP_STAGE_SOLVING
17328  */
17329 extern
17331  SCIP* scip /**< SCIP data structure */
17332  );
17333 
17334 /** returns whether the current node is already solved and only propagated again
17335  *
17336  * @return TRUE is returned if \SCIP performance repropagation, otherwise FALSE.
17337  *
17338  * @pre This method can be called if @p scip is in one of the following stages:
17339  * - \ref SCIP_STAGE_INITPRESOLVE
17340  * - \ref SCIP_STAGE_PRESOLVING
17341  * - \ref SCIP_STAGE_EXITPRESOLVE
17342  * - \ref SCIP_STAGE_SOLVING
17343  */
17344 extern
17346  SCIP* scip /**< SCIP data structure */
17347  );
17348 
17349 /** gets children of focus node along with the number of children
17350  *
17351  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17352  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17353  *
17354  * @pre This method can be called if @p scip is in one of the following stages:
17355  * - \ref SCIP_STAGE_SOLVING
17356  */
17357 extern
17359  SCIP* scip, /**< SCIP data structure */
17360  SCIP_NODE*** children, /**< pointer to store children array, or NULL if not needed */
17361  int* nchildren /**< pointer to store number of children, or NULL if not needed */
17362  );
17363 
17364 /** gets number of children of focus node
17365  *
17366  * @return number of children of the focus node
17367  *
17368  * @pre This method can be called if @p scip is in one of the following stages:
17369  * - \ref SCIP_STAGE_SOLVING
17370  */
17371 extern
17372 int SCIPgetNChildren(
17373  SCIP* scip /**< SCIP data structure */
17374  );
17375 
17376 /** gets siblings of focus node along with the number of siblings
17377  *
17378  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17379  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17380  *
17381  * @pre This method can be called if @p scip is in one of the following stages:
17382  * - \ref SCIP_STAGE_SOLVING
17383  */
17384 extern
17386  SCIP* scip, /**< SCIP data structure */
17387  SCIP_NODE*** siblings, /**< pointer to store siblings array, or NULL if not needed */
17388  int* nsiblings /**< pointer to store number of siblings, or NULL if not needed */
17389  );
17390 
17391 /** gets number of siblings of focus node
17392  *
17393  * @return the number of siblings of focus node
17394  *
17395  * @pre This method can be called if @p scip is in one of the following stages:
17396  * - \ref SCIP_STAGE_SOLVING
17397  */
17398 extern
17399 int SCIPgetNSiblings(
17400  SCIP* scip /**< SCIP data structure */
17401  );
17402 
17403 /** gets leaves of the tree along with the number of leaves
17404  *
17405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17407  *
17408  * @pre This method can be called if @p scip is in one of the following stages:
17409  * - \ref SCIP_STAGE_SOLVING
17410  */
17411 extern
17413  SCIP* scip, /**< SCIP data structure */
17414  SCIP_NODE*** leaves, /**< pointer to store leaves array, or NULL if not needed */
17415  int* nleaves /**< pointer to store number of leaves, or NULL if not needed */
17416  );
17417 
17418 /** gets number of leaves in the tree
17419  *
17420  * @return the number of leaves in the tree
17421  *
17422  * @pre This method can be called if @p scip is in one of the following stages:
17423  * - \ref SCIP_STAGE_SOLVING
17424  */
17425 extern
17426 int SCIPgetNLeaves(
17427  SCIP* scip /**< SCIP data structure */
17428  );
17429 
17430 /** gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
17431  *
17432  * @return the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
17433  *
17434  * @pre This method can be called if @p scip is in one of the following stages:
17435  * - \ref SCIP_STAGE_SOLVING
17436  */
17437 extern
17439  SCIP* scip /**< SCIP data structure */
17440  );
17441 
17442 /** gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
17443  *
17444  * @return the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
17445  *
17446  * @pre This method can be called if @p scip is in one of the following stages:
17447  * - \ref SCIP_STAGE_SOLVING
17448  */
17449 extern
17451  SCIP* scip /**< SCIP data structure */
17452  );
17453 
17454 /** gets the best child of the focus node w.r.t. the node selection strategy
17455  *
17456  * @return the best child of the focus node w.r.t. the node selection strategy
17457  *
17458  * @pre This method can be called if @p scip is in one of the following stages:
17459  * - \ref SCIP_STAGE_SOLVING
17460  */
17461 extern
17463  SCIP* scip /**< SCIP data structure */
17464  );
17465 
17466 /** gets the best sibling of the focus node w.r.t. the node selection strategy
17467  *
17468  * @return the best sibling of the focus node w.r.t. the node selection strategy
17469  *
17470  * @pre This method can be called if @p scip is in one of the following stages:
17471  * - \ref SCIP_STAGE_SOLVING
17472  */
17473 extern
17475  SCIP* scip /**< SCIP data structure */
17476  );
17477 
17478 /** gets the best leaf from the node queue w.r.t. the node selection strategy
17479  *
17480  * @return the best leaf from the node queue w.r.t. the node selection strategy
17481  *
17482  * @pre This method can be called if @p scip is in one of the following stages:
17483  * - \ref SCIP_STAGE_SOLVING
17484  */
17485 extern
17487  SCIP* scip /**< SCIP data structure */
17488  );
17489 
17490 /** gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
17491  *
17492  * @return the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
17493  *
17494  * @pre This method can be called if @p scip is in one of the following stages:
17495  * - \ref SCIP_STAGE_SOLVING
17496  */
17497 extern
17499  SCIP* scip /**< SCIP data structure */
17500  );
17501 
17502 /** gets the node with smallest lower bound from the tree (child, sibling, or leaf)
17503  *
17504  * @return the node with smallest lower bound from the tree (child, sibling, or leaf)
17505  *
17506  * @pre This method can be called if @p scip is in one of the following stages:
17507  * - \ref SCIP_STAGE_SOLVING
17508  */
17509 extern
17511  SCIP* scip /**< SCIP data structure */
17512  );
17513 
17514 /** access to all data of open nodes (leaves, children, and siblings)
17515  *
17516  * @pre This method can be called if @p scip is in one of the following stages:
17517  * - \ref SCIP_STAGE_SOLVING
17518  */
17519 extern
17521  SCIP* scip, /**< SCIP data structure */
17522  SCIP_NODE*** leaves, /**< pointer to store the leaves, or NULL if not needed */
17523  SCIP_NODE*** children, /**< pointer to store the children, or NULL if not needed */
17524  SCIP_NODE*** siblings, /**< pointer to store the siblings, or NULL if not needed */
17525  int* nleaves, /**< pointer to store the number of leaves, or NULL */
17526  int* nchildren, /**< pointer to store the number of children, or NULL */
17527  int* nsiblings /**< pointer to store the number of siblings, or NULL */
17528  );
17529 
17530 /** cuts off node and whole sub tree from branch and bound tree
17531  *
17532  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17533  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17534  *
17535  * @pre This method can be called if @p scip is in one of the following stages:
17536  * - \ref SCIP_STAGE_SOLVING
17537  */
17538 extern
17540  SCIP* scip, /**< SCIP data structure */
17541  SCIP_NODE* node /**< node that should be cut off */
17542  );
17543 
17544 /** marks the given node to be propagated again the next time a node of its subtree is processed
17545  *
17546  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17547  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17548  *
17549  * @pre This method can be called if @p scip is in one of the following stages:
17550  * - \ref SCIP_STAGE_SOLVING
17551  */
17552 extern
17554  SCIP* scip, /**< SCIP data structure */
17555  SCIP_NODE* node /**< node that should be propagated again */
17556  );
17557 
17558 /** returns depth of first node in active path that is marked being cutoff
17559  *
17560  * @return depth of first node in active path that is marked being cutoff
17561  *
17562  * @pre This method can be called if @p scip is in one of the following stages:
17563  * - \ref SCIP_STAGE_SOLVING
17564  */
17565 extern
17566 int SCIPgetCutoffdepth(
17567  SCIP* scip /**< SCIP data structure */
17568  );
17569 
17570 /** returns depth of first node in active path that has to be propagated again
17571  *
17572  * @return depth of first node in active path that has to be propagated again
17573  *
17574  * @pre This method can be called if @p scip is in one of the following stages:
17575  * - \ref SCIP_STAGE_SOLVING
17576  */
17577 extern
17578 int SCIPgetRepropdepth(
17579  SCIP* scip /**< SCIP data structure */
17580  );
17581 
17582 /** prints all branching decisions on variables from the root to the given node
17583  *
17584  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17585  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17586  *
17587  * @pre This method can be called if @p scip is in one of the following stages:
17588  * - \ref SCIP_STAGE_SOLVING
17589  */
17590 extern
17592  SCIP* scip, /**< SCIP data structure */
17593  SCIP_NODE* node, /**< node data */
17594  FILE* file /**< output file (or NULL for standard output) */
17595  );
17596 
17597 /** sets whether the LP should be solved at the focus node
17598  *
17599  * @note In order to have an effect, this method needs to be called after a node is focused but before the LP is
17600  * solved.
17601  *
17602  * @pre This method can be called if @p scip is in one of the following stages:
17603  * - \ref SCIP_STAGE_SOLVING
17604  */
17605 extern
17606 void SCIPsetFocusnodeLP(
17607  SCIP* scip, /**< SCIP data structure */
17608  SCIP_Bool solvelp /**< should the LP be solved? */
17609  );
17610 
17611 /**@} */
17612 
17613 
17614 /*
17615  * reoptimization methods
17616  */
17617 
17618 /**@name Reoptimization Methods */
17619 /**@{ */
17620 
17621 /** return the ids of child nodes stored in the reoptimization tree
17622  *
17623  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17624  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17625  *
17626  * @pre This method can be called if @p scip is in one of the following stages:
17627  * - \ref SCIP_STAGE_PRESOLVED
17628  * - \ref SCIP_STAGE_SOLVING
17629  * - \ref SCIP_STAGE_SOLVED
17630  */
17631 extern
17633  SCIP* scip, /**< SCIP data structure */
17634  SCIP_NODE* node, /**< node of the search tree */
17635  unsigned int* ids, /**< array to store the ids of child nodes */
17636  int mem, /**< allocated memory */
17637  int* nids /**< number of child nodes */
17638  );
17639 
17640 /** return the ids of all leave nodes store in the reoptimization tree induced by the given node
17641  *
17642  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17643  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17644  *
17645  * @pre This method can be called if @p scip is in one of the following stages:
17646  * - \ref SCIP_STAGE_PRESOLVED
17647  * - \ref SCIP_STAGE_SOLVING
17648  * - \ref SCIP_STAGE_SOLVED
17649  */
17650 extern
17652  SCIP* scip, /**< SCIP data strcuture */
17653  SCIP_NODE* node, /**< node of the search tree */
17654  unsigned int* ids, /**< array of ids */
17655  int mem, /**< allocated memory */
17656  int* nids /**< number of child nodes */
17657  );
17658 
17659 /** returns the number of nodes in the reoptimization tree induced by @p node; if @p node == NULL, the method
17660  * returns the number of nodes of the whole reoptimization tree.
17661  */
17662 extern
17663 int SCIPgetNReoptnodes(
17664  SCIP* scip, /**< SCIP data structure */
17665  SCIP_NODE* node /**< node of the search tree */
17666  );
17667 
17668 /** returns the number of leave nodes of the subtree induced by @p node; if @p node == NULL, the method
17669  * returns the number of leaf nodes of the whole reoptimization tree.
17670  */
17671 extern
17673  SCIP* scip, /**< SCIP data structure */
17674  SCIP_NODE* node /**< node of the search tree */
17675  );
17676 
17677 /** gets the node of the reoptimization tree corresponding to the unique @p id */
17679  SCIP* scip, /**< SCIP data structure */
17680  unsigned int id /**< unique id */
17681  );
17682 
17683 /** add a variable bound change to a given reoptnode
17684  *
17685  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17686  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17687  *
17688  * @pre This method can be called if @p scip is in one of the following stages:
17689  * - \ref SCIP_STAGE_PRESOLVED
17690  * - \ref SCIP_STAGE_SOLVING
17691  * - \ref SCIP_STAGE_SOLVED
17692  */
17693 extern
17695  SCIP* scip, /**< SCIP data structure */
17696  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
17697  SCIP_VAR* var, /**< variable pointer */
17698  SCIP_Real val, /**< value of the variable */
17699  SCIP_BOUNDTYPE boundtype /**< bound type of the variable value */
17700  );
17701 
17702 /** set the @p representation as the new search frontier
17703  *
17704  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17705  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17706  *
17707  * @pre This method can be called if @p scip is in one of the following stages:
17708  * - \ref SCIP_STAGE_PRESOLVED
17709  */
17710 extern
17712  SCIP* scip, /**< SCIP data structure */
17713  SCIP_REOPTNODE** representation, /**< array of representatives */
17714  int nrepresentatives, /**< number of representatives */
17715  SCIP_Bool* success /**< pointer to store the result */
17716  );
17717 
17718 /** add stored constraint to a reoptimization node
17719  *
17720  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17721  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17722  *
17723  * @pre This method can be called if @p scip is in one of the following stages:
17724  * - \ref SCIP_STAGE_PRESOLVED
17725  */
17726 extern
17728  SCIP* scip, /**< SCIP data structure */
17729  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
17730  SCIP_VAR** vars, /**< array of variables */
17731  SCIP_Real* vals, /**< array of variable bounds */
17732  int nvars, /**< number of variables */
17733  REOPT_CONSTYPE constype /**< type of the constraint */
17734  );
17735 
17736 /** return the branching path stored in the reoptree at ID id */
17737 extern
17739  SCIP* scip, /**< SCIP data structure */
17740  SCIP_REOPTNODE* reoptnode, /**< node of the reoptimization tree */
17741  SCIP_VAR** vars, /**< array of variables */
17742  SCIP_Real* vals, /**< array of variable bounds */
17743  SCIP_BOUNDTYPE* boundtypes, /**< array of bound types */
17744  int mem, /**< allocated memory */
17745  int* nvars, /**< number of variables */
17746  int* nafterdualvars /**< number of variables directly after the first based on dual information */
17747  );
17748 
17749 /** initialize a set of empty reoptimization nodes
17750  *
17751  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17752  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17753  *
17754  * @pre This method can be called if @p scip is in one of the following stages:
17755  * - \ref SCIP_STAGE_PRESOLVED
17756  */
17757 extern
17759  SCIP* scip, /**< SCIP data structure */
17760  SCIP_REOPTNODE** representatives, /**< array of representatives */
17761  int nrepresentatives /**< number of representatives */
17762  );
17763 
17764 /** reset a set of initialized reoptimization nodes
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 @p scip is in one of the following stages:
17770  * - \ref SCIP_STAGE_PRESOLVED
17771  */
17773  SCIP* scip, /**< SCIP data structure */
17774  SCIP_REOPTNODE** representatives, /**< array of representatives */
17775  int nrepresentatives /**< number of representatives */
17776  );
17777 
17778 /** free a set of initialized reoptimization nodes
17779  *
17780  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17781  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17782  *
17783  * @pre This method can be called if @p scip is in one of the following stages:
17784  * - \ref SCIP_STAGE_PRESOLVED
17785  */
17786 extern
17788  SCIP* scip, /**< SCIP data structure */
17789  SCIP_REOPTNODE** representatives, /**< array of representatives */
17790  int nrepresentatives /**< number of representatives */
17791  );
17792 
17793 /** reactivate the given @p reoptnode and split them into several nodes if necessary
17794  *
17795  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17796  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17797  *
17798  * @pre This method can be called if @p scip is in one of the following stages:
17799  * - \ref SCIP_STAGE_SOLVING
17800  * - \ref SCIP_STAGE_SOLVED
17801  */
17802 extern
17804  SCIP* scip, /**< SCIP data structure */
17805  SCIP_REOPTNODE* reoptnode, /**< node to reactivate */
17806  unsigned int id, /**< unique id of the reoptimization node */
17807  SCIP_Real estimate, /**< estimate of the child nodes that should be created */
17808  SCIP_NODE** childnodes, /**< array to store the created child nodes */
17809  int* ncreatedchilds, /**< pointer to store number of created child nodes */
17810  int* naddedconss, /**< pointer to store number of generated constraints */
17811  int childnodessize, /**< available size of childnodes array */
17812  SCIP_Bool* success /**< pointer store the result*/
17813  );
17814 
17815 /** remove the stored information about bound changes based in dual information
17816  *
17817  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17818  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17819  *
17820  * @pre This method can be called if @p scip is in one of the following stages:
17821  * - \ref SCIP_STAGE_SOLVING
17822  * - \ref SCIP_STAGE_SOLVED
17823  */
17824 extern
17826  SCIP* scip, /**< SCIP data structure */
17827  SCIP_NODE* node /**< node of the search tree */
17828  );
17829 
17830 /** splits the root into several nodes and moves the child nodes of the root to one of the created nodes
17831  *
17832  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17833  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17834  *
17835  * @pre This method can be called if @p scip is in one of the following stages:
17836  * - \ref SCIP_STAGE_TRANSFORMED
17837  * - \ref SCIP_STAGE_SOLVING
17838  */
17839 extern
17841  SCIP* scip, /**< SCIP data structure */
17842  int* ncreatedchilds, /**< pointer to store the number of created nodes */
17843  int* naddedconss /**< pointer to store the number added constraints */
17844  );
17845 
17846 /** returns if a node should be reoptimized */
17847 extern
17849  SCIP* scip, /**< SCIP data structure */
17850  SCIP_NODE* node /**< node of the search tree */
17851  );
17852 
17853 /** deletes the given reoptimization node
17854  *
17855  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17856  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17857  *
17858  * @pre This method can be called if @p scip is in one of the following stages:
17859  * - \ref SCIP_STAGE_SOLVING
17860  */
17861 extern
17863  SCIP* scip, /**< SCIP data structure */
17864  SCIP_REOPTNODE** reoptnode /**< node of the reoptimization tree */
17865  );
17866 
17867 /** return the similarity between two objective functions */
17868 extern
17870  SCIP* scip, /**< SCIP data structure */
17871  int run1, /**< number of run */
17872  int run2 /**< number of run */
17873  );
17874 
17875 /** check the changes of teh variable coefficient in the objective function */
17876 extern
17877 void SCIPgetVarCoefChg(
17878  SCIP* scip, /**< SCIP data structure */
17879  int varidx, /**< index of variable */
17880  SCIP_Bool* negated, /**< coefficient changed the sign */
17881  SCIP_Bool* entering, /**< coefficient gets non-zero coefficient */
17882  SCIP_Bool* leaving /**< coefficient gets zero coefficient */
17883  );
17884 
17885 /*
17886  * statistic methods
17887  */
17888 
17889 /**@name Statistic Methods */
17890 /**@{ */
17891 
17892 /** gets number of branch and bound runs performed, including the current run
17893  *
17894  * @return the number of branch and bound runs performed, including the current run
17895  *
17896  * @pre This method can be called if SCIP is in one of the following stages:
17897  * - \ref SCIP_STAGE_PROBLEM
17898  * - \ref SCIP_STAGE_TRANSFORMING
17899  * - \ref SCIP_STAGE_TRANSFORMED
17900  * - \ref SCIP_STAGE_INITPRESOLVE
17901  * - \ref SCIP_STAGE_PRESOLVING
17902  * - \ref SCIP_STAGE_EXITPRESOLVE
17903  * - \ref SCIP_STAGE_PRESOLVED
17904  * - \ref SCIP_STAGE_INITSOLVE
17905  * - \ref SCIP_STAGE_SOLVING
17906  * - \ref SCIP_STAGE_SOLVED
17907  * - \ref SCIP_STAGE_EXITSOLVE
17908  * - \ref SCIP_STAGE_FREETRANS
17909  */
17910 extern
17911 int SCIPgetNRuns(
17912  SCIP* scip /**< SCIP data structure */
17913  );
17914 
17915 /** gets number of reoptimization runs performed, including the current run
17916  *
17917  * @return the number of reoptimization runs performed, including the current run
17918  *
17919  * @pre This method can be called if SCIP is in one of the following stages:
17920  * - \ref SCIP_STAGE_PROBLEM
17921  * - \ref SCIP_STAGE_TRANSFORMING
17922  * - \ref SCIP_STAGE_TRANSFORMED
17923  * - \ref SCIP_STAGE_INITPRESOLVE
17924  * - \ref SCIP_STAGE_PRESOLVING
17925  * - \ref SCIP_STAGE_EXITPRESOLVE
17926  * - \ref SCIP_STAGE_PRESOLVED
17927  * - \ref SCIP_STAGE_INITSOLVE
17928  * - \ref SCIP_STAGE_SOLVING
17929  * - \ref SCIP_STAGE_SOLVED
17930  * - \ref SCIP_STAGE_EXITSOLVE
17931  * - \ref SCIP_STAGE_FREETRANS
17932  */
17933 extern
17934 int SCIPgetNReoptRuns(
17935  SCIP* scip /**< SCIP data structure */
17936  );
17937 
17938 /** gets number of processed nodes in current run, including the focus node
17939  *
17940  * @return the number of processed nodes in current run, including the focus node
17941  *
17942  * @pre This method can be called if SCIP is in one of the following stages:
17943  * - \ref SCIP_STAGE_PROBLEM
17944  * - \ref SCIP_STAGE_TRANSFORMING
17945  * - \ref SCIP_STAGE_TRANSFORMED
17946  * - \ref SCIP_STAGE_INITPRESOLVE
17947  * - \ref SCIP_STAGE_PRESOLVING
17948  * - \ref SCIP_STAGE_EXITPRESOLVE
17949  * - \ref SCIP_STAGE_PRESOLVED
17950  * - \ref SCIP_STAGE_INITSOLVE
17951  * - \ref SCIP_STAGE_SOLVING
17952  * - \ref SCIP_STAGE_SOLVED
17953  * - \ref SCIP_STAGE_EXITSOLVE
17954  * - \ref SCIP_STAGE_FREETRANS
17955  */
17956 extern
17958  SCIP* scip /**< SCIP data structure */
17959  );
17960 
17961 /** gets total number of processed nodes in all runs, including the focus node
17962  *
17963  * @return the total number of processed nodes in all runs, including the focus node
17964  *
17965  * @pre This method can be called if SCIP is in one of the following stages:
17966  * - \ref SCIP_STAGE_PROBLEM
17967  * - \ref SCIP_STAGE_TRANSFORMING
17968  * - \ref SCIP_STAGE_TRANSFORMED
17969  * - \ref SCIP_STAGE_INITPRESOLVE
17970  * - \ref SCIP_STAGE_PRESOLVING
17971  * - \ref SCIP_STAGE_EXITPRESOLVE
17972  * - \ref SCIP_STAGE_PRESOLVED
17973  * - \ref SCIP_STAGE_INITSOLVE
17974  * - \ref SCIP_STAGE_SOLVING
17975  * - \ref SCIP_STAGE_SOLVED
17976  * - \ref SCIP_STAGE_EXITSOLVE
17977  * - \ref SCIP_STAGE_FREETRANS
17978  */
17979 extern
17981  SCIP* scip /**< SCIP data structure */
17982  );
17983 
17984 /** gets number of nodes left in the tree (children + siblings + leaves)
17985  *
17986  * @return the number of nodes left in the tree (children + siblings + leaves)
17987  *
17988  * @pre This method can be called if SCIP is in one of the following stages:
17989  * - \ref SCIP_STAGE_PRESOLVED
17990  * - \ref SCIP_STAGE_SOLVING
17991  * - \ref SCIP_STAGE_SOLVED
17992  */
17993 extern
17994 int SCIPgetNNodesLeft(
17995  SCIP* scip /**< SCIP data structure */
17996  );
17997 
17998 /** gets total number of LPs solved so far
17999  *
18000  * @return the total number of LPs solved so far
18001  *
18002  * @pre This method can be called if SCIP is in one of the following stages:
18003  * - \ref SCIP_STAGE_PRESOLVED
18004  * - \ref SCIP_STAGE_SOLVING
18005  * - \ref SCIP_STAGE_SOLVED
18006  */
18007 extern
18009  SCIP* scip /**< SCIP data structure */
18010  );
18011 
18012 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
18013  *
18014  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
18015  *
18016  * @pre This method can be called if SCIP is in one of the following stages:
18017  * - \ref SCIP_STAGE_PRESOLVING
18018  * - \ref SCIP_STAGE_PRESOLVED
18019  * - \ref SCIP_STAGE_SOLVING
18020  * - \ref SCIP_STAGE_SOLVED
18021  */
18022 extern
18024  SCIP* scip /**< SCIP data structure */
18025  );
18026 
18027 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
18028  *
18029  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
18030  *
18031  * @pre This method can be called if SCIP is in one of the following stages:
18032  * - \ref SCIP_STAGE_PRESOLVED
18033  * - \ref SCIP_STAGE_SOLVING
18034  * - \ref SCIP_STAGE_SOLVED
18035  */
18036 extern
18038  SCIP* scip /**< SCIP data structure */
18039  );
18040 
18041 /** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
18042  * node
18043  *
18044  * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
18045  *
18046  * @pre This method can be called if SCIP is in one of the following stages:
18047  * - \ref SCIP_STAGE_PRESOLVED
18048  * - \ref SCIP_STAGE_SOLVING
18049  * - \ref SCIP_STAGE_SOLVED
18050  */
18051 extern
18053  SCIP* scip /**< SCIP data structure */
18054  );
18055 
18056 /** gets total number of primal LPs solved so far
18057  *
18058  * @return the total number of primal LPs solved so far
18059  *
18060  * @pre This method can be called if SCIP is in one of the following stages:
18061  * - \ref SCIP_STAGE_PRESOLVED
18062  * - \ref SCIP_STAGE_SOLVING
18063  * - \ref SCIP_STAGE_SOLVED
18064  */
18065 extern
18067  SCIP* scip /**< SCIP data structure */
18068  );
18069 
18070 /** gets total number of iterations used so far in primal simplex
18071  *
18072  * @return total number of iterations used so far in primal simplex
18073  *
18074  * @pre This method can be called if SCIP is in one of the following stages:
18075  * - \ref SCIP_STAGE_PRESOLVED
18076  * - \ref SCIP_STAGE_SOLVING
18077  * - \ref SCIP_STAGE_SOLVED
18078  */
18079 extern
18081  SCIP* scip /**< SCIP data structure */
18082  );
18083 
18084 /** gets total number of dual LPs solved so far
18085  *
18086  * @return the total number of dual LPs solved so far
18087  *
18088  * @pre This method can be called if SCIP is in one of the following stages:
18089  * - \ref SCIP_STAGE_PRESOLVED
18090  * - \ref SCIP_STAGE_SOLVING
18091  * - \ref SCIP_STAGE_SOLVED
18092  */
18093 extern
18095  SCIP* scip /**< SCIP data structure */
18096  );
18097 
18098 /** gets total number of iterations used so far in dual simplex
18099  *
18100  * @return the total number of iterations used so far in dual simplex
18101  *
18102  * @pre This method can be called if SCIP is in one of the following stages:
18103  * - \ref SCIP_STAGE_PRESOLVED
18104  * - \ref SCIP_STAGE_SOLVING
18105  * - \ref SCIP_STAGE_SOLVED
18106  */
18107 extern
18109  SCIP* scip /**< SCIP data structure */
18110  );
18111 
18112 /** gets total number of barrier LPs solved so far
18113  *
18114  * @return the total number of barrier LPs solved so far
18115  *
18116  * @pre This method can be called if SCIP is in one of the following stages:
18117  * - \ref SCIP_STAGE_PRESOLVED
18118  * - \ref SCIP_STAGE_SOLVING
18119  * - \ref SCIP_STAGE_SOLVED
18120  */
18121 extern
18123  SCIP* scip /**< SCIP data structure */
18124  );
18125 
18126 /** gets total number of iterations used so far in barrier algorithm
18127  *
18128  * @return the total number of iterations used so far in barrier algorithm
18129  *
18130  * @pre This method can be called if SCIP is in one of the following stages:
18131  * - \ref SCIP_STAGE_PRESOLVED
18132  * - \ref SCIP_STAGE_SOLVING
18133  * - \ref SCIP_STAGE_SOLVED
18134  */
18135 extern
18137  SCIP* scip /**< SCIP data structure */
18138  );
18139 
18140 /** gets total number of LPs solved so far that were resolved from an advanced start basis
18141  *
18142  * @return the total number of LPs solved so far that were resolved from an advanced start basis
18143  *
18144  * @pre This method can be called if SCIP is in one of the following stages:
18145  * - \ref SCIP_STAGE_PRESOLVED
18146  * - \ref SCIP_STAGE_SOLVING
18147  * - \ref SCIP_STAGE_SOLVED
18148  */
18149 extern
18151  SCIP* scip /**< SCIP data structure */
18152  );
18153 
18154 /** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
18155  * was available
18156  *
18157  * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
18158  * basis was available
18159  *
18160  * @pre This method can be called if SCIP is in one of the following stages:
18161  * - \ref SCIP_STAGE_PRESOLVED
18162  * - \ref SCIP_STAGE_SOLVING
18163  * - \ref SCIP_STAGE_SOLVED
18164  */
18165 extern
18167  SCIP* scip /**< SCIP data structure */
18168  );
18169 
18170 /** gets total number of primal LPs solved so far that were resolved from an advanced start basis
18171  *
18172  * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
18173  *
18174  * @pre This method can be called if SCIP is in one of the following stages:
18175  * - \ref SCIP_STAGE_PRESOLVED
18176  * - \ref SCIP_STAGE_SOLVING
18177  * - \ref SCIP_STAGE_SOLVED
18178  */
18179 extern
18181  SCIP* scip /**< SCIP data structure */
18182  );
18183 
18184 /** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
18185  * was available
18186  *
18187  * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
18188  * basis was available
18189  *
18190  * @pre This method can be called if SCIP is in one of the following stages:
18191  * - \ref SCIP_STAGE_PRESOLVED
18192  * - \ref SCIP_STAGE_SOLVING
18193  * - \ref SCIP_STAGE_SOLVED
18194  */
18195 extern
18197  SCIP* scip /**< SCIP data structure */
18198  );
18199 
18200 /** gets total number of dual LPs solved so far that were resolved from an advanced start basis
18201  *
18202  * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
18203  *
18204  * @pre This method can be called if SCIP is in one of the following stages:
18205  * - \ref SCIP_STAGE_PRESOLVED
18206  * - \ref SCIP_STAGE_SOLVING
18207  * - \ref SCIP_STAGE_SOLVED
18208  */
18209 extern
18211  SCIP* scip /**< SCIP data structure */
18212  );
18213 
18214 /** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
18215  * was available
18216  *
18217  * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
18218  * basis was available
18219  *
18220  * @pre This method can be called if SCIP is in one of the following stages:
18221  * - \ref SCIP_STAGE_PRESOLVED
18222  * - \ref SCIP_STAGE_SOLVING
18223  * - \ref SCIP_STAGE_SOLVED
18224  */
18225 extern
18227  SCIP* scip /**< SCIP data structure */
18228  );
18229 
18230 /** gets total number of LPs solved so far for node relaxations
18231  *
18232  * @return the total number of LPs solved so far for node relaxations
18233  *
18234  * @pre This method can be called if SCIP is in one of the following stages:
18235  * - \ref SCIP_STAGE_PRESOLVED
18236  * - \ref SCIP_STAGE_SOLVING
18237  * - \ref SCIP_STAGE_SOLVED
18238  */
18239 extern
18241  SCIP* scip /**< SCIP data structure */
18242  );
18243 
18244 /** gets total number of simplex iterations used so far for node relaxations
18245  *
18246  * @return the total number of simplex iterations used so far for node relaxations
18247  *
18248  * @pre This method can be called if SCIP is in one of the following stages:
18249  * - \ref SCIP_STAGE_PRESOLVED
18250  * - \ref SCIP_STAGE_SOLVING
18251  * - \ref SCIP_STAGE_SOLVED
18252  */
18253 extern
18255  SCIP* scip /**< SCIP data structure */
18256  );
18257 
18258 /** gets total number of LPs solved so far for initial LP in node relaxations
18259  *
18260  * @return the total number of LPs solved so far for initial LP in node relaxations
18261  *
18262  * @pre This method can be called if SCIP is in one of the following stages:
18263  * - \ref SCIP_STAGE_PRESOLVED
18264  * - \ref SCIP_STAGE_SOLVING
18265  * - \ref SCIP_STAGE_SOLVED
18266  */
18267 extern
18269  SCIP* scip /**< SCIP data structure */
18270  );
18271 
18272 /** gets total number of simplex iterations used so far for initial LP in node relaxations
18273  *
18274  * @return the total number of simplex iterations used so far for initial LP in node relaxations
18275  *
18276  * @pre This method can be called if SCIP is in one of the following stages:
18277  * - \ref SCIP_STAGE_PRESOLVED
18278  * - \ref SCIP_STAGE_SOLVING
18279  * - \ref SCIP_STAGE_SOLVED
18280  */
18281 extern
18283  SCIP* scip /**< SCIP data structure */
18284  );
18285 
18286 /** gets total number of LPs solved so far during diving and probing
18287  *
18288  * @return total number of LPs solved so far during diving and probing
18289  *
18290  * @pre This method can be called if SCIP is in one of the following stages:
18291  * - \ref SCIP_STAGE_PRESOLVED
18292  * - \ref SCIP_STAGE_SOLVING
18293  * - \ref SCIP_STAGE_SOLVED
18294  */
18295 extern
18297  SCIP* scip /**< SCIP data structure */
18298  );
18299 
18300 /** gets total number of simplex iterations used so far during diving and probing
18301  *
18302  * @return the total number of simplex iterations used so far during diving and probing
18303  *
18304  * @pre This method can be called if SCIP is in one of the following stages:
18305  * - \ref SCIP_STAGE_PRESOLVED
18306  * - \ref SCIP_STAGE_SOLVING
18307  * - \ref SCIP_STAGE_SOLVED
18308  */
18309 extern
18311  SCIP* scip /**< SCIP data structure */
18312  );
18313 
18314 /** gets total number of times, strong branching was called (each call represents solving two LPs)
18315  *
18316  * @return the total number of times, strong branching was called (each call represents solving two LPs)
18317  *
18318  * @pre This method can be called if SCIP is in one of the following stages:
18319  * - \ref SCIP_STAGE_PRESOLVED
18320  * - \ref SCIP_STAGE_SOLVING
18321  * - \ref SCIP_STAGE_SOLVED
18322  */
18323 extern
18325  SCIP* scip /**< SCIP data structure */
18326  );
18327 
18328 /** gets total number of simplex iterations used so far in strong branching
18329  *
18330  * @return the total number of simplex iterations used so far in strong branching
18331  *
18332  * @pre This method can be called if SCIP is in one of the following stages:
18333  * - \ref SCIP_STAGE_PRESOLVED
18334  * - \ref SCIP_STAGE_SOLVING
18335  * - \ref SCIP_STAGE_SOLVED
18336  */
18337 extern
18339  SCIP* scip /**< SCIP data structure */
18340  );
18341 
18342 /** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
18343  *
18344  * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
18345  *
18346  * @pre This method can be called if SCIP is in one of the following stages:
18347  * - \ref SCIP_STAGE_PRESOLVED
18348  * - \ref SCIP_STAGE_SOLVING
18349  * - \ref SCIP_STAGE_SOLVED
18350  */
18351 extern
18353  SCIP* scip /**< SCIP data structure */
18354  );
18355 
18356 /** gets total number of simplex iterations used so far in strong branching at the root node
18357  *
18358  * @return the total number of simplex iterations used so far in strong branching at the root node
18359  *
18360  * @pre This method can be called if SCIP is in one of the following stages:
18361  * - \ref SCIP_STAGE_PRESOLVED
18362  * - \ref SCIP_STAGE_SOLVING
18363  * - \ref SCIP_STAGE_SOLVED
18364  */
18365 extern
18367  SCIP* scip /**< SCIP data structure */
18368  );
18369 
18370 /** gets number of pricing rounds performed so far at the current node
18371  *
18372  * @return the number of pricing rounds performed so far at the current node
18373  *
18374  * @pre This method can be called if SCIP is in one of the following stages:
18375  * - \ref SCIP_STAGE_SOLVING
18376  */
18377 extern
18379  SCIP* scip /**< SCIP data structure */
18380  );
18381 
18382 /** get current number of variables in the pricing store
18383  *
18384  * @return the current number of variables in the pricing store
18385  *
18386  * @pre This method can be called if SCIP is in one of the following stages:
18387  * - \ref SCIP_STAGE_PRESOLVED
18388  * - \ref SCIP_STAGE_SOLVING
18389  * - \ref SCIP_STAGE_SOLVED
18390  */
18391 extern
18392 int SCIPgetNPricevars(
18393  SCIP* scip /**< SCIP data structure */
18394  );
18395 
18396 /** get total number of pricing variables found so far
18397  *
18398  * @return the total number of pricing variables found so far
18399  *
18400  * @pre This method can be called if SCIP is in one of the following stages:
18401  * - \ref SCIP_STAGE_PRESOLVED
18402  * - \ref SCIP_STAGE_SOLVING
18403  * - \ref SCIP_STAGE_SOLVED
18404  */
18405 extern
18407  SCIP* scip /**< SCIP data structure */
18408  );
18409 
18410 /** get total number of pricing variables applied to the LPs
18411  *
18412  * @return the total number of pricing variables applied to the LPs
18413  *
18414  * @pre This method can be called if SCIP is in one of the following stages:
18415  * - \ref SCIP_STAGE_PRESOLVED
18416  * - \ref SCIP_STAGE_SOLVING
18417  * - \ref SCIP_STAGE_SOLVED
18418  */
18419 extern
18421  SCIP* scip /**< SCIP data structure */
18422  );
18423 
18424 /** gets number of separation rounds performed so far at the current node
18425  *
18426  * @return the number of separation rounds performed so far at the current node
18427  *
18428  * @pre This method can be called if SCIP is in one of the following stages:
18429  * - \ref SCIP_STAGE_SOLVING
18430  */
18431 extern
18432 int SCIPgetNSepaRounds(
18433  SCIP* scip /**< SCIP data structure */
18434  );
18435 
18436 /** get total number of cuts found so far
18437  *
18438  * @return the total number of cuts found so far
18439  *
18440  * @pre This method can be called if SCIP is in one of the following stages:
18441  * - \ref SCIP_STAGE_PRESOLVED
18442  * - \ref SCIP_STAGE_SOLVING
18443  * - \ref SCIP_STAGE_SOLVED
18444  */
18445 extern
18446 int SCIPgetNCutsFound(
18447  SCIP* scip /**< SCIP data structure */
18448  );
18449 
18450 /** get number of cuts found so far in current separation round
18451  *
18452  * @return the number of cuts found so far in current separation round
18453  *
18454  * @pre This method can be called if SCIP is in one of the following stages:
18455  * - \ref SCIP_STAGE_PRESOLVED
18456  * - \ref SCIP_STAGE_SOLVING
18457  * - \ref SCIP_STAGE_SOLVED
18458  */
18459 extern
18461  SCIP* scip /**< SCIP data structure */
18462  );
18463 
18464 /** get total number of cuts applied to the LPs
18465  *
18466  * @return the total number of cuts applied to the LPs
18467  *
18468  * @pre This method can be called if SCIP is in one of the following stages:
18469  * - \ref SCIP_STAGE_PRESOLVED
18470  * - \ref SCIP_STAGE_SOLVING
18471  * - \ref SCIP_STAGE_SOLVED
18472  */
18473 extern
18475  SCIP* scip /**< SCIP data structure */
18476  );
18477 
18478 /** get total number of constraints found in conflict analysis (conflict and reconvergence constraints)
18479  *
18480  * @return the total number of constraints found in conflict analysis (conflict and reconvergence constraints)
18481  *
18482  * @pre This method can be called if SCIP is in one of the following stages:
18483  * - \ref SCIP_STAGE_TRANSFORMED
18484  * - \ref SCIP_STAGE_INITPRESOLVE
18485  * - \ref SCIP_STAGE_PRESOLVING
18486  * - \ref SCIP_STAGE_EXITPRESOLVE
18487  * - \ref SCIP_STAGE_PRESOLVED
18488  * - \ref SCIP_STAGE_INITSOLVE
18489  * - \ref SCIP_STAGE_SOLVING
18490  * - \ref SCIP_STAGE_SOLVED
18491  * - \ref SCIP_STAGE_EXITSOLVE
18492  */
18493 extern
18495  SCIP* scip /**< SCIP data structure */
18496  );
18497 
18498 /** get number of conflict constraints found so far at the current node
18499  *
18500  * @return the number of conflict constraints found so far at the current node
18501  *
18502  * @pre This method can be called if SCIP is in one of the following stages:
18503  * - \ref SCIP_STAGE_TRANSFORMED
18504  * - \ref SCIP_STAGE_INITPRESOLVE
18505  * - \ref SCIP_STAGE_PRESOLVING
18506  * - \ref SCIP_STAGE_EXITPRESOLVE
18507  * - \ref SCIP_STAGE_PRESOLVED
18508  * - \ref SCIP_STAGE_INITSOLVE
18509  * - \ref SCIP_STAGE_SOLVING
18510  * - \ref SCIP_STAGE_SOLVED
18511  * - \ref SCIP_STAGE_EXITSOLVE
18512  */
18513 extern
18515  SCIP* scip /**< SCIP data structure */
18516  );
18517 
18518 /** get total number of conflict constraints added to the problem
18519  *
18520  * @return the total number of conflict constraints added to the problem
18521  *
18522  * @pre This method can be called if SCIP is in one of the following stages:
18523  * - \ref SCIP_STAGE_TRANSFORMED
18524  * - \ref SCIP_STAGE_INITPRESOLVE
18525  * - \ref SCIP_STAGE_PRESOLVING
18526  * - \ref SCIP_STAGE_EXITPRESOLVE
18527  * - \ref SCIP_STAGE_PRESOLVED
18528  * - \ref SCIP_STAGE_INITSOLVE
18529  * - \ref SCIP_STAGE_SOLVING
18530  * - \ref SCIP_STAGE_SOLVED
18531  * - \ref SCIP_STAGE_EXITSOLVE
18532  */
18533 extern
18535  SCIP* scip /**< SCIP data structure */
18536  );
18537 
18538 /** gets depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
18539  * such that the depth includes the probing path
18540  *
18541  * @return the depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
18542  * such that the depth includes the probing path
18543  *
18544  * @pre This method can be called if SCIP is in one of the following stages:
18545  * - \ref SCIP_STAGE_TRANSFORMED
18546  * - \ref SCIP_STAGE_INITPRESOLVE
18547  * - \ref SCIP_STAGE_PRESOLVING
18548  * - \ref SCIP_STAGE_EXITPRESOLVE
18549  * - \ref SCIP_STAGE_PRESOLVED
18550  * - \ref SCIP_STAGE_INITSOLVE
18551  * - \ref SCIP_STAGE_SOLVING
18552  * - \ref SCIP_STAGE_SOLVED
18553  * - \ref SCIP_STAGE_EXITSOLVE
18554  */
18555 extern
18556 int SCIPgetDepth(
18557  SCIP* scip /**< SCIP data structure */
18558  );
18559 
18560 /** gets depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
18561  * branching tree, excluding the nodes of the probing path
18562  *
18563  * @return the depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
18564  * branching tree, excluding the nodes of the probing path
18565  *
18566  * @pre This method can be called if SCIP is in one of the following stages:
18567  * - \ref SCIP_STAGE_TRANSFORMED
18568  * - \ref SCIP_STAGE_INITPRESOLVE
18569  * - \ref SCIP_STAGE_PRESOLVING
18570  * - \ref SCIP_STAGE_EXITPRESOLVE
18571  * - \ref SCIP_STAGE_PRESOLVED
18572  * - \ref SCIP_STAGE_INITSOLVE
18573  * - \ref SCIP_STAGE_SOLVING
18574  * - \ref SCIP_STAGE_SOLVED
18575  * - \ref SCIP_STAGE_EXITSOLVE
18576  */
18577 extern
18578 int SCIPgetFocusDepth(
18579  SCIP* scip /**< SCIP data structure */
18580  );
18581 
18582 /** gets maximal allowed tree depth
18583  *
18584  * @return gets maximal allowed tree depth
18585  *
18586  * @pre This method can be called if SCIP is in one of the following stages:
18587  * - \ref SCIP_STAGE_TRANSFORMED
18588  * - \ref SCIP_STAGE_INITPRESOLVE
18589  * - \ref SCIP_STAGE_PRESOLVING
18590  * - \ref SCIP_STAGE_EXITPRESOLVE
18591  * - \ref SCIP_STAGE_PRESOLVED
18592  * - \ref SCIP_STAGE_INITSOLVE
18593  * - \ref SCIP_STAGE_SOLVING
18594  * - \ref SCIP_STAGE_SOLVED
18595  * - \ref SCIP_STAGE_EXITSOLVE
18596  */
18597 extern
18598 int SCIPgetDepthLimit(
18599  SCIP* scip /**< SCIP data structure */
18600  );
18601 
18602 /** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
18603  *
18604  * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
18605  *
18606  * @pre This method can be called if SCIP is in one of the following stages:
18607  * - \ref SCIP_STAGE_TRANSFORMED
18608  * - \ref SCIP_STAGE_INITPRESOLVE
18609  * - \ref SCIP_STAGE_PRESOLVING
18610  * - \ref SCIP_STAGE_EXITPRESOLVE
18611  * - \ref SCIP_STAGE_PRESOLVED
18612  * - \ref SCIP_STAGE_INITSOLVE
18613  * - \ref SCIP_STAGE_SOLVING
18614  * - \ref SCIP_STAGE_SOLVED
18615  * - \ref SCIP_STAGE_EXITSOLVE
18616  */
18617 extern
18618 int SCIPgetMaxDepth(
18619  SCIP* scip /**< SCIP data structure */
18620  );
18621 
18622 /** gets maximal depth of all processed nodes over all branch and bound runs
18623  *
18624  * @return the maximal depth of all processed nodes over all branch and bound runs
18625  *
18626  * @pre This method can be called if SCIP is in one of the following stages:
18627  * - \ref SCIP_STAGE_TRANSFORMED
18628  * - \ref SCIP_STAGE_INITPRESOLVE
18629  * - \ref SCIP_STAGE_PRESOLVING
18630  * - \ref SCIP_STAGE_EXITPRESOLVE
18631  * - \ref SCIP_STAGE_PRESOLVED
18632  * - \ref SCIP_STAGE_INITSOLVE
18633  * - \ref SCIP_STAGE_SOLVING
18634  * - \ref SCIP_STAGE_SOLVED
18635  * - \ref SCIP_STAGE_EXITSOLVE
18636  */
18637 extern
18639  SCIP* scip /**< SCIP data structure */
18640  );
18641 
18642 /** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
18643  *
18644  * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
18645  *
18646  * @pre This method can be called if SCIP is in one of the following stages:
18647  * - \ref SCIP_STAGE_TRANSFORMED
18648  * - \ref SCIP_STAGE_INITPRESOLVE
18649  * - \ref SCIP_STAGE_PRESOLVING
18650  * - \ref SCIP_STAGE_EXITPRESOLVE
18651  * - \ref SCIP_STAGE_PRESOLVED
18652  * - \ref SCIP_STAGE_INITSOLVE
18653  * - \ref SCIP_STAGE_SOLVING
18654  * - \ref SCIP_STAGE_SOLVED
18655  * - \ref SCIP_STAGE_EXITSOLVE
18656  */
18657 extern
18659  SCIP* scip /**< SCIP data structure */
18660  );
18661 
18662 /** gets current plunging depth (successive times, a child was selected as next node)
18663  *
18664  * @return the current plunging depth (successive times, a child was selected as next node)
18665  *
18666  * @pre This method can be called if SCIP is in one of the following stages:
18667  * - \ref SCIP_STAGE_PRESOLVED
18668  * - \ref SCIP_STAGE_SOLVING
18669  */
18670 extern
18671 int SCIPgetPlungeDepth(
18672  SCIP* scip /**< SCIP data structure */
18673  );
18674 
18675 /** gets total number of active constraints at the current node
18676  *
18677  * @return the total number of active constraints at the current node
18678  *
18679  * @pre This method can be called if SCIP is in one of the following stages:
18680  * - \ref SCIP_STAGE_PRESOLVED
18681  * - \ref SCIP_STAGE_SOLVING
18682  */
18683 extern
18685  SCIP* scip /**< SCIP data structure */
18686  );
18687 
18688 /** gets total number of enabled constraints at the current node
18689  *
18690  * @return the total number of enabled constraints at the current node
18691  *
18692  * @pre This method can be called if SCIP is in one of the following stages:
18693  * - \ref SCIP_STAGE_PRESOLVED
18694  * - \ref SCIP_STAGE_SOLVING
18695  */
18696 extern
18698  SCIP* scip /**< SCIP data structure */
18699  );
18700 
18701 /** gets average dual bound of all unprocessed nodes for original problem */
18702 extern
18704  SCIP* scip /**< SCIP data structure */
18705  );
18706 
18707 /** gets average lower (dual) bound of all unprocessed nodes in transformed problem
18708  *
18709  * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
18710  *
18711  * @pre This method can be called if SCIP is in one of the following stages:
18712  * - \ref SCIP_STAGE_PRESOLVED
18713  * - \ref SCIP_STAGE_SOLVING
18714  * - \ref SCIP_STAGE_SOLVED
18715  */
18716 extern
18718  SCIP* scip /**< SCIP data structure */
18719  );
18720 
18721 /** gets global dual bound
18722  *
18723  * @return the global dual bound
18724  *
18725  * @pre This method can be called if SCIP is in one of the following stages:
18726  * - \ref SCIP_STAGE_PRESOLVING
18727  * - \ref SCIP_STAGE_EXITPRESOLVE
18728  * - \ref SCIP_STAGE_PRESOLVED
18729  * - \ref SCIP_STAGE_INITSOLVE
18730  * - \ref SCIP_STAGE_SOLVING
18731  * - \ref SCIP_STAGE_SOLVED
18732  */
18733 extern
18735  SCIP* scip /**< SCIP data structure */
18736  );
18737 
18738 /** gets global lower (dual) bound in transformed problem
18739  *
18740  * @return the global lower (dual) bound in transformed problem
18741  *
18742  * @pre This method can be called if SCIP is in one of the following stages:
18743  * - \ref SCIP_STAGE_PRESOLVING
18744  * - \ref SCIP_STAGE_EXITPRESOLVE
18745  * - \ref SCIP_STAGE_PRESOLVED
18746  * - \ref SCIP_STAGE_INITSOLVE
18747  * - \ref SCIP_STAGE_SOLVING
18748  * - \ref SCIP_STAGE_SOLVED
18749  */
18750 extern
18752  SCIP* scip /**< SCIP data structure */
18753  );
18754 
18755 /** gets dual bound of the root node for the original problem
18756  *
18757  * @return the dual bound of the root node for the original problem
18758  *
18759  * @pre This method can be called if SCIP is in one of the following stages:
18760  * - \ref SCIP_STAGE_PRESOLVING
18761  * - \ref SCIP_STAGE_EXITPRESOLVE
18762  * - \ref SCIP_STAGE_PRESOLVED
18763  * - \ref SCIP_STAGE_INITSOLVE
18764  * - \ref SCIP_STAGE_SOLVING
18765  * - \ref SCIP_STAGE_SOLVED
18766  */
18767 extern
18769  SCIP* scip /**< SCIP data structure */
18770  );
18771 
18772 /** gets lower (dual) bound in transformed problem of the root node
18773  *
18774  * @return the lower (dual) bound in transformed problem of the root node
18775  *
18776  * @pre This method can be called if SCIP is in one of the following stages:
18777  * - \ref SCIP_STAGE_PRESOLVING
18778  * - \ref SCIP_STAGE_EXITPRESOLVE
18779  * - \ref SCIP_STAGE_PRESOLVED
18780  * - \ref SCIP_STAGE_INITSOLVE
18781  * - \ref SCIP_STAGE_SOLVING
18782  * - \ref SCIP_STAGE_SOLVED
18783  */
18784 extern
18786  SCIP* scip /**< SCIP data structure */
18787  );
18788 
18789 /** gets dual bound for the original problem obtained by the first LP solve at the root node
18790  *
18791  * @return the dual bound for the original problem of the first LP solve at the root node
18792  *
18793  * @pre This method can be called if SCIP is in one of the following stages:
18794  * - \ref SCIP_STAGE_PRESOLVING
18795  * - \ref SCIP_STAGE_EXITPRESOLVE
18796  * - \ref SCIP_STAGE_PRESOLVED
18797  * - \ref SCIP_STAGE_INITSOLVE
18798  * - \ref SCIP_STAGE_SOLVING
18799  * - \ref SCIP_STAGE_SOLVED
18800  */
18801 extern
18803  SCIP* scip /**< SCIP data structure */
18804  );
18805 
18806 /** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
18807  *
18808  * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
18809  *
18810  * @pre This method can be called if SCIP is in one of the following stages:
18811  * - \ref SCIP_STAGE_PRESOLVING
18812  * - \ref SCIP_STAGE_EXITPRESOLVE
18813  * - \ref SCIP_STAGE_PRESOLVED
18814  * - \ref SCIP_STAGE_INITSOLVE
18815  * - \ref SCIP_STAGE_SOLVING
18816  * - \ref SCIP_STAGE_SOLVED
18817  */
18818 extern
18820  SCIP* scip /**< SCIP data structure */
18821  );
18822 
18823 
18824 /** gets global primal bound (objective value of best solution or user objective limit) for the original problem
18825  *
18826  * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
18827  *
18828  * @pre This method can be called if SCIP is in one of the following stages:
18829  * - \ref SCIP_STAGE_TRANSFORMED
18830  * - \ref SCIP_STAGE_INITPRESOLVE
18831  * - \ref SCIP_STAGE_PRESOLVING
18832  * - \ref SCIP_STAGE_EXITPRESOLVE
18833  * - \ref SCIP_STAGE_PRESOLVED
18834  * - \ref SCIP_STAGE_INITSOLVE
18835  * - \ref SCIP_STAGE_SOLVING
18836  * - \ref SCIP_STAGE_SOLVED
18837  * - \ref SCIP_STAGE_EXITSOLVE
18838  */
18839 extern
18841  SCIP* scip /**< SCIP data structure */
18842  );
18843 
18844 /** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
18845  *
18846  * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
18847  *
18848  * @pre This method can be called if SCIP is in one of the following stages:
18849  * - \ref SCIP_STAGE_TRANSFORMED
18850  * - \ref SCIP_STAGE_INITPRESOLVE
18851  * - \ref SCIP_STAGE_PRESOLVING
18852  * - \ref SCIP_STAGE_EXITPRESOLVE
18853  * - \ref SCIP_STAGE_PRESOLVED
18854  * - \ref SCIP_STAGE_INITSOLVE
18855  * - \ref SCIP_STAGE_SOLVING
18856  * - \ref SCIP_STAGE_SOLVED
18857  * - \ref SCIP_STAGE_EXITSOLVE
18858  */
18859 extern
18861  SCIP* scip /**< SCIP data structure */
18862  );
18863 
18864 /** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
18865  * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
18866  * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
18867  * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
18868  *
18869  * @return global cutoff bound in transformed problem
18870  *
18871  * @pre This method can be called if SCIP is in one of the following stages:
18872  * - \ref SCIP_STAGE_TRANSFORMED
18873  * - \ref SCIP_STAGE_INITPRESOLVE
18874  * - \ref SCIP_STAGE_PRESOLVING
18875  * - \ref SCIP_STAGE_EXITPRESOLVE
18876  * - \ref SCIP_STAGE_PRESOLVED
18877  * - \ref SCIP_STAGE_INITSOLVE
18878  * - \ref SCIP_STAGE_SOLVING
18879  * - \ref SCIP_STAGE_SOLVED
18880  * - \ref SCIP_STAGE_EXITSOLVE
18881  */
18882 extern
18884  SCIP* scip /**< SCIP data structure */
18885  );
18886 
18887 /** updates the cutoff bound
18888  *
18889  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18890  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18891  *
18892  * @note using this method in the solving stage can lead to an erroneous SCIP solving status; in particular,
18893  * if a solution not respecting the cutoff bound was found before installing a cutoff bound which
18894  * renders the remaining problem infeasible, this solution may be reported as optimal
18895  *
18896  * @pre This method can be called if SCIP is in one of the following stages:
18897  * - \ref SCIP_STAGE_TRANSFORMED
18898  * - \ref SCIP_STAGE_PRESOLVING
18899  * - \ref SCIP_STAGE_PRESOLVED
18900  * - \ref SCIP_STAGE_INITSOLVE
18901  * - \ref SCIP_STAGE_SOLVING
18902  *
18903  * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
18904  */
18905 extern
18907  SCIP* scip, /**< SCIP data structure */
18908  SCIP_Real cutoffbound /**< new cutoff bound */
18909  );
18910 
18911 /** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
18912  * was set from the user as objective limit
18913  *
18914  * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
18915  *
18916  * @pre This method can be called if SCIP is in one of the following stages:
18917  * - \ref SCIP_STAGE_TRANSFORMED
18918  * - \ref SCIP_STAGE_INITPRESOLVE
18919  * - \ref SCIP_STAGE_PRESOLVING
18920  * - \ref SCIP_STAGE_EXITPRESOLVE
18921  * - \ref SCIP_STAGE_PRESOLVED
18922  * - \ref SCIP_STAGE_INITSOLVE
18923  * - \ref SCIP_STAGE_SOLVING
18924  * - \ref SCIP_STAGE_SOLVED
18925  * - \ref SCIP_STAGE_EXITSOLVE
18926  */
18927 extern
18929  SCIP* scip /**< SCIP data structure */
18930  );
18931 
18932 /** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
18933  * or infinity, if they have opposite sign
18934  *
18935  * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
18936  * or infinity, if they have opposite sign
18937  *
18938  * @pre This method can be called if SCIP is in one of the following stages:
18939  * - \ref SCIP_STAGE_PRESOLVED
18940  * - \ref SCIP_STAGE_SOLVING
18941  * - \ref SCIP_STAGE_SOLVED
18942  */
18943 extern
18945  SCIP* scip /**< SCIP data structure */
18946  );
18947 
18948 /** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
18949  * have same sign, or infinity, if they have opposite sign
18950  *
18951  * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
18952  * have same sign, or infinity, if they have opposite sign
18953  *
18954  * @pre This method can be called if SCIP is in one of the following stages:
18955  * - \ref SCIP_STAGE_PRESOLVED
18956  * - \ref SCIP_STAGE_SOLVING
18957  * - \ref SCIP_STAGE_SOLVED
18958  */
18959 extern
18961  SCIP* scip /**< SCIP data structure */
18962  );
18963 
18964 /** gets number of feasible primal solutions found so far
18965  *
18966  * @return the number of feasible primal solutions found so far
18967  *
18968  * @pre This method can be called if SCIP is in one of the following stages:
18969  * - \ref SCIP_STAGE_TRANSFORMED
18970  * - \ref SCIP_STAGE_INITPRESOLVE
18971  * - \ref SCIP_STAGE_PRESOLVING
18972  * - \ref SCIP_STAGE_EXITPRESOLVE
18973  * - \ref SCIP_STAGE_PRESOLVED
18974  * - \ref SCIP_STAGE_INITSOLVE
18975  * - \ref SCIP_STAGE_SOLVING
18976  * - \ref SCIP_STAGE_SOLVED
18977  * - \ref SCIP_STAGE_EXITSOLVE
18978  */
18979 extern
18981  SCIP* scip /**< SCIP data structure */
18982  );
18983 
18984 /** gets number of feasible primal solutions respecting the objective limit found so far
18985  *
18986  * @return the number of feasible primal solutions respecting the objective limit found so far
18987  *
18988  * @pre This method can be called if SCIP is in one of the following stages:
18989  * - \ref SCIP_STAGE_TRANSFORMED
18990  * - \ref SCIP_STAGE_INITPRESOLVE
18991  * - \ref SCIP_STAGE_PRESOLVING
18992  * - \ref SCIP_STAGE_EXITPRESOLVE
18993  * - \ref SCIP_STAGE_PRESOLVED
18994  * - \ref SCIP_STAGE_INITSOLVE
18995  * - \ref SCIP_STAGE_SOLVING
18996  * - \ref SCIP_STAGE_SOLVED
18997  * - \ref SCIP_STAGE_EXITSOLVE
18998  */
18999 extern
19001  SCIP* scip /**< SCIP data structure */
19002  );
19003 
19004 /** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
19005  *
19006  * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
19007  *
19008  * @pre This method can be called if SCIP is in one of the following stages:
19009  * - \ref SCIP_STAGE_TRANSFORMED
19010  * - \ref SCIP_STAGE_INITPRESOLVE
19011  * - \ref SCIP_STAGE_PRESOLVING
19012  * - \ref SCIP_STAGE_EXITPRESOLVE
19013  * - \ref SCIP_STAGE_PRESOLVED
19014  * - \ref SCIP_STAGE_INITSOLVE
19015  * - \ref SCIP_STAGE_SOLVING
19016  * - \ref SCIP_STAGE_SOLVED
19017  * - \ref SCIP_STAGE_EXITSOLVE
19018  */
19019 extern
19021  SCIP* scip /**< SCIP data structure */
19022  );
19023 
19024 /** gets the average pseudo cost value for the given direction over all variables
19025  *
19026  * @return the average pseudo cost value for the given direction over all variables
19027  *
19028  * @pre This method can be called if SCIP is in one of the following stages:
19029  * - \ref SCIP_STAGE_SOLVING
19030  * - \ref SCIP_STAGE_SOLVED
19031  */
19032 extern
19034  SCIP* scip, /**< SCIP data structure */
19035  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
19036  );
19037 
19038 /** gets the average pseudo cost value for the given direction over all variables,
19039  * only using the pseudo cost information of the current run
19040  *
19041  * @return the average pseudo cost value for the given direction over all variables,
19042  * only using the pseudo cost information of the current run
19043  *
19044  * @pre This method can be called if SCIP is in one of the following stages:
19045  * - \ref SCIP_STAGE_SOLVING
19046  * - \ref SCIP_STAGE_SOLVED
19047  */
19048 extern
19050  SCIP* scip, /**< SCIP data structure */
19051  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
19052  );
19053 
19054 /** gets the average number of pseudo cost updates for the given direction over all variables
19055  *
19056  * @return the average number of pseudo cost updates for the given direction over all variables
19057  *
19058  * @pre This method can be called if SCIP is in one of the following stages:
19059  * - \ref SCIP_STAGE_SOLVING
19060  * - \ref SCIP_STAGE_SOLVED
19061  */
19062 extern
19064  SCIP* scip, /**< SCIP data structure */
19065  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
19066  );
19067 
19068 /** gets the average number of pseudo cost updates for the given direction over all variables,
19069  * only using the pseudo cost information of the current run
19070  *
19071  * @return the average number of pseudo cost updates for the given direction over all variables,
19072  * only using the pseudo cost information of the current run
19073  *
19074  * @pre This method can be called if SCIP is in one of the following stages:
19075  * - \ref SCIP_STAGE_SOLVING
19076  * - \ref SCIP_STAGE_SOLVED
19077  */
19078 extern
19080  SCIP* scip, /**< SCIP data structure */
19081  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
19082  );
19083 
19084 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
19085  *
19086  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
19087  *
19088  * @pre This method can be called if SCIP is in one of the following stages:
19089  * - \ref SCIP_STAGE_SOLVING
19090  * - \ref SCIP_STAGE_SOLVED
19091  */
19092 extern
19094  SCIP* scip /**< SCIP data structure */
19095  );
19096 
19097 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
19098  * only using the pseudo cost information of the current run
19099  *
19100  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
19101  * only using the pseudo cost information of the current run
19102  *
19103  * @pre This method can be called if SCIP is in one of the following stages:
19104  * - \ref SCIP_STAGE_SOLVING
19105  * - \ref SCIP_STAGE_SOLVED
19106  */
19107 extern
19109  SCIP* scip /**< SCIP data structure */
19110  );
19111 
19112 /** gets the average conflict score value over all variables */
19113 extern
19115  SCIP* scip /**< SCIP data structure */
19116  );
19117 
19118 /** gets the average conflict score value over all variables, only using the pseudo cost information of the current run
19119  *
19120  * @return the average conflict score value over all variables, only using the pseudo cost information of the current run
19121  *
19122  * @pre This method can be called if SCIP is in one of the following stages:
19123  * - \ref SCIP_STAGE_SOLVING
19124  * - \ref SCIP_STAGE_SOLVED
19125  */
19126 extern
19128  SCIP* scip /**< SCIP data structure */
19129  );
19130 
19131 /** gets the average inference score value over all variables
19132  *
19133  * @return the average inference score value over all variables
19134  *
19135  * @pre This method can be called if SCIP is in one of the following stages:
19136  * - \ref SCIP_STAGE_SOLVING
19137  * - \ref SCIP_STAGE_SOLVED
19138  */
19139 extern
19141  SCIP* scip /**< SCIP data structure */
19142  );
19143 
19144 /** gets the average conflictlength score value over all variables, only using the pseudo cost information of the
19145  * current run
19146  *
19147  * @return the average conflictlength score value over all variables, only using the pseudo cost information of the
19148  * current run
19149  *
19150  * @pre This method can be called if SCIP is in one of the following stages:
19151  * - \ref SCIP_STAGE_SOLVING
19152  * - \ref SCIP_STAGE_SOLVED
19153  */
19154 extern
19156  SCIP* scip /**< SCIP data structure */
19157  );
19158 
19159 /** returns the average number of inferences found after branching in given direction over all variables
19160  *
19161  * @return the average number of inferences found after branching in given direction over all variables
19162  *
19163  * @pre This method can be called if SCIP is in one of the following stages:
19164  * - \ref SCIP_STAGE_SOLVING
19165  * - \ref SCIP_STAGE_SOLVED
19166  */
19167 extern
19169  SCIP* scip, /**< SCIP data structure */
19170  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
19171  );
19172 
19173 /** returns the average number of inferences found after branching in given direction over all variables,
19174  * only using the pseudo cost information of the current run
19175  *
19176  * @return the average number of inferences found after branching in given direction over all variables,
19177  * only using the pseudo cost information of the current run
19178  *
19179  * @pre This method can be called if SCIP is in one of the following stages:
19180  * - \ref SCIP_STAGE_SOLVING
19181  * - \ref SCIP_STAGE_SOLVED
19182  */
19183 extern
19185  SCIP* scip, /**< SCIP data structure */
19186  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
19187  );
19188 
19189 /** gets the average inference score value over all variables
19190  *
19191  * @return the average inference score value over all variables
19192  *
19193  * @pre This method can be called if SCIP is in one of the following stages:
19194  * - \ref SCIP_STAGE_SOLVING
19195  * - \ref SCIP_STAGE_SOLVED
19196  */
19197 extern
19199  SCIP* scip /**< SCIP data structure */
19200  );
19201 
19202 /** gets the average inference score value over all variables, only using the inference information information of the
19203  * current run
19204  *
19205  * @return the average inference score value over all variables, only using the inference information information of the
19206  * current run
19207  *
19208  * @pre This method can be called if SCIP is in one of the following stages:
19209  * - \ref SCIP_STAGE_SOLVING
19210  * - \ref SCIP_STAGE_SOLVED
19211  */
19212 extern
19214  SCIP* scip /**< SCIP data structure */
19215  );
19216 
19217 /** returns the average number of cutoffs found after branching in given direction over all variables
19218  *
19219  * @return the average number of cutoffs found after branching in given direction over all variables
19220  *
19221  * @pre This method can be called if SCIP is in one of the following stages:
19222  * - \ref SCIP_STAGE_SOLVING
19223  * - \ref SCIP_STAGE_SOLVED
19224  */
19225 extern
19227  SCIP* scip, /**< SCIP data structure */
19228  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
19229  );
19230 
19231 /** returns the average number of cutoffs found after branching in given direction over all variables,
19232  * only using the pseudo cost information of the current run
19233  *
19234  * @return the average number of cutoffs found after branching in given direction over all variables,
19235  * only using the pseudo cost information of the current run
19236  *
19237  * @pre This method can be called if SCIP is in one of the following stages:
19238  * - \ref SCIP_STAGE_SOLVING
19239  * - \ref SCIP_STAGE_SOLVED
19240  */
19241 extern
19243  SCIP* scip, /**< SCIP data structure */
19244  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
19245  );
19246 
19247 /** gets the average cutoff score value over all variables
19248  *
19249  * @return the average cutoff score value over all variables
19250  *
19251  * @pre This method can be called if SCIP is in one of the following stages:
19252  * - \ref SCIP_STAGE_SOLVING
19253  * - \ref SCIP_STAGE_SOLVED
19254  */
19255 extern
19257  SCIP* scip /**< SCIP data structure */
19258  );
19259 
19260 /** gets the average cutoff score value over all variables, only using the pseudo cost information of the current run
19261  *
19262  * @return the average cutoff score value over all variables, only using the pseudo cost information of the current run
19263  *
19264  * @pre This method can be called if SCIP is in one of the following stages:
19265  * - \ref SCIP_STAGE_SOLVING
19266  * - \ref SCIP_STAGE_SOLVED
19267  */
19268 extern
19270  SCIP* scip /**< SCIP data structure */
19271  );
19272 
19273 /** outputs original problem to file stream
19274  *
19275  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19276  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
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  FILE* file, /**< output file (or NULL for standard output) */
19296  const char* extension, /**< file format (or NULL for default CIP format)*/
19297  SCIP_Bool genericnames /**< using generic variable and constraint names? */
19298  );
19299 
19300 /** outputs transformed problem of the current node to file stream
19301  *
19302  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19303  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19304  *
19305  * @pre This method can be called if SCIP is in one of the following stages:
19306  * - \ref SCIP_STAGE_TRANSFORMED
19307  * - \ref SCIP_STAGE_INITPRESOLVE
19308  * - \ref SCIP_STAGE_PRESOLVING
19309  * - \ref SCIP_STAGE_EXITPRESOLVE
19310  * - \ref SCIP_STAGE_PRESOLVED
19311  * - \ref SCIP_STAGE_INITSOLVE
19312  * - \ref SCIP_STAGE_SOLVING
19313  * - \ref SCIP_STAGE_SOLVED
19314  * - \ref SCIP_STAGE_EXITSOLVE
19315  * - \ref SCIP_STAGE_FREETRANS
19316  */
19317 extern
19319  SCIP* scip, /**< SCIP data structure */
19320  FILE* file, /**< output file (or NULL for standard output) */
19321  const char* extension, /**< file format (or NULL for default CIP format)*/
19322  SCIP_Bool genericnames /**< using generic variable and constraint names? */
19323  );
19324 
19325 /** outputs solving statistics
19326  *
19327  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19328  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19329  *
19330  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
19331  * thus may to correspond to the original status.
19332  *
19333  * @pre This method can be called if SCIP is in one of the following stages:
19334  * - \ref SCIP_STAGE_INIT
19335  * - \ref SCIP_STAGE_PROBLEM
19336  * - \ref SCIP_STAGE_TRANSFORMED
19337  * - \ref SCIP_STAGE_INITPRESOLVE
19338  * - \ref SCIP_STAGE_PRESOLVING
19339  * - \ref SCIP_STAGE_EXITPRESOLVE
19340  * - \ref SCIP_STAGE_PRESOLVED
19341  * - \ref SCIP_STAGE_SOLVING
19342  * - \ref SCIP_STAGE_SOLVED
19343  */
19344 extern
19346  SCIP* scip, /**< SCIP data structure */
19347  FILE* file /**< output file (or NULL for standard output) */
19348  );
19349 
19350 /** outputs reoptimization statistics
19351  *
19352  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19353  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19354  *
19355  * @pre This method can be called if SCIP is in one of the following stages:
19356  * - \ref SCIP_STAGE_INIT
19357  * - \ref SCIP_STAGE_PROBLEM
19358  * - \ref SCIP_STAGE_TRANSFORMED
19359  * - \ref SCIP_STAGE_INITPRESOLVE
19360  * - \ref SCIP_STAGE_PRESOLVING
19361  * - \ref SCIP_STAGE_EXITPRESOLVE
19362  * - \ref SCIP_STAGE_PRESOLVED
19363  * - \ref SCIP_STAGE_SOLVING
19364  * - \ref SCIP_STAGE_SOLVED
19365  */
19366 extern
19368  SCIP* scip, /**< SCIP data structure */
19369  FILE* file /**< output file (or NULL for standard output) */
19370  );
19371 
19372 /** outputs history statistics about branchings on variables
19373  *
19374  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19375  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19376  *
19377  * @pre This method can be called if SCIP is in one of the following stages:
19378  * - \ref SCIP_STAGE_INIT
19379  * - \ref SCIP_STAGE_PROBLEM
19380  * - \ref SCIP_STAGE_TRANSFORMED
19381  * - \ref SCIP_STAGE_INITPRESOLVE
19382  * - \ref SCIP_STAGE_PRESOLVING
19383  * - \ref SCIP_STAGE_EXITPRESOLVE
19384  * - \ref SCIP_STAGE_PRESOLVED
19385  * - \ref SCIP_STAGE_SOLVING
19386  * - \ref SCIP_STAGE_SOLVED
19387  */
19388 extern
19390  SCIP* scip, /**< SCIP data structure */
19391  FILE* file /**< output file (or NULL for standard output) */
19392  );
19393 
19394 /** outputs node information display line
19395  *
19396  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19397  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19398  *
19399  * @pre This method can be called if SCIP is in one of the following stages:
19400  * - \ref SCIP_STAGE_SOLVING
19401  */
19402 extern
19404  SCIP* scip, /**< SCIP data structure */
19405  FILE* file, /**< output file (or NULL for standard output) */
19406  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
19407  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
19408  );
19409 
19410 /** gets total number of implications between variables that are stored in the implication graph
19411  *
19412  * @return the total number of implications between variables that are stored in the implication graph
19413  *
19414  * @pre This method can be called if SCIP is in one of the following stages:
19415  * - \ref SCIP_STAGE_INITPRESOLVE
19416  * - \ref SCIP_STAGE_PRESOLVING
19417  * - \ref SCIP_STAGE_EXITPRESOLVE
19418  * - \ref SCIP_STAGE_PRESOLVED
19419  * - \ref SCIP_STAGE_INITSOLVE
19420  * - \ref SCIP_STAGE_SOLVING
19421  * - \ref SCIP_STAGE_SOLVED
19422  */
19423 extern
19425  SCIP* scip /**< SCIP data structure */
19426  );
19427 
19428 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
19429  *
19430  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19431  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19432  *
19433  * @pre This method can be called if SCIP is in one of the following stages:
19434  * - \ref SCIP_STAGE_TRANSFORMED
19435  * - \ref SCIP_STAGE_INITPRESOLVE
19436  * - \ref SCIP_STAGE_PRESOLVING
19437  * - \ref SCIP_STAGE_EXITPRESOLVE
19438  * - \ref SCIP_STAGE_PRESOLVED
19439  * - \ref SCIP_STAGE_INITSOLVE
19440  * - \ref SCIP_STAGE_SOLVING
19441  * - \ref SCIP_STAGE_SOLVED
19442  * - \ref SCIP_STAGE_EXITSOLVE
19443  *
19444  * @deprecated because binary implications are now stored as cliques
19445  */
19446 extern
19448  SCIP* scip, /**< SCIP data structure */
19449  const char* filename /**< file name, or NULL for stdout */
19450  );
19451 
19452 /**@} */
19453 
19454 
19455 
19456 
19457 /*
19458  * timing methods
19459  */
19460 
19461 /**@name Timing Methods */
19462 /**@{ */
19463 
19464 /** gets current time of day in seconds (standard time zone)
19465  *
19466  * @return the current time of day in seconds (standard time zone).
19467  */
19468 extern
19470  SCIP* scip /**< SCIP data structure */
19471  );
19472 
19473 /** creates a clock using the default clock type
19474  *
19475  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19476  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19477  */
19478 extern
19480  SCIP* scip, /**< SCIP data structure */
19481  SCIP_CLOCK** clck /**< pointer to clock timer */
19482  );
19483 
19484 /** creates a clock counting the CPU user seconds
19485  *
19486  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19487  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19488  */
19489 extern
19491  SCIP* scip, /**< SCIP data structure */
19492  SCIP_CLOCK** clck /**< pointer to clock timer */
19493  );
19494 
19495 /** creates a clock counting the wall clock seconds
19496  *
19497  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19498  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19499  */
19500 extern
19502  SCIP* scip, /**< SCIP data structure */
19503  SCIP_CLOCK** clck /**< pointer to clock timer */
19504  );
19505 
19506 /** frees a clock
19507  *
19508  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19509  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19510  */
19511 extern
19513  SCIP* scip, /**< SCIP data structure */
19514  SCIP_CLOCK** clck /**< pointer to clock timer */
19515  );
19516 
19517 /** resets the time measurement of a clock to zero and completely stops the clock
19518  *
19519  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19520  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19521  */
19522 extern
19524  SCIP* scip, /**< SCIP data structure */
19525  SCIP_CLOCK* clck /**< clock timer */
19526  );
19527 
19528 /** starts the time measurement of a clock
19529  *
19530  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19531  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19532  */
19533 extern
19535  SCIP* scip, /**< SCIP data structure */
19536  SCIP_CLOCK* clck /**< clock timer */
19537  );
19538 
19539 /** stops the time measurement of a clock
19540  *
19541  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19542  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19543  */
19544 extern
19546  SCIP* scip, /**< SCIP data structure */
19547  SCIP_CLOCK* clck /**< clock timer */
19548  );
19549 
19550 /** enables or disables all statistic clocks of SCIP concerning plugin statistics,
19551  * LP execution time, strong branching time, etc.
19552  *
19553  * Method reads the value of the parameter timing/statistictiming. In order to disable statistic timing,
19554  * set the parameter to FALSE.
19555  *
19556  * @note: The (pre-)solving time clocks which are relevant for the output during (pre-)solving
19557  * are not affected by this method
19558  *
19559  * @see: For completely disabling all timing of SCIP, consider setting the parameter timing/enabled to FALSE
19560  *
19561  * @pre This method can be called if SCIP is in one of the following stages:
19562  * - \ref SCIP_STAGE_PROBLEM
19563  * - \ref SCIP_STAGE_TRANSFORMING
19564  * - \ref SCIP_STAGE_TRANSFORMED
19565  * - \ref SCIP_STAGE_INITPRESOLVE
19566  * - \ref SCIP_STAGE_PRESOLVING
19567  * - \ref SCIP_STAGE_EXITPRESOLVE
19568  * - \ref SCIP_STAGE_PRESOLVED
19569  * - \ref SCIP_STAGE_INITSOLVE
19570  * - \ref SCIP_STAGE_SOLVING
19571  * - \ref SCIP_STAGE_SOLVED
19572  * - \ref SCIP_STAGE_EXITSOLVE
19573  * - \ref SCIP_STAGE_FREETRANS
19574  *
19575  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19576  */
19577 extern
19579  SCIP* scip /**< SCIP data structure */
19580  );
19581 
19582 /** starts the current solving time
19583  *
19584  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19585  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19586  *
19587  * @pre This method can be called if SCIP is in one of the following stages:
19588  * - \ref SCIP_STAGE_PROBLEM
19589  * - \ref SCIP_STAGE_TRANSFORMING
19590  * - \ref SCIP_STAGE_TRANSFORMED
19591  * - \ref SCIP_STAGE_INITPRESOLVE
19592  * - \ref SCIP_STAGE_PRESOLVING
19593  * - \ref SCIP_STAGE_EXITPRESOLVE
19594  * - \ref SCIP_STAGE_PRESOLVED
19595  * - \ref SCIP_STAGE_INITSOLVE
19596  * - \ref SCIP_STAGE_SOLVING
19597  * - \ref SCIP_STAGE_SOLVED
19598  * - \ref SCIP_STAGE_EXITSOLVE
19599  * - \ref SCIP_STAGE_FREETRANS
19600  *
19601  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19602  */
19603 extern
19605  SCIP* scip /**< SCIP data structure */
19606  );
19607 
19608 /** stops the current solving time in seconds
19609  *
19610  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19611  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19612  *
19613  * @pre This method can be called if SCIP is in one of the following stages:
19614  * - \ref SCIP_STAGE_PROBLEM
19615  * - \ref SCIP_STAGE_TRANSFORMING
19616  * - \ref SCIP_STAGE_TRANSFORMED
19617  * - \ref SCIP_STAGE_INITPRESOLVE
19618  * - \ref SCIP_STAGE_PRESOLVING
19619  * - \ref SCIP_STAGE_EXITPRESOLVE
19620  * - \ref SCIP_STAGE_PRESOLVED
19621  * - \ref SCIP_STAGE_INITSOLVE
19622  * - \ref SCIP_STAGE_SOLVING
19623  * - \ref SCIP_STAGE_SOLVED
19624  * - \ref SCIP_STAGE_EXITSOLVE
19625  * - \ref SCIP_STAGE_FREETRANS
19626  *
19627  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19628  */
19629 extern
19631  SCIP* scip /**< SCIP data structure */
19632  );
19633 
19634 /** gets the measured time of a clock in seconds
19635  *
19636  * @return the measured time of a clock in seconds.
19637  */
19638 extern
19640  SCIP* scip, /**< SCIP data structure */
19641  SCIP_CLOCK* clck /**< clock timer */
19642  );
19643 
19644 /** sets the measured time of a clock to the given value in seconds
19645  *
19646  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19647  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19648  */
19649 extern
19651  SCIP* scip, /**< SCIP data structure */
19652  SCIP_CLOCK* clck, /**< clock timer */
19653  SCIP_Real sec /**< time in seconds to set the clock's timer to */
19654  );
19655 
19656 /** gets the current total SCIP time in seconds, possibly accumulated over several problems.
19657  *
19658  * @return the current total SCIP time in seconds, ie. the total time since the SCIP instance has been created
19659  */
19660 extern
19662  SCIP* scip /**< SCIP data structure */
19663  );
19664 
19665 /** gets the current solving time in seconds
19666  *
19667  * @return the current solving time in seconds.
19668  *
19669  * @pre This method can be called if SCIP is in one of the following stages:
19670  * - \ref SCIP_STAGE_PROBLEM
19671  * - \ref SCIP_STAGE_TRANSFORMING
19672  * - \ref SCIP_STAGE_TRANSFORMED
19673  * - \ref SCIP_STAGE_INITPRESOLVE
19674  * - \ref SCIP_STAGE_PRESOLVING
19675  * - \ref SCIP_STAGE_EXITPRESOLVE
19676  * - \ref SCIP_STAGE_PRESOLVED
19677  * - \ref SCIP_STAGE_INITSOLVE
19678  * - \ref SCIP_STAGE_SOLVING
19679  * - \ref SCIP_STAGE_SOLVED
19680  *
19681  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19682  */
19683 extern
19685  SCIP* scip /**< SCIP data structure */
19686  );
19687 
19688 /** gets the current reading time in seconds
19689  *
19690  * @return the current reading time in seconds.
19691  *
19692  * @pre This method can be called if SCIP is in one of the following stages:
19693  * - \ref SCIP_STAGE_PROBLEM
19694  * - \ref SCIP_STAGE_TRANSFORMING
19695  * - \ref SCIP_STAGE_TRANSFORMED
19696  * - \ref SCIP_STAGE_INITPRESOLVE
19697  * - \ref SCIP_STAGE_PRESOLVING
19698  * - \ref SCIP_STAGE_EXITPRESOLVE
19699  * - \ref SCIP_STAGE_PRESOLVED
19700  * - \ref SCIP_STAGE_INITSOLVE
19701  * - \ref SCIP_STAGE_SOLVING
19702  * - \ref SCIP_STAGE_SOLVED
19703  *
19704  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19705  */
19706 extern
19708  SCIP* scip /**< SCIP data structure */
19709  );
19710 
19711 /** gets the current presolving time in seconds
19712  *
19713  * @return the current presolving time in seconds.
19714  *
19715  * @pre This method can be called if SCIP is in one of the following stages:
19716  * - \ref SCIP_STAGE_INITPRESOLVE
19717  * - \ref SCIP_STAGE_PRESOLVING
19718  * - \ref SCIP_STAGE_EXITPRESOLVE
19719  * - \ref SCIP_STAGE_PRESOLVED
19720  * - \ref SCIP_STAGE_INITSOLVE
19721  * - \ref SCIP_STAGE_SOLVING
19722  * - \ref SCIP_STAGE_SOLVED
19723  *
19724  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19725  */
19726 extern
19728  SCIP* scip /**< SCIP data structure */
19729  );
19730 
19731 /** gets the time need to solve the first LP in the root node
19732  *
19733  * @return the solving time for the first LP in the root node in seconds.
19734  *
19735  * @pre This method can be called if SCIP is in one of the following stages:
19736  * - \ref SCIP_STAGE_TRANSFORMING
19737  * - \ref SCIP_STAGE_TRANSFORMED
19738  * - \ref SCIP_STAGE_INITPRESOLVE
19739  * - \ref SCIP_STAGE_PRESOLVING
19740  * - \ref SCIP_STAGE_EXITPRESOLVE
19741  * - \ref SCIP_STAGE_PRESOLVED
19742  * - \ref SCIP_STAGE_INITSOLVE
19743  * - \ref SCIP_STAGE_SOLVING
19744  * - \ref SCIP_STAGE_SOLVED
19745  *
19746  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
19747  */
19748 extern
19750  SCIP* scip /**< SCIP data structure */
19751  );
19752 
19753 /**@} */
19754 
19755 
19756 
19757 
19758 /*
19759  * numeric values and comparisons
19760  */
19761 
19762 /**@name Numerical Methods */
19763 /**@{ */
19764 
19765 
19766 /** returns value treated as zero
19767  *
19768  * @return value treated as zero
19769  */
19770 extern
19772  SCIP* scip /**< SCIP data structure */
19773  );
19774 
19775 /** returns value treated as zero for sums of floating point values
19776  *
19777  * @return value treated as zero for sums of floating point values
19778  */
19779 extern
19781  SCIP* scip /**< SCIP data structure */
19782  );
19783 
19784 /** returns feasibility tolerance for constraints
19785  *
19786  * @return feasibility tolerance for constraints
19787  */
19788 extern
19790  SCIP* scip /**< SCIP data structure */
19791  );
19792 
19793 /** returns primal feasibility tolerance of LP solver
19794  *
19795  * @return primal feasibility tolerance of LP solver
19796  */
19797 extern
19799  SCIP* scip /**< SCIP data structure */
19800  );
19801 
19802 /** returns feasibility tolerance for reduced costs
19803  *
19804  * @return feasibility tolerance for reduced costs
19805  */
19806 extern
19808  SCIP* scip /**< SCIP data structure */
19809  );
19810 
19811 /** returns convergence tolerance used in barrier algorithm
19812  *
19813  * @return convergence tolerance used in barrier algorithm
19814  */
19815 extern
19817  SCIP* scip /**< SCIP data structure */
19818  );
19819 
19820 /** return the cutoff bound delta
19821  *
19822  * @return cutoff bound data
19823  */
19824 extern
19826  SCIP* scip /**< SCIP data structure */
19827  );
19828 
19829 /** sets the feasibility tolerance for constraints
19830  *
19831  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19832  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19833  */
19834 extern
19836  SCIP* scip, /**< SCIP data structure */
19837  SCIP_Real feastol /**< new feasibility tolerance for constraints */
19838  );
19839 
19840 /** sets the primal feasibility tolerance of LP solver
19841  *
19842  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19843  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19844  */
19845 extern
19847  SCIP* scip, /**< SCIP data structure */
19848  SCIP_Real lpfeastol, /**< new primal feasibility tolerance of LP solver */
19849  SCIP_Bool printnewvalue /**< should "numerics/lpfeastol = ..." be printed? */
19850  );
19851 
19852 /** sets the feasibility tolerance for reduced costs
19853  *
19854  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19855  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19856  */
19857 extern
19859  SCIP* scip, /**< SCIP data structure */
19860  SCIP_Real dualfeastol /**< new feasibility tolerance for reduced costs */
19861  );
19862 
19863 /** sets the convergence tolerance used in barrier algorithm
19864  *
19865  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19866  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19867  */
19868 extern
19870  SCIP* scip, /**< SCIP data structure */
19871  SCIP_Real barrierconvtol /**< new convergence tolerance used in barrier algorithm */
19872  );
19873 
19874 /** marks that some limit parameter was changed */
19875 extern
19877  SCIP* scip /**< SCIP data structure */
19878  );
19879 
19880 /** returns value treated as infinity */
19881 extern
19883  SCIP* scip /**< SCIP data structure */
19884  );
19885 
19886 /** returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity
19887  * computation)
19888  */
19889 extern
19891  SCIP* scip /**< SCIP data structure */
19892  );
19893 
19894 /** checks, if values are in range of epsilon */
19895 extern
19897  SCIP* scip, /**< SCIP data structure */
19898  SCIP_Real val1, /**< first value to be compared */
19899  SCIP_Real val2 /**< second value to be compared */
19900  );
19901 
19902 /** checks, if val1 is (more than epsilon) lower than val2 */
19903 extern
19905  SCIP* scip, /**< SCIP data structure */
19906  SCIP_Real val1, /**< first value to be compared */
19907  SCIP_Real val2 /**< second value to be compared */
19908  );
19909 
19910 /** checks, if val1 is not (more than epsilon) greater than val2 */
19911 extern
19913  SCIP* scip, /**< SCIP data structure */
19914  SCIP_Real val1, /**< first value to be compared */
19915  SCIP_Real val2 /**< second value to be compared */
19916  );
19917 
19918 /** checks, if val1 is (more than epsilon) greater than val2 */
19919 extern
19921  SCIP* scip, /**< SCIP data structure */
19922  SCIP_Real val1, /**< first value to be compared */
19923  SCIP_Real val2 /**< second value to be compared */
19924  );
19925 
19926 /** checks, if val1 is not (more than epsilon) lower than val2 */
19927 extern
19929  SCIP* scip, /**< SCIP data structure */
19930  SCIP_Real val1, /**< first value to be compared */
19931  SCIP_Real val2 /**< second value to be compared */
19932  );
19933 
19934 /** checks, if value is (positive) infinite */
19935 extern
19937  SCIP* scip, /**< SCIP data structure */
19938  SCIP_Real val /**< value to be compared against infinity */
19939  );
19940 
19941 /** checks, if value is huge and should be handled separately (e.g., in activity computation) */
19942 extern
19944  SCIP* scip, /**< SCIP data structure */
19945  SCIP_Real val /**< value to be checked whether it is huge */
19946  );
19947 
19948 /** checks, if value is in range epsilon of 0.0 */
19949 extern
19951  SCIP* scip, /**< SCIP data structure */
19952  SCIP_Real val /**< value to process */
19953  );
19954 
19955 /** checks, if value is greater than epsilon */
19956 extern
19958  SCIP* scip, /**< SCIP data structure */
19959  SCIP_Real val /**< value to process */
19960  );
19961 
19962 /** checks, if value is lower than -epsilon */
19963 extern
19965  SCIP* scip, /**< SCIP data structure */
19966  SCIP_Real val /**< value to process */
19967  );
19968 
19969 /** checks, if value is integral within epsilon */
19970 extern
19972  SCIP* scip, /**< SCIP data structure */
19973  SCIP_Real val /**< value to process */
19974  );
19975 
19976 /** checks whether the product val * scalar is integral in epsilon scaled by scalar */
19977 extern
19979  SCIP* scip, /**< SCIP data structure */
19980  SCIP_Real val, /**< unscaled value to check for scaled integrality */
19981  SCIP_Real scalar /**< value to scale val with for checking for integrality */
19982  );
19983 
19984 /** checks, if given fractional part is smaller than epsilon */
19985 extern
19987  SCIP* scip, /**< SCIP data structure */
19988  SCIP_Real val /**< value to process */
19989  );
19990 
19991 /** rounds value + epsilon down to the next integer */
19992 extern
19994  SCIP* scip, /**< SCIP data structure */
19995  SCIP_Real val /**< value to process */
19996  );
19997 
19998 /** rounds value - epsilon up to the next integer */
19999 extern
20001  SCIP* scip, /**< SCIP data structure */
20002  SCIP_Real val /**< value to process */
20003  );
20004 
20005 /** rounds value to the nearest integer with epsilon tolerance */
20006 extern
20008  SCIP* scip, /**< SCIP data structure */
20009  SCIP_Real val /**< value to process */
20010  );
20011 
20012 /** returns fractional part of value, i.e. x - floor(x) in epsilon tolerance */
20013 extern
20015  SCIP* scip, /**< SCIP data structure */
20016  SCIP_Real val /**< value to return fractional part for */
20017  );
20018 
20019 /** checks, if values are in range of sumepsilon */
20020 extern
20022  SCIP* scip, /**< SCIP data structure */
20023  SCIP_Real val1, /**< first value to be compared */
20024  SCIP_Real val2 /**< second value to be compared */
20025  );
20026 
20027 /** checks, if val1 is (more than sumepsilon) lower than val2 */
20028 extern
20030  SCIP* scip, /**< SCIP data structure */
20031  SCIP_Real val1, /**< first value to be compared */
20032  SCIP_Real val2 /**< second value to be compared */
20033  );
20034 
20035 /** checks, if val1 is not (more than sumepsilon) greater than val2 */
20036 extern
20038  SCIP* scip, /**< SCIP data structure */
20039  SCIP_Real val1, /**< first value to be compared */
20040  SCIP_Real val2 /**< second value to be compared */
20041  );
20042 
20043 /** checks, if val1 is (more than sumepsilon) greater than val2 */
20044 extern
20046  SCIP* scip, /**< SCIP data structure */
20047  SCIP_Real val1, /**< first value to be compared */
20048  SCIP_Real val2 /**< second value to be compared */
20049  );
20050 
20051 /** checks, if val1 is not (more than sumepsilon) lower than val2 */
20052 extern
20054  SCIP* scip, /**< SCIP data structure */
20055  SCIP_Real val1, /**< first value to be compared */
20056  SCIP_Real val2 /**< second value to be compared */
20057  );
20058 
20059 /** checks, if value is in range sumepsilon of 0.0 */
20060 extern
20062  SCIP* scip, /**< SCIP data structure */
20063  SCIP_Real val /**< value to process */
20064  );
20065 
20066 /** checks, if value is greater than sumepsilon */
20067 extern
20069  SCIP* scip, /**< SCIP data structure */
20070  SCIP_Real val /**< value to process */
20071  );
20072 
20073 /** checks, if value is lower than -sumepsilon */
20074 extern
20076  SCIP* scip, /**< SCIP data structure */
20077  SCIP_Real val /**< value to process */
20078  );
20079 
20080 /** checks, if relative difference of values is in range of feasibility tolerance */
20081 extern
20083  SCIP* scip, /**< SCIP data structure */
20084  SCIP_Real val1, /**< first value to be compared */
20085  SCIP_Real val2 /**< second value to be compared */
20086  );
20087 
20088 /** checks, if relative difference val1 and val2 is lower than feasibility tolerance */
20089 extern
20091  SCIP* scip, /**< SCIP data structure */
20092  SCIP_Real val1, /**< first value to be compared */
20093  SCIP_Real val2 /**< second value to be compared */
20094  );
20095 
20096 /** checks, if relative difference of val1 and val2 is not greater than feasibility tolerance */
20097 extern
20099  SCIP* scip, /**< SCIP data structure */
20100  SCIP_Real val1, /**< first value to be compared */
20101  SCIP_Real val2 /**< second value to be compared */
20102  );
20103 
20104 /** checks, if relative difference of val1 and val2 is greater than feastol */
20105 extern
20107  SCIP* scip, /**< SCIP data structure */
20108  SCIP_Real val1, /**< first value to be compared */
20109  SCIP_Real val2 /**< second value to be compared */
20110  );
20111 
20112 /** checks, if relative difference of val1 and val2 is not lower than -feastol */
20113 extern
20115  SCIP* scip, /**< SCIP data structure */
20116  SCIP_Real val1, /**< first value to be compared */
20117  SCIP_Real val2 /**< second value to be compared */
20118  );
20119 
20120 /** checks, if value is in range feasibility tolerance of 0.0 */
20121 extern
20123  SCIP* scip, /**< SCIP data structure */
20124  SCIP_Real val /**< value to process */
20125  );
20126 
20127 /** checks, if value is greater than feasibility tolerance */
20128 extern
20130  SCIP* scip, /**< SCIP data structure */
20131  SCIP_Real val /**< value to process */
20132  );
20133 
20134 /** checks, if value is lower than -feasibility tolerance */
20135 extern
20137  SCIP* scip, /**< SCIP data structure */
20138  SCIP_Real val /**< value to process */
20139  );
20140 
20141 /** checks, if value is integral within the LP feasibility bounds */
20142 extern
20144  SCIP* scip, /**< SCIP data structure */
20145  SCIP_Real val /**< value to process */
20146  );
20147 
20148 /** checks, if given fractional part is smaller than feastol */
20149 extern
20151  SCIP* scip, /**< SCIP data structure */
20152  SCIP_Real val /**< value to process */
20153  );
20154 
20155 /** rounds value + feasibility tolerance down to the next integer */
20156 extern
20158  SCIP* scip, /**< SCIP data structure */
20159  SCIP_Real val /**< value to process */
20160  );
20161 
20162 /** rounds value - feasibility tolerance up to the next integer */
20163 extern
20165  SCIP* scip, /**< SCIP data structure */
20166  SCIP_Real val /**< value to process */
20167  );
20168 
20169 /** rounds value to the nearest integer in feasibility tolerance */
20170 extern
20172  SCIP* scip, /**< SCIP data structure */
20173  SCIP_Real val /**< value to process */
20174  );
20175 
20176 /** returns fractional part of value, i.e. x - floor(x) */
20177 extern
20179  SCIP* scip, /**< SCIP data structure */
20180  SCIP_Real val /**< value to process */
20181  );
20182 
20183 /** checks, if relative difference of values is in range of dual feasibility tolerance */
20184 extern
20186  SCIP* scip, /**< SCIP data structure */
20187  SCIP_Real val1, /**< first value to be compared */
20188  SCIP_Real val2 /**< second value to be compared */
20189  );
20190 
20191 /** checks, if relative difference val1 and val2 is lower than dual feasibility tolerance */
20192 extern
20194  SCIP* scip, /**< SCIP data structure */
20195  SCIP_Real val1, /**< first value to be compared */
20196  SCIP_Real val2 /**< second value to be compared */
20197  );
20198 
20199 /** checks, if relative difference of val1 and val2 is not greater than dual feasibility tolerance */
20200 extern
20202  SCIP* scip, /**< SCIP data structure */
20203  SCIP_Real val1, /**< first value to be compared */
20204  SCIP_Real val2 /**< second value to be compared */
20205  );
20206 
20207 /** checks, if relative difference of val1 and val2 is greater than dual feasibility tolerance */
20208 extern
20210  SCIP* scip, /**< SCIP data structure */
20211  SCIP_Real val1, /**< first value to be compared */
20212  SCIP_Real val2 /**< second value to be compared */
20213  );
20214 
20215 /** checks, if relative difference of val1 and val2 is not lower than -dual feasibility tolerance */
20216 extern
20218  SCIP* scip, /**< SCIP data structure */
20219  SCIP_Real val1, /**< first value to be compared */
20220  SCIP_Real val2 /**< second value to be compared */
20221  );
20222 
20223 /** checks, if value is in range dual feasibility tolerance of 0.0 */
20224 extern
20226  SCIP* scip, /**< SCIP data structure */
20227  SCIP_Real val /**< value to process */
20228  );
20229 
20230 /** checks, if value is greater than dual feasibility tolerance */
20231 extern
20233  SCIP* scip, /**< SCIP data structure */
20234  SCIP_Real val /**< value to process */
20235  );
20236 
20237 /** checks, if value is lower than -dual feasibility tolerance */
20238 extern
20240  SCIP* scip, /**< SCIP data structure */
20241  SCIP_Real val /**< value to process */
20242  );
20243 
20244 /** checks, if value is integral within the LP dual feasibility tolerance */
20245 extern
20247  SCIP* scip, /**< SCIP data structure */
20248  SCIP_Real val /**< value to process */
20249  );
20250 
20251 /** checks, if given fractional part is smaller than dual feasibility tolerance */
20252 extern
20254  SCIP* scip, /**< SCIP data structure */
20255  SCIP_Real val /**< value to process */
20256  );
20257 
20258 /** rounds value + dual feasibility tolerance down to the next integer */
20259 extern
20261  SCIP* scip, /**< SCIP data structure */
20262  SCIP_Real val /**< value to process */
20263  );
20264 
20265 /** rounds value - dual feasibility tolerance up to the next integer */
20266 extern
20268  SCIP* scip, /**< SCIP data structure */
20269  SCIP_Real val /**< value to process */
20270  );
20271 
20272 /** rounds value to the nearest integer in dual feasibility tolerance */
20273 extern
20275  SCIP* scip, /**< SCIP data structure */
20276  SCIP_Real val /**< value to process */
20277  );
20278 
20279 /** returns fractional part of value, i.e. x - floor(x) in dual feasibility tolerance */
20280 extern
20282  SCIP* scip, /**< SCIP data structure */
20283  SCIP_Real val /**< value to process */
20284  );
20285 
20286 /** checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
20287 extern
20289  SCIP* scip, /**< SCIP data structure */
20290  SCIP_Real newlb, /**< new lower bound */
20291  SCIP_Real oldlb, /**< old lower bound */
20292  SCIP_Real oldub /**< old upper bound */
20293  );
20294 
20295 /** checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
20297  SCIP* scip, /**< SCIP data structure */
20298  SCIP_Real newub, /**< new upper bound */
20299  SCIP_Real oldlb, /**< old lower bound */
20300  SCIP_Real oldub /**< old upper bound */
20301  );
20302 
20303 /** checks, if relative difference of values is in range of epsilon */
20304 extern
20306  SCIP* scip, /**< SCIP data structure */
20307  SCIP_Real val1, /**< first value to be compared */
20308  SCIP_Real val2 /**< second value to be compared */
20309  );
20310 
20311 /** checks, if relative difference of val1 and val2 is lower than epsilon */
20312 extern
20314  SCIP* scip, /**< SCIP data structure */
20315  SCIP_Real val1, /**< first value to be compared */
20316  SCIP_Real val2 /**< second value to be compared */
20317  );
20318 
20319 /** checks, if relative difference of val1 and val2 is not greater than epsilon */
20320 extern
20322  SCIP* scip, /**< SCIP data structure */
20323  SCIP_Real val1, /**< first value to be compared */
20324  SCIP_Real val2 /**< second value to be compared */
20325  );
20326 
20327 /** checks, if relative difference of val1 and val2 is greater than epsilon */
20328 extern
20330  SCIP* scip, /**< SCIP data structure */
20331  SCIP_Real val1, /**< first value to be compared */
20332  SCIP_Real val2 /**< second value to be compared */
20333  );
20334 
20335 /** checks, if relative difference of val1 and val2 is not lower than -epsilon */
20336 extern
20338  SCIP* scip, /**< SCIP data structure */
20339  SCIP_Real val1, /**< first value to be compared */
20340  SCIP_Real val2 /**< second value to be compared */
20341  );
20342 
20343 /** checks, if relative difference of values is in range of sumepsilon */
20344 extern
20346  SCIP* scip, /**< SCIP data structure */
20347  SCIP_Real val1, /**< first value to be compared */
20348  SCIP_Real val2 /**< second value to be compared */
20349  );
20350 
20351 /** checks, if relative difference of val1 and val2 is lower than sumepsilon */
20352 extern
20354  SCIP* scip, /**< SCIP data structure */
20355  SCIP_Real val1, /**< first value to be compared */
20356  SCIP_Real val2 /**< second value to be compared */
20357  );
20358 
20359 /** checks, if relative difference of val1 and val2 is not greater than sumepsilon */
20360 extern
20362  SCIP* scip, /**< SCIP data structure */
20363  SCIP_Real val1, /**< first value to be compared */
20364  SCIP_Real val2 /**< second value to be compared */
20365  );
20366 
20367 /** checks, if relative difference of val1 and val2 is greater than sumepsilon */
20368 extern
20370  SCIP* scip, /**< SCIP data structure */
20371  SCIP_Real val1, /**< first value to be compared */
20372  SCIP_Real val2 /**< second value to be compared */
20373  );
20374 
20375 /** checks, if relative difference of val1 and val2 is not lower than -sumepsilon */
20376 extern
20378  SCIP* scip, /**< SCIP data structure */
20379  SCIP_Real val1, /**< first value to be compared */
20380  SCIP_Real val2 /**< second value to be compared */
20381  );
20382 
20383 /** converts the given real number representing an integer to an int; in optimized mode the function gets inlined for
20384  * performance; in debug mode we check some additional conditions
20385  */
20386 extern
20388  SCIP* scip, /**< SCIP data structure */
20389  SCIP_Real real /**< double bound to convert */
20390  );
20391 
20392 /** converts the given real number representing an integer to a long integer; in optimized mode the function gets inlined for
20393  * performance; in debug mode we check some additional conditions
20394  */
20395 extern
20397  SCIP* scip, /**< SCIP data structure */
20398  SCIP_Real real /**< double bound to convert */
20399  );
20400 
20401 /** Checks, if an iteratively updated value is reliable or should be recomputed from scratch.
20402  * This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high
20403  * absolute value during the optimization process which is later reduced significantly. In this case, the last digits
20404  * were canceled out when increasing the value and are random after decreasing it.
20405  * We do not consider the cancellations which can occur during increasing the absolute value because they just cannot
20406  * be expressed using fixed precision floating point arithmetic, anymore.
20407  * In order to get more reliable values, the idea is to always store the last reliable value, where increasing the
20408  * absolute of the value is viewed as preserving reliability. Then, after each update, the new absolute value can be
20409  * compared against the last reliable one with this method, checking whether it was decreased by a factor of at least
20410  * "lp/recompfac" and should be recomputed.
20411  */
20412 extern
20414  SCIP* scip, /**< SCIP data structure */
20415  SCIP_Real newvalue, /**< new value after update */
20416  SCIP_Real oldvalue /**< old value, i.e., last reliable value */
20417  );
20418 
20419 #ifdef NDEBUG
20420 
20421 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
20422  * speed up the algorithms.
20423  */
20424 
20425 #define SCIPinfinity(scip) SCIPsetInfinity((scip)->set)
20426 #define SCIPisInfinity(scip, val) SCIPsetIsInfinity((scip)->set, val)
20427 #define SCIPisHugeValue(scip, val) SCIPsetIsHugeValue((scip)->set, val)
20428 #define SCIPgetHugeValue(scip) SCIPsetGetHugeValue((scip)->set)
20429 #define SCIPisEQ(scip, val1, val2) SCIPsetIsEQ((scip)->set, val1, val2)
20430 #define SCIPisLT(scip, val1, val2) SCIPsetIsLT((scip)->set, val1, val2)
20431 #define SCIPisLE(scip, val1, val2) SCIPsetIsLE((scip)->set, val1, val2)
20432 #define SCIPisGT(scip, val1, val2) SCIPsetIsGT((scip)->set, val1, val2)
20433 #define SCIPisGE(scip, val1, val2) SCIPsetIsGE((scip)->set, val1, val2)
20434 #define SCIPisZero(scip, val) SCIPsetIsZero((scip)->set, val)
20435 #define SCIPisPositive(scip, val) SCIPsetIsPositive((scip)->set, val)
20436 #define SCIPisNegative(scip, val) SCIPsetIsNegative((scip)->set, val)
20437 #define SCIPisIntegral(scip, val) SCIPsetIsIntegral((scip)->set, val)
20438 #define SCIPisScalingIntegral(scip, val, scalar) SCIPsetIsScalingIntegral((scip)->set, val, scalar)
20439 #define SCIPisFracIntegral(scip, val) SCIPsetIsFracIntegral((scip)->set, val)
20440 #define SCIPfloor(scip, val) SCIPsetFloor((scip)->set, val)
20441 #define SCIPceil(scip, val) SCIPsetCeil((scip)->set, val)
20442 #define SCIPround(scip, val) SCIPsetRound((scip)->set, val)
20443 #define SCIPfrac(scip, val) SCIPsetFrac((scip)->set, val)
20444 
20445 #define SCIPisSumEQ(scip, val1, val2) SCIPsetIsSumEQ((scip)->set, val1, val2)
20446 #define SCIPisSumLT(scip, val1, val2) SCIPsetIsSumLT((scip)->set, val1, val2)
20447 #define SCIPisSumLE(scip, val1, val2) SCIPsetIsSumLE((scip)->set, val1, val2)
20448 #define SCIPisSumGT(scip, val1, val2) SCIPsetIsSumGT((scip)->set, val1, val2)
20449 #define SCIPisSumGE(scip, val1, val2) SCIPsetIsSumGE((scip)->set, val1, val2)
20450 #define SCIPisSumZero(scip, val) SCIPsetIsSumZero((scip)->set, val)
20451 #define SCIPisSumPositive(scip, val) SCIPsetIsSumPositive((scip)->set, val)
20452 #define SCIPisSumNegative(scip, val) SCIPsetIsSumNegative((scip)->set, val)
20453 
20454 #define SCIPisFeasEQ(scip, val1, val2) SCIPsetIsFeasEQ((scip)->set, val1, val2)
20455 #define SCIPisFeasLT(scip, val1, val2) SCIPsetIsFeasLT((scip)->set, val1, val2)
20456 #define SCIPisFeasLE(scip, val1, val2) SCIPsetIsFeasLE((scip)->set, val1, val2)
20457 #define SCIPisFeasGT(scip, val1, val2) SCIPsetIsFeasGT((scip)->set, val1, val2)
20458 #define SCIPisFeasGE(scip, val1, val2) SCIPsetIsFeasGE((scip)->set, val1, val2)
20459 #define SCIPisFeasZero(scip, val) SCIPsetIsFeasZero((scip)->set, val)
20460 #define SCIPisFeasPositive(scip, val) SCIPsetIsFeasPositive((scip)->set, val)
20461 #define SCIPisFeasNegative(scip, val) SCIPsetIsFeasNegative((scip)->set, val)
20462 #define SCIPisFeasIntegral(scip, val) SCIPsetIsFeasIntegral((scip)->set, val)
20463 #define SCIPisFeasFracIntegral(scip, val) SCIPsetIsFeasFracIntegral((scip)->set, val)
20464 #define SCIPfeasFloor(scip, val) SCIPsetFeasFloor((scip)->set, val)
20465 #define SCIPfeasCeil(scip, val) SCIPsetFeasCeil((scip)->set, val)
20466 #define SCIPfeasRound(scip, val) SCIPsetFeasRound((scip)->set, val)
20467 #define SCIPfeasFrac(scip, val) SCIPsetFeasFrac((scip)->set, val)
20468 
20469 #define SCIPisDualfeasEQ(scip, val1, val2) SCIPsetIsDualfeasEQ((scip)->set, val1, val2)
20470 #define SCIPisDualfeasLT(scip, val1, val2) SCIPsetIsDualfeasLT((scip)->set, val1, val2)
20471 #define SCIPisDualfeasLE(scip, val1, val2) SCIPsetIsDualfeasLE((scip)->set, val1, val2)
20472 #define SCIPisDualfeasGT(scip, val1, val2) SCIPsetIsDualfeasGT((scip)->set, val1, val2)
20473 #define SCIPisDualfeasGE(scip, val1, val2) SCIPsetIsDualfeasGE((scip)->set, val1, val2)
20474 #define SCIPisDualfeasZero(scip, val) SCIPsetIsDualfeasZero((scip)->set, val)
20475 #define SCIPisDualfeasPositive(scip, val) SCIPsetIsDualfeasPositive((scip)->set, val)
20476 #define SCIPisDualfeasNegative(scip, val) SCIPsetIsDualfeasNegative((scip)->set, val)
20477 #define SCIPisDualfeasIntegral(scip, val) SCIPsetIsDualfeasIntegral((scip)->set, val)
20478 #define SCIPisDualfeasFracIntegral(scip, val) SCIPsetIsDualfeasFracIntegral((scip)->set, val)
20479 #define SCIPdualfeasFloor(scip, val) SCIPsetDualfeasFloor((scip)->set, val)
20480 #define SCIPdualfeasCeil(scip, val) SCIPsetDualfeasCeil((scip)->set, val)
20481 #define SCIPdualfeasRound(scip, val) SCIPsetDualfeasRound((scip)->set, val)
20482 #define SCIPdualfeasFrac(scip, val) SCIPsetDualfeasFrac((scip)->set, val)
20483 
20484 #define SCIPisLbBetter(scip, newlb, oldlb, oldub) SCIPsetIsLbBetter(scip->set, newlb, oldlb, oldub)
20485 #define SCIPisUbBetter(scip, newub, oldlb, oldub) SCIPsetIsUbBetter(scip->set, newub, oldlb, oldub)
20486 
20487 #define SCIPisRelEQ(scip, val1, val2) SCIPsetIsRelEQ((scip)->set, val1, val2)
20488 #define SCIPisRelLT(scip, val1, val2) SCIPsetIsRelLT((scip)->set, val1, val2)
20489 #define SCIPisRelLE(scip, val1, val2) SCIPsetIsRelLE((scip)->set, val1, val2)
20490 #define SCIPisRelGT(scip, val1, val2) SCIPsetIsRelGT((scip)->set, val1, val2)
20491 #define SCIPisRelGE(scip, val1, val2) SCIPsetIsRelGE((scip)->set, val1, val2)
20492 
20493 #define SCIPisSumRelEQ(scip, val1, val2) SCIPsetIsSumRelEQ((scip)->set, val1, val2)
20494 #define SCIPisSumRelLT(scip, val1, val2) SCIPsetIsSumRelLT((scip)->set, val1, val2)
20495 #define SCIPisSumRelLE(scip, val1, val2) SCIPsetIsSumRelLE((scip)->set, val1, val2)
20496 #define SCIPisSumRelGT(scip, val1, val2) SCIPsetIsSumRelGT((scip)->set, val1, val2)
20497 #define SCIPisSumRelGE(scip, val1, val2) SCIPsetIsSumRelGE((scip)->set, val1, val2)
20498 #define SCIPconvertRealToInt(scip, real) ((int)((real) < 0 ? ((real) - 0.5) : ((real) + 0.5)))
20499 #define SCIPconvertRealToLongint(scip, real) ((SCIP_Longint)((real) < 0 ? ((real) - 0.5) : ((real) + 0.5)))
20500 
20501 #define SCIPisUpdateUnreliable(scip, newval, oldval) SCIPsetIsUpdateUnreliable((scip)->set, newval, oldval)
20502 #endif
20503 
20504 /** outputs a real number, or "+infinity", or "-infinity" to a file */
20505 extern
20506 void SCIPprintReal(
20507  SCIP* scip, /**< SCIP data structure */
20508  FILE* file, /**< output file (or NULL for standard output) */
20509  SCIP_Real val, /**< value to print */
20510  int width, /**< width of the field */
20511  int precision /**< number of significant digits printed */
20512  );
20513 
20514 /**@} */
20515 
20516 
20517 
20518 
20519 /*
20520  * memory management
20521  */
20522 
20523 /**@name Standard Memory Management Macros */
20524 /**@{ */
20525 
20526 #define SCIPallocMemory(scip,ptr) ( (BMSallocMemory((ptr)) == NULL) \
20527  ? SCIP_NOMEMORY : SCIP_OKAY )
20528 #define SCIPallocMemoryArray(scip,ptr,num) ( (BMSallocMemoryArray((ptr), (num)) == NULL) \
20529  ? SCIP_NOMEMORY : SCIP_OKAY )
20530 #define SCIPallocClearMemoryArray(scip,ptr,num) ( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \
20531  ? SCIP_NOMEMORY : SCIP_OKAY )
20532 #define SCIPallocMemorySize(scip,ptr,size) ( (BMSallocMemorySize((ptr), (size)) == NULL) \
20533  ? SCIP_NOMEMORY : SCIP_OKAY )
20534 #define SCIPreallocMemoryArray(scip,ptr,newnum) ( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \
20535  ? SCIP_NOMEMORY : SCIP_OKAY )
20536 #define SCIPreallocMemorySize(scip,ptr,newsize) ( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \
20537  ? SCIP_NOMEMORY : SCIP_OKAY )
20538 #define SCIPduplicateMemory(scip, ptr, source) ( (BMSduplicateMemory((ptr), (source)) == NULL) \
20539  ? SCIP_NOMEMORY : SCIP_OKAY )
20540 #define SCIPduplicateMemoryArray(scip, ptr, source, num) ( (BMSduplicateMemoryArray((ptr), (source), (num)) == NULL) \
20541  ? SCIP_NOMEMORY : SCIP_OKAY )
20542 #define SCIPfreeMemory(scip,ptr) BMSfreeMemory(ptr)
20543 #define SCIPfreeMemoryNull(scip,ptr) BMSfreeMemoryNull(ptr)
20544 #define SCIPfreeMemoryArray(scip,ptr) BMSfreeMemoryArray(ptr)
20545 #define SCIPfreeMemoryArrayNull(scip,ptr) BMSfreeMemoryArrayNull(ptr)
20546 #define SCIPfreeMemorySize(scip,ptr) BMSfreeMemorySize(ptr)
20547 #define SCIPfreeMemorySizeNull(scip,ptr) BMSfreeMemorySizeNull(ptr)
20548 /**@} */
20549 
20550 
20551 /**@name Block Memory Management Macros */
20552 /**@{ */
20553 
20554 #define SCIPallocBlockMemory(scip,ptr) ( (BMSallocBlockMemory(SCIPblkmem(scip), (ptr)) == NULL) \
20555  ? SCIP_NOMEMORY : SCIP_OKAY )
20556 #define SCIPallocBlockMemoryArray(scip,ptr,num) ( (BMSallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
20557  ? SCIP_NOMEMORY : SCIP_OKAY )
20558 #define SCIPallocBlockMemorySize(scip,ptr,size) ( (BMSallocBlockMemorySize(SCIPblkmem(scip), (ptr), (size)) == NULL) \
20559  ? SCIP_NOMEMORY : SCIP_OKAY )
20560 #define SCIPallocClearBlockMemoryArray(scip,ptr,num) ( (BMSallocClearBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
20561  ? SCIP_NOMEMORY : SCIP_OKAY )
20562 #define SCIPreallocBlockMemoryArray(scip,ptr,oldnum,newnum) ( (BMSreallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (oldnum), (newnum)) == NULL) \
20563  ? SCIP_NOMEMORY : SCIP_OKAY )
20564 #define SCIPreallocBlockMemorySize(scip,ptr,oldsize,newsize) ( (BMSreallocBlockMemorySize(SCIPblkmem(scip), (ptr), (oldsize), (newsize)) == NULL) \
20565  ? SCIP_NOMEMORY : SCIP_OKAY )
20566 #define SCIPduplicateBlockMemory(scip, ptr, source) ( (BMSduplicateBlockMemory(SCIPblkmem(scip), (ptr), (source)) == NULL) \
20567  ? SCIP_NOMEMORY : SCIP_OKAY )
20568 #define SCIPduplicateBlockMemoryArray(scip, ptr, source, num) ( (BMSduplicateBlockMemoryArray(SCIPblkmem(scip), (ptr), (source), (num)) == NULL) \
20569  ? SCIP_NOMEMORY : SCIP_OKAY )
20570 #define SCIPensureBlockMemoryArray(scip,ptr,arraysizeptr,minsize) ( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), (arraysizeptr), (minsize))) )
20571 #define SCIPfreeBlockMemory(scip,ptr) BMSfreeBlockMemory(SCIPblkmem(scip), (ptr))
20572 #define SCIPfreeBlockMemoryNull(scip,ptr) BMSfreeBlockMemoryNull(SCIPblkmem(scip), (ptr))
20573 #define SCIPfreeBlockMemoryArray(scip,ptr,num) BMSfreeBlockMemoryArray(SCIPblkmem(scip), (ptr), (num))
20574 #define SCIPfreeBlockMemoryArrayNull(scip,ptr,num) BMSfreeBlockMemoryArrayNull(SCIPblkmem(scip), (ptr), (num))
20575 #define SCIPfreeBlockMemorySize(scip,ptr,size) BMSfreeBlockMemorySize(SCIPblkmem(scip), (ptr), (size))
20576 #define SCIPfreeBlockMemorySizeNull(scip,ptr,size) BMSfreeBlockMemorySizeNull(SCIPblkmem(scip), (ptr), (size))
20577 /**@} */
20578 
20579 
20580 /**@name Buffer Memory Management Macros */
20581 /**@{ */
20582 
20583 #define SCIPallocBuffer(scip,ptr) ( (BMSallocBufferMemory(SCIPbuffer(scip), (ptr)) == NULL) \
20584  ? SCIP_NOMEMORY : SCIP_OKAY )
20585 #define SCIPallocBufferArray(scip,ptr,num) ( (BMSallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
20586  ? SCIP_NOMEMORY : SCIP_OKAY )
20587 #define SCIPallocClearBufferArray(scip,ptr,num) ( (BMSallocClearBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
20588  ? SCIP_NOMEMORY : SCIP_OKAY )
20589 #define SCIPreallocBufferArray(scip,ptr,num) ( (BMSreallocBufferMemoryArray(SCIPbuffer(scip), (ptr), (num)) == NULL) \
20590  ? SCIP_NOMEMORY : SCIP_OKAY )
20591 #define SCIPduplicateBuffer(scip,ptr,source) ( (BMSduplicateBufferMemory(SCIPbuffer(scip), (ptr), (source), (size_t)sizeof(**(ptr))) \
20592  ? SCIP_NOMEMORY : SCIP_OKAY )
20593 #define SCIPduplicateBufferArray(scip,ptr,source,num) ( (BMSduplicateBufferMemoryArray(SCIPbuffer(scip), (ptr), (source), (num)) == NULL) \
20594  ? SCIP_NOMEMORY : SCIP_OKAY )
20595 #define SCIPfreeBuffer(scip,ptr) BMSfreeBufferMemorySize(SCIPbuffer(scip), (ptr))
20596 #define SCIPfreeBufferNull(scip,ptr) BMSfreeBufferMemoryNull(SCIPbuffer(scip), (ptr))
20597 #define SCIPfreeBufferArray(scip,ptr) BMSfreeBufferMemoryArray(SCIPbuffer(scip), (ptr))
20598 #define SCIPfreeBufferArrayNull(scip,ptr) BMSfreeBufferMemoryArrayNull(SCIPbuffer(scip), (ptr))
20599 
20600 
20601 #define SCIPallocCleanBuffer(scip,ptr) ( (BMSallocBufferMemory(SCIPcleanbuffer(scip), (ptr)) == NULL) \
20602  ? SCIP_NOMEMORY : SCIP_OKAY )
20603 #define SCIPallocCleanBufferArray(scip,ptr,num) ( (BMSallocBufferMemoryArray(SCIPcleanbuffer(scip), (ptr), (num)) == NULL) \
20604  ? SCIP_NOMEMORY : SCIP_OKAY )
20605 #define SCIPfreeCleanBuffer(scip,ptr) BMSfreeBufferMemorySize(SCIPcleanbuffer(scip), (ptr))
20606 #define SCIPfreeCleanBufferNull(scip,ptr) BMSfreeBufferMemoryNull(SCIPcleanbuffer(scip), (ptr))
20607 #define SCIPfreeCleanBufferArray(scip,ptr) BMSfreeBufferMemoryArray(SCIPcleanbuffer(scip), (ptr))
20608 #define SCIPfreeCleanBufferArrayNull(scip,ptr) BMSfreeBufferMemoryArrayNull(SCIPcleanbuffer(scip), (ptr))
20609 
20610 /**@} */
20611 
20612 
20613 /**@name Memory Management Functions */
20614 /**@{ */
20615 
20616 /** returns block memory to use at the current time
20617  *
20618  * @return the block memory to use at the current time.
20619  */
20620 extern
20621 BMS_BLKMEM* SCIPblkmem(
20622  SCIP* scip /**< SCIP data structure */
20623  );
20624 
20625 /** returns buffer memory for short living temporary objects
20626  *
20627  * @return the buffer memory for short living temporary objects
20628  */
20629 extern
20630 BMS_BUFMEM* SCIPbuffer(
20631  SCIP* scip /**< SCIP data structure */
20632  );
20633 
20634 /** returns clean buffer memory for short living temporary objects initialized to all zero
20635  *
20636  * @return the buffer memory for short living temporary objects initialized to all zero
20637  */
20638 extern
20639 BMS_BUFMEM* SCIPcleanbuffer(
20640  SCIP* scip /**< SCIP data structure */
20641  );
20642 
20643 /** returns the total number of bytes used in block and buffer memory
20644  *
20645  * @return the total number of bytes used in block and buffer memory.
20646  */
20647 extern
20649  SCIP* scip /**< SCIP data structure */
20650  );
20651 
20652 /** returns the estimated number of bytes used by external software, e.g., the LP solver
20653  *
20654  * @return the estimated number of bytes used by external software, e.g., the LP solver.
20655  */
20656 extern
20658  SCIP* scip /**< SCIP data structure */
20659  );
20660 
20661 /** calculate memory size for dynamically allocated arrays
20662  *
20663  * @return the memory size for dynamically allocated arrays.
20664  */
20665 extern
20667  SCIP* scip, /**< SCIP data structure */
20668  int num /**< minimum number of entries to store */
20669  );
20670 
20671 /** extends a dynamically allocated block memory array to be able to store at least the given number of elements;
20672  * use SCIPensureBlockMemoryArray() define to call this method!
20673  *
20674  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20675  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20676  */
20677 extern
20679  SCIP* scip, /**< SCIP data structure */
20680  void** arrayptr, /**< pointer to dynamically sized array */
20681  size_t elemsize, /**< size in bytes of each element in array */
20682  int* arraysize, /**< pointer to current array size */
20683  int minsize /**< required minimal array size */
20684  );
20685 
20686 /** prints output about used memory */
20687 extern
20689  SCIP* scip /**< SCIP data structure */
20690  );
20691 
20692 /**@} */
20693 
20694 
20695 
20696 
20697 /*
20698  * dynamic arrays
20699  */
20700 
20701 /**@name Dynamic Arrays */
20702 /**@{ */
20703 
20704 /** creates a dynamic array of real values
20705  *
20706  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20707  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20708  */
20709 extern
20711  SCIP* scip, /**< SCIP data structure */
20712  SCIP_REALARRAY** realarray /**< pointer to store the real array */
20713  );
20714 
20715 /** frees a dynamic array of real values
20716  *
20717  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20718  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20719  */
20720 extern
20722  SCIP* scip, /**< SCIP data structure */
20723  SCIP_REALARRAY** realarray /**< pointer to the real array */
20724  );
20725 
20726 /** extends dynamic array to be able to store indices from minidx to maxidx
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 extern
20733  SCIP* scip, /**< SCIP data structure */
20734  SCIP_REALARRAY* realarray, /**< dynamic real array */
20735  int minidx, /**< smallest index to allocate storage for */
20736  int maxidx /**< largest index to allocate storage for */
20737  );
20738 
20739 /** clears a dynamic real array
20740  *
20741  * @return clears a dynamic real array
20742  */
20743 extern
20745  SCIP* scip, /**< SCIP data structure */
20746  SCIP_REALARRAY* realarray /**< dynamic real array */
20747  );
20748 
20749 /** gets value of entry in dynamic array */
20750 extern
20752  SCIP* scip, /**< SCIP data structure */
20753  SCIP_REALARRAY* realarray, /**< dynamic real array */
20754  int idx /**< array index to get value for */
20755  );
20756 
20757 /** sets value of entry in dynamic array
20758  *
20759  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20760  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20761  */
20762 extern
20764  SCIP* scip, /**< SCIP data structure */
20765  SCIP_REALARRAY* realarray, /**< dynamic real array */
20766  int idx, /**< array index to set value for */
20767  SCIP_Real val /**< value to set array index to */
20768  );
20769 
20770 /** increases value of entry in dynamic array
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 extern
20777  SCIP* scip, /**< SCIP data structure */
20778  SCIP_REALARRAY* realarray, /**< dynamic real array */
20779  int idx, /**< array index to increase value for */
20780  SCIP_Real incval /**< value to increase array index */
20781  );
20782 
20783 /** returns the minimal index of all stored non-zero elements
20784  *
20785  * @return the minimal index of all stored non-zero elements
20786  */
20787 extern
20789  SCIP* scip, /**< SCIP data structure */
20790  SCIP_REALARRAY* realarray /**< dynamic real array */
20791  );
20792 
20793 /** returns the maximal index of all stored non-zero elements
20794  *
20795  * @return the maximal index of all stored non-zero elements
20796  */
20797 extern
20799  SCIP* scip, /**< SCIP data structure */
20800  SCIP_REALARRAY* realarray /**< dynamic real array */
20801  );
20802 
20803 /** creates a dynamic array of int values
20804  *
20805  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20806  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20807  */
20808 extern
20810  SCIP* scip, /**< SCIP data structure */
20811  SCIP_INTARRAY** intarray /**< pointer to store the int array */
20812  );
20813 
20814 /** frees a dynamic array of int values
20815  *
20816  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20817  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20818  */
20819 extern
20821  SCIP* scip, /**< SCIP data structure */
20822  SCIP_INTARRAY** intarray /**< pointer to the int array */
20823  );
20824 
20825 /** extends dynamic array to be able to store indices from minidx to maxidx
20826  *
20827  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20828  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20829  */
20830 extern
20832  SCIP* scip, /**< SCIP data structure */
20833  SCIP_INTARRAY* intarray, /**< dynamic int array */
20834  int minidx, /**< smallest index to allocate storage for */
20835  int maxidx /**< largest index to allocate storage for */
20836  );
20837 
20838 /** clears a dynamic int array
20839  *
20840  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20841  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20842  */
20843 extern
20845  SCIP* scip, /**< SCIP data structure */
20846  SCIP_INTARRAY* intarray /**< dynamic int array */
20847  );
20848 
20849 /** gets value of entry in dynamic array
20850  *
20851  * @return value of entry in dynamic array
20852  */
20853 extern
20854 int SCIPgetIntarrayVal(
20855  SCIP* scip, /**< SCIP data structure */
20856  SCIP_INTARRAY* intarray, /**< dynamic int array */
20857  int idx /**< array index to get value for */
20858  );
20859 
20860 /** sets value of entry in dynamic array
20861  *
20862  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20863  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20864  */
20865 extern
20867  SCIP* scip, /**< SCIP data structure */
20868  SCIP_INTARRAY* intarray, /**< dynamic int array */
20869  int idx, /**< array index to set value for */
20870  int val /**< value to set array index to */
20871  );
20872 
20873 /** increases value of entry in dynamic array
20874  *
20875  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20876  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20877  */
20878 extern
20880  SCIP* scip, /**< SCIP data structure */
20881  SCIP_INTARRAY* intarray, /**< dynamic int array */
20882  int idx, /**< array index to increase value for */
20883  int incval /**< value to increase array index */
20884  );
20885 
20886 /** returns the minimal index of all stored non-zero elements
20887  *
20888  * @return the minimal index of all stored non-zero elements
20889  */
20890 extern
20892  SCIP* scip, /**< SCIP data structure */
20893  SCIP_INTARRAY* intarray /**< dynamic int array */
20894  );
20895 
20896 /** returns the maximal index of all stored non-zero elements
20897  *
20898  * @return the maximal index of all stored non-zero elements
20899  */
20900 extern
20902  SCIP* scip, /**< SCIP data structure */
20903  SCIP_INTARRAY* intarray /**< dynamic int array */
20904  );
20905 
20906 /** creates a dynamic array of bool values
20907  *
20908  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20909  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20910  */
20911 extern
20913  SCIP* scip, /**< SCIP data structure */
20914  SCIP_BOOLARRAY** boolarray /**< pointer to store the bool array */
20915  );
20916 
20917 /** frees a dynamic array of bool values
20918  *
20919  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20920  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20921  */
20922 extern
20924  SCIP* scip, /**< SCIP data structure */
20925  SCIP_BOOLARRAY** boolarray /**< pointer to the bool array */
20926  );
20927 
20928 /** extends dynamic array to be able to store indices from minidx to maxidx
20929  *
20930  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20931  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20932  */
20933 extern
20935  SCIP* scip, /**< SCIP data structure */
20936  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
20937  int minidx, /**< smallest index to allocate storage for */
20938  int maxidx /**< largest index to allocate storage for */
20939  );
20940 
20941 /** clears a dynamic bool array
20942  *
20943  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20944  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20945  */
20946 extern
20948  SCIP* scip, /**< SCIP data structure */
20949  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
20950  );
20951 
20952 /** gets value of entry in dynamic array
20953  *
20954  * @return value of entry in dynamic array at position idx
20955  */
20956 extern
20958  SCIP* scip, /**< SCIP data structure */
20959  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
20960  int idx /**< array index to get value for */
20961  );
20962 
20963 /** sets value of entry in dynamic array
20964  *
20965  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20966  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
20967  */
20968 extern
20970  SCIP* scip, /**< SCIP data structure */
20971  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
20972  int idx, /**< array index to set value for */
20973  SCIP_Bool val /**< value to set array index to */
20974  );
20975 
20976 /** returns the minimal index of all stored non-zero elements
20977  *
20978  * @return the minimal index of all stored non-zero elements
20979  */
20980 extern
20982  SCIP* scip, /**< SCIP data structure */
20983  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
20984  );
20985 
20986 /** returns the maximal index of all stored non-zero elements
20987  *
20988  * @return the maximal index of all stored non-zero elements
20989  */
20990 extern
20992  SCIP* scip, /**< SCIP data structure */
20993  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
20994  );
20995 
20996 /** creates a dynamic array of pointers
20997  *
20998  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
20999  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21000  */
21001 extern
21003  SCIP* scip, /**< SCIP data structure */
21004  SCIP_PTRARRAY** ptrarray /**< pointer to store the int array */
21005  );
21006 
21007 /** frees a dynamic array of pointers
21008  *
21009  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21010  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21011  */
21012 extern
21014  SCIP* scip, /**< SCIP data structure */
21015  SCIP_PTRARRAY** ptrarray /**< pointer to the int array */
21016  );
21017 
21018 /** extends dynamic array to be able to store indices from minidx to maxidx
21019  *
21020  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21021  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21022  */
21023 extern
21025  SCIP* scip, /**< SCIP data structure */
21026  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
21027  int minidx, /**< smallest index to allocate storage for */
21028  int maxidx /**< largest index to allocate storage for */
21029  );
21030 
21031 /** clears a dynamic pointer array
21032  *
21033  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21034  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21035  */
21036 extern
21038  SCIP* scip, /**< SCIP data structure */
21039  SCIP_PTRARRAY* ptrarray /**< dynamic int array */
21040  );
21041 
21042 /** gets value of entry in dynamic array */
21043 extern
21044 void* SCIPgetPtrarrayVal(
21045  SCIP* scip, /**< SCIP data structure */
21046  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
21047  int idx /**< array index to get value for */
21048  );
21049 
21050 /** sets value of entry in dynamic array
21051  *
21052  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
21053  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
21054  */
21055 extern
21057  SCIP* scip, /**< SCIP data structure */
21058  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
21059  int idx, /**< array index to set value for */
21060  void* val /**< value to set array index to */
21061  );
21062 
21063 /** returns the minimal index of all stored non-zero elements
21064  *
21065  * @return the minimal index of all stored non-zero elements
21066  */
21067 extern
21069  SCIP* scip, /**< SCIP data structure */
21070  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
21071  );
21072 
21073 /** returns the maximal index of all stored non-zero elements
21074  *
21075  * @return the maximal index of all stored non-zero elements
21076  */
21077 extern
21079  SCIP* scip, /**< SCIP data structure */
21080  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
21081  );
21082 
21083 
21084 /**@} */
21085 #ifdef __cplusplus
21086 }
21087 #endif
21088 
21089 #endif
SCIP_Real SCIPdualfeasCeil(SCIP *scip, SCIP_Real val)
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:51
int SCIPgetNOrigIntVars(SCIP *scip)
SCIP_RETCODE SCIPsetNLPRealPar(SCIP *scip, SCIP_NLPPARAM type, SCIP_Real dval)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_RETCODE SCIPsetPresolInitpre(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINITPRE((*presolinitpre)))
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPrestartSolve(SCIP *scip)
SCIP_RETCODE SCIPgetOpenNodesData(SCIP *scip, SCIP_NODE ***leaves, SCIP_NODE ***children, SCIP_NODE ***siblings, int *nleaves, int *nchildren, int *nsiblings)
SCIP_RETCODE SCIPlinkRelaxSol(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPdeleteReoptnode(SCIP *scip, SCIP_REOPTNODE **reoptnode)
SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
SCIP_RETCODE SCIPsetNlRowExprtreeParam(SCIP *scip, SCIP_NLROW *nlrow, int paramidx, SCIP_Real paramval)
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
struct SCIP_Nlpi SCIP_NLPI
Definition: type_nlpi.h:37
SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
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)
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
void SCIPprintError(SCIP_RETCODE retcode)
#define SCIP_DECL_RELAXFREE(x)
Definition: type_relax.h:55
void SCIPenableDebugSol(SCIP *scip)
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:50
SCIP_RETCODE SCIPstartClock(SCIP *scip, SCIP_CLOCK *clck)
char ** SCIPgetExternalCodeDescriptions(SCIP *scip)
SCIP_RETCODE SCIPcopyImplicationsCliques(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *infeasible, int *nbdchgs, int *ncopied)
SCIP_RETCODE SCIPsetSepaInit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINIT((*sepainit)))
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
SCIP_Real SCIPgetFirstLPTime(SCIP *scip)
SCIP_RETCODE SCIPsetBranchruleInit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINIT((*branchinit)))
SCIP_RETCODE SCIPcreateNlRowFromRow(SCIP *scip, SCIP_NLROW **nlrow, SCIP_ROW *row)
SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
SCIP_COMPR ** SCIPgetComprs(SCIP *scip)
SCIP_RETCODE SCIPsetPricerPriority(SCIP *scip, SCIP_PRICER *pricer, int priority)
SCIP_RETCODE SCIPdelRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
struct SCIP_Dialog SCIP_DIALOG
Definition: type_dialog.h:41
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
struct SCIP_Heur SCIP_HEUR
Definition: type_heur.h:50
int SCIPgetNObjVars(SCIP *scip)
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
#define SCIP_DECL_NODESELCOMP(x)
Definition: type_nodesel.h:126
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
int SCIPgetNBinVars(SCIP *scip)
struct SCIP_PresolData SCIP_PRESOLDATA
Definition: type_presol.h:37
SCIP_RETCODE SCIPsetBranchruleExit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))
#define SCIP_DECL_HEURINITSOL(x)
Definition: type_heur.h:95
SCIP_RETCODE SCIPsetNLPStringPar(SCIP *scip, SCIP_NLPPARAM type, const char *sval)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPincludeNlpi(SCIP *scip, SCIP_NLPI *nlpi)
#define SCIP_DECL_DISPINITSOL(x)
Definition: type_disp.h:97
int SCIPgetNRelaxs(SCIP *scip)
SCIP_RETCODE SCIPsetNodeselInitsol(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELINITSOL((*nodeselinitsol)))
SCIP_RETCODE SCIPisConflictVarUsed(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
SCIP_RETCODE SCIPdeactiveCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))
enum SCIP_NlpTermStat SCIP_NLPTERMSTAT
Definition: type_nlpi.h:85
int SCIPgetNNLPVars(SCIP *scip)
#define SCIP_DECL_EVENTDELETE(x)
Definition: type_event.h:211
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
SCIP_RETCODE SCIPsetNLPIntPar(SCIP *scip, SCIP_NLPPARAM type, int ival)
SCIP_Real SCIPgetClockTime(SCIP *scip, SCIP_CLOCK *clck)
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)
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
SCIP_RETCODE SCIPgetIntParam(SCIP *scip, const char *name, int *value)
SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
#define SCIP_DECL_EVENTEXIT(x)
Definition: type_event.h:180
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
SCIP_RETCODE SCIPgetNlRowPseudoActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudoactivity)
SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIPgetTimeOfDay(SCIP *scip)
void SCIPenableVarHistory(SCIP *scip)
SCIP_RETCODE SCIPsetNlpiPriority(SCIP *scip, SCIP_NLPI *nlpi, int priority)
SCIP_Real SCIPgetReadingTime(SCIP *scip)
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
SCIP_Bool SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPversion(void)
public methods for branching and inference history structure
SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPrecalcNlRowPseudoActivity(SCIP *scip, SCIP_NLROW *nlrow)
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)
SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
SCIP_Bool SCIPisDualfeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
struct SCIP_DispData SCIP_DISPDATA
Definition: type_disp.h:53
struct SCIP_Cons SCIP_CONS
Definition: type_cons.h:48
int SCIPgetNProps(SCIP *scip)
public methods for branch and bound tree
SCIP_RETCODE SCIPgetNLPI(SCIP *scip, SCIP_NLPI **nlpi, SCIP_NLPIPROBLEM **nlpiproblem)
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
type definitions for miscellaneous datastructures
timing definitions for SCIP
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
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)
SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)
SCIP_RETCODE SCIPcaptureRow(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPwriteVarsPolynomial(SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
SCIP_RETCODE SCIPincludeExternalCodeInformation(SCIP *scip, const char *name, const char *description)
#define SCIP_DECL_CONSLOCK(x)
Definition: type_cons.h:591
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
#define SCIP_DECL_COMPREXEC(x)
Definition: type_compr.h:111
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPfreeProb(SCIP *scip)
SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPisSumGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetIntarrayMinIdx(SCIP *scip, SCIP_INTARRAY *intarray)
SCIP_RETCODE SCIPgetNlRowNLPActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
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)
SCIP_RETCODE SCIPprintStage(SCIP *scip, FILE *file)
type definitions for NLP management
SCIP_READER ** SCIPgetReaders(SCIP *scip)
SCIP_RETCODE SCIPactiveCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetHugeValue(SCIP *scip)
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)
SCIP_RETCODE SCIPsetPropExitpre(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITPRE((*propexitpre)))
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
SCIP_RETCODE SCIPsetCharParam(SCIP *scip, const char *name, char value)
SCIP_RETCODE SCIPsetPropInit(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINIT((*propinit)))
SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
#define SCIP_DECL_DIALOGCOPY(x)
Definition: type_dialog.h:53
SCIP_Real SCIPgetRelaxFeastolFactor(SCIP *scip)
struct SCIP_NlpStatistics SCIP_NLPSTATISTICS
Definition: type_nlpi.h:40
int SCIPcalcMemGrowSize(SCIP *scip, int num)
SCIP_Bool SCIPisSumRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPhasPerformedPresolve(SCIP *scip)
SCIP_RETCODE SCIPsetNodeselExitsol(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)))
struct SCIP_QuadElement SCIP_QUADELEM
Definition: type_expr.h:106
SCIP_RETCODE SCIPenableReoptimization(SCIP *scip, SCIP_Bool enable)
SCIP_RETCODE SCIPrecalcRowLPActivity(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPsolveNLP(SCIP *scip)
SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPCOPY((*propcopy)))
SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)
SCIP_RETCODE SCIPsetProbName(SCIP *scip, const char *name)
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)
SCIP_RETCODE SCIPsetConflicthdlrCopy(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)))
#define SCIP_DECL_VARTRANS(x)
Definition: type_var.h:127
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPsetNodeselCopy(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELCOPY((*nodeselcopy)))
SCIP_RETCODE SCIPtrySolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool printreason, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_Bool SCIPisSumZero(SCIP *scip, SCIP_Real val)
int SCIPgetNPrioLPBranchCands(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
#define SCIP_DECL_PROBINITSOL(x)
Definition: type_prob.h:97
SCIP_Real SCIPgetVarObjDive(SCIP *scip, SCIP_VAR *var)
public methods for implications, variable bounds, and cliques
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
SCIP_NODE * SCIPgetBestboundNode(SCIP *scip)
SCIP_RETCODE SCIPsetComprPriority(SCIP *scip, SCIP_COMPR *compr, int priority)
int SCIPgetNPrioPseudoBranchCands(SCIP *scip)
SCIP_NODE * SCIPgetBestChild(SCIP *scip)
SCIP_RETCODE SCIPdelPoolCut(SCIP *scip, SCIP_ROW *row)
int SCIPgetNContVars(SCIP *scip)
SCIP_RETCODE SCIPclearRealarray(SCIP *scip, SCIP_REALARRAY *realarray)
#define SCIP_DECL_CONSDELETE(x)
Definition: type_cons.h:187
int SCIPgetNLeaves(SCIP *scip)
#define SCIP_DECL_BRANCHEXECPS(x)
Definition: type_branch.h:161
SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_RETCODE SCIPrecalcRowActivity(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPaddConflictRelaxedBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
void SCIPupdateDivesetLPStats(SCIP *scip, SCIP_DIVESET *diveset, SCIP_Longint niterstoadd)
SCIP_CUTPOOL * SCIPgetDelayedGlobalCutpool(SCIP *scip)
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_RETCODE SCIPaddCut(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPfreeRealarray(SCIP *scip, SCIP_REALARRAY **realarray)
SCIP_RETCODE SCIPcreateNLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
struct SCIP_Disp SCIP_DISP
Definition: type_disp.h:52
#define SCIP_DECL_PROBDELORIG(x)
Definition: type_prob.h:55
#define SCIP_DECL_CONSINITPRE(x)
Definition: type_cons.h:114
void SCIPdialogMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
SCIP_RETCODE SCIPsetSepaExit(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXIT((*sepaexit)))
SCIP_RETCODE SCIPchgNlRowQuadElement(SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelement)
SCIP_CUTPOOL * SCIPgetGlobalCutpool(SCIP *scip)
SCIP_RETCODE SCIPaddConflictBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPcopyProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, const char *name)
SCIP_RETCODE SCIPsolveDiveNLP(SCIP *scip)
SCIP_NLPTERMSTAT SCIPgetNLPTermstat(SCIP *scip)
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
Definition: type_cons.h:837
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
#define SCIP_DECL_CONSPRESOL(x)
Definition: type_cons.h:479
SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
struct SCIP_Compr SCIP_COMPR
Definition: type_compr.h:39
SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
SCIP_RETCODE SCIPstartDive(SCIP *scip)
SCIP_RETCODE SCIPsetNodeselInit(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELINIT((*nodeselinit)))
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
int SCIPgetSubscipDepth(SCIP *scip)
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
struct SCIP_ParamData SCIP_PARAMDATA
Definition: type_paramset.h:73
int SCIPgetPtrarrayMaxIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
struct SCIP_NlpiProblem SCIP_NLPIPROBLEM
Definition: type_nlpi.h:39
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
#define SCIP_DECL_CONSCHECK(x)
Definition: type_cons.h:391
int SCIPgetNOrigImplVars(SCIP *scip)
int SCIPgetNExternBranchCands(SCIP *scip)
#define SCIP_DECL_NODESELINITSOL(x)
Definition: type_nodesel.h:83
SCIP_RETCODE SCIPcreateUnknownSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPstartInteraction(SCIP *scip)
#define SCIP_DECL_CONSTRANS(x)
Definition: type_cons.h:197
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
int SCIPgetRealarrayMaxIdx(SCIP *scip, SCIP_REALARRAY *realarray)
SCIP_NLPI * SCIPfindNlpi(SCIP *scip, const char *name)
SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
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)
#define SCIP_DECL_COMPREXITSOL(x)
Definition: type_compr.h:95
struct SCIP_Row SCIP_ROW
Definition: type_lp.h:93
SCIP_RETCODE SCIPsetParam(SCIP *scip, const char *name, void *value)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
SCIP_RETCODE SCIPfreeClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_RETCODE SCIPchgChildPrio(SCIP *scip, SCIP_NODE *child, SCIP_Real priority)
SCIP_RETCODE SCIPbranchVar(SCIP *scip, SCIP_VAR *var, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
Definition: type_branch.h:43
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)
void SCIPdisableVarHistory(SCIP *scip)
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)
SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
int SCIPgetNActiveConss(SCIP *scip)
SCIP_RETCODE SCIPprintBestSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
SCIP_Bool SCIPisSumGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIP_DECL_PRESOLINITPRE(x)
Definition: type_presol.h:84
SCIP_RETCODE SCIPevalExprtreeLocalBounds(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
SCIP_NODE * SCIPgetPrioSibling(SCIP *scip)
SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
void SCIPgetReoptnodePath(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int mem, int *nvars, int *nafterdualvars)
SCIP_RETCODE SCIPresetParams(SCIP *scip)
SCIP_RETCODE SCIPaddPricedVar(SCIP *scip, SCIP_VAR *var, SCIP_Real score)
struct SCIP_Eventhdlr SCIP_EVENTHDLR
Definition: type_event.h:128
SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
int SCIPgetNReaders(SCIP *scip)
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_RETCODE SCIPconvertCutsToConss(SCIP *scip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_EVENTHDLR * SCIPfindEventhdlr(SCIP *scip, const char *name)
interface methods for specific LP solvers
struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA
Definition: type_event.h:129
SCIP_RETCODE SCIPensureBlockMemoryArray_call(SCIP *scip, void **arrayptr, size_t elemsize, int *arraysize, int minsize)
SCIP_DISP ** SCIPgetDisps(SCIP *scip)
SCIP_Real SCIPgetTransObjoffset(SCIP *scip)
#define SCIP_DECL_PRICEREXIT(x)
Definition: type_pricer.h:70
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
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)
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)
SCIP_Real SCIPgetNLPObjval(SCIP *scip)
SCIP_RETCODE SCIPaddRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPisPrimalboundSol(SCIP *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)
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
SCIP_Real SCIPgetOrigObjscale(SCIP *scip)
SCIP_HEUR * SCIPgetSolHeur(SCIP *scip, SCIP_SOL *sol)
SCIP_Bool SCIPisSumRelLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
#define SCIP_DECL_PROBDELTRANS(x)
Definition: type_prob.h:86
SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNOrigVars(SCIP *scip)
SCIP_RETCODE SCIPchgLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
Definition: type_message.h:50
#define SCIP_DECL_BRANCHFREE(x)
Definition: type_branch.h:60
SCIP_RETCODE SCIPprintStatus(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPsetConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_PRESOL ** SCIPgetPresols(SCIP *scip)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)
#define SCIP_DECL_CONSRESPROP(x)
Definition: type_cons.h:530
SCIP_Real SCIPdualfeastol(SCIP *scip)
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
SCIP_RETCODE SCIPsetPricerInitsol(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINITSOL((*pricerinitsol)))
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)
SCIP_RETCODE SCIPenableOrDisableStatisticTiming(SCIP *scip)
struct SCIP_Param SCIP_PARAM
Definition: type_paramset.h:72
SCIP_Real SCIPgetGap(SCIP *scip)
struct SCIP_HashMap SCIP_HASHMAP
Definition: type_misc.h:78
SCIP_DISP * SCIPfindDisp(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetRelaxPriority(SCIP *scip, SCIP_RELAX *relax, int priority)
SCIP_RETCODE SCIPgetNlRowNLPFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
SCIP_RETCODE SCIPchgIntParam(SCIP *scip, SCIP_PARAM *param, int value)
SCIP_RETCODE SCIPaddExternBranchCand(SCIP *scip, SCIP_VAR *var, SCIP_Real score, SCIP_Real solval)
SCIP_RETCODE SCIPsetObjIntegral(SCIP *scip)
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPcomputeLPRelIntPoint(SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)
#define SCIP_DECL_PRESOLCOPY(x)
Definition: type_presol.h:46
SCIP_RETCODE SCIPsetPricerExit(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXIT((*pricerexit)))
struct SCIP_Nodesel SCIP_NODESEL
Definition: type_nodesel.h:37
#define SCIP_DECL_PRICERINIT(x)
Definition: type_pricer.h:62
SCIP_Bool SCIPisLPConstructed(SCIP *scip)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPresetClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPrecalcNlRowActivity(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
int SCIPgetNPricevars(SCIP *scip)
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)
struct SCIP_VarData SCIP_VARDATA
Definition: type_var.h:96
SCIP_RETCODE SCIPpermuteProb(SCIP *scip, unsigned int randseed, SCIP_Bool permuteconss, SCIP_Bool permutebinvars, SCIP_Bool permuteintvars, SCIP_Bool permuteimplvars, SCIP_Bool permutecontvars)
SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)
SCIP_RETCODE SCIPchgVarsBoundsDiveNLP(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *lbs, SCIP_Real *ubs)
SCIP_RETCODE SCIPresetReoptnodeDualcons(SCIP *scip, SCIP_NODE *node)
SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
#define SCIP_DECL_RELAXINIT(x)
Definition: type_relax.h:63
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)
#define SCIP_DECL_RELAXINITSOL(x)
Definition: type_relax.h:82
SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
struct SCIP_IntArray SCIP_INTARRAY
Definition: type_misc.h:87
int SCIPgetNConss(SCIP *scip)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetNConflictConssFoundNode(SCIP *scip)
SCIP_RETCODE SCIPgetNLPNlRowsData(SCIP *scip, SCIP_NLROW ***nlrows, int *nnlrows)
SCIP_RETCODE SCIPwriteParam(SCIP *scip, SCIP_PARAM *param, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
SCIP_RETCODE SCIPstopClock(SCIP *scip, SCIP_CLOCK *clck)
SCIP_RETCODE SCIPincludeRelax(SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_DECL_RELAXCOPY((*relaxcopy)), SCIP_DECL_RELAXFREE((*relaxfree)), SCIP_DECL_RELAXINIT((*relaxinit)), SCIP_DECL_RELAXEXIT((*relaxexit)), SCIP_DECL_RELAXINITSOL((*relaxinitsol)), SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
SCIP_RETCODE SCIPunfixParam(SCIP *scip, const char *name)
int SCIPgetNNodesels(SCIP *scip)
struct SCIP_Clock SCIP_CLOCK
Definition: type_clock.h:40
SCIP_NODE * SCIPgetBestLeaf(SCIP *scip)
SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)
SCIP_RETCODE SCIPdelConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)
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 *success)
#define SCIP_DECL_HEURCOPY(x)
Definition: type_heur.h:60
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
SCIP_Bool SCIPallowDualReds(SCIP *scip)
#define SCIP_DECL_PROPEXITPRE(x)
Definition: type_prop.h:100
#define SCIP_DECL_HEUREXEC(x)
Definition: type_heur.h:126
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)
#define SCIP_DECL_CONSGETNVARS(x)
Definition: type_cons.h:798
SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
SCIP_RETCODE SCIPincludeBranchruleBasic(SCIP *scip, SCIP_BRANCHRULE **branchruleptr, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_BRANCHRULEDATA *branchruledata)
SCIP_Bool SCIPisCutApplicable(SCIP *scip, SCIP_ROW *cut)
int SCIPgetNPricers(SCIP *scip)
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)
SCIP_RETCODE SCIPcreateIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPincIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int incval)
SCIP_Bool SCIPisDualfeasPositive(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPsetClockTime(SCIP *scip, SCIP_CLOCK *clck, SCIP_Real sec)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_RETCODE SCIPcreateCPUClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_Bool SCIPisDualfeasZero(SCIP *scip, SCIP_Real val)
#define SCIP_DECL_VARCOPY(x)
Definition: type_var.h:170
SCIP_RETCODE SCIPsetRootDialog(SCIP *scip, SCIP_DIALOG *dialog)
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
SCIP_Bool SCIPallColsInLP(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
int SCIPgetNParams(SCIP *scip)
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
char ** SCIPgetExternalCodeNames(SCIP *scip)
void SCIPclearExternBranchCands(SCIP *scip)
SCIP_RETCODE SCIPsetSepaInitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAINITSOL((*sepainitsol)))
struct SCIP_HeurData SCIP_HEURDATA
Definition: type_heur.h:51
SCIP_RETCODE SCIPgetReoptOldObjCoef(SCIP *scip, SCIP_VAR *var, int run, SCIP_Real *objcoef)
#define SCIP_DECL_CONSEXITSOL(x)
Definition: type_cons.h:174
public methods for displaying runtime statistics
public methods for problem variables
SCIP_RETCODE SCIPfreePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
SCIP_RETCODE SCIPsetConflicthdlrInitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)))
SCIP_RETCODE SCIPsetMessagehdlr(SCIP *scip, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_RETCODE SCIPsetPricerFree(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERFREE((*pricerfree)))
int SCIPconvertRealToInt(SCIP *scip, SCIP_Real real)
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)
struct SCIP_DialogData SCIP_DIALOGDATA
Definition: type_dialog.h:42
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
SCIP_RETCODE SCIPsetPresolExitpre(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXITPRE((*presolexitpre)))
int SCIPgetRepropdepth(SCIP *scip)
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
SCIP_DIALOG * SCIPgetRootDialog(SCIP *scip)
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)
int SCIPgetNDelayedPoolCuts(SCIP *scip)
#define SCIP_DECL_BRANCHEXECEXT(x)
Definition: type_branch.h:140
int SCIPgetNCutsFoundRound(SCIP *scip)
void SCIPaddSquareLinearization(SCIP *scip, SCIP_Real sqrcoef, SCIP_Real refpoint, SCIP_Bool isint, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)
SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
void SCIPprintExternalCodes(SCIP *scip, FILE *file)
SCIP_Bool SCIPhasNLPSolution(SCIP *scip)
SCIP_Real SCIPdualfeasRound(SCIP *scip, SCIP_Real val)
int SCIPgetNConshdlrs(SCIP *scip)
type definitions for return codes for SCIP methods
struct SCIP_Cut SCIP_CUT
Definition: type_cutpool.h:31
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
#define SCIP_DECL_PRICEREXITSOL(x)
Definition: type_pricer.h:92
unsigned int SCIP_DIVETYPE
Definition: type_heur.h:48
public methods for branching rules
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
int SCIPgetNEventhdlrs(SCIP *scip)
SCIP_RETCODE SCIPaddReoptDualBndchg(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_Real oldbound)
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
SCIP_RETCODE SCIPsetBranchruleExecPs(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECPS((*branchexecps)))
SCIP_Bool SCIPisDualfeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIP_DECL_SEPAEXECLP(x)
Definition: type_sepa.h:115
SCIP_RETCODE SCIPfreeBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
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)
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)
SCIP_RETCODE SCIPseparateCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_RESULT *result)
SCIP_Real SCIPepsilon(SCIP *scip)
#define SCIP_DECL_PROBCOPY(x)
Definition: type_prob.h:140
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
SCIP_Bool SCIPisFracIntegral(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPsetConsDynamic(SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)
SCIP_RETCODE SCIPsetReaderFree(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERFREE((*readerfree)))
enum SCIP_NlpParam SCIP_NLPPARAM
Definition: type_nlpi.h:56
SCIP_Real SCIPcutoffbounddelta(SCIP *scip)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
SCIP_RETCODE SCIPaddQuadElementToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_QUADELEM quadelem)
void SCIPdisableDebugSol(SCIP *scip)
SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
type definitions for presolvers
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
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)
SCIP_RETCODE SCIPsetRelaxCopy(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXCOPY((*relaxcopy)))
SCIP_Real SCIPgetLPObjval(SCIP *scip)
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)
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, SCIP_Bool backtrack, SCIP_Bool onlylpbranchcands, SCIP_Bool specificsos1score, SCIP_DECL_DIVESETGETSCORE((*divesetgetscore)))
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPcheckStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
#define SCIP_DECL_BRANCHEXITSOL(x)
Definition: type_branch.h:98
SCIP_Bool SCIPisSumLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
struct SCIP_Cutpool SCIP_CUTPOOL
Definition: type_cutpool.h:30
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
SCIP_RETCODE SCIPgetNLPFracVars(SCIP *scip, SCIP_VAR ***fracvars, SCIP_Real **fracvarssol, SCIP_Real **fracvarsfrac, int *nfracvars, int *npriofracvars)
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
SCIP_RETCODE SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
#define SCIP_DECL_PROPEXEC(x)
Definition: type_prop.h:202
SCIP_PARAM * SCIPgetParam(SCIP *scip, const char *name)
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPsetEventhdlrInit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINIT((*eventinit)))
#define SCIP_DECL_PRICERCOPY(x)
Definition: type_pricer.h:46
SCIP_RETCODE SCIPbranchExtern(SCIP *scip, SCIP_RESULT *result)
int SCIPgetFocusDepth(SCIP *scip)
SCIP_RETCODE SCIPsetProbDelorig(SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))
#define SCIP_DECL_DIVESETGETSCORE(x)
Definition: type_heur.h:146
SCIP_Real SCIPgetLPRootObjval(SCIP *scip)
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
SCIP_RETCODE SCIPtryCurrentSol(SCIP *scip, SCIP_HEUR *heur, SCIP_Bool printreason, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_SEPA ** SCIPgetSepas(SCIP *scip)
SCIP_RETCODE SCIPupdateNodeDualbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
#define SCIP_DECL_NODESELEXITSOL(x)
Definition: type_nodesel.h:94
#define SCIP_DECL_CONFLICTEXIT(x)
Definition: type_conflict.h:76
int SCIPmajorVersion(void)
#define SCIP_DECL_COMPRINIT(x)
Definition: type_compr.h:65
SCIP_RETCODE SCIPcheckReoptRestart(SCIP *scip, SCIP_NODE *node, SCIP_Bool *restart)
SCIP_RETCODE SCIPsetReoptCompression(SCIP *scip, SCIP_REOPTNODE **representation, int nrepresentatives, SCIP_Bool *success)
SCIP_RETCODE SCIPsetPresolPriority(SCIP *scip, SCIP_PRESOL *presol, int priority)
#define SCIP_DECL_EVENTEXEC(x)
Definition: type_event.h:226
SCIP_Bool SCIPisScalingIntegral(SCIP *scip, SCIP_Real val, SCIP_Real scalar)
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
SCIP_RETCODE SCIPsetNodeselExit(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELEXIT((*nodeselexit)))
int SCIPgetNEnabledConss(SCIP *scip)
#define SCIP_DECL_CONSINITLP(x)
Definition: type_cons.h:210
SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
SCIP_RETCODE SCIPincludeRelaxBasic(SCIP *scip, SCIP_RELAX **relaxptr, const char *name, const char *desc, int priority, int freq, SCIP_DECL_RELAXEXEC((*relaxexec)), SCIP_RELAXDATA *relaxdata)
SCIP_Bool SCIPallVarsInProb(SCIP *scip)
SCIP_RETCODE SCIPaddDialogEntry(SCIP *scip, SCIP_DIALOG *dialog, SCIP_DIALOG *subdialog)
type definitions for branching rules
#define SCIP_DECL_EVENTFREE(x)
Definition: type_event.h:164
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
struct SCIP_ReoptNode SCIP_REOPTNODE
Definition: type_reopt.h:38
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
#define SCIP_DECL_DISPCOPY(x)
Definition: type_disp.h:62
int SCIPgetNSols(SCIP *scip)
SCIP_RETCODE SCIPsetBranchruleInitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINITSOL((*branchinitsol)))
SCIP_Real SCIPgetDualbound(SCIP *scip)
BMS_BUFMEM * SCIPcleanbuffer(SCIP *scip)
SCIP_RETCODE SCIPaddQuadElementsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nquadelems, SCIP_QUADELEM *quadelems)
int SCIPgetNPrioExternBranchImpls(SCIP *scip)
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)
int SCIPgetNSepas(SCIP *scip)
SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPcreateBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
SCIP_RETCODE SCIPincludeHeur(SCIP *scip, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, unsigned int 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)
SCIP_RETCODE SCIPprintNodeRootPath(SCIP *scip, SCIP_NODE *node, FILE *file)
SCIP_Real SCIPgetVectorEfficacyNorm(SCIP *scip, SCIP_Real *vals, int nvals)
SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip)
SCIP_NODE * SCIPgetRootNode(SCIP *scip)
#define SCIP_DECL_COMPRFREE(x)
Definition: type_compr.h:57
SCIP_RETCODE SCIPcreateCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool, int agelimit)
SCIP_RETCODE SCIPsetConflicthdlrInit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)))
SCIP_Bool SCIPisUpdateUnreliable(SCIP *scip, SCIP_Real newvalue, SCIP_Real oldvalue)
SCIP_CONS * SCIPfindOrigCons(SCIP *scip, const char *name)
enum SCIP_ParamSetting SCIP_PARAMSETTING
Definition: type_paramset.h:56
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
SCIP_RETCODE SCIPrecomputeSolObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
#define SCIP_DECL_NODESELINIT(x)
Definition: type_nodesel.h:64
int SCIPgetNSepaRounds(SCIP *scip)
SCIP_RETCODE SCIPaddCurrentSol(SCIP *scip, SCIP_HEUR *heur, SCIP_Bool *stored)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
public methods for expressions, expression trees, expression graphs, and related stuff ...
SCIP_Bool SCIPisSumRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPinitRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
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)
SCIP_RETCODE SCIPsetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx, SCIP_Bool val)
SCIP_Real SCIPgetPrimalRayVal(SCIP *scip, SCIP_VAR *var)
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)
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
#define SCIP_DECL_VARDELTRANS(x)
Definition: type_var.h:140
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
SCIP_RETCODE SCIPcopyConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)
type definitions for LP management
#define SCIP_DECL_SEPACOPY(x)
Definition: type_sepa.h:47
SCIP_NODESEL ** SCIPgetNodesels(SCIP *scip)
SCIP_RETCODE SCIPincludeHeurBasic(SCIP *scip, SCIP_HEUR **heur, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, unsigned int timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
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)
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
int SCIPgetNPrioExternBranchCands(SCIP *scip)
SCIP_RETCODE SCIPsetRelaxInit(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINIT((*relaxinit)))
SCIP_RETCODE SCIPenableConsSeparation(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)
SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
SCIP_RETCODE SCIPupdateLocalDualbound(SCIP *scip, SCIP_Real newbound)
SCIP_RETCODE SCIPsetPropPresolPriority(SCIP *scip, SCIP_PROP *prop, int presolpriority)
SCIP_RETCODE SCIPsetPresolInit(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLINIT((*presolinit)))
SCIP_RETCODE SCIPcreatePseudoSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
#define SCIP_DECL_DIALOGDESC(x)
Definition: type_dialog.h:73
SCIP_RETCODE SCIPcreateEmptyNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real lhs, SCIP_Real rhs)
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
int SCIPgetNLPCols(SCIP *scip)
SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)
void SCIPupdateDivesetStats(SCIP *scip, SCIP_DIVESET *diveset, int nprobingnodes, int nbacktracks, SCIP_Longint nsolsfound, SCIP_Longint nbestsolsfound, SCIP_Bool leavewassol)
void SCIPprintMemoryDiagnostic(SCIP *scip)
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
struct SCIP_Prop SCIP_PROP
Definition: type_prop.h:37
SCIP_Bool SCIPinProbing(SCIP *scip)
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
#define SCIP_DECL_CONSINITSOL(x)
Definition: type_cons.h:159
SCIP_RETCODE SCIPdelDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPpropCons(SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
SCIP_RETCODE SCIPgetSolVarsData(SCIP *scip, SCIP_SOL *sol, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
SCIP_Real * SCIPgetNLPVarsUbDualsol(SCIP *scip)
void SCIPmarkColNotRemovableLocal(SCIP *scip, SCIP_COL *col)
SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
struct SCIP_NodeselData SCIP_NODESELDATA
Definition: type_nodesel.h:38
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)
SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPsetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx, void *val)
SCIP_RETCODE SCIPgetLeaves(SCIP *scip, SCIP_NODE ***leaves, int *nleaves)
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)
int SCIPgetProbingDepth(SCIP *scip)
SCIP_RETCODE SCIPremoveInefficaciousCuts(SCIP *scip)
SCIP_RETCODE SCIPgetDiveBoundChanges(SCIP *scip, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
#define SCIP_DECL_PRESOLEXEC(x)
Definition: type_presol.h:153
SCIP_RETCODE SCIPchgDualfeastol(SCIP *scip, SCIP_Real dualfeastol)
#define SCIP_DECL_BRANCHINIT(x)
Definition: type_branch.h:68
SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)
#define SCIP_DECL_DISPINIT(x)
Definition: type_disp.h:78
SCIP_RETCODE SCIPextendIntarray(SCIP *scip, SCIP_INTARRAY *intarray, int minidx, int maxidx)
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
public methods for handling parameter settings
SCIP_Bool SCIPpressedCtrlC(SCIP *scip)
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
public methods for managing constraints
SCIP_Bool SCIPisDualfeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
struct SCIP_Clique SCIP_CLIQUE
Definition: type_implics.h:32
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
SCIP_RETCODE SCIPaddDialogHistoryLine(SCIP *scip, const char *inputline)
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
#define SCIP_DECL_RELAXEXIT(x)
Definition: type_relax.h:71
SCIP_RETCODE SCIPsetPricerInit(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERINIT((*pricerinit)))
SCIP_NODE * SCIPgetBestNode(SCIP *scip)
int SCIPgetNPseudoBranchCands(SCIP *scip)
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
Definition: type_misc.h:44
SCIP_Real SCIPgetUpperbound(SCIP *scip)
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)
#define SCIP_DECL_CONSPRINT(x)
Definition: type_cons.h:682
int SCIPgetNPrioPseudoBranchBins(SCIP *scip)
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)
int SCIPgetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx)
int SCIPsubversion(void)
SCIP_RETCODE SCIPsetConsStickingAtNode(SCIP *scip, SCIP_CONS *cons, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPsetRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real val)
#define SCIP_DECL_CONFLICTINITSOL(x)
Definition: type_conflict.h:87
SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPsetEventhdlrExit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXIT((*eventexit)))
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
SCIP_NLPSOLSTAT SCIPgetNLPSolstat(SCIP *scip)
struct SCIP_Diveset SCIP_DIVESET
Definition: type_heur.h:52
SCIP_RETCODE SCIPsetPricerExitsol(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICEREXITSOL((*pricerexitsol)))
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
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)
#define SCIP_DECL_BRANCHCOPY(x)
Definition: type_branch.h:52
struct SCIP_Col SCIP_COL
Definition: type_lp.h:87
SCIP_Bool SCIPisDualfeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Longint SCIPgetNLPs(SCIP *scip)
SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
#define SCIP_DECL_CONFLICTEXEC(x)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip)
#define SCIP_DECL_CONSDELVARS(x)
Definition: type_cons.h:668
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
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)
void SCIPgetDiveBoundChangeData(SCIP *scip, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
SCIP_CUT ** SCIPgetDelayedPoolCuts(SCIP *scip)
SCIP_RETCODE SCIPcopyCuts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
SCIP_RETCODE SCIPresetParam(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
type definitions for variable pricers
SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
SCIP_RETCODE SCIPdeactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
SCIP_RETCODE SCIPsetConflicthdlrPriority(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)
SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)
SCIP_RETCODE SCIPsetReaderRead(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERREAD((*readerread)))
SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
#define SCIP_DECL_PRESOLFREE(x)
Definition: type_presol.h:54
int SCIPgetNActivePricers(SCIP *scip)
SCIP_Bool SCIPisRelLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetMaxDepth(SCIP *scip)
int SCIPgetNReoptRuns(SCIP *scip)
void SCIPenableNLP(SCIP *scip)
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)
SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPcreateFiniteSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol, SCIP_Bool *success)
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)
int SCIPgetNReoptLeaves(SCIP *scip, SCIP_NODE *node)
SCIP_RETCODE SCIPsetHeurPriority(SCIP *scip, SCIP_HEUR *heur, int priority)
#define SCIP_DECL_PRICERFARKAS(x)
Definition: type_pricer.h:165
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
type definitions for primal heuristics
#define SCIP_DECL_COMPRCOPY(x)
Definition: type_compr.h:49
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)
#define SCIP_DECL_CONSPARSE(x)
Definition: type_cons.h:758
enum SCIP_NlpSolStat SCIP_NLPSOLSTAT
Definition: type_nlpi.h:69
SCIP_RETCODE SCIPrecalcRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
int SCIPgetNPrioPseudoBranchInts(SCIP *scip)
SCIP_RETCODE SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
SCIP_Bool SCIPcontainsExternBranchCand(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPaddDialogInputLine(SCIP *scip, const char *inputline)
int SCIPgetPlungeDepth(SCIP *scip)
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
SCIP_RETCODE SCIPsetNLPInitialGuess(SCIP *scip, SCIP_Real *initialguess)
SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
#define SCIP_DECL_CONSDEACTIVE(x)
Definition: type_cons.h:621
SCIP_RETCODE SCIPgetExprtreeTransformedVars(SCIP *scip, SCIP_EXPRTREE *tree)
SCIP_NODESEL * SCIPgetNodesel(SCIP *scip)
SCIP_RETCODE SCIPgetLPBInvCol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
#define SCIP_DECL_PRESOLEXIT(x)
Definition: type_presol.h:70
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
type definitions for SCIP&#39;s main datastructure
SCIP_RETCODE SCIPgetNLPStatistics(SCIP *scip, SCIP_NLPSTATISTICS *statistics)
SCIP_Real SCIPgetPseudoObjval(SCIP *scip)
SCIP_Real SCIPgetNodeLowerbound(SCIP *scip, SCIP_NODE *node)
SCIP_Bool SCIPisSumPositive(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPsetProbDeltrans(SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))
SCIP_Real SCIPcalcNodeselPriority(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
SCIP_RETCODE SCIPsetNlRowExprtree(SCIP *scip, SCIP_NLROW *nlrow, SCIP_EXPRTREE *exprtree)
SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
SCIP_RETCODE SCIPaddRowDive(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPsetNlRowExprtreeParams(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *paramvals)
SCIP_NLROW ** SCIPgetNLPNlRows(SCIP *scip)
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)
SCIP_RETCODE SCIPgetNlRowActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *activity)
#define SCIP_DECL_BRANCHINITSOL(x)
Definition: type_branch.h:87
SCIP_RETCODE SCIPsetPropInitpre(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITPRE((*propinitpre)))
#define SCIP_DECL_EVENTINIT(x)
Definition: type_event.h:172
int SCIPgetNCompr(SCIP *scip)
SCIP_RETCODE SCIPchgNlRowRhs(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real rhs)
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPcopyParamSettings(SCIP *sourcescip, SCIP *targetscip)
SCIP_RETCODE SCIPadjustImplicitSolVals(SCIP *scip, SCIP_SOL *sol, SCIP_Bool uselprows)
#define SCIP_DECL_PROPEXITSOL(x)
Definition: type_prop.h:127
struct SCIP_NlRow SCIP_NLROW
Definition: type_nlp.h:31
SCIP_Bool SCIPisInRestart(SCIP *scip)
int SCIPgetNExternalCodes(SCIP *scip)
SCIP_RETCODE SCIPsetConflicthdlrExit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)))
SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)
int SCIPgetDepthLimit(SCIP *scip)
SCIP_RETCODE SCIPrecalcNlRowNLPActivity(SCIP *scip, SCIP_NLROW *nlrow)
struct SCIP_PtrArray SCIP_PTRARRAY
Definition: type_misc.h:93
SCIP_Bool SCIPexistsDialog(SCIP *scip, SCIP_DIALOG *dialog)
int SCIPgetNPrioExternBranchBins(SCIP *scip)
#define SCIP_DECL_PROPCOPY(x)
Definition: type_prop.h:47
SCIP_RETCODE SCIPsolveProbingLPWithPricing(SCIP *scip, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPaddReoptnodeBndchg(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE boundtype)
int SCIPgetNPoolCuts(SCIP *scip)
#define SCIP_DECL_BRANCHEXECLP(x)
Definition: type_branch.h:119
SCIP_RETCODE SCIPchgNlRowConstant(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real constant)
SCIP_Bool SCIPdoNotAggr(SCIP *scip)
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)
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:146
SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPbarrierconvtol(SCIP *scip)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPsetReaderCopy(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERCOPY((*readercopy)))
SCIP_RETCODE SCIPsetBranchruleMaxdepth(SCIP *scip, SCIP_BRANCHRULE *branchrule, int maxdepth)
#define SCIP_DECL_PARAMCHGD(x)
Definition: type_paramset.h:88
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_RETCODE SCIPchgCutoffboundDive(SCIP *scip, SCIP_Real newcutoffbound)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
#define SCIP_DECL_NODESELFREE(x)
Definition: type_nodesel.h:56
SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
SCIP_EVENTHDLR ** SCIPgetEventhdlrs(SCIP *scip)
#define SCIP_DECL_RELAXCOPY(x)
Definition: type_relax.h:47
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)
SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
int SCIPgetNNLPNlRows(SCIP *scip)
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip)
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)
SCIP_Bool SCIPisDualfeasFracIntegral(SCIP *scip, SCIP_Real val)
SCIP_CUT ** SCIPgetPoolCuts(SCIP *scip)
int SCIPgetNOrigBinVars(SCIP *scip)
void SCIPsetFocusnodeLP(SCIP *scip, SCIP_Bool solvelp)
#define SCIP_DECL_CONSDISABLE(x)
Definition: type_cons.h:651
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPgetNlRowSolFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Real *feasibility)
struct SCIP_Reader SCIP_READER
Definition: type_reader.h:36
SCIP_RETCODE SCIPclearBoolarray(SCIP *scip, SCIP_BOOLARRAY *boolarray)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_RETCODE SCIPcopyVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global)
SCIP_RETCODE SCIPgetNLPVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars)
SCIP_RETCODE SCIPsetProbInitsol(SCIP *scip, SCIP_DECL_PROBINITSOL((*probinitsol)))
SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
SCIP_ROW ** SCIPgetCuts(SCIP *scip)
SCIP_RETCODE SCIPgetStringParam(SCIP *scip, const char *name, char **value)
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)
SCIP_RETCODE SCIPcatchRowEvent(SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_SEPA * SCIPfindSepa(SCIP *scip, const char *name)
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)
SCIP_RETCODE SCIPprintBestTransSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
SCIP_READER * SCIPfindReader(SCIP *scip, const char *name)
int SCIPgetNPresols(SCIP *scip)
SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPRESPROP((*propresprop)))
public methods for primal CIP solutions
SCIP_RETCODE SCIPgetPseudoBranchCands(SCIP *scip, SCIP_VAR ***pseudocands, int *npseudocands, int *npriopseudocands)
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
int SCIPgetNPrioPseudoBranchImpls(SCIP *scip)
SCIP_RETCODE SCIPcopyOrigVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap)
SCIP_Bool SCIPisSumLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPstopSolvingTime(SCIP *scip)
SCIP_RETCODE SCIPchgRowRhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
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)
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
Definition: type_conflict.h:40
SCIP_RETCODE SCIPmergeVariableStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **sourcevars, SCIP_VAR **targetvars, int nvars)
SCIP_Bool SCIPisRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPendDiveNLP(SCIP *scip)
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)
SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
unsigned int SCIP_PRESOLTIMING
Definition: type_timing.h:50
SCIP_RETCODE SCIPaddConsLocks(SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
SCIP_RETCODE SCIPpropagateProbingImplications(SCIP *scip, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPresetRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
SCIP_RETCODE SCIPcheckCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
#define SCIP_DECL_EVENTEXITSOL(x)
Definition: type_event.h:202
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
SCIP_RETCODE SCIPprintTransSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
int SCIPgetNCutsFound(SCIP *scip)
SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
SCIP_RETCODE SCIPsetRelaxFree(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXFREE((*relaxfree)))
#define SCIP_DECL_PROPINITPRE(x)
Definition: type_prop.h:85
SCIP_RETCODE SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
struct SCIP_ComprData SCIP_COMPRDATA
Definition: type_compr.h:40
SCIP_RETCODE SCIPsetBranchrulePriority(SCIP *scip, SCIP_BRANCHRULE *branchrule, int priority)
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
type definitions for problem variables
#define SCIP_DECL_CONSENABLE(x)
Definition: type_cons.h:636
SCIP_RETCODE SCIPcheckSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)
SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPaddNewRowCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_ROW *row)
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)
SCIP_PROP ** SCIPgetProps(SCIP *scip)
#define SCIP_DECL_CONFLICTCOPY(x)
Definition: type_conflict.h:52
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_Bool SCIPgetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx)
int SCIPgetNCutsApplied(SCIP *scip)
SCIP_RETCODE SCIPbranchLP(SCIP *scip, SCIP_RESULT *result)
SCIP_RETCODE SCIPsetProbCopy(SCIP *scip, SCIP_DECL_PROBCOPY((*probcopy)))
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
type definitions for relaxators
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
#define SCIP_DECL_READERWRITE(x)
Definition: type_reader.h:110
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
struct Scip SCIP
Definition: type_scip.h:30
#define SCIP_DECL_CONSENFOLP(x)
Definition: type_cons.h:313
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
struct SCIP_Conflicthdlr SCIP_CONFLICTHDLR
Definition: type_conflict.h:39
SCIP_Real SCIPgetRowPseudoFeasibility(SCIP *scip, SCIP_ROW *row)
int SCIPgetNRuns(SCIP *scip)
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:50
SCIP_RETCODE SCIPsetComprFree(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRFREE((*comprfree)))
type definitions for conflict analysis
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPchgNlRowLinearCoef(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real coef)
SCIP_Bool SCIPisRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPgetOrigVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
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)
SCIP_SOL * SCIPgetReoptLastOptSol(SCIP *scip)
SCIP_RETCODE SCIPendProbing(SCIP *scip)
SCIP_RETCODE SCIPaddLinearCoefsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_RETCODE SCIPfree(SCIP **scip)
type definitions for managing events
SCIP_RETCODE SCIPfixParam(SCIP *scip, const char *name)
SCIP_Bool SCIPisDualfeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetNSiblings(SCIP *scip)
SCIP_RETCODE SCIPsetHeuristics(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)
SCIP_RETCODE SCIPprintDualSol(SCIP *scip, FILE *file, SCIP_Bool printzeros)
SCIP_RETCODE SCIPextendPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray, int minidx, int maxidx)
public methods for NLP management
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
#define SCIP_DECL_CONSSEPALP(x)
Definition: type_cons.h:239
public methods for node selectors
wrapper functions to map file i/o to standard or zlib file i/o
struct SCIP_ExprTree SCIP_EXPRTREE
Definition: type_expr.h:92
#define SCIP_DECL_COMPRINITSOL(x)
Definition: type_compr.h:84
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)
SCIP_RETCODE SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
#define SCIP_DECL_PROBTRANS(x)
Definition: type_prob.h:74
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)
SCIP_RETCODE SCIPgetNlRowActivityBounds(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *minactivity, SCIP_Real *maxactivity)
SCIP_Real SCIPgetLPRootColumnObjval(SCIP *scip)
SCIP_Real SCIPdualfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPgetTotalTime(SCIP *scip)
SCIP_Longint SCIPgetSolNodenum(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPsetPropFree(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPFREE((*propfree)))
SCIP_Real SCIPgetLPRootLooseObjval(SCIP *scip)
#define SCIP_DECL_CONSGETVARS(x)
Definition: type_cons.h:780
SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
struct SCIP_Sepa SCIP_SEPA
Definition: type_sepa.h:37
#define SCIP_DECL_CONSEXIT(x)
Definition: type_cons.h:94
SCIP_RETCODE SCIPbranchVarHole(SCIP *scip, SCIP_VAR *var, SCIP_Real left, SCIP_Real right, SCIP_NODE **downchild, SCIP_NODE **upchild)
struct SCIP_ReaderData SCIP_READERDATA
Definition: type_reader.h:37
SCIP_RETCODE SCIPclearCuts(SCIP *scip)
SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
public data structures and miscellaneous methods
SCIP_RETCODE SCIPsetReaderWrite(SCIP *scip, SCIP_READER *reader, SCIP_DECL_READERWRITE((*readerwrite)))
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)
SCIP_RETCODE SCIPcalcCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
unsigned int SCIP_EVENTTYPE
Definition: type_event.h:125
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
struct SCIP_Sol SCIP_SOL
Definition: type_sol.h:45
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)
int SCIPgetNReoptnodes(SCIP *scip, SCIP_NODE *node)
SCIP_PRICER * SCIPfindPricer(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetPresolExit(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLEXIT((*presolexit)))
SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
SCIP_RETCODE SCIPgetNlRowPseudoFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *pseudofeasibility)
SCIP_RETCODE SCIPlinkNLPSol(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPpresolve(SCIP *scip)
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
#define SCIP_Bool
Definition: def.h:53
#define SCIP_DECL_SEPAINIT(x)
Definition: type_sepa.h:63
int SCIPgetNPrioExternBranchConts(SCIP *scip)
#define SCIP_DECL_PRICERINITSOL(x)
Definition: type_pricer.h:81
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_RETCODE SCIPsetEventhdlrExitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXITSOL((*eventexitsol)))
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Real SCIPgetRowPseudoActivity(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPaddObjoffset(SCIP *scip, SCIP_Real addval)
#define SCIP_DECL_PRESOLEXITPRE(x)
Definition: type_presol.h:102
#define SCIP_DECL_PROBEXITSOL(x)
Definition: type_prob.h:110
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIP_DECL_NODESELEXIT(x)
Definition: type_nodesel.h:72
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPaddSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *stored)
public methods for storing cuts in a cut pool
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
type definitions for input file readers
SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
struct SCIP_Relax SCIP_RELAX
Definition: type_relax.h:36
SCIP_RETCODE SCIPsetRelaxInitsol(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXINITSOL((*relaxinitsol)))
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
void SCIPgetVarCoefChg(SCIP *scip, int varidx, SCIP_Bool *negated, SCIP_Bool *entering, SCIP_Bool *leaving)
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPcreateCurrentSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
int SCIPgetNCheckConss(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:41
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
enum SCIP_Status SCIP_STATUS
Definition: type_stat.h:57
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)
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)
#define SCIP_DECL_DISPFREE(x)
Definition: type_disp.h:70
#define SCIP_DECL_PROPFREE(x)
Definition: type_prop.h:55
SCIP_RETCODE SCIPchgVarObjDiveNLP(SCIP *scip, SCIP_VAR *var, SCIP_Real coef)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPevalExprtreeGlobalBounds(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_Real infinity, SCIP_INTERVAL *val)
SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPINITSOL((*propinitsol)))
SCIP_RETCODE SCIPsumLPRows(SCIP *scip, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
SCIP_RETCODE SCIPchgConsName(SCIP *scip, SCIP_CONS *cons, const char *name)
SCIP_RETCODE SCIPgetLPBInvACol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)
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)
SCIP_RETCODE SCIPsetPricerCopy(SCIP *scip, SCIP_PRICER *pricer, SCIP_DECL_PRICERCOPY((*pricercopy)))
SCIP_RETCODE SCIPfreeIntarray(SCIP *scip, SCIP_INTARRAY **intarray)
SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
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)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
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)
SCIP_RETCODE SCIPsetBranchruleExecExt(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECEXT((*branchexecext)))
SCIP_RETCODE SCIPsetComprCopy(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRCOPY((*comprcopy)))
SCIP_Bool SCIPisRelLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIP_DECL_CONSEXITPRE(x)
Definition: type_cons.h:138
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXIT((*heurexit)))
SCIP_COMPR * SCIPfindCompr(SCIP *scip, const char *name)
public methods for variable pricers
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)
#define SCIP_DECL_PRESOLINIT(x)
Definition: type_presol.h:62
SCIP_RETCODE SCIPsetComprExitsol(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPREXITSOL((*comprexitsol)))
SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)
SCIP_RETCODE SCIPcopyOrigConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool enablepricing, SCIP_Bool *valid)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_NODE * SCIPgetBestSibling(SCIP *scip)
struct SCIP_BdChgIdx SCIP_BDCHGIDX
Definition: type_var.h:83
int SCIPgetNCuts(SCIP *scip)
public methods for LP management
SCIP_RETCODE SCIPchgLpfeastol(SCIP *scip, SCIP_Real lpfeastol, SCIP_Bool printnewvalue)
SCIP_Bool SCIPisRootLPRelax(SCIP *scip)
SCIP_RETCODE SCIPsetNodeselFree(SCIP *scip, SCIP_NODESEL *nodesel, SCIP_DECL_NODESELFREE((*nodeselfree)))
SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
#define SCIP_DECL_PROPINITSOL(x)
Definition: type_prop.h:115
SCIP_Bool SCIPisSumNegative(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPaddLinearCoefToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
int SCIPgetNConflicthdlrs(SCIP *scip)
int SCIPgetNPricevarsFound(SCIP *scip)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPsetPropPresol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPPRESOL((*proppresol)), int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming)
SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
SCIP_PRESOL * SCIPfindPresol(SCIP *scip, const char *name)
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
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)
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
SCIP_RETCODE SCIPsetSepaPriority(SCIP *scip, SCIP_SEPA *sepa, int priority)
type definitions for branch and bound tree
SCIP_Longint SCIPgetLastDivenode(SCIP *scip)
SCIP_Real SCIPgetTransGap(SCIP *scip)
SCIP_RETCODE SCIPfreeSolve(SCIP *scip, SCIP_Bool restart)
SCIP_Bool SCIPallowObjProp(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPsetBranchruleExitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))
#define SCIP_DECL_DIALOGFREE(x)
Definition: type_dialog.h:61
#define SCIP_DECL_COMPREXIT(x)
Definition: type_compr.h:73
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
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)
SCIP_NODE * SCIPgetPrioChild(SCIP *scip)
int SCIPgetNPrioExternBranchInts(SCIP *scip)
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
int SCIPgetNNlpis(SCIP *scip)
struct SCIP_Var SCIP_VAR
Definition: type_var.h:95
SCIP_NLPI ** SCIPgetNlpis(SCIP *scip)
struct SCIP_RealArray SCIP_REALARRAY
Definition: type_misc.h:84
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)
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
SCIP_RETCODE SCIPsetPresolFree(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLFREE((*presolfree)))
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
SCIP_RETCODE SCIPaddReoptnodeCons(SCIP *scip, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, int nvars, REOPT_CONSTYPE constype)
#define SCIP_DECL_SEPAEXITSOL(x)
Definition: type_sepa.h:93
SCIP_BRANCHRULE ** SCIPgetBranchrules(SCIP *scip)
SCIP_RETCODE SCIPaddQuadVarsToNlRow(SCIP *scip, SCIP_NLROW *nlrow, int nvars, SCIP_VAR **vars)
#define SCIP_DECL_SEPAEXECSOL(x)
Definition: type_sepa.h:138
SCIP_Real SCIPgetObjlimit(SCIP *scip)
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)
SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
type definitions for clocks and timing issues
SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
SCIP_PARAM ** SCIPgetParams(SCIP *scip)
SCIP_RETCODE SCIPdisableConsSeparation(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPflushLP(SCIP *scip)
SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
SCIP_RETCODE SCIPprintRay(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
SCIP_RETCODE SCIPsetRelaxExit(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXIT((*relaxexit)))
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
SCIP_RETCODE SCIPgetSiblings(SCIP *scip, SCIP_NODE ***siblings, int *nsiblings)
SCIP_RETCODE SCIPgetReoptChildIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
SCIP_RETCODE SCIPfreeCutpool(SCIP *scip, SCIP_CUTPOOL **cutpool)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
#define SCIP_DECL_CONSENFOPS(x)
Definition: type_cons.h:356
SCIP_RETCODE SCIPcreatePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
SCIP_RETCODE SCIPreadParams(SCIP *scip, const char *filename)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
SCIP_RETCODE SCIPaddQuadVarToNlRow(SCIP *scip, SCIP_NLROW *nlrow, SCIP_VAR *var)
SCIP_RETCODE SCIPextendBoolarray(SCIP *scip, SCIP_BOOLARRAY *boolarray, int minidx, int maxidx)
SCIP_CONS ** SCIPgetConss(SCIP *scip)
SCIP_RETCODE SCIPseparateSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
type definitions for storing and manipulating the main problem
SCIP_SOL ** SCIPgetSols(SCIP *scip)
SCIP_RETCODE SCIPinitlpCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
void SCIPsetMessagehdlrQuiet(SCIP *scip, SCIP_Bool quiet)
SCIP_Real SCIPlpfeastol(SCIP *scip)
SCIP_RETCODE SCIPgetTransformedConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPchgRealParam(SCIP *scip, SCIP_PARAM *param, SCIP_Real value)
int SCIPgetPtrarrayMinIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
SCIP_Real SCIPgetBranchingPoint(SCIP *scip, SCIP_VAR *var, SCIP_Real suggestion)
#define SCIP_DECL_READERCOPY(x)
Definition: type_reader.h:46
SCIP_Real SCIPfeasRound(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPgetLongintParam(SCIP *scip, const char *name, SCIP_Longint *value)
enum SCIP_ParamEmphasis SCIP_PARAMEMPHASIS
Definition: type_paramset.h:70
SCIP_RETCODE SCIPcreateOrigSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
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)
SCIP_RETCODE SCIPflushNLP(SCIP *scip)
SCIP_PRICER ** SCIPgetPricers(SCIP *scip)
SCIP_RETCODE SCIPrepropagateNode(SCIP *scip, SCIP_NODE *node)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
#define SCIP_DECL_VARDELORIG(x)
Definition: type_var.h:107
SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPreadSol(SCIP *scip, const char *filename)
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
type definitions for propagators
SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
#define SCIP_DECL_DIALOGEXEC(x)
Definition: type_dialog.h:87
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
SCIP_Real SCIPgetReoptSimilarity(SCIP *scip, int run1, int run2)
SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPsetComprExit(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPREXIT((*comprexit)))
SCIP_Real SCIPgetLPColumnObjval(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
SCIP_VERBLEVEL SCIPgetVerbLevel(SCIP *scip)
SCIP_RETCODE SCIPgetNlRowSolActivity(SCIP *scip, SCIP_NLROW *nlrow, SCIP_SOL *sol, SCIP_Real *activity)
struct SCIP_Pricer SCIP_PRICER
Definition: type_pricer.h:35
public methods for presolvers
SCIP_RETCODE SCIPlinkCurrentSol(SCIP *scip, SCIP_SOL *sol)
SCIP_COL ** SCIPgetLPCols(SCIP *scip)
SCIP_RETCODE SCIPgetNLPIntPar(SCIP *scip, SCIP_NLPPARAM type, int *ival)
public methods for managing events
#define SCIP_DECL_DISPEXITSOL(x)
Definition: type_disp.h:108
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)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
SCIP_RETCODE SCIPcreateSolCopyOrig(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
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)
struct SCIP_RelaxData SCIP_RELAXDATA
Definition: type_relax.h:38
SCIP_RETCODE SCIPsetConshdlrDelvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
#define SCIP_DECL_RELAXEXEC(x)
Definition: type_relax.h:118
unsigned int SCIP_PROPTIMING
Definition: type_timing.h:64
struct SCIP_BoolArray SCIP_BOOLARRAY
Definition: type_misc.h:90
int SCIPgetNIntVars(SCIP *scip)
SCIP_Real SCIPgetTransObjscale(SCIP *scip)
SCIP_Bool SCIPisLPRelax(SCIP *scip)
struct SCIP_ProbData SCIP_PROBDATA
Definition: type_prob.h:44
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPsetProbExitsol(SCIP *scip, SCIP_DECL_PROBEXITSOL((*probexitsol)))
SCIP_RETCODE SCIPretransformSol(SCIP *scip, SCIP_SOL *sol)
int SCIPgetMaxTotalDepth(SCIP *scip)
SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
SCIP_RETCODE SCIPchgStringParam(SCIP *scip, SCIP_PARAM *param, const char *value)
SCIP_Real SCIPfrac(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPchgVarBoundsDiveNLP(SCIP *scip, SCIP_VAR *var, SCIP_Real lb, SCIP_Real ub)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
void SCIPprintReal(SCIP *scip, FILE *file, SCIP_Real val, int width, int precision)
type definitions for tree compression
SCIP_Bool SCIPisSumEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPchgNlRowLhs(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real lhs)
int SCIPgetEffectiveRootDepth(SCIP *scip)
int SCIPgetNPriceRounds(SCIP *scip)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
SCIP_Real * SCIPgetNLPVarsLbDualsol(SCIP *scip)
#define SCIP_DECL_EVENTINITSOL(x)
Definition: type_event.h:191
#define SCIP_DECL_SEPAEXIT(x)
Definition: type_sepa.h:71
void * SCIPgetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx)
SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
SCIP_RETCODE SCIPstartSolvingTime(SCIP *scip)
int SCIPgetNLPRows(SCIP *scip)
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)
SCIP_NODESEL * SCIPfindNodesel(SCIP *scip, const char *name)
SCIP_Bool SCIPhasPrimalRay(SCIP *scip)
SCIP_Real SCIPretransformObj(SCIP *scip, SCIP_Real obj)
public methods for conflict analysis handlers
SCIP_RETCODE SCIPtrySol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
#define SCIP_DECL_CONSFREE(x)
Definition: type_cons.h:74
int SCIPgetNOrigConss(SCIP *scip)
SCIP_RETCODE SCIPdropRowEvent(SCIP *scip, SCIP_ROW *row, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
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)
SCIP_Real SCIPgetBranchScoreMultiple(SCIP *scip, SCIP_VAR *var, int nchildren, SCIP_Real *gains)
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
public methods for tree compressions
type definitions for separators
int SCIPgetNCliques(SCIP *scip)
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
#define SCIP_DECL_DISPEXIT(x)
Definition: type_disp.h:86
int SCIPminorVersion(void)
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
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)
#define SCIP_DECL_SEPAINITSOL(x)
Definition: type_sepa.h:82
SCIP_Bool SCIPinRepropagation(SCIP *scip)
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
#define SCIP_DECL_PROPRESPROP(x)
Definition: type_prop.h:243
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
#define SCIP_DECL_HEUREXIT(x)
Definition: type_heur.h:84
SCIP_Longint SCIPconvertRealToLongint(SCIP *scip, SCIP_Real real)
SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
int SCIPgetNNodesLeft(SCIP *scip)
SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
SCIP_RELAX * SCIPfindRelax(SCIP *scip, const char *name)
SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
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)
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)
public methods for message output
SCIP_Bool SCIPisExactSolve(SCIP *scip)
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
SCIP_RETCODE SCIPincludeReaderBasic(SCIP *scip, SCIP_READER **readerptr, const char *name, const char *desc, const char *extension, SCIP_READERDATA *readerdata)
#define SCIP_DECL_HEURINIT(x)
Definition: type_heur.h:76
SCIP_RETCODE SCIPsetSepaExitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
SCIP_RETCODE SCIPsetPropExit(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXIT((*propexit)))
#define SCIP_DECL_CONSINIT(x)
Definition: type_cons.h:84
#define SCIP_DECL_PROPPRESOL(x)
Definition: type_prop.h:179
SCIP_RETCODE SCIPsetRelaxExitsol(SCIP *scip, SCIP_RELAX *relax, SCIP_DECL_RELAXEXITSOL((*relaxexitsol)))
SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
SCIP_RETCODE SCIPbranchVarValNary(SCIP *scip, SCIP_VAR *var, SCIP_Real val, int n, SCIP_Real minwidth, SCIP_Real widthfactor, int *nchildren)
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)
struct SCIP_Conshdlr SCIP_CONSHDLR
Definition: type_cons.h:47
SCIP_RETCODE SCIPsetEventhdlrDelete(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTDELETE((*eventdelete)))
type definitions for handling parameter settings
SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
struct SCIP_LPi SCIP_LPI
Definition: type_lpi.h:94
enum SCIP_DispStatus SCIP_DISPSTATUS
Definition: type_disp.h:50
SCIP_RETCODE SCIPclearPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray)
SCIP_RETCODE SCIProundSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *success)
SCIP_RETCODE SCIPchgBarrierconvtol(SCIP *scip, SCIP_Real barrierconvtol)
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
SCIP_Bool SCIPisNLPEnabled(SCIP *scip)
#define SCIP_Real
Definition: def.h:127
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
type definitions for user interface dialog
int SCIPgetNPricevarsApplied(SCIP *scip)
const char * SCIPgetProbName(SCIP *scip)
SCIP_RETCODE SCIPprintNlRow(SCIP *scip, SCIP_NLROW *nlrow, FILE *file)
SCIP_RETCODE SCIPsetProbData(SCIP *scip, SCIP_PROBDATA *probdata)
enum SCIP_Stage SCIP_STAGE
Definition: type_set.h:48
public methods for relaxation handlers
SCIP_RETCODE SCIPsetEventhdlrFree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))
SCIP_Real SCIPgetPresolvingTime(SCIP *scip)
struct SCIP_PropData SCIP_PROPDATA
Definition: type_prop.h:38
result codes for SCIP callback methods
type definitions for branching and inference history
SCIP_RETCODE SCIPgetNLPRealPar(SCIP *scip, SCIP_NLPPARAM type, SCIP_Real *dval)
SCIP_RETCODE SCIPincSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real incval)
int SCIPgetCutoffdepth(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
public methods for input file readers
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
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_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)
#define SCIP_DECL_EVENTCOPY(x)
Definition: type_event.h:156
#define SCIP_DECL_NODESELCOPY(x)
Definition: type_nodesel.h:47
SCIP_Bool SCIPisDualfeasNegative(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPlinkLPSol(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)
SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)
SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
SCIP_RETCODE SCIPcheckBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
SCIP_RETCODE SCIPgetChildren(SCIP *scip, SCIP_NODE ***children, int *nchildren)
SCIP_RETCODE SCIPlinkPseudoSol(SCIP *scip, SCIP_SOL *sol)
SCIP_Real SCIPtransformObj(SCIP *scip, SCIP_Real obj)
#define SCIP_DECL_CONSSEPASOL(x)
Definition: type_cons.h:271
SCIP_RETCODE SCIPsetComprInit(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINIT((*comprinit)))
#define SCIP_DECL_READERREAD(x)
Definition: type_reader.h:71
#define SCIP_DECL_HEURFREE(x)
Definition: type_heur.h:68
int SCIPgetNImplVars(SCIP *scip)
void SCIPresetReoptSolMarks(SCIP *scip)
SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
#define SCIP_DECL_CONSPROP(x)
Definition: type_cons.h:421
SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
SCIP_RETCODE SCIPreleaseDialog(SCIP *scip, SCIP_DIALOG **dialog)
SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
#define SCIP_DECL_CONFLICTINIT(x)
Definition: type_conflict.h:68
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_Real SCIPround(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPgetNLPVarsNonlinearity(SCIP *scip, int *nlcount)
SCIP_RETCODE SCIPclearIntarray(SCIP *scip, SCIP_INTARRAY *intarray)
#define SCIP_DECL_CONSACTIVE(x)
Definition: type_cons.h:606
SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val)
int SCIPgetNHeurs(SCIP *scip)
SCIP_RETCODE SCIPsetStringParam(SCIP *scip, const char *name, const char *value)
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPsetNodeselStdPriority(SCIP *scip, SCIP_NODESEL *nodesel, int priority)
SCIP_RETCODE SCIPactivatePricer(SCIP *scip, SCIP_PRICER *pricer)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
void SCIPprintVersion(SCIP *scip, FILE *file)
SCIP_Real SCIPgetRelaxSolObj(SCIP *scip)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
#define SCIP_Longint
Definition: def.h:112
int SCIPgetNUpgrConss(SCIP *scip)
SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
#define SCIP_DECL_PROPEXIT(x)
Definition: type_prop.h:71
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
struct SCIP_Presol SCIP_PRESOL
Definition: type_presol.h:36
SCIP_RETCODE SCIPautoselectDisps(SCIP *scip)
SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
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)
SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *const scip, SCIP_VAR **const vars, int const nvars, int *const cliquepartition, int *const ncliques)
SCIP_RETCODE SCIPgetNLPStringPar(SCIP *scip, SCIP_NLPPARAM type, const char **sval)
SCIP_RETCODE SCIPclearSol(SCIP *scip, SCIP_SOL *sol)
SCIP_Real SCIPgetSolTime(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPcreate(SCIP **scip)
int SCIPtechVersion(void)
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
void SCIPclearDiveBoundChanges(SCIP *scip)
SCIP_Bool SCIPareSolsEqual(SCIP *scip, SCIP_SOL *sol1, SCIP_SOL *sol2)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPsetNLPInitialGuessSol(SCIP *scip, SCIP_SOL *sol)
struct SCIP_PricerData SCIP_PRICERDATA
Definition: type_pricer.h:36
int SCIPgetNDisps(SCIP *scip)
SCIP_VAR ** SCIPgetNLPVars(SCIP *scip)
SCIP_RETCODE SCIPsetEventhdlrInitsol(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINITSOL((*eventinitsol)))
SCIP_RETCODE SCIPcopyOrigProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name)
SCIP_RETCODE SCIPfreeRepresentation(SCIP *scip, SCIP_REOPTNODE **representatives, int nrepresentatives)
int SCIPgetNBranchrules(SCIP *scip)
SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)
#define SCIP_DECL_CONSHDLRCOPY(x)
Definition: type_cons.h:66
enum SCIP_Vartype SCIP_VARTYPE
Definition: type_var.h:58
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:49
void SCIPstoreSolutionGap(SCIP *scip)
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
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)
SCIP_RETCODE SCIPwriteNLP(SCIP *scip, const char *filename)
enum Reopt_ConsType REOPT_CONSTYPE
Definition: type_reopt.h:64
SCIP_RETCODE SCIPcaptureNlRow(SCIP *scip, SCIP_NLROW *nlrow)
#define SCIP_DECL_PRICERFREE(x)
Definition: type_pricer.h:54
SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
SCIP_RETCODE SCIPbranchVarVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
SCIP_RETCODE SCIPextendRealarray(SCIP *scip, SCIP_REALARRAY *realarray, int minidx, int maxidx)
SCIP_RETCODE SCIPcreateWallClock(SCIP *scip, SCIP_CLOCK **clck)
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)
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
SCIP_CONFLICTHDLR * SCIPfindConflicthdlr(SCIP *scip, const char *name)
void SCIPsetMessagehdlrLogfile(SCIP *scip, const char *filename)
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
void SCIPmarkLimitChanged(SCIP *scip)
SCIP_Bool SCIPisReoptEnabled(SCIP *scip)
int SCIPgetBoolarrayMinIdx(SCIP *scip, SCIP_BOOLARRAY *boolarray)
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)
int SCIPgetNTotalVars(SCIP *scip)
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
SCIP_RETCODE SCIPbranchPseudo(SCIP *scip, SCIP_RESULT *result)
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
SCIP_RETCODE SCIPgetReopSolsRun(SCIP *scip, int run, SCIP_SOL **sols, int allocmem, int *nsols)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
#define SCIP_DECL_RELAXEXITSOL(x)
Definition: type_relax.h:93
SCIP_Bool SCIPisSumRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
SCIP_Bool SCIPisSumRelGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)
public methods for separators
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
#define SCIP_DECL_CONSCOPY(x)
Definition: type_cons.h:723
public methods for primal heuristics
SCIP_RETCODE SCIPendDive(SCIP *scip)
SCIP_Real SCIPsumepsilon(SCIP *scip)
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPsolve(SCIP *scip)
SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
#define SCIP_DECL_DISPOUTPUT(x)
Definition: type_disp.h:117
SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPincRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx, SCIP_Real incval)
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
#define SCIP_DECL_CONFLICTFREE(x)
Definition: type_conflict.h:60
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
SCIP_RETCODE SCIPcreateRealarray(SCIP *scip, SCIP_REALARRAY **realarray)
SCIP_Real SCIPgetNodeDualbound(SCIP *scip, SCIP_NODE *node)
struct SCIP_Branchrule SCIP_BRANCHRULE
Definition: type_branch.h:42
int SCIPgetNLPBranchCands(SCIP *scip)
SCIP_RETCODE SCIPcheckCharParam(SCIP *scip, SCIP_PARAM *param, const char value)
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
SCIP_RETCODE SCIPgetReoptLeaveIDs(SCIP *scip, SCIP_NODE *node, unsigned int *ids, int mem, int *nids)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
type definitions for node selectors
SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop, SCIP_DECL_PROPEXITSOL((*propexitsol)))
int SCIPgetIntarrayMaxIdx(SCIP *scip, SCIP_INTARRAY *intarray)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)
SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
int SCIPgetNFixedVars(SCIP *scip)
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)
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
SCIP_RETCODE SCIPcreateClock(SCIP *scip, SCIP_CLOCK **clck)
SCIP_RETCODE SCIPcaptureDialog(SCIP *scip, SCIP_DIALOG *dialog)
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)
SCIP_RETCODE SCIPseparateSolCutpool(SCIP *scip, SCIP_CUTPOOL *cutpool, SCIP_SOL *sol, SCIP_RESULT *result)
SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
#define SCIP_DECL_PRICERREDCOST(x)
Definition: type_pricer.h:130
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
SCIP_RETCODE SCIPsetComprInitsol(SCIP *scip, SCIP_COMPR *compr, SCIP_DECL_COMPRINITSOL((*comprinitsol)))
SCIP_RETCODE SCIPevalExprtreeSol(SCIP *scip, SCIP_EXPRTREE *tree, SCIP_SOL *sol, SCIP_Real *val)
#define SCIP_DECL_HEUREXITSOL(x)
Definition: type_heur.h:106
void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
#define SCIP_DECL_NODESELSELECT(x)
Definition: type_nodesel.h:109
int SCIPgetNOrigContVars(SCIP *scip)
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPcreateRelaxSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPsetEventhdlrCopy(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTCOPY((*eventcopy)))
struct SCIP_Node SCIP_NODE
Definition: type_tree.h:54
SCIP_RELAX ** SCIPgetRelaxs(SCIP *scip)
SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
SCIP_RETCODE SCIPstartDiveNLP(SCIP *scip)
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)
SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
SCIP_RETCODE SCIPsetConflicthdlrExitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)))
SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
int SCIPgetBoolarrayMaxIdx(SCIP *scip, SCIP_BOOLARRAY *boolarray)
SCIP_RETCODE SCIPsetPropPriority(SCIP *scip, SCIP_PROP *prop, int priority)
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)
public methods for user interface dialog
#define SCIP_DECL_BRANCHEXIT(x)
Definition: type_branch.h:76
SCIP_RETCODE SCIPchgRowLhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPsetConsModifiable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)
SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPchgCharParam(SCIP *scip, SCIP_PARAM *param, char value)
SCIP_RETCODE SCIPmarkRelaxSolInvalid(SCIP *scip)
SCIP_Real SCIPgetObjNorm(SCIP *scip)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPsetNodeselMemsavePriority(SCIP *scip, SCIP_NODESEL *nodesel, int priority)
int SCIPgetSolRunnum(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPgetExternBranchCands(SCIP *scip, SCIP_VAR ***externcands, SCIP_Real **externcandssol, SCIP_Real **externcandsscore, int *nexterncands, int *nprioexterncands, int *nprioexternbins, int *nprioexternints, int *nprioexternimpls)
SCIP_RETCODE SCIPcheckLongintParam(SCIP *scip, SCIP_PARAM *param, SCIP_Longint value)
SCIP_RETCODE SCIPsetPresolCopy(SCIP *scip, SCIP_PRESOL *presol, SCIP_DECL_PRESOLCOPY((*presolcopy)))
SCIP_Real SCIPdualfeasFrac(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
int SCIPgetRealarrayMinIdx(SCIP *scip, SCIP_REALARRAY *realarray)
#define SCIP_DECL_SEPAFREE(x)
Definition: type_sepa.h:55
int SCIPgetNChildren(SCIP *scip)
SCIP_Bool SCIPisLPSolBasic(SCIP *scip)
SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPgetNlRowFeasibility(SCIP *scip, SCIP_NLROW *nlrow, SCIP_Real *feasibility)
struct SCIP_SepaData SCIP_SEPADATA
Definition: type_sepa.h:38
SCIP_Bool SCIPisDualfeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPaddDelayedPoolCut(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_RETCODE SCIPsetProbTrans(SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))
type definitions for constraints and constraint handlers
SCIP_HEUR ** SCIPgetHeurs(SCIP *scip)
SCIP_Real SCIPgetLPLooseObjval(SCIP *scip)
#define SCIP_DECL_READERFREE(x)
Definition: type_reader.h:55
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
public methods for propagators
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
#define SCIP_DECL_PROPINIT(x)
Definition: type_prop.h:63
SCIP_RETCODE SCIPinferBinvarProp(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Bool SCIPisFeasFracIntegral(SCIP *scip, SCIP_Real val)
int SCIPgetNImplications(SCIP *scip)
SCIP_REOPTNODE * SCIPgetReoptnode(SCIP *scip, unsigned int id)
SCIP_RETCODE SCIPaddSolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool *stored)
SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
type definitions for specific NLP solver interfaces
SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
SCIP_Bool SCIPinDive(SCIP *scip)
SCIP_RETCODE SCIPsetIntarrayVal(SCIP *scip, SCIP_INTARRAY *intarray, int idx, int val)
#define SCIP_DECL_CONFLICTEXITSOL(x)
Definition: type_conflict.h:98
SCIP_RETCODE SCIPsplitReoptRoot(SCIP *scip, int *ncreatedchilds, int *naddedconss)
SCIP_RETCODE SCIPsetBranchruleMaxbounddist(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_Real maxbounddist)
SCIP_Bool SCIPhasNLPContinuousNonlinearity(SCIP *scip)
SCIP_Real SCIPgetRealarrayVal(SCIP *scip, SCIP_REALARRAY *realarray, int idx)
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
type definitions for displaying runtime statistics
SCIP_Bool SCIPreoptimizeNode(SCIP *scip, SCIP_NODE *node)
SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)
SCIP_RETCODE SCIPsetRelaxSolValsSol(SCIP *scip, SCIP_SOL *sol)