Scippy

SCIP

Solving Constraint Integer Programs

scip.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2014 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip.h
17  * @ingroup PUBLICMETHODS
18  * @brief SCIP callable library
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  */
26 
27 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
28 
29 #ifndef __SCIP_SCIP_H__
30 #define __SCIP_SCIP_H__
31 
32 
33 #include <stdio.h>
34 
35 #include "scip/def.h"
36 #include "blockmemshell/memory.h"
37 #include "scip/type_retcode.h"
38 #include "scip/type_result.h"
39 #include "scip/type_clock.h"
40 #include "scip/type_misc.h"
41 #include "scip/type_timing.h"
42 #include "scip/type_paramset.h"
43 #include "scip/type_event.h"
44 #include "scip/type_lp.h"
45 #include "scip/type_nlp.h"
46 #include "scip/type_var.h"
47 #include "scip/type_prob.h"
48 #include "scip/type_tree.h"
49 #include "scip/type_scip.h"
50 
51 #include "scip/type_branch.h"
52 #include "scip/type_conflict.h"
53 #include "scip/type_cons.h"
54 #include "scip/type_dialog.h"
55 #include "scip/type_disp.h"
56 #include "scip/type_heur.h"
57 #include "scip/type_history.h"
58 #include "scip/type_nodesel.h"
59 #include "scip/type_presol.h"
60 #include "scip/type_pricer.h"
61 #include "scip/type_reader.h"
62 #include "scip/type_relax.h"
63 #include "scip/type_sepa.h"
64 #include "scip/type_prop.h"
65 #include "nlpi/type_nlpi.h"
66 
67 /* include public interfaces, s.t. the user only needs to include scip.h */
68 #include "scip/pub_branch.h"
69 #include "scip/pub_conflict.h"
70 #include "scip/pub_cons.h"
71 #include "scip/pub_cutpool.h"
72 #include "scip/pub_dialog.h"
73 #include "scip/pub_disp.h"
74 #include "scip/pub_event.h"
75 #include "scip/pub_fileio.h"
76 #include "scip/pub_heur.h"
77 #include "scip/pub_history.h"
78 #include "scip/pub_implics.h"
79 #include "scip/pub_lp.h"
80 #include "scip/pub_nlp.h"
81 #include "scip/pub_message.h"
82 #include "scip/pub_misc.h"
83 #include "scip/pub_nodesel.h"
84 #include "scip/pub_paramset.h"
85 #include "scip/pub_presol.h"
86 #include "scip/pub_pricer.h"
87 #include "scip/pub_reader.h"
88 #include "scip/pub_relax.h"
89 #include "scip/pub_sepa.h"
90 #include "scip/pub_prop.h"
91 #include "scip/pub_sol.h"
92 #include "scip/pub_tree.h"
93 #include "scip/pub_var.h"
94 #include "lpi/lpi.h"
95 #include "nlpi/pub_expr.h"
96 
97 /* include global presolving methods */
98 #include "scip/presolve.h"
99 
100 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
101  * this structure except the interface methods in scip.c.
102  * In optimized mode, the structure is included in scip.h, because some of the methods
103  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
104  * Additionally, the internal "set.h" is included, such that the defines in set.h are
105  * available in optimized mode.
106  */
107 #ifdef NDEBUG
108 #include "scip/struct_scip.h"
109 #include "scip/set.h"
110 #include "scip/tree.h"
111 #include "scip/misc.h"
112 #include "scip/var.h"
113 #endif
114 
115 #ifdef __cplusplus
116 extern "C" {
117 #endif
118 
119 /*
120  * miscellaneous methods
121  */
122 
123 /**@name Miscellaneous Methods */
124 /**@{ */
125 
126 /** returns complete SCIP version number in the format "major . minor tech"
127  *
128  * @return complete SCIP version
129  */
130 extern
132  void
133  );
134 
135 /** returns SCIP major version
136  *
137  * @return major SCIP version
138  */
139 extern
140 int SCIPmajorVersion(
141  void
142  );
143 
144 /** returns SCIP minor version
145  *
146  * @return minor SCIP version
147  */
148 extern
149 int SCIPminorVersion(
150  void
151  );
152 
153 /** returns SCIP technical version
154  *
155  * @return technical SCIP version
156  */
157 extern
158 int SCIPtechVersion(
159  void
160  );
161 
162 /** returns SCIP sub version number
163  *
164  * @return subversion SCIP version
165  */
166 extern
167 int SCIPsubversion(
168  void
169  );
170 
171 /** prints a version information line to a file stream via the message handler system
172  *
173  * @note If the message handler is set to a NULL pointer nothing will be printed
174  */
175 extern
176 void SCIPprintVersion(
177  SCIP* scip, /**< SCIP data structure */
178  FILE* file /**< output file (or NULL for standard output) */
179  );
180 
181 /** prints error message for the given SCIP_RETCODE via the error prints method */
182 extern
183 void SCIPprintError(
184  SCIP_RETCODE retcode /**< SCIP return code causing the error */
185  );
186 
187 /** update statistical information when a new solution was found */
188 extern
190  SCIP* scip /**< SCIP data structure */
191  );
192 
193 /**@} */
194 
195 
196 
197 
198 /*
199  * general SCIP methods
200  */
201 
202 /**@name General SCIP Methods */
203 /**@{ */
204 
205 /** creates and initializes SCIP data structures
206  *
207  * @note The SCIP default message handler is installed. Use the method SCIPsetMessagehdlr() to install your own
208  * message handler or SCIPsetMessagehdlrLogfile() and SCIPsetMessagehdlrQuiet() to write into a log
209  * file and turn off/on the display output, respectively.
210  *
211  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
212  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
213  *
214  * @post After calling this method @p scip reached the solving stage \ref SCIP_STAGE_INIT
215  *
216  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
217  */
218 extern
220  SCIP** scip /**< pointer to SCIP data structure */
221  );
222 
223 /** frees SCIP data structures
224  *
225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
227  *
228  * @pre This method can be called if @p scip is in one of the following stages:
229  * - \ref SCIP_STAGE_INIT
230  * - \ref SCIP_STAGE_PROBLEM
231  * - \ref SCIP_STAGE_TRANSFORMED
232  * - \ref SCIP_STAGE_INITPRESOLVE
233  * - \ref SCIP_STAGE_PRESOLVING
234  * - \ref SCIP_STAGE_PRESOLVED
235  * - \ref SCIP_STAGE_EXITPRESOLVE
236  * - \ref SCIP_STAGE_SOLVING
237  * - \ref SCIP_STAGE_SOLVED
238  * - \ref SCIP_STAGE_FREE
239  *
240  * @post After calling this method \SCIP reached the solving stage \ref SCIP_STAGE_FREE
241  *
242  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
243  */
244 extern
246  SCIP** scip /**< pointer to SCIP data structure */
247  );
248 
249 /** returns current stage of SCIP
250  *
251  * @return the current SCIP stage
252  *
253  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
254  */
255 extern
257  SCIP* scip /**< SCIP data structure */
258  );
259 
260 /** outputs SCIP stage and solution status if applicable via the message handler
261  *
262  * @note If the message handler is set to a NULL pointer nothing will be printed
263  *
264  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
265  * thus may to correspond to the original status.
266  *
267  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
268  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
269  *
270  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
271  */
272 extern
274  SCIP* scip, /**< SCIP data structure */
275  FILE* file /**< output file (or NULL for standard output) */
276  );
277 
278 /** gets solution status
279  *
280  * @return SCIP solution status
281  *
282  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
283  */
284 extern
286  SCIP* scip /**< SCIP data structure */
287  );
288 
289 /** outputs solution status
290  *
291  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
292  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
293  *
294  * See \ref SCIP_Status "SCIP_STATUS" for a complete list of all possible solving status.
295  */
296 extern
298  SCIP* scip, /**< SCIP data structure */
299  FILE* file /**< output file (or NULL for standard output) */
300  );
301 
302 /** returns whether the current stage belongs to the transformed problem space
303  *
304  * @return Returns TRUE if the \SCIP instance is transformed, otherwise FALSE
305  */
306 extern
308  SCIP* scip /**< SCIP data structure */
309  );
310 
311 /** returns whether the solution process should be probably correct
312  *
313  * @note This feature is not supported yet!
314  *
315  * @return Returns TRUE if \SCIP is exact solving mode, otherwise FALSE
316  */
317 extern
319  SCIP* scip /**< SCIP data structure */
320  );
321 
322 /** returns whether the presolving process would be finished given no more presolving reductions are found in this
323  * presolving round
324  *
325  * Checks whether the number of presolving rounds is not exceeded and the presolving reductions found in the current
326  * presolving round suffice to trigger another presolving round.
327  *
328  * @note if subsequent presolvers find more reductions, presolving might continue even if the method returns FALSE
329  * @note does not check whether infeasibility or unboundedness was already detected in presolving (which would result
330  * in presolving being stopped although the method returns TRUE)
331  *
332  * @return Returns TRUE if presolving is finished if no further reductions are detected
333  */
334 extern
336  SCIP* scip /**< SCIP data structure */
337  );
338 
339 /** returns whether the user pressed CTRL-C to interrupt the solving process
340  *
341  * @return Returns TRUE if Ctrl-C was pressed, otherwise FALSE.
342  */
343 extern
345  SCIP* scip /**< SCIP data structure */
346  );
347 
348 /** returns whether the solving process should be / was stopped before proving optimality;
349  * if the solving process should be / was stopped, the status returned by SCIPgetStatus() yields
350  * the reason for the premature abort
351  *
352  * @return Returns TRUE if solving process is stopped/interrupted, otherwise FALSE.
353  */
354 extern
356  SCIP* scip /**< SCIP data structure */
357  );
358 
359 
360 /**@} */
361 
362 
363 
364 /*
365  * message output methods
366  */
367 
368 /**@name Message Output Methods */
369 /**@{ */
370 
371 /** installs the given message handler, such that all messages are passed to this handler. A messages handler can be
372  * created via SCIPmessagehdlrCreate().
373  *
374  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
375  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
376  *
377  * @pre this method can be called in one of the following stages of the SCIP solving process:
378  * - \ref SCIP_STAGE_INIT
379  * - \ref SCIP_STAGE_PROBLEM
380  *
381  * @note The currently installed messages handler gets freed if this SCIP instance is its last user (w.r.t. capture/release).
382  */
383 extern
385  SCIP* scip, /**< SCIP data structure */
386  SCIP_MESSAGEHDLR* messagehdlr /**< message handler to install, or NULL to suppress all output */
387  );
388 
389 /** returns the currently installed message handler
390  *
391  * @return the currently installed message handler, or NULL if messages are currently suppressed
392  */
393 extern
395  SCIP* scip /**< SCIP data structure */
396  );
397 
398 /** sets the log file name for the currently installed message handler */
399 extern
401  SCIP* scip, /**< SCIP data structure */
402  const char* filename /**< name of log file, or NULL (no log) */
403  );
404 
405 /** sets the currently installed message handler to be quiet (or not) */
406 extern
408  SCIP* scip, /**< SCIP data structure */
409  SCIP_Bool quiet /**< should screen messages be suppressed? */
410  );
411 
412 /** prints a warning message via the message handler */
413 extern
414 void SCIPwarningMessage(
415  SCIP* scip, /**< SCIP data structure */
416  const char* formatstr, /**< format string like in printf() function */
417  ... /**< format arguments line in printf() function */
418  );
419 
420 /** prints a dialog message that requests user interaction or is a direct response to a user interactive command */
421 extern
422 void SCIPdialogMessage(
423  SCIP* scip, /**< SCIP data structure */
424  FILE* file, /**< file stream to print into, or NULL for stdout */
425  const char* formatstr, /**< format string like in printf() function */
426  ... /**< format arguments line in printf() function */
427  );
428 
429 /** prints a message */
430 extern
431 void SCIPinfoMessage(
432  SCIP* scip, /**< SCIP data structure */
433  FILE* file, /**< file stream to print into, or NULL for stdout */
434  const char* formatstr, /**< format string like in printf() function */
435  ... /**< format arguments line in printf() function */
436  );
437 
438 /** prints a message depending on the verbosity level */
439 extern
440 void SCIPverbMessage(
441  SCIP* scip, /**< SCIP data structure */
442  SCIP_VERBLEVEL msgverblevel, /**< verbosity level of this message */
443  FILE* file, /**< file stream to print into, or NULL for stdout */
444  const char* formatstr, /**< format string like in printf() function */
445  ... /**< format arguments line in printf() function */
446  );
447 
448 /** returns the current message verbosity level
449  *
450  * @return message verbosity level of SCIP
451  *
452  * @see \ref SCIP_VerbLevel "SCIP_VERBLEVEL" for a list of all verbosity levels
453  */
454 extern
456  SCIP* scip /**< SCIP data structure */
457  );
458 
459 
460 /**@} */
461 
462 
463 
464 
465 /*
466  * SCIP copy methods
467  */
468 
469 /**@name Copy Methods */
470 /**@{ */
471 
472 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
473  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
474  * copied SCIP instance might not represent the same problem semantics as the original.
475  * Note that in this case dual reductions might be invalid.
476  *
477  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
478  * Also, 'passmessagehdlr' should be set to FALSE.
479  * @note Do not change the source SCIP environment during the copying process
480  *
481  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
482  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
483  *
484  * @pre This method can be called if sourcescip is in one of the following stages:
485  * - \ref SCIP_STAGE_PROBLEM
486  * - \ref SCIP_STAGE_TRANSFORMED
487  * - \ref SCIP_STAGE_INITPRESOLVE
488  * - \ref SCIP_STAGE_PRESOLVING
489  * - \ref SCIP_STAGE_EXITPRESOLVE
490  * - \ref SCIP_STAGE_PRESOLVED
491  * - \ref SCIP_STAGE_INITSOLVE
492  * - \ref SCIP_STAGE_SOLVING
493  * - \ref SCIP_STAGE_SOLVED
494  *
495  * @pre This method can be called if targetscip is in one of the following stages:
496  * - \ref SCIP_STAGE_INIT
497  * - \ref SCIP_STAGE_FREE
498  *
499  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
500  * process was interrupted:
501  * - \ref SCIP_STAGE_PROBLEM
502  *
503  * @note sourcescip stage does not get changed
504  *
505  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
506  */
507 extern
509  SCIP* sourcescip, /**< source SCIP data structure */
510  SCIP* targetscip, /**< target SCIP data structure */
511  SCIP_Bool copyreaders, /**< should the file readers be copied */
512  SCIP_Bool copypricers, /**< should the variable pricers be copied */
513  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
514  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
515  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
516  SCIP_Bool copyrelaxators, /**< should the relaxation handler be copied */
517  SCIP_Bool copyseparators, /**< should the separators be copied */
518  SCIP_Bool copypropagators, /**< should the propagators be copied */
519  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
520  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
521  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
522  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
523  SCIP_Bool copydisplays, /**< should the display columns be copied */
524  SCIP_Bool copydialogs, /**< should the dialogs be copied */
525  SCIP_Bool copynlpis, /**< should the NLPIs be copied */
526  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
527  SCIP_Bool* valid /**< pointer to store whether plugins, in particular all constraint
528  * handlers which do not need constraints were validly copied */
529  );
530 
531 /** create a problem by copying the problem data of the source SCIP
532  *
533  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
534  * @note Do not change the source SCIP environment during the copying process
535  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
537  *
538  * @pre This method can be called if sourcescip is in one of the following stages:
539  * - \ref SCIP_STAGE_PROBLEM
540  * - \ref SCIP_STAGE_TRANSFORMED
541  * - \ref SCIP_STAGE_INITPRESOLVE
542  * - \ref SCIP_STAGE_PRESOLVING
543  * - \ref SCIP_STAGE_EXITPRESOLVE
544  * - \ref SCIP_STAGE_PRESOLVED
545  * - \ref SCIP_STAGE_INITSOLVE
546  * - \ref SCIP_STAGE_SOLVING
547  * - \ref SCIP_STAGE_SOLVED
548  *
549  * @pre This method can be called if targetscip is in one of the following stages:
550  * - \ref SCIP_STAGE_INIT
551  * - \ref SCIP_STAGE_FREE
552  *
553  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
554  * process was interrupted:
555  * - \ref SCIP_STAGE_PROBLEM
556  *
557  * @note sourcescip stage does not get changed
558  *
559  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
560  */
561 extern
563  SCIP* sourcescip, /**< source SCIP data structure */
564  SCIP* targetscip, /**< target SCIP data structure */
565  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
566  * target variables, or NULL */
567  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
568  * target constraints, or NULL */
569  SCIP_Bool global, /**< create a global or a local copy? */
570  const char* name /**< problem name */
571  );
572 
573 /** create a problem by copying the original problem data of the source SCIP
574  *
575  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
576  * @note Do not change the source SCIP environment during the copying process
577  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
578  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
579  *
580  * @pre This method can be called if sourcescip is in one of the following stages:
581  * - \ref SCIP_STAGE_PROBLEM
582  * - \ref SCIP_STAGE_TRANSFORMED
583  * - \ref SCIP_STAGE_INITPRESOLVE
584  * - \ref SCIP_STAGE_PRESOLVING
585  * - \ref SCIP_STAGE_EXITPRESOLVE
586  * - \ref SCIP_STAGE_PRESOLVED
587  * - \ref SCIP_STAGE_INITSOLVE
588  * - \ref SCIP_STAGE_SOLVING
589  * - \ref SCIP_STAGE_SOLVED
590  *
591  * @pre This method can be called if targetscip is in one of the following stages:
592  * - \ref SCIP_STAGE_INIT
593  * - \ref SCIP_STAGE_FREE
594  *
595  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
596  * process was interrupted:
597  * - \ref SCIP_STAGE_PROBLEM
598  *
599  * @note sourcescip stage does not get changed
600  *
601  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
602  */
603 extern
605  SCIP* sourcescip, /**< source SCIP data structure */
606  SCIP* targetscip, /**< target SCIP data structure */
607  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
608  * target variables, or NULL */
609  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
610  * target constraints, or NULL */
611  const char* name /**< problem name of target */
612  );
613 
614 /** returns copy of the source variable; if there already is a copy of the source variable in the variable hash map,
615  * it is just returned as target variable; elsewise a new variable will be created and added to the target SCIP; this
616  * created variable is added to the variable hash map and returned as target variable
617  *
618  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
619  * @note Do not change the source SCIP environment during the copying process
620  * @note if a new variable was created, this variable will be added to the target-SCIP, but it is not captured
621  *
622  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
623  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
624  *
625  * @pre This method can be called if sourcescip is in one of the following stages:
626  * - \ref SCIP_STAGE_PROBLEM
627  * - \ref SCIP_STAGE_TRANSFORMED
628  * - \ref SCIP_STAGE_INITPRESOLVE
629  * - \ref SCIP_STAGE_PRESOLVING
630  * - \ref SCIP_STAGE_EXITPRESOLVE
631  * - \ref SCIP_STAGE_PRESOLVED
632  * - \ref SCIP_STAGE_INITSOLVE
633  * - \ref SCIP_STAGE_SOLVING
634  * - \ref SCIP_STAGE_SOLVED
635  *
636  * @pre This method can be called if targetscip is in one of the following stages:
637  * - \ref SCIP_STAGE_PROBLEM
638  * - \ref SCIP_STAGE_TRANSFORMED
639  * - \ref SCIP_STAGE_INITPRESOLVE
640  * - \ref SCIP_STAGE_PRESOLVING
641  * - \ref SCIP_STAGE_EXITPRESOLVE
642  * - \ref SCIP_STAGE_SOLVING
643  *
644  * @note targetscip stage does not get changed
645  *
646  * @note sourcescip stage does not get changed
647  *
648  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
649  */
650 extern
652  SCIP* sourcescip, /**< source SCIP data structure */
653  SCIP* targetscip, /**< target SCIP data structure */
654  SCIP_VAR* sourcevar, /**< source variable */
655  SCIP_VAR** targetvar, /**< pointer to store the target variable */
656  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
657  * target variables, or NULL */
658  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
659  * target constraints, or NULL */
660  SCIP_Bool global, /**< should global or local bounds be used? */
661  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
662  );
663 
664 /** copies all active variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
665  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
666  * variables do not get copied
667  *
668  * @note the variables are added to the target-SCIP but not captured
669  *
670  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
671  * @note Do not change the source SCIP environment during the copying process
672  *
673  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
674  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
675  *
676  * @pre This method can be called if sourcescip is in one of the following stages:
677  * - \ref SCIP_STAGE_PROBLEM
678  * - \ref SCIP_STAGE_TRANSFORMED
679  * - \ref SCIP_STAGE_INITPRESOLVE
680  * - \ref SCIP_STAGE_PRESOLVING
681  * - \ref SCIP_STAGE_EXITPRESOLVE
682  * - \ref SCIP_STAGE_PRESOLVED
683  * - \ref SCIP_STAGE_INITSOLVE
684  * - \ref SCIP_STAGE_SOLVING
685  * - \ref SCIP_STAGE_SOLVED
686  *
687  * @pre This method can be called if targetscip is in one of the following stages:
688  * - \ref SCIP_STAGE_PROBLEM
689  *
690  * @note sourcescip stage does not get changed
691  *
692  * @note targetscip stage does not get changed
693  *
694  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
695  */
696 extern
698  SCIP* sourcescip, /**< source SCIP data structure */
699  SCIP* targetscip, /**< target SCIP data structure */
700  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
701  * target variables, or NULL */
702  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
703  * target constraints, or NULL */
704  SCIP_Bool global /**< should global or local bounds be used? */
705  );
706 
707 /** copies all original variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
708  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
709  * variables do not get copied
710  *
711  * @note the variables are added to the target-SCIP but not captured
712  *
713  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
714  * @note Do not change the source SCIP environment during the copying process
715  *
716  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
717  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
718  *
719  * @pre This method can be called if sourcescip is in one of the following stages:
720  * - \ref SCIP_STAGE_PROBLEM
721  * - \ref SCIP_STAGE_TRANSFORMED
722  * - \ref SCIP_STAGE_INITPRESOLVE
723  * - \ref SCIP_STAGE_PRESOLVING
724  * - \ref SCIP_STAGE_EXITPRESOLVE
725  * - \ref SCIP_STAGE_PRESOLVED
726  * - \ref SCIP_STAGE_INITSOLVE
727  * - \ref SCIP_STAGE_SOLVING
728  * - \ref SCIP_STAGE_SOLVED
729  *
730  * @pre This method can be called if targetscip is in one of the following stages:
731  * - \ref SCIP_STAGE_PROBLEM
732  *
733  * @note sourcescip stage does not get changed
734  *
735  * @note targetscip stage does not get changed
736  *
737  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
738  */
739 extern
741  SCIP* sourcescip, /**< source SCIP data structure */
742  SCIP* targetscip, /**< target SCIP data structure */
743  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
744  * target variables, or NULL */
745  SCIP_HASHMAP* consmap /**< a hashmap to store the mapping of source constraints to the corresponding
746  * target constraints, or NULL */
747  );
748 
749 /** returns copy of the source constraint; if there already is a copy of the source constraint in the constraint hash
750  * map, it is just returned as target constraint; elsewise a new constraint will be created; this created constraint is
751  * added to the constraint hash map and returned as target constraint; the variable map is used to map the variables of
752  * the source SCIP to the variables of the target SCIP
753  *
754  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
755  * be declared feasible even if it violates this particular constraint. This constellation should only be
756  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
757  * to the variable's local bounds.
758  *
759  * @note The constraint is not added to the target SCIP. You can check whether a constraint is added by calling
760  * SCIPconsIsAdded(). (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add
761  * explicitly and what is already added.)
762  *
763  * @note The constraint is always captured, either during the creation of the copy or after finding the copy of the
764  * constraint in the constraint hash map
765  *
766  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
767  * @note Do not change the source SCIP environment during the copying process
768  *
769  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
770  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
771  *
772  * @pre This method can be called if sourcescip is in one of the following stages:
773  * - \ref SCIP_STAGE_PROBLEM
774  * - \ref SCIP_STAGE_TRANSFORMED
775  * - \ref SCIP_STAGE_INITPRESOLVE
776  * - \ref SCIP_STAGE_PRESOLVING
777  * - \ref SCIP_STAGE_EXITPRESOLVE
778  * - \ref SCIP_STAGE_PRESOLVED
779  * - \ref SCIP_STAGE_INITSOLVE
780  * - \ref SCIP_STAGE_SOLVING
781  * - \ref SCIP_STAGE_SOLVED
782  *
783  * @pre This method can be called if targetscip is in one of the following stages:
784  * - \ref SCIP_STAGE_PROBLEM
785  * - \ref SCIP_STAGE_TRANSFORMING
786  * - \ref SCIP_STAGE_INITPRESOLVE
787  * - \ref SCIP_STAGE_PRESOLVING
788  * - \ref SCIP_STAGE_EXITPRESOLVE
789  * - \ref SCIP_STAGE_PRESOLVED
790  * - \ref SCIP_STAGE_SOLVING
791  * - \ref SCIP_STAGE_EXITSOLVE
792  *
793  * @note sourcescip stage does not get changed
794  *
795  * @note targetscip stage does not get changed
796  *
797  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
798  */
799 extern
801  SCIP* sourcescip, /**< source SCIP data structure */
802  SCIP* targetscip, /**< target SCIP data structure */
803  SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
804  SCIP_CONS** targetcons, /**< pointer to store the created target constraint */
805  SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
806  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
807  * variables of the target SCIP, or NULL */
808  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
809  * target constraints, or NULL */
810  const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
811  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
812  SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
813  SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
814  SCIP_Bool check, /**< should the constraint be checked for feasibility? */
815  SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
816  SCIP_Bool local, /**< is constraint only valid locally? */
817  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
818  SCIP_Bool dynamic, /**< is constraint subject to aging? */
819  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
820  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
821  * if it may be moved to a more global node? */
822  SCIP_Bool global, /**< create a global or a local copy? */
823  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
824  );
825 
826 /** copies constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
827  * variables between the source and the target SCIP a hash map can be given; if the variable hash
828  * map is NULL or necessary variable mapping is missing, the required variables are created in the
829  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
830  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
831  * between the constraints of the source and target-SCIP is stored
832  *
833  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
834  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
835  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
836  *
837  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
838  * @note Do not change the source SCIP environment during the copying process
839  *
840  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
841  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
842  *
843  * @pre This method can be called if sourcescip is in one of the following stages:
844  * - \ref SCIP_STAGE_PROBLEM
845  * - \ref SCIP_STAGE_TRANSFORMED
846  * - \ref SCIP_STAGE_INITPRESOLVE
847  * - \ref SCIP_STAGE_PRESOLVING
848  * - \ref SCIP_STAGE_EXITPRESOLVE
849  * - \ref SCIP_STAGE_PRESOLVED
850  * - \ref SCIP_STAGE_INITSOLVE
851  * - \ref SCIP_STAGE_SOLVING
852  * - \ref SCIP_STAGE_SOLVED
853  *
854  * @pre This method can be called if targetscip is in one of the following stages:
855  * - \ref SCIP_STAGE_PROBLEM
856  *
857  * @note sourcescip stage does not get changed
858  *
859  * @note targetscip stage does not get changed
860  *
861  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
862  */
863 extern
865  SCIP* sourcescip, /**< source SCIP data structure */
866  SCIP* targetscip, /**< target SCIP data structure */
867  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
868  * variables of the target SCIP, must not be NULL! */
869  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
870  * target constraints, or NULL */
871  SCIP_Bool global, /**< create a global or a local copy? */
872  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
873  * If TRUE, the modifiable flag of constraints will be copied. */
874  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
875  );
876 
877 /** copies all original constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
878  * variables between the source and the target SCIP a hash map can be given; if the variable hash
879  * map is NULL or necessary variable mapping is missing, the required variables are created in the
880  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
881  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
882  * between the constraints of the source and target-SCIP is stored
883  *
884  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
885  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
886  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
887  *
888  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
889  * @note Do not change the source SCIP environment during the copying process
890  *
891  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
892  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
893  *
894  * @pre This method can be called if sourcescip is in one of the following stages:
895  * - \ref SCIP_STAGE_PROBLEM
896  * - \ref SCIP_STAGE_TRANSFORMED
897  * - \ref SCIP_STAGE_INITPRESOLVE
898  * - \ref SCIP_STAGE_PRESOLVING
899  * - \ref SCIP_STAGE_EXITPRESOLVE
900  * - \ref SCIP_STAGE_PRESOLVED
901  * - \ref SCIP_STAGE_INITSOLVE
902  * - \ref SCIP_STAGE_SOLVING
903  * - \ref SCIP_STAGE_SOLVED
904  *
905  * @pre This method can be called if targetscip is in one of the following stages:
906  * - \ref SCIP_STAGE_PROBLEM
907  *
908  * @note sourcescip stage does not get changed
909  *
910  * @note targetscip stage does not get changed
911  *
912  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
913  */
914 extern
916  SCIP* sourcescip, /**< source SCIP data structure */
917  SCIP* targetscip, /**< target SCIP data structure */
918  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
919  * variables of the target SCIP, or NULL */
920  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
921  * target constraints, or NULL */
922  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
923  * If TRUE, the modifiable flag of constraints will be copied. */
924  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
925  );
926 
927 /** convert all active cuts from cutpool to linear constraints
928  *
929  * @note Do not change the source SCIP environment during the copying process
930  *
931  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
932  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
933  *
934  * @pre This method can be called if SCIP is in one of the following stages:
935  * - \ref SCIP_STAGE_PROBLEM
936  * - \ref SCIP_STAGE_INITPRESOLVE
937  * - \ref SCIP_STAGE_PRESOLVING
938  * - \ref SCIP_STAGE_EXITPRESOLVE
939  * - \ref SCIP_STAGE_PRESOLVED
940  * - \ref SCIP_STAGE_SOLVING
941  * - \ref SCIP_STAGE_EXITSOLVE
942  *
943  * @note SCIP stage does not get changed
944  *
945  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
946  */
947 extern
949  SCIP* scip, /**< SCIP data structure */
950  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
951  * target variables, or NULL */
952  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
953  * target constraints, or NULL */
954  SCIP_Bool global, /**< create a global or a local copy? */
955  int* ncutsadded /**< pointer to store number of added cuts, or NULL */
956  );
957 
958 /** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip
959  *
960  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
961  * @note Do not change the source SCIP environment during the copying process
962  *
963  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
964  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
965  *
966  * @pre This method can be called if sourcescip is in one of the following stages:
967  * - \ref SCIP_STAGE_PROBLEM
968  * - \ref SCIP_STAGE_TRANSFORMED
969  * - \ref SCIP_STAGE_INITPRESOLVE
970  * - \ref SCIP_STAGE_PRESOLVING
971  * - \ref SCIP_STAGE_EXITPRESOLVE
972  * - \ref SCIP_STAGE_PRESOLVED
973  * - \ref SCIP_STAGE_SOLVING
974  * - \ref SCIP_STAGE_SOLVED
975  * - \ref SCIP_STAGE_EXITSOLVE
976  *
977  * @pre This method can be called if targetscip is in one of the following stages:
978  * - \ref SCIP_STAGE_PROBLEM
979  * - \ref SCIP_STAGE_INITPRESOLVE
980  * - \ref SCIP_STAGE_PRESOLVING
981  * - \ref SCIP_STAGE_EXITPRESOLVE
982  * - \ref SCIP_STAGE_PRESOLVED
983  * - \ref SCIP_STAGE_SOLVING
984  * - \ref SCIP_STAGE_EXITSOLVE
985  *
986  * @note sourcescip stage does not get changed
987  *
988  * @note targetscip stage does not get changed
989  *
990  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
991  */
992 extern
994  SCIP* sourcescip, /**< source SCIP data structure */
995  SCIP* targetscip, /**< target SCIP data structure */
996  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
997  * target variables, or NULL */
998  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
999  * target constraints, or NULL */
1000  SCIP_Bool global, /**< create a global or a local copy? */
1001  int* ncutsadded /**< pointer to store number of copied cuts, or NULL */
1002  );
1003 
1004 /** copies implications and cliques of sourcescip to targetscip
1005  *
1006  * This function should be called for a targetscip in transformed stage. It can save time in presolving of the
1007  * targetscip, since implications and cliques are copied.
1008  *
1009  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1010  * @note Do not change the source SCIP environment during the copying process
1011  *
1012  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1013  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1014  *
1015  * @pre This method can be called if sourcescip is in one of the following stages:
1016  * - \ref SCIP_STAGE_TRANSFORMED
1017  * - \ref SCIP_STAGE_INITPRESOLVE
1018  * - \ref SCIP_STAGE_PRESOLVING
1019  * - \ref SCIP_STAGE_EXITPRESOLVE
1020  * - \ref SCIP_STAGE_PRESOLVED
1021  * - \ref SCIP_STAGE_SOLVING
1022  * - \ref SCIP_STAGE_SOLVED
1023  * - \ref SCIP_STAGE_EXITSOLVE
1024  *
1025  * @pre This method can be called if targetscip is in one of the following stages:
1026  * - \ref SCIP_STAGE_TRANSFORMED
1027  * - \ref SCIP_STAGE_INITPRESOLVE
1028  * - \ref SCIP_STAGE_PRESOLVING
1029  * - \ref SCIP_STAGE_EXITPRESOLVE
1030  * - \ref SCIP_STAGE_PRESOLVED
1031  * - \ref SCIP_STAGE_INITSOLVE
1032  * - \ref SCIP_STAGE_SOLVING
1033  *
1034  * @note sourcescip stage does not get changed
1035  *
1036  * @note targetscip stage does not get changed
1037  *
1038  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1039  */
1040 extern
1042  SCIP* sourcescip, /**< source SCIP data structure */
1043  SCIP* targetscip, /**< target SCIP data structure */
1044  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1045  * target variables, or NULL */
1046  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1047  * target constraints, or NULL */
1048  SCIP_Bool global, /**< create a global or a local copy? */
1049  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
1050  int* nbdchgs, /**< pointer to store the number of performed bound changes, or NULL */
1051  int* ncopied /**< pointer to store number of copied implications and cliques, or NULL */
1052  );
1053 
1054 /** copies parameter settings from sourcescip to targetscip
1055  *
1056  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1057  * @note Do not change the source SCIP environment during the copying process
1058  *
1059  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1060  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1061  *
1062  * @pre This method can be called if sourcescip is in one of the following stages:
1063  * - \ref SCIP_STAGE_PROBLEM
1064  * - \ref SCIP_STAGE_TRANSFORMED
1065  * - \ref SCIP_STAGE_INITPRESOLVE
1066  * - \ref SCIP_STAGE_PRESOLVING
1067  * - \ref SCIP_STAGE_EXITPRESOLVE
1068  * - \ref SCIP_STAGE_PRESOLVED
1069  * - \ref SCIP_STAGE_INITSOLVE
1070  * - \ref SCIP_STAGE_SOLVING
1071  * - \ref SCIP_STAGE_SOLVED
1072  *
1073  * @pre This method can be called if targetscip is in one of the following stages:
1074  * - \ref SCIP_STAGE_INIT
1075  * - \ref SCIP_STAGE_PROBLEM
1076  * - \ref SCIP_STAGE_FREE
1077  *
1078  * @note sourcescip stage does not get changed
1079  *
1080  * @note targetscip stage does not get changed
1081  *
1082  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1083  */
1084 extern
1086  SCIP* sourcescip, /**< source SCIP data structure */
1087  SCIP* targetscip /**< target SCIP data structure */
1088  );
1089 
1090 /** gets depth of current scip instance (increased by each copy call)
1091  *
1092  * @return Depth of subscip of SCIP is returned.
1093  *
1094  * @pre This method can be called if SCIP is in one of the following stages:
1095  * - \ref SCIP_STAGE_PROBLEM
1096  * - \ref SCIP_STAGE_TRANSFORMING
1097  * - \ref SCIP_STAGE_TRANSFORMED
1098  * - \ref SCIP_STAGE_INITPRESOLVE
1099  * - \ref SCIP_STAGE_PRESOLVING
1100  * - \ref SCIP_STAGE_EXITPRESOLVE
1101  * - \ref SCIP_STAGE_PRESOLVED
1102  * - \ref SCIP_STAGE_INITSOLVE
1103  * - \ref SCIP_STAGE_SOLVING
1104  * - \ref SCIP_STAGE_SOLVED
1105  * - \ref SCIP_STAGE_EXITSOLVE
1106  * - \ref SCIP_STAGE_FREETRANS
1107  *
1108  * @note SCIP stage does not get changed
1109  *
1110  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1111  */
1112 extern
1114  SCIP* scip /**< SCIP data structure */
1115  );
1116 
1117 /** copies source SCIP to target SCIP; the copying process is done in the following order:
1118  * 1) copy the plugins
1119  * 2) copy the settings
1120  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1121  * 4) copy all active variables
1122  * 5) copy all constraints
1123  *
1124  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1125  *
1126  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1127  * Also, 'passmessagehdlr' should be set to FALSE.
1128  * @note Do not change the source SCIP environment during the copying process
1129  *
1130  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1131  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1132  *
1133  * @pre This method can be called if sourcescip is in one of the following stages:
1134  * - \ref SCIP_STAGE_PROBLEM
1135  * - \ref SCIP_STAGE_TRANSFORMED
1136  * - \ref SCIP_STAGE_INITPRESOLVE
1137  * - \ref SCIP_STAGE_PRESOLVING
1138  * - \ref SCIP_STAGE_EXITPRESOLVE
1139  * - \ref SCIP_STAGE_PRESOLVED
1140  * - \ref SCIP_STAGE_INITSOLVE
1141  * - \ref SCIP_STAGE_SOLVING
1142  * - \ref SCIP_STAGE_SOLVED
1143  *
1144  * @pre This method can be called if targetscip is in one of the following stages:
1145  * - \ref SCIP_STAGE_INIT
1146  * - \ref SCIP_STAGE_FREE
1147  *
1148  * @note sourcescip stage does not get changed
1149  *
1150  * @note targetscip stage does not get changed
1151  *
1152  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1153  */
1154 extern
1156  SCIP* sourcescip, /**< source SCIP data structure */
1157  SCIP* targetscip, /**< target SCIP data structure */
1158  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1159  * target variables, or NULL */
1160  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1161  * target constraints, or NULL */
1162  const char* suffix, /**< suffix which will be added to the names of the source SCIP */
1163  SCIP_Bool global, /**< create a global or a local copy? */
1164  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1165  * plugins will be copied and activated, and the modifiable flag of
1166  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1167  * there are pricers present */
1168  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1169  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
1170  );
1171 
1172 /** copies source SCIP original problem to target SCIP; the copying process is done in the following order:
1173  * 1) copy the plugins
1174  * 2) copy the settings
1175  * 3) create problem data in target-SCIP and copy the original problem data of the source-SCIP
1176  * 4) copy all original variables
1177  * 5) copy all original constraints
1178  *
1179  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1180  *
1181  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1182  * Also, 'passmessagehdlr' should be set to FALSE.
1183  * @note Do not change the source SCIP environment during the copying process
1184  *
1185  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1186  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1187  *
1188  * @pre This method can be called if sourcescip is in one of the following stages:
1189  * - \ref SCIP_STAGE_PROBLEM
1190  * - \ref SCIP_STAGE_TRANSFORMED
1191  * - \ref SCIP_STAGE_INITPRESOLVE
1192  * - \ref SCIP_STAGE_PRESOLVING
1193  * - \ref SCIP_STAGE_EXITPRESOLVE
1194  * - \ref SCIP_STAGE_PRESOLVED
1195  * - \ref SCIP_STAGE_INITSOLVE
1196  * - \ref SCIP_STAGE_SOLVING
1197  * - \ref SCIP_STAGE_SOLVED
1198  *
1199  * @pre This method can be called if targetscip is in one of the following stages:
1200  * - \ref SCIP_STAGE_INIT
1201  * - \ref SCIP_STAGE_FREE
1202  *
1203  * @note sourcescip stage does not get changed
1204  *
1205  * @note targetscip stage does not get changed
1206  *
1207  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1208  */
1209 extern
1211  SCIP* sourcescip, /**< source SCIP data structure */
1212  SCIP* targetscip, /**< target SCIP data structure */
1213  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1214  * target variables, or NULL */
1215  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1216  * target constraints, or NULL */
1217  const char* suffix, /**< suffix which will be added to the names of the target SCIP, might be empty */
1218  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1219  * plugins will be copied and activated, and the modifiable flag of
1220  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1221  * there are pricers present */
1222  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1223  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
1224  );
1225 
1226 /**@} */
1227 
1228 /*
1229  * parameter settings
1230  */
1231 
1232 /**@name Parameter Methods */
1233 /**@{ */
1234 
1235 /** creates a SCIP_Bool parameter, sets it to its default value, and adds it to the parameter set
1236  *
1237  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1238  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1239  */
1240 extern
1242  SCIP* scip, /**< SCIP data structure */
1243  const char* name, /**< name of the parameter */
1244  const char* desc, /**< description of the parameter */
1245  SCIP_Bool* valueptr, /**< pointer to store the current parameter value, or NULL */
1246  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1247  SCIP_Bool defaultvalue, /**< default value of the parameter */
1248  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1249  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1250  );
1251 
1252 /** creates a int parameter, sets it to its default value, and adds it to the parameter set
1253  *
1254  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1255  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1256  */
1257 extern
1259  SCIP* scip, /**< SCIP data structure */
1260  const char* name, /**< name of the parameter */
1261  const char* desc, /**< description of the parameter */
1262  int* valueptr, /**< pointer to store the current parameter value, or NULL */
1263  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1264  int defaultvalue, /**< default value of the parameter */
1265  int minvalue, /**< minimum value for parameter */
1266  int maxvalue, /**< maximum value for parameter */
1267  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1268  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1269  );
1270 
1271 /** creates a SCIP_Longint parameter, sets it to its default value, and adds it to the parameter set
1272  *
1273  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1274  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1275  */
1276 extern
1278  SCIP* scip, /**< SCIP data structure */
1279  const char* name, /**< name of the parameter */
1280  const char* desc, /**< description of the parameter */
1281  SCIP_Longint* valueptr, /**< pointer to store the current parameter value, or NULL */
1282  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1283  SCIP_Longint defaultvalue, /**< default value of the parameter */
1284  SCIP_Longint minvalue, /**< minimum value for parameter */
1285  SCIP_Longint maxvalue, /**< maximum value for parameter */
1286  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1287  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1288  );
1289 
1290 /** creates a SCIP_Real parameter, sets it to its default value, and adds it to the parameter set
1291  *
1292  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1293  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1294  */
1295 extern
1297  SCIP* scip, /**< SCIP data structure */
1298  const char* name, /**< name of the parameter */
1299  const char* desc, /**< description of the parameter */
1300  SCIP_Real* valueptr, /**< pointer to store the current parameter value, or NULL */
1301  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1302  SCIP_Real defaultvalue, /**< default value of the parameter */
1303  SCIP_Real minvalue, /**< minimum value for parameter */
1304  SCIP_Real maxvalue, /**< maximum value for parameter */
1305  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1306  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1307  );
1308 
1309 /** creates a char parameter, sets it to its default value, and adds it to the parameter set
1310  *
1311  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1312  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1313  */
1314 extern
1316  SCIP* scip, /**< SCIP data structure */
1317  const char* name, /**< name of the parameter */
1318  const char* desc, /**< description of the parameter */
1319  char* valueptr, /**< pointer to store the current parameter value, or NULL */
1320  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1321  char defaultvalue, /**< default value of the parameter */
1322  const char* allowedvalues, /**< array with possible parameter values, or NULL if not restricted */
1323  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1324  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1325  );
1326 
1327 /** creates a string(char*) parameter, sets it to its default value, and adds it to the parameter set
1328  *
1329  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1330  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1331  */
1332 extern
1334  SCIP* scip, /**< SCIP data structure */
1335  const char* name, /**< name of the parameter */
1336  const char* desc, /**< description of the parameter */
1337  char** valueptr, /**< pointer to store the current parameter value, or NULL; if not NULL then *valueptr should be NULL */
1338  SCIP_Bool isadvanced, /**< is this parameter an advanced parameter? */
1339  const char* defaultvalue, /**< default value of the parameter */
1340  SCIP_DECL_PARAMCHGD ((*paramchgd)), /**< change information method of parameter */
1341  SCIP_PARAMDATA* paramdata /**< locally defined parameter specific data */
1342  );
1343 
1344 /** gets the fixing status of an existing parameter
1345  *
1346  * @return TRUE if the parameter is fixed to a value, otherwise FALSE.
1347  */
1348 extern
1350  SCIP* scip, /**< SCIP data structure */
1351  const char* name /**< name of the parameter */
1352  );
1353 
1354 /** returns the pointer to the SCIP parameter with the given name
1355  *
1356  * @return pointer to the parameter with the given name
1357  */
1358 extern
1360  SCIP* scip, /**< SCIP data structure */
1361  const char* name /**< name of the parameter */
1362  );
1363 
1364 /** gets the value of an existing SCIP_Bool parameter
1365  *
1366  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1367  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1368  */
1369 extern
1371  SCIP* scip, /**< SCIP data structure */
1372  const char* name, /**< name of the parameter */
1373  SCIP_Bool* value /**< pointer to store the parameter */
1374  );
1375 
1376 /** gets the value of an existing int parameter
1377  *
1378  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1379  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1380  */
1381 extern
1383  SCIP* scip, /**< SCIP data structure */
1384  const char* name, /**< name of the parameter */
1385  int* value /**< pointer to store the parameter */
1386  );
1387 
1388 /** gets the value of an existing SCIP_Longint parameter
1389  *
1390  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1391  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1392  */
1393 extern
1395  SCIP* scip, /**< SCIP data structure */
1396  const char* name, /**< name of the parameter */
1397  SCIP_Longint* value /**< pointer to store the parameter */
1398  );
1399 
1400 /** gets the value of an existing SCIP_Real parameter
1401  *
1402  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1403  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1404  */
1405 extern
1407  SCIP* scip, /**< SCIP data structure */
1408  const char* name, /**< name of the parameter */
1409  SCIP_Real* value /**< pointer to store the parameter */
1410  );
1411 
1412 /** gets the value of an existing char parameter
1413  *
1414  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1415  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1416  */
1417 extern
1419  SCIP* scip, /**< SCIP data structure */
1420  const char* name, /**< name of the parameter */
1421  char* value /**< pointer to store the parameter */
1422  );
1423 
1424 /** gets the value of an existing string(char*) parameter
1425  *
1426  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1427  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1428  */
1429 extern
1431  SCIP* scip, /**< SCIP data structure */
1432  const char* name, /**< name of the parameter */
1433  char** value /**< pointer to store the parameter */
1434  );
1435 
1436 /** fixes the value of an existing parameter
1437  *
1438  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1439  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1440  *
1441  * @note: Be careful with this method! Some general settings, e.g., the time or node limit, should not be fixed because
1442  * they have to be changed for sub-SCIPs.
1443  */
1444 extern
1446  SCIP* scip, /**< SCIP data structure */
1447  const char* name /**< name of the parameter */
1448  );
1449 
1450 /** unfixes the value of an existing parameter
1451  *
1452  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1453  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1454  */
1455 extern
1457  SCIP* scip, /**< SCIP data structure */
1458  const char* name /**< name of the parameter */
1459  );
1460 
1461 /** changes the value of an existing parameter
1462  *
1463  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1464  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1465  */
1466 extern
1468  SCIP* scip, /**< SCIP data structure */
1469  const char* name, /**< name of the parameter */
1470  void* value /**< new value of the parameter */
1471  );
1472 
1473 /** changes the value of an existing SCIP_Bool parameter
1474  *
1475  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1476  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1477  */
1478 extern
1480  SCIP* scip, /**< SCIP data structure */
1481  SCIP_PARAM* param, /**< parameter */
1482  SCIP_Bool value /**< new value of the parameter */
1483  );
1484 
1485 /** changes the value of an existing SCIP_Bool parameter
1486  *
1487  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1488  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1489  */
1490 extern
1492  SCIP* scip, /**< SCIP data structure */
1493  const char* name, /**< name of the parameter */
1494  SCIP_Bool value /**< new value of the parameter */
1495  );
1496 
1497 /** changes the value of an existing int parameter
1498  *
1499  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1500  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1501  */
1502 extern
1504  SCIP* scip, /**< SCIP data structure */
1505  SCIP_PARAM* param, /**< parameter */
1506  int value /**< new value of the parameter */
1507  );
1508 
1509 /** changes the value of an existing int parameter
1510  *
1511  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1512  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1513  */
1514 extern
1516  SCIP* scip, /**< SCIP data structure */
1517  const char* name, /**< name of the parameter */
1518  int value /**< new value of the parameter */
1519  );
1520 
1521 /** changes the value of an existing SCIP_Longint parameter
1522  *
1523  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1524  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1525  */
1526 extern
1528  SCIP* scip, /**< SCIP data structure */
1529  SCIP_PARAM* param, /**< parameter */
1530  SCIP_Longint value /**< new value of the parameter */
1531  );
1532 
1533 /** changes the value of an existing SCIP_Longint parameter
1534  *
1535  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1537  */
1538 extern
1540  SCIP* scip, /**< SCIP data structure */
1541  const char* name, /**< name of the parameter */
1542  SCIP_Longint value /**< new value of the parameter */
1543  );
1544 
1545 /** changes the value of an existing SCIP_Real parameter
1546  *
1547  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1548  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1549  */
1550 extern
1552  SCIP* scip, /**< SCIP data structure */
1553  SCIP_PARAM* param, /**< parameter */
1554  SCIP_Real value /**< new value of the parameter */
1555  );
1556 
1557 /** changes the value of an existing SCIP_Real parameter
1558  *
1559  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1560  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1561  */
1562 extern
1564  SCIP* scip, /**< SCIP data structure */
1565  const char* name, /**< name of the parameter */
1566  SCIP_Real value /**< new value of the parameter */
1567  );
1568 
1569 /** changes the value of an existing char parameter
1570  *
1571  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1572  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1573  */
1574 extern
1576  SCIP* scip, /**< SCIP data structure */
1577  SCIP_PARAM* param, /**< parameter */
1578  char value /**< new value of the parameter */
1579  );
1580 
1581 /** changes the value of an existing char parameter
1582  *
1583  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1584  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1585  */
1586 extern
1588  SCIP* scip, /**< SCIP data structure */
1589  const char* name, /**< name of the parameter */
1590  char value /**< new value of the parameter */
1591  );
1592 
1593 /** changes the value of an existing string(char*) parameter
1594  *
1595  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1596  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1597  */
1598 extern
1600  SCIP* scip, /**< SCIP data structure */
1601  SCIP_PARAM* param, /**< parameter */
1602  const char* value /**< new value of the parameter */
1603  );
1604 
1605 /** changes the value of an existing string(char*) parameter
1606  *
1607  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1608  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1609  */
1610 extern
1612  SCIP* scip, /**< SCIP data structure */
1613  const char* name, /**< name of the parameter */
1614  const char* value /**< new value of the parameter */
1615  );
1616 
1617 /** reads parameters from a file
1618  *
1619  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1620  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1621  */
1622 extern
1624  SCIP* scip, /**< SCIP data structure */
1625  const char* filename /**< file name */
1626  );
1627 
1628 /** writes all parameters in the parameter set to a file
1629  *
1630  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1631  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1632  */
1633 extern
1635  SCIP* scip, /**< SCIP data structure */
1636  const char* filename, /**< file name, or NULL for stdout */
1637  SCIP_Bool comments, /**< should parameter descriptions be written as comments? */
1638  SCIP_Bool onlychanged /**< should only the parameters been written, that are changed from default? */
1639  );
1640 
1641 /** resets a single parameter to its default value
1642  *
1643  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1644  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1645  */
1646 extern
1648  SCIP* scip, /**< SCIP data structure */
1649  const char* name /**< name of the parameter */
1650  );
1651 
1652 /** resets all parameters to their default values
1653  *
1654  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1655  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1656  */
1657 extern
1659  SCIP* scip /**< SCIP data structure */
1660  );
1661 
1662 /** sets parameters to
1663  *
1664  * - SCIP_PARAMEMPHASIS_DEFAULT to use default values (see also SCIPresetParams())
1665  * - SCIP_PARAMEMPHASIS_COUNTER to get feasible and "fast" counting process
1666  * - SCIP_PARAMEMPHASIS_CPSOLVER to get CP like search (e.g. no LP relaxation)
1667  * - SCIP_PARAMEMPHASIS_EASYCIP to solve easy problems fast
1668  * - SCIP_PARAMEMPHASIS_FEASIBILITY to detect feasibility fast
1669  * - SCIP_PARAMEMPHASIS_HARDLP to be capable to handle hard LPs
1670  * - SCIP_PARAMEMPHASIS_OPTIMALITY to prove optimality fast
1671  *
1672  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1673  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1674  */
1675 extern
1677  SCIP* scip, /**< SCIP data structure */
1678  SCIP_PARAMEMPHASIS paramemphasis, /**< parameter settings */
1679  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1680  );
1681 
1682 /** sets parameters to deactivate separators and heuristics that use auxiliary SCIP instances; should be called for
1683  * auxiliary SCIP instances to avoid recursion
1684  *
1685  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1686  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1687  */
1688 extern
1690  SCIP* scip, /**< (auxiliary) SCIP data structure */
1691  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1692  );
1693 
1694 /** sets heuristic parameters values to
1695  *
1696  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all heuristic parameters
1697  * - SCIP_PARAMSETTING_FAST such that the time spend for heuristic is decreased
1698  * - SCIP_PARAMSETTING_AGGRESSIVE such that the heuristic are called more aggregative
1699  * - SCIP_PARAMSETTING_OFF which turn off all heuristics
1700  *
1701  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1702  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1703  */
1704 extern
1706  SCIP* scip, /**< SCIP data structure */
1707  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1708  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1709  );
1710 
1711 /** sets presolving parameters to
1712  *
1713  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all presolving parameters
1714  * - SCIP_PARAMSETTING_FAST such that the time spend for presolving is decreased
1715  * - SCIP_PARAMSETTING_AGGRESSIVE such that the presolving is more aggregative
1716  * - SCIP_PARAMSETTING_OFF which turn off all presolving
1717  *
1718  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1719  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1720  */
1721 extern
1723  SCIP* scip, /**< SCIP data structure */
1724  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1725  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1726  );
1727 
1728 /** sets separating parameters to
1729  *
1730  * - SCIP_PARAMSETTING_DEFAULT which are the default values of all separating parameters
1731  * - SCIP_PARAMSETTING_FAST such that the time spend for separating is decreased
1732  * - SCIP_PARAMSETTING_AGGRESSIVE such that the separating is done more aggregative
1733  * - SCIP_PARAMSETTING_OFF which turn off all separating
1734  *
1735  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1736  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1737  */
1738 extern
1740  SCIP* scip, /**< SCIP data structure */
1741  SCIP_PARAMSETTING paramsetting, /**< parameter settings */
1742  SCIP_Bool quiet /**< should the parameter be set quiet (no output) */
1743  );
1744 
1745 /** returns the array of all available SCIP parameters
1746  *
1747  * @return SCIP_PARAM* array, containing all SCIP parameters.
1748  */
1749 extern
1751  SCIP* scip /**< SCIP data structure */
1752  );
1753 
1754 /** returns the total number of all available SCIP parameters
1755  *
1756  * @return number of all SCIP parameters.
1757  */
1758 extern
1759 int SCIPgetNParams(
1760  SCIP* scip /**< SCIP data structure */
1761  );
1762 
1763 /**@} */
1764 
1765 
1766 /*
1767  * SCIP user functionality methods: managing plugins
1768  */
1769 
1770 /**@name SCIP User Functionality Methods: Managing Plugins */
1771 /**@{ */
1772 
1773 /** creates a reader and includes it in SCIP
1774  *
1775  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1776  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1777  *
1778  * @pre This method can be called if SCIP is in one of the following stages:
1779  * - \ref SCIP_STAGE_INIT
1780  * - \ref SCIP_STAGE_PROBLEM
1781  *
1782  * @note method has all reader callbacks as arguments and is thus changed every time a new callback is added
1783  * in future releases; consider using SCIPincludeReaderBasic() and setter functions
1784  * if you seek for a method which is less likely to change in future releases
1785  */
1786 extern
1788  SCIP* scip, /**< SCIP data structure */
1789  const char* name, /**< name of reader */
1790  const char* desc, /**< description of reader */
1791  const char* extension, /**< file extension that reader processes */
1792  SCIP_DECL_READERCOPY ((*readercopy)), /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
1793  SCIP_DECL_READERFREE ((*readerfree)), /**< destructor of reader */
1794  SCIP_DECL_READERREAD ((*readerread)), /**< read method */
1795  SCIP_DECL_READERWRITE ((*readerwrite)), /**< write method */
1796  SCIP_READERDATA* readerdata /**< reader data */
1797  );
1798 
1799 /** creates a reader and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
1800  * Optional callbacks can be set via specific setter functions, see
1801  * SCIPsetReaderCopy(), SCIPsetReaderFree(), SCIPsetReaderRead(), SCIPsetReaderWrite().
1802  *
1803  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1804  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1805  *
1806  * @pre This method can be called if SCIP is in one of the following stages:
1807  * - \ref SCIP_STAGE_INIT
1808  * - \ref SCIP_STAGE_PROBLEM
1809  *
1810  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeReader() instead
1811  */
1812 extern
1814  SCIP* scip, /**< SCIP data structure */
1815  SCIP_READER** readerptr, /**< reference to reader pointer, or NULL */
1816  const char* name, /**< name of reader */
1817  const char* desc, /**< description of reader */
1818  const char* extension, /**< file extension that reader processes */
1819  SCIP_READERDATA* readerdata /**< reader data */
1820  );
1821 
1822 /** set copy method of reader
1823  *
1824  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1825  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1826  *
1827  * @pre This method can be called if SCIP is in one of the following stages:
1828  * - \ref SCIP_STAGE_INIT
1829  * - \ref SCIP_STAGE_PROBLEM
1830  */
1831 extern
1833  SCIP* scip, /**< SCIP data structure */
1834  SCIP_READER* reader, /**< reader */
1835  SCIP_DECL_READERCOPY ((*readercopy)) /**< copy method of reader or NULL if you don't want to copy your plugin into sub-SCIPs */
1836  );
1837 
1838 /** set deinitialization method of reader
1839  *
1840  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1841  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1842  *
1843  * @pre This method can be called if SCIP is in one of the following stages:
1844  * - \ref SCIP_STAGE_INIT
1845  * - \ref SCIP_STAGE_PROBLEM
1846  */
1847 extern
1849  SCIP* scip, /**< SCIP data structure */
1850  SCIP_READER* reader, /**< reader */
1851  SCIP_DECL_READERFREE ((*readerfree)) /**< destructor of reader */
1852  );
1853 
1854 /** set read method of reader
1855  *
1856  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1857  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1858  *
1859  * @pre This method can be called if SCIP is in one of the following stages:
1860  * - \ref SCIP_STAGE_INIT
1861  * - \ref SCIP_STAGE_PROBLEM
1862  */
1863 extern
1865  SCIP* scip, /**< SCIP data structure */
1866  SCIP_READER* reader, /**< reader */
1867  SCIP_DECL_READERREAD ((*readerread)) /**< read method of reader */
1868  );
1869 
1870 /** set write method of reader
1871  *
1872  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1873  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1874  *
1875  * @pre This method can be called if SCIP is in one of the following stages:
1876  * - \ref SCIP_STAGE_INIT
1877  * - \ref SCIP_STAGE_PROBLEM
1878  */
1879 extern
1881  SCIP* scip, /**< SCIP data structure */
1882  SCIP_READER* reader, /**< reader */
1883  SCIP_DECL_READERWRITE ((*readerwrite)) /**< write method of reader */
1884  );
1885 
1886 /** returns the reader of the given name, or NULL if not existing */
1887 extern
1889  SCIP* scip, /**< SCIP data structure */
1890  const char* name /**< name of reader */
1891  );
1892 
1893 /** returns the array of currently available readers */
1894 extern
1896  SCIP* scip /**< SCIP data structure */
1897  );
1898 
1899 /** returns the number of currently available readers */
1900 extern
1901 int SCIPgetNReaders(
1902  SCIP* scip /**< SCIP data structure */
1903  );
1904 
1905 /** creates a variable pricer and includes it in SCIP
1906  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
1907  * This should be done during the problem creation stage.
1908  *
1909  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1910  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1911  *
1912  * @pre This method can be called if SCIP is in one of the following stages:
1913  * - \ref SCIP_STAGE_INIT
1914  * - \ref SCIP_STAGE_PROBLEM
1915  *
1916  * @note method has all pricer callbacks as arguments and is thus changed every time a new callback is added
1917  * in future releases; consider using SCIPincludePricerBasic() and setter functions
1918  * if you seek for a method which is less likely to change in future releases
1919  */
1920 extern
1922  SCIP* scip, /**< SCIP data structure */
1923  const char* name, /**< name of variable pricer */
1924  const char* desc, /**< description of variable pricer */
1925  int priority, /**< priority of the variable pricer */
1926  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
1927  * problem variables with negative reduced costs are found?
1928  * if this is set to FALSE it may happen that the pricer produces columns
1929  * that already exist in the problem (which are also priced in by the
1930  * default problem variable pricing in the same round) */
1931  SCIP_DECL_PRICERCOPY ((*pricercopy)), /**< copy method of variable pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
1932  SCIP_DECL_PRICERFREE ((*pricerfree)), /**< destructor of variable pricer */
1933  SCIP_DECL_PRICERINIT ((*pricerinit)), /**< initialize variable pricer */
1934  SCIP_DECL_PRICEREXIT ((*pricerexit)), /**< deinitialize variable pricer */
1935  SCIP_DECL_PRICERINITSOL((*pricerinitsol)),/**< solving process initialization method of variable pricer */
1936  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)),/**< solving process deinitialization method of variable pricer */
1937  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
1938  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
1939  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
1940  );
1941 
1942 /** creates a variable pricer and includes it in SCIP with all non-fundamental callbacks set to NULL;
1943  * if needed, these can be added afterwards via setter functions SCIPsetPricerCopy(), SCIPsetPricerFree(),
1944  * SCIPsetPricerInity(), SCIPsetPricerExit(), SCIPsetPricerInitsol(), SCIPsetPricerExitsol(),
1945  * SCIPsetPricerFarkas();
1946  *
1947  * To use the variable pricer for solving a problem, it first has to be activated with a call to SCIPactivatePricer().
1948  * This should be done during the problem creation stage.
1949  *
1950  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1951  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1952  *
1953  * @pre This method can be called if SCIP is in one of the following stages:
1954  * - \ref SCIP_STAGE_INIT
1955  * - \ref SCIP_STAGE_PROBLEM
1956  *
1957  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePricer() instead
1958  */
1959 extern
1961  SCIP* scip, /**< SCIP data structure */
1962  SCIP_PRICER** pricerptr, /**< reference to a pricer, or NULL */
1963  const char* name, /**< name of variable pricer */
1964  const char* desc, /**< description of variable pricer */
1965  int priority, /**< priority of the variable pricer */
1966  SCIP_Bool delay, /**< should the pricer be delayed until no other pricers or already existing
1967  * problem variables with negative reduced costs are found?
1968  * if this is set to FALSE it may happen that the pricer produces columns
1969  * that already exist in the problem (which are also priced in by the
1970  * default problem variable pricing in the same round) */
1971  SCIP_DECL_PRICERREDCOST((*pricerredcost)),/**< reduced cost pricing method of variable pricer for feasible LPs */
1972  SCIP_DECL_PRICERFARKAS((*pricerfarkas)), /**< Farkas pricing method of variable pricer for infeasible LPs */
1973  SCIP_PRICERDATA* pricerdata /**< variable pricer data */
1974  );
1975 
1976 /** sets copy method of pricer
1977  *
1978  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1979  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1980  *
1981  * @pre This method can be called if SCIP is in one of the following stages:
1982  * - \ref SCIP_STAGE_INIT
1983  * - \ref SCIP_STAGE_PROBLEM
1984  */
1985 extern
1987  SCIP* scip, /**< SCIP data structure */
1988  SCIP_PRICER* pricer, /**< pricer */
1989  SCIP_DECL_PRICERCOPY ((*pricercopy)) /**< copy method of pricer or NULL if you don't want to copy your plugin into sub-SCIPs */
1990  );
1991 
1992 /** sets destructor method of pricer
1993  *
1994  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1995  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1996  *
1997  * @pre This method can be called if SCIP is in one of the following stages:
1998  * - \ref SCIP_STAGE_INIT
1999  * - \ref SCIP_STAGE_PROBLEM
2000  */
2001 extern
2003  SCIP* scip, /**< SCIP data structure */
2004  SCIP_PRICER* pricer, /**< pricer */
2005  SCIP_DECL_PRICERFREE ((*pricerfree)) /**< destructor of pricer */
2006  );
2007 
2008 /** sets initialization method of pricer
2009  *
2010  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2011  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2012  *
2013  * @pre This method can be called if SCIP is in one of the following stages:
2014  * - \ref SCIP_STAGE_INIT
2015  * - \ref SCIP_STAGE_PROBLEM
2016  */
2017 extern
2019  SCIP* scip, /**< SCIP data structure */
2020  SCIP_PRICER* pricer, /**< pricer */
2021  SCIP_DECL_PRICERINIT ((*pricerinit)) /**< initialize pricer */
2022  );
2023 
2024 /** sets deinitialization method of pricer
2025  *
2026  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2027  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2028  *
2029  * @pre This method can be called if SCIP is in one of the following stages:
2030  * - \ref SCIP_STAGE_INIT
2031  * - \ref SCIP_STAGE_PROBLEM
2032  */
2033 extern
2035  SCIP* scip, /**< SCIP data structure */
2036  SCIP_PRICER* pricer, /**< pricer */
2037  SCIP_DECL_PRICEREXIT ((*pricerexit)) /**< deinitialize pricer */
2038  );
2039 
2040 /** sets solving process initialization method of pricer
2041  *
2042  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2043  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2044  *
2045  * @pre This method can be called if SCIP is in one of the following stages:
2046  * - \ref SCIP_STAGE_INIT
2047  * - \ref SCIP_STAGE_PROBLEM
2048  */
2049 extern
2051  SCIP* scip, /**< SCIP data structure */
2052  SCIP_PRICER* pricer, /**< pricer */
2053  SCIP_DECL_PRICERINITSOL ((*pricerinitsol))/**< solving process initialization method of pricer */
2054  );
2055 
2056 /** sets solving process deinitialization method of pricer
2057  *
2058  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2059  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2060  *
2061  * @pre This method can be called if SCIP is in one of the following stages:
2062  * - \ref SCIP_STAGE_INIT
2063  * - \ref SCIP_STAGE_PROBLEM
2064  */
2065 extern
2067  SCIP* scip, /**< SCIP data structure */
2068  SCIP_PRICER* pricer, /**< pricer */
2069  SCIP_DECL_PRICEREXITSOL((*pricerexitsol)) /**< solving process deinitialization method of pricer */
2070  );
2071 
2072 /** returns the variable pricer of the given name, or NULL if not existing */
2073 extern
2075  SCIP* scip, /**< SCIP data structure */
2076  const char* name /**< name of variable pricer */
2077  );
2078 
2079 /** returns the array of currently available variable pricers; active pricers are in the first slots of the array */
2080 extern
2082  SCIP* scip /**< SCIP data structure */
2083  );
2084 
2085 /** returns the number of currently available variable pricers */
2086 extern
2087 int SCIPgetNPricers(
2088  SCIP* scip /**< SCIP data structure */
2089  );
2090 
2091 /** returns the number of currently active variable pricers, that are used in the LP solving loop */
2092 extern
2094  SCIP* scip /**< SCIP data structure */
2095  );
2096 
2097 /** sets the priority of a variable pricer */
2098 extern
2100  SCIP* scip, /**< SCIP data structure */
2101  SCIP_PRICER* pricer, /**< variable pricer */
2102  int priority /**< new priority of the variable pricer */
2103  );
2104 
2105 /** activates pricer to be used for the current problem
2106  * This method should be called during the problem creation stage for all pricers that are necessary to solve
2107  * the problem model.
2108  * The pricers are automatically deactivated when the problem is freed.
2109  *
2110  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2111  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2112  *
2113  * @pre This method can be called if SCIP is in one of the following stages:
2114  * - \ref SCIP_STAGE_PROBLEM
2115  */
2116 extern
2118  SCIP* scip, /**< SCIP data structure */
2119  SCIP_PRICER* pricer /**< variable pricer */
2120  );
2121 
2122 /** deactivates pricer
2123  *
2124  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2125  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2126  *
2127  * @pre This method can be called if SCIP is in one of the following stages:
2128  * - \ref SCIP_STAGE_PROBLEM
2129  * - \ref SCIP_STAGE_EXITSOLVE
2130  */
2131 extern
2133  SCIP* scip, /**< SCIP data structure */
2134  SCIP_PRICER* pricer /**< variable pricer */
2135  );
2136 
2137 /** creates a constraint handler and includes it in SCIP.
2138  *
2139  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2140  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2141  *
2142  * @pre This method can be called if SCIP is in one of the following stages:
2143  * - \ref SCIP_STAGE_INIT
2144  * - \ref SCIP_STAGE_PROBLEM
2145  *
2146  * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
2147  * callback is added
2148  * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
2149  * if you seek for a method which is less likely to change in future releases
2150  */
2151 extern
2153  SCIP* scip, /**< SCIP data structure */
2154  const char* name, /**< name of constraint handler */
2155  const char* desc, /**< description of constraint handler */
2156  int sepapriority, /**< priority of the constraint handler for separation */
2157  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2158  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2159  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2160  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2161  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2162  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2163  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2164  SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
2165  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2166  SCIP_Bool delaypresol, /**< should presolving method be delayed, if other presolvers found reductions? */
2167  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2168  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagators should be executed */
2169  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2170  SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
2171  SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
2172  SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
2173  SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
2174  SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
2175  SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
2176  SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
2177  SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
2178  SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
2179  SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
2180  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2181  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2182  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2183  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2184  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2185  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2186  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
2187  SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
2188  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2189  SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
2190  SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
2191  SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
2192  SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
2193  SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
2194  SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
2195  SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
2196  SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
2197  SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
2198  SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
2199  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2200  );
2201 
2202 /** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
2203  * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
2204  * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
2205  * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
2206  * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
2207  * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
2208  * SCIPsetConshdlrPrint(), and SCIPsetConshdlrParse().
2209  *
2210  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2211  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2212  *
2213  * @pre This method can be called if SCIP is in one of the following stages:
2214  * - \ref SCIP_STAGE_INIT
2215  * - \ref SCIP_STAGE_PROBLEM
2216  *
2217  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
2218  */
2219 extern
2221  SCIP* scip, /**< SCIP data structure */
2222  SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
2223  const char* name, /**< name of constraint handler */
2224  const char* desc, /**< description of constraint handler */
2225  int enfopriority, /**< priority of the constraint handler for constraint enforcing */
2226  int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
2227  int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
2228  * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
2229  SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
2230  SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
2231  SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
2232  SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
2233  SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
2234  SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
2235  );
2236 
2237 /** sets all separation related callbacks/parameters of the constraint handler
2238  *
2239  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2240  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2241  *
2242  * @pre This method can be called if SCIP is in one of the following stages:
2243  * - \ref SCIP_STAGE_INIT
2244  * - \ref SCIP_STAGE_PROBLEM
2245  */
2246 extern
2248  SCIP* scip, /**< SCIP data structure */
2249  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2250  SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
2251  SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
2252  int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
2253  int sepapriority, /**< priority of the constraint handler for separation */
2254  SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
2255  );
2256 
2257 /** sets both the propagation callback and the propagation frequency of the constraint handler
2258  *
2259  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2260  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2261  *
2262  * @pre This method can be called if SCIP is in one of the following stages:
2263  * - \ref SCIP_STAGE_INIT
2264  * - \ref SCIP_STAGE_PROBLEM
2265  */
2266 extern
2268  SCIP* scip, /**< SCIP data structure */
2269  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2270  SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
2271  int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
2272  SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
2273  SCIP_PROPTIMING timingmask /**< positions in the node solving loop where propagators should be executed */
2274  );
2275 
2276 /** sets copy method of both the constraint handler and each associated constraint
2277  *
2278  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2279  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2280  *
2281  * @pre This method can be called if SCIP is in one of the following stages:
2282  * - \ref SCIP_STAGE_INIT
2283  * - \ref SCIP_STAGE_PROBLEM
2284  */
2285 extern
2287  SCIP* scip, /**< SCIP data structure */
2288  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2289  SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2290  SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
2291  );
2292 
2293 /** sets destructor method of constraint handler
2294  *
2295  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2296  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2297  *
2298  * @pre This method can be called if SCIP is in one of the following stages:
2299  * - \ref SCIP_STAGE_INIT
2300  * - \ref SCIP_STAGE_PROBLEM
2301  */
2302 extern
2304  SCIP* scip, /**< SCIP data structure */
2305  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2306  SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
2307  );
2308 
2309 /** sets initialization method of constraint handler
2310  *
2311  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2312  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2313  *
2314  * @pre This method can be called if SCIP is in one of the following stages:
2315  * - \ref SCIP_STAGE_INIT
2316  * - \ref SCIP_STAGE_PROBLEM
2317  */
2318 extern
2320  SCIP* scip, /**< SCIP data structure */
2321  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2322  SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
2323  );
2324 
2325 /** sets deinitialization method of constraint handler
2326  *
2327  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2328  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2329  *
2330  * @pre This method can be called if SCIP is in one of the following stages:
2331  * - \ref SCIP_STAGE_INIT
2332  * - \ref SCIP_STAGE_PROBLEM
2333  */
2334 extern
2336  SCIP* scip, /**< SCIP data structure */
2337  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2338  SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
2339  );
2340 
2341 /** sets solving process initialization method of constraint handler
2342  *
2343  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2344  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2345  *
2346  * @pre This method can be called if SCIP is in one of the following stages:
2347  * - \ref SCIP_STAGE_INIT
2348  * - \ref SCIP_STAGE_PROBLEM
2349  */
2350 extern
2352  SCIP* scip, /**< SCIP data structure */
2353  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2354  SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
2355  );
2356 
2357 /** sets solving process deinitialization method of constraint handler
2358  *
2359  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2360  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2361  *
2362  * @pre This method can be called if SCIP is in one of the following stages:
2363  * - \ref SCIP_STAGE_INIT
2364  * - \ref SCIP_STAGE_PROBLEM
2365  */
2366 extern
2368  SCIP* scip, /**< SCIP data structure */
2369  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2370  SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
2371  );
2372 
2373 /** sets preprocessing initialization method of constraint handler
2374  *
2375  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2376  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2377  *
2378  * @pre This method can be called if SCIP is in one of the following stages:
2379  * - \ref SCIP_STAGE_INIT
2380  * - \ref SCIP_STAGE_PROBLEM
2381  */
2382 extern
2384  SCIP* scip, /**< SCIP data structure */
2385  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2386  SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
2387  );
2388 
2389 /** sets preprocessing deinitialization method of constraint handler
2390  *
2391  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2392  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2393  *
2394  * @pre This method can be called if SCIP is in one of the following stages:
2395  * - \ref SCIP_STAGE_INIT
2396  * - \ref SCIP_STAGE_PROBLEM
2397  */
2398 extern
2400  SCIP* scip, /**< SCIP data structure */
2401  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2402  SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
2403  );
2404 
2405 /** sets presolving method of constraint handler
2406  *
2407  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2408  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2409  *
2410  * @pre This method can be called if SCIP is in one of the following stages:
2411  * - \ref SCIP_STAGE_INIT
2412  * - \ref SCIP_STAGE_PROBLEM
2413  */
2414 extern
2416  SCIP* scip, /**< SCIP data structure */
2417  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2418  SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
2419  int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
2420  SCIP_Bool delaypresol /**< should presolving method be delayed, if other presolvers found reductions? */
2421  );
2422 
2423 /** sets method of constraint handler to free specific constraint data
2424  *
2425  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2426  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2427  *
2428  * @pre This method can be called if SCIP is in one of the following stages:
2429  * - \ref SCIP_STAGE_INIT
2430  * - \ref SCIP_STAGE_PROBLEM
2431  */
2432 extern
2434  SCIP* scip, /**< SCIP data structure */
2435  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2436  SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
2437  );
2438 
2439 /** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
2440  *
2441  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2442  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2443  *
2444  * @pre This method can be called if SCIP is in one of the following stages:
2445  * - \ref SCIP_STAGE_INIT
2446  * - \ref SCIP_STAGE_PROBLEM
2447  */
2448 extern
2450  SCIP* scip, /**< SCIP data structure */
2451  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2452  SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
2453  );
2454 
2455 /** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
2456  *
2457  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2458  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2459  *
2460  * @pre This method can be called if SCIP is in one of the following stages:
2461  * - \ref SCIP_STAGE_INIT
2462  * - \ref SCIP_STAGE_PROBLEM
2463  */
2464 extern
2466  SCIP* scip, /**< SCIP data structure */
2467  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2468  SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
2469  );
2470 
2471 /** sets propagation conflict resolving method of constraint handler
2472  *
2473  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2474  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2475  *
2476  * @pre This method can be called if SCIP is in one of the following stages:
2477  * - \ref SCIP_STAGE_INIT
2478  * - \ref SCIP_STAGE_PROBLEM
2479  */
2480 extern
2482  SCIP* scip, /**< SCIP data structure */
2483  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2484  SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
2485  );
2486 
2487 /** sets activation notification method of constraint handler
2488  *
2489  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2490  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2491  *
2492  * @pre This method can be called if SCIP is in one of the following stages:
2493  * - \ref SCIP_STAGE_INIT
2494  * - \ref SCIP_STAGE_PROBLEM
2495  */
2496 extern
2498  SCIP* scip, /**< SCIP data structure */
2499  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2500  SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
2501  );
2502 
2503 /** sets deactivation notification method of constraint handler
2504  *
2505  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2506  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2507  *
2508  * @pre This method can be called if SCIP is in one of the following stages:
2509  * - \ref SCIP_STAGE_INIT
2510  * - \ref SCIP_STAGE_PROBLEM
2511  */
2512 extern
2514  SCIP* scip, /**< SCIP data structure */
2515  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2516  SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
2517  );
2518 
2519 /** sets enabling notification method of constraint handler
2520  *
2521  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2522  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2523  *
2524  * @pre This method can be called if SCIP is in one of the following stages:
2525  * - \ref SCIP_STAGE_INIT
2526  * - \ref SCIP_STAGE_PROBLEM
2527  */
2528 extern
2530  SCIP* scip, /**< SCIP data structure */
2531  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2532  SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
2533  );
2534 
2535 /** sets disabling notification method of constraint handler
2536  *
2537  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2538  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2539  *
2540  * @pre This method can be called if SCIP is in one of the following stages:
2541  * - \ref SCIP_STAGE_INIT
2542  * - \ref SCIP_STAGE_PROBLEM
2543  */
2544 extern
2546  SCIP* scip, /**< SCIP data structure */
2547  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2548  SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
2549  );
2550 
2551 /** sets variable deletion method of constraint handler
2552  *
2553  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2554  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2555  *
2556  * @pre This method can be called if SCIP is in one of the following stages:
2557  * - \ref SCIP_STAGE_INIT
2558  * - \ref SCIP_STAGE_PROBLEM
2559  */
2560 extern
2562  SCIP* scip, /**< SCIP data structure */
2563  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2564  SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
2565  );
2566 
2567 /** sets constraint display method of constraint handler
2568  *
2569  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2570  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2571  *
2572  * @pre This method can be called if SCIP is in one of the following stages:
2573  * - \ref SCIP_STAGE_INIT
2574  * - \ref SCIP_STAGE_PROBLEM
2575  */
2576 extern
2578  SCIP* scip, /**< SCIP data structure */
2579  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2580  SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
2581  );
2582 
2583 /** sets constraint parsing method of constraint handler
2584  *
2585  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2586  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2587  *
2588  * @pre This method can be called if SCIP is in one of the following stages:
2589  * - \ref SCIP_STAGE_INIT
2590  * - \ref SCIP_STAGE_PROBLEM
2591  */
2592 extern
2594  SCIP* scip, /**< SCIP data structure */
2595  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2596  SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
2597  );
2598 
2599 /** sets constraint variable getter method of constraint handler
2600  *
2601  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2602  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2603  *
2604  * @pre This method can be called if SCIP is in one of the following stages:
2605  * - \ref SCIP_STAGE_INIT
2606  * - \ref SCIP_STAGE_PROBLEM
2607  */
2608 extern
2610  SCIP* scip, /**< SCIP data structure */
2611  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2612  SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
2613  );
2614 
2615 /** sets constraint variable number getter method of constraint handler
2616  *
2617  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2618  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2619  *
2620  * @pre This method can be called if SCIP is in one of the following stages:
2621  * - \ref SCIP_STAGE_INIT
2622  * - \ref SCIP_STAGE_PROBLEM
2623  */
2624 extern
2626  SCIP* scip, /**< SCIP data structure */
2627  SCIP_CONSHDLR* conshdlr, /**< constraint handler */
2628  SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
2629  );
2630 
2631 /** returns the constraint handler of the given name, or NULL if not existing */
2632 extern
2634  SCIP* scip, /**< SCIP data structure */
2635  const char* name /**< name of constraint handler */
2636  );
2637 
2638 /** returns the array of currently available constraint handlers */
2639 extern
2641  SCIP* scip /**< SCIP data structure */
2642  );
2643 
2644 /** returns the number of currently available constraint handlers */
2645 extern
2646 int SCIPgetNConshdlrs(
2647  SCIP* scip /**< SCIP data structure */
2648  );
2649 
2650 /** creates a conflict handler and includes it in SCIP
2651  *
2652  * @note method has all conflict handler callbacks as arguments and is thus changed every time a new
2653  * callback is added
2654  * in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions
2655  * if you seek for a method which is less likely to change in future releases
2656  */
2657 extern
2659  SCIP* scip, /**< SCIP data structure */
2660  const char* name, /**< name of conflict handler */
2661  const char* desc, /**< description of conflict handler */
2662  int priority, /**< priority of the conflict handler */
2663  SCIP_DECL_CONFLICTCOPY((*conflictcopy)), /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2664  SCIP_DECL_CONFLICTFREE((*conflictfree)), /**< destructor of conflict handler */
2665  SCIP_DECL_CONFLICTINIT((*conflictinit)), /**< initialize conflict handler */
2666  SCIP_DECL_CONFLICTEXIT((*conflictexit)), /**< deinitialize conflict handler */
2667  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
2668  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
2669  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
2670  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
2671  );
2672 
2673 /** creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental
2674  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
2675  * Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(),
2676  * SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(),
2677  * and SCIPsetConflicthdlrExitsol()
2678  *
2679  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead
2680  */
2681 extern
2683  SCIP* scip, /**< SCIP data structure */
2684  SCIP_CONFLICTHDLR** conflicthdlrptr, /**< reference to a conflict handler pointer, or NULL */
2685  const char* name, /**< name of conflict handler */
2686  const char* desc, /**< description of conflict handler */
2687  int priority, /**< priority of the conflict handler */
2688  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
2689  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
2690  );
2691 
2692 /** set copy method of conflict handler */
2693 extern
2695  SCIP* scip, /**< SCIP data structure */
2696  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2697  SCIP_DECL_CONFLICTCOPY((*conflictcopy)) /**< copy method of conflict handler */
2698  );
2699 
2700 /** set destructor of conflict handler */
2701 extern
2703  SCIP* scip, /**< SCIP data structure */
2704  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2705  SCIP_DECL_CONFLICTFREE((*conflictfree)) /**< destructor of conflict handler */
2706  );
2707 
2708 /** set initialization method of conflict handler */
2709 extern
2711  SCIP* scip, /**< SCIP data structure */
2712  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2713  SCIP_DECL_CONFLICTINIT((*conflictinit)) /**< initialize conflict handler */
2714  );
2715 
2716 /** set deinitialization method of conflict handler */
2717 extern
2719  SCIP* scip, /**< SCIP data structure */
2720  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2721  SCIP_DECL_CONFLICTEXIT((*conflictexit)) /**< deinitialize conflict handler */
2722  );
2723 
2724 /** set solving process initialization method of conflict handler */
2725 extern
2727  SCIP* scip, /**< SCIP data structure */
2728  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2729  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
2730  );
2731 
2732 /** set solving process deinitialization method of conflict handler */
2733 extern
2735  SCIP* scip, /**< SCIP data structure */
2736  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2737  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
2738  );
2739 
2740 /** returns the conflict handler of the given name, or NULL if not existing */
2741 extern
2743  SCIP* scip, /**< SCIP data structure */
2744  const char* name /**< name of conflict handler */
2745  );
2746 
2747 /** returns the array of currently available conflict handlers */
2748 extern
2750  SCIP* scip /**< SCIP data structure */
2751  );
2752 
2753 /** returns the number of currently available conflict handlers */
2754 extern
2756  SCIP* scip /**< SCIP data structure */
2757  );
2758 
2759 /** sets the priority of a conflict handler */
2760 extern
2762  SCIP* scip, /**< SCIP data structure */
2763  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
2764  int priority /**< new priority of the conflict handler */
2765  );
2766 
2767 /** creates a presolver and includes it in SCIP
2768  *
2769  * @note method has all presolver callbacks as arguments and is thus changed every time a new
2770  * callback is added
2771  * in future releases; consider using SCIPincludePresolBasic() and setter functions
2772  * if you seek for a method which is less likely to change in future releases
2773  */
2774 extern
2776  SCIP* scip, /**< SCIP data structure */
2777  const char* name, /**< name of presolver */
2778  const char* desc, /**< description of presolver */
2779  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
2780  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
2781  SCIP_Bool delay, /**< should presolver be delayed, if other presolvers found reductions? */
2782  SCIP_DECL_PRESOLCOPY ((*presolcopy)), /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
2783  SCIP_DECL_PRESOLFREE ((*presolfree)), /**< destructor of presolver to free user data (called when SCIP is exiting) */
2784  SCIP_DECL_PRESOLINIT ((*presolinit)), /**< initialization method of presolver (called after problem was transformed) */
2785  SCIP_DECL_PRESOLEXIT ((*presolexit)), /**< deinitialization method of presolver (called before transformed problem is freed) */
2786  SCIP_DECL_PRESOLINITPRE((*presolinitpre)),/**< presolving initialization method of presolver (called when presolving is about to begin) */
2787  SCIP_DECL_PRESOLEXITPRE((*presolexitpre)),/**< presolving deinitialization method of presolver (called after presolving has been finished) */
2788  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
2789  SCIP_PRESOLDATA* presoldata /**< presolver data */
2790  );
2791 
2792 /** Creates a presolver and includes it in SCIP with its fundamental callback. All non-fundamental (or optional)
2793  * callbacks as, e.g., init and exit callbacks, will be set to NULL. Optional callbacks can be set via specific setter
2794  * functions. These are SCIPsetPresolCopy(), SCIPsetPresolFree(), SCIPsetPresolInit(), SCIPsetPresolExit(),
2795  * SCIPsetPresolInitpre(), and SCIPsetPresolExitPre().
2796  *
2797  * @note if you want to set all callbacks with a single method call, consider using SCIPincludePresol() instead
2798  */
2799 extern
2801  SCIP* scip, /**< SCIP data structure */
2802  SCIP_PRESOL** presolptr, /**< reference to presolver, or NULL */
2803  const char* name, /**< name of presolver */
2804  const char* desc, /**< description of presolver */
2805  int priority, /**< priority of the presolver (>= 0: before, < 0: after constraint handlers) */
2806  int maxrounds, /**< maximal number of presolving rounds the presolver participates in (-1: no limit) */
2807  SCIP_Bool delay, /**< should presolver be delayed, if other presolvers found reductions? */
2808  SCIP_DECL_PRESOLEXEC ((*presolexec)), /**< execution method of presolver */
2809  SCIP_PRESOLDATA* presoldata /**< presolver data */
2810  );
2811 
2812 /** sets copy method of presolver */
2813 extern
2815  SCIP* scip, /**< SCIP data structure */
2816  SCIP_PRESOL* presol, /**< presolver */
2817  SCIP_DECL_PRESOLCOPY ((*presolcopy)) /**< copy method of presolver or NULL if you don't want to copy your plugin into sub-SCIPs */
2818  );
2819 
2820 /** sets destructor method of presolver */
2821 extern
2823  SCIP* scip, /**< SCIP data structure */
2824  SCIP_PRESOL* presol, /**< presolver */
2825  SCIP_DECL_PRESOLFREE ((*presolfree)) /**< destructor of presolver */
2826  );
2827 
2828 /** sets initialization method of presolver */
2829 extern
2831  SCIP* scip, /**< SCIP data structure */
2832  SCIP_PRESOL* presol, /**< presolver */
2833  SCIP_DECL_PRESOLINIT ((*presolinit)) /**< initialize presolver */
2834  );
2835 
2836 /** sets deinitialization method of presolver */
2837 extern
2839  SCIP* scip, /**< SCIP data structure */
2840  SCIP_PRESOL* presol, /**< presolver */
2841  SCIP_DECL_PRESOLEXIT ((*presolexit)) /**< deinitialize presolver */
2842  );
2843 
2844 /** sets solving process initialization method of presolver */
2845 extern
2847  SCIP* scip, /**< SCIP data structure */
2848  SCIP_PRESOL* presol, /**< presolver */
2849  SCIP_DECL_PRESOLINITPRE ((*presolinitpre))/**< solving process initialization method of presolver */
2850  );
2851 
2852 /** sets solving process deinitialization method of presolver */
2854  SCIP* scip, /**< SCIP data structure */
2855  SCIP_PRESOL* presol, /**< presolver */
2856  SCIP_DECL_PRESOLEXITPRE ((*presolexitpre))/**< solving process deinitialization method of presolver */
2857  );
2858 
2859 /** returns the presolver of the given name, or NULL if not existing */
2860 extern
2862  SCIP* scip, /**< SCIP data structure */
2863  const char* name /**< name of presolver */
2864  );
2865 
2866 /** returns the array of currently available presolvers */
2867 extern
2869  SCIP* scip /**< SCIP data structure */
2870  );
2871 
2872 /** returns the number of currently available presolvers */
2873 extern
2874 int SCIPgetNPresols(
2875  SCIP* scip /**< SCIP data structure */
2876  );
2877 
2878 /** sets the priority of a presolver */
2879 extern
2881  SCIP* scip, /**< SCIP data structure */
2882  SCIP_PRESOL* presol, /**< presolver */
2883  int priority /**< new priority of the presolver */
2884  );
2885 
2886 /** creates a relaxation handler and includes it in SCIP
2887  *
2888  * @note method has all relaxation handler callbacks as arguments and is thus changed every time a new
2889  * callback is added
2890  * in future releases; consider using SCIPincludeRelaxBasic() and setter functions
2891  * if you seek for a method which is less likely to change in future releases
2892  */
2893 extern
2895  SCIP* scip, /**< SCIP data structure */
2896  const char* name, /**< name of relaxation handler */
2897  const char* desc, /**< description of relaxation handler */
2898  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
2899  int freq, /**< frequency for calling relaxation handler */
2900  SCIP_DECL_RELAXCOPY ((*relaxcopy)), /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2901  SCIP_DECL_RELAXFREE ((*relaxfree)), /**< destructor of relaxation handler */
2902  SCIP_DECL_RELAXINIT ((*relaxinit)), /**< initialize relaxation handler */
2903  SCIP_DECL_RELAXEXIT ((*relaxexit)), /**< deinitialize relaxation handler */
2904  SCIP_DECL_RELAXINITSOL((*relaxinitsol)), /**< solving process initialization method of relaxation handler */
2905  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)), /**< solving process deinitialization method of relaxation handler */
2906  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
2907  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
2908  );
2909 
2910 /** creates a relaxation handler and includes it in SCIP. All non fundamental
2911  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
2912  * Optional callbacks can be set via specific setter functions, see SCIPsetRelaxInit(), SCIPsetRelaxExit(),
2913  * SCIPsetRelaxCopy(), SCIPsetRelaxFree(), SCIPsetRelaxInitsol(), and SCIPsetRelaxExitsol()
2914  *
2915  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeRelax() instead
2916  */
2917 extern
2919  SCIP* scip, /**< SCIP data structure */
2920  SCIP_RELAX** relaxptr, /**< reference to relaxation pointer, or NULL */
2921  const char* name, /**< name of relaxation handler */
2922  const char* desc, /**< description of relaxation handler */
2923  int priority, /**< priority of the relaxation handler (negative: after LP, non-negative: before LP) */
2924  int freq, /**< frequency for calling relaxation handler */
2925  SCIP_DECL_RELAXEXEC ((*relaxexec)), /**< execution method of relaxation handler */
2926  SCIP_RELAXDATA* relaxdata /**< relaxation handler data */
2927  );
2928 
2929 /** sets copy method of relaxation handler */
2930 extern
2932  SCIP* scip, /**< SCIP data structure */
2933  SCIP_RELAX* relax, /**< relaxation handler */
2934  SCIP_DECL_RELAXCOPY ((*relaxcopy)) /**< copy method of relaxation handler or NULL if you don't want to copy your plugin into sub-SCIPs */
2935  );
2936 
2937 /** sets destructor method of relaxation handler */
2938 extern
2940  SCIP* scip, /**< SCIP data structure */
2941  SCIP_RELAX* relax, /**< relaxation handler */
2942  SCIP_DECL_RELAXFREE ((*relaxfree)) /**< destructor of relaxation handler */
2943  );
2944 
2945 /** sets initialization method of relaxation handler */
2946 extern
2948  SCIP* scip, /**< SCIP data structure */
2949  SCIP_RELAX* relax, /**< relaxation handler */
2950  SCIP_DECL_RELAXINIT ((*relaxinit)) /**< initialize relaxation handler */
2951  );
2952 
2953 /** sets deinitialization method of relaxation handler */
2954 extern
2956  SCIP* scip, /**< SCIP data structure */
2957  SCIP_RELAX* relax, /**< relaxation handler */
2958  SCIP_DECL_RELAXEXIT ((*relaxexit)) /**< deinitialize relaxation handler */
2959  );
2960 
2961 /** sets solving process initialization method of relaxation handler */
2962 extern
2964  SCIP* scip, /**< SCIP data structure */
2965  SCIP_RELAX* relax, /**< relaxation handler */
2966  SCIP_DECL_RELAXINITSOL((*relaxinitsol)) /**< solving process initialization method of relaxation handler */
2967  );
2968 
2969 /** sets solving process deinitialization method of relaxation handler */
2970 extern
2972  SCIP* scip, /**< SCIP data structure */
2973  SCIP_RELAX* relax, /**< relaxation handler */
2974  SCIP_DECL_RELAXEXITSOL((*relaxexitsol)) /**< solving process deinitialization method of relaxation handler */
2975  );
2976 
2977 /** returns the relaxation handler of the given name, or NULL if not existing */
2978 extern
2980  SCIP* scip, /**< SCIP data structure */
2981  const char* name /**< name of relaxation handler*/
2982  );
2983 
2984 /** returns the array of currently available relaxation handlers */
2985 extern
2987  SCIP* scip /**< SCIP data structure */
2988  );
2989 
2990 /** returns the number of currently available relaxation handlers */
2991 extern
2992 int SCIPgetNRelaxs(
2993  SCIP* scip /**< SCIP data structure */
2994  );
2995 
2996 /** sets the priority of a relaxation handler*/
2997 extern
2999  SCIP* scip, /**< SCIP data structure */
3000  SCIP_RELAX* relax, /**< relaxation handler */
3001  int priority /**< new priority of the relaxation handler */
3002  );
3003 
3004 /** creates a separator and includes it in SCIP.
3005  *
3006  * @note method has all separator callbacks as arguments and is thus changed every time a new
3007  * callback is added
3008  * in future releases; consider using SCIPincludeSepaBasic() and setter functions
3009  * if you seek for a method which is less likely to change in future releases
3010  */
3011 extern
3013  SCIP* scip, /**< SCIP data structure */
3014  const char* name, /**< name of separator */
3015  const char* desc, /**< description of separator */
3016  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3017  int freq, /**< frequency for calling separator */
3018  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3019  * to best node's dual bound for applying separation */
3020  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3021  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3022  SCIP_DECL_SEPACOPY ((*sepacopy)), /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3023  SCIP_DECL_SEPAFREE ((*sepafree)), /**< destructor of separator */
3024  SCIP_DECL_SEPAINIT ((*sepainit)), /**< initialize separator */
3025  SCIP_DECL_SEPAEXIT ((*sepaexit)), /**< deinitialize separator */
3026  SCIP_DECL_SEPAINITSOL ((*sepainitsol)), /**< solving process initialization method of separator */
3027  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)), /**< solving process deinitialization method of separator */
3028  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3029  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3030  SCIP_SEPADATA* sepadata /**< separator data */
3031  );
3032 
3033 /** creates a separator and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3034  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3035  * Optional callbacks can be set via specific setter functions, see SCIPsetSepaInit(), SCIPsetSepaFree(),
3036  * SCIPsetSepaInitsol(), SCIPsetSepaExitsol(), SCIPsetSepaCopy(), SCIPsetExit().
3037  *
3038  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeSepa() instead
3039  */
3040 extern
3042  SCIP* scip, /**< SCIP data structure */
3043  SCIP_SEPA** sepa, /**< reference to a separator, or NULL */
3044  const char* name, /**< name of separator */
3045  const char* desc, /**< description of separator */
3046  int priority, /**< priority of separator (>= 0: before, < 0: after constraint handlers) */
3047  int freq, /**< frequency for calling separator */
3048  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound compared
3049  * to best node's dual bound for applying separation */
3050  SCIP_Bool usessubscip, /**< does the separator use a secondary SCIP instance? */
3051  SCIP_Bool delay, /**< should separator be delayed, if other separators found cuts? */
3052  SCIP_DECL_SEPAEXECLP ((*sepaexeclp)), /**< LP solution separation method of separator */
3053  SCIP_DECL_SEPAEXECSOL ((*sepaexecsol)), /**< arbitrary primal solution separation method of separator */
3054  SCIP_SEPADATA* sepadata /**< separator data */
3055  );
3056 
3057 /** sets copy method of separator */
3058 extern
3060  SCIP* scip, /**< SCIP data structure */
3061  SCIP_SEPA* sepa, /**< separator */
3062  SCIP_DECL_SEPACOPY ((*sepacopy)) /**< copy method of separator or NULL if you don't want to copy your plugin into sub-SCIPs */
3063  );
3064 
3065 /** sets destructor method of separator */
3066 extern
3068  SCIP* scip, /**< SCIP data structure */
3069  SCIP_SEPA* sepa, /**< separator */
3070  SCIP_DECL_SEPAFREE ((*sepafree)) /**< destructor of separator */
3071  );
3072 
3073 /** sets initialization method of separator */
3074 extern
3076  SCIP* scip, /**< SCIP data structure */
3077  SCIP_SEPA* sepa, /**< separator */
3078  SCIP_DECL_SEPAINIT ((*sepainit)) /**< initialize separator */
3079  );
3080 
3081 /** sets deinitialization method of separator */
3082 extern
3084  SCIP* scip, /**< SCIP data structure */
3085  SCIP_SEPA* sepa, /**< separator */
3086  SCIP_DECL_SEPAEXIT ((*sepaexit)) /**< deinitialize separator */
3087  );
3088 
3089 /** sets solving process initialization method of separator */
3090 extern
3092  SCIP* scip, /**< SCIP data structure */
3093  SCIP_SEPA* sepa, /**< separator */
3094  SCIP_DECL_SEPAINITSOL ((*sepainitsol)) /**< solving process initialization method of separator */
3095  );
3096 
3097 /** sets solving process deinitialization method of separator */
3098 extern
3100  SCIP* scip, /**< SCIP data structure */
3101  SCIP_SEPA* sepa, /**< separator */
3102  SCIP_DECL_SEPAEXITSOL ((*sepaexitsol)) /**< solving process deinitialization method of separator */
3103  );
3104 
3105 /** returns the separator of the given name, or NULL if not existing */
3106 extern
3108  SCIP* scip, /**< SCIP data structure */
3109  const char* name /**< name of separator */
3110  );
3111 
3112 /** returns the array of currently available separators */
3113 extern
3115  SCIP* scip /**< SCIP data structure */
3116  );
3117 
3118 /** returns the number of currently available separators */
3119 extern
3120 int SCIPgetNSepas(
3121  SCIP* scip /**< SCIP data structure */
3122  );
3123 
3124 /** sets the priority of a separator */
3125 extern
3127  SCIP* scip, /**< SCIP data structure */
3128  SCIP_SEPA* sepa, /**< separator */
3129  int priority /**< new priority of the separator */
3130  );
3131 
3132 /** creates a propagator and includes it in SCIP.
3133  *
3134  * @note method has all propagator callbacks as arguments and is thus changed every time a new
3135  * callback is added
3136  * in future releases; consider using SCIPincludePropBasic() and setter functions
3137  * if you seek for a method which is less likely to change in future releases
3138  */
3139 extern
3141  SCIP* scip, /**< SCIP data structure */
3142  const char* name, /**< name of propagator */
3143  const char* desc, /**< description of propagator */
3144  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3145  int freq, /**< frequency for calling propagator */
3146  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3147  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagators should be executed */
3148  int presolpriority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3149  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3150  SCIP_Bool presoldelay, /**< should presolving be delayed, if other presolvers found reductions? */
3151  SCIP_DECL_PROPCOPY ((*propcopy)), /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3152  SCIP_DECL_PROPFREE ((*propfree)), /**< destructor of propagator */
3153  SCIP_DECL_PROPINIT ((*propinit)), /**< initialize propagator */
3154  SCIP_DECL_PROPEXIT ((*propexit)), /**< deinitialize propagator */
3155  SCIP_DECL_PROPINITPRE ((*propinitpre)), /**< presolving initialization method of propagator */
3156  SCIP_DECL_PROPEXITPRE ((*propexitpre)), /**< presolving deinitialization method of propagator */
3157  SCIP_DECL_PROPINITSOL ((*propinitsol)), /**< solving process initialization method of propagator */
3158  SCIP_DECL_PROPEXITSOL ((*propexitsol)), /**< solving process deinitialization method of propagator */
3159  SCIP_DECL_PROPPRESOL ((*proppresol)), /**< presolving method */
3160  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3161  SCIP_DECL_PROPRESPROP ((*propresprop)), /**< propagation conflict resolving method */
3162  SCIP_PROPDATA* propdata /**< propagator data */
3163  );
3164 
3165 /** creates a propagator and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
3166  * Optional callbacks can be set via specific setter functions, see SCIPsetPropInit(), SCIPsetPropExit(),
3167  * SCIPsetPropCopy(), SCIPsetPropFree(), SCIPsetPropInitsol(), SCIPsetPropExitsol(),
3168  * SCIPsetPropInitpre(), SCIPsetPropExitpre(), SCIPsetPropPresol(), and SCIPsetPropResprop().
3169  *
3170  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeProp() instead
3171  */
3172 extern
3174  SCIP* scip, /**< SCIP data structure */
3175  SCIP_PROP** propptr, /**< reference to a propagator pointer, or NULL */
3176  const char* name, /**< name of propagator */
3177  const char* desc, /**< description of propagator */
3178  int priority, /**< priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3179  int freq, /**< frequency for calling propagator */
3180  SCIP_Bool delay, /**< should propagator be delayed, if other propagators found reductions? */
3181  SCIP_PROPTIMING timingmask, /**< positions in the node solving loop where propagators should be executed */
3182  SCIP_DECL_PROPEXEC ((*propexec)), /**< execution method of propagator */
3183  SCIP_PROPDATA* propdata /**< propagator data */
3184  );
3185 
3186 /** sets copy method of propagator */
3187 extern
3189  SCIP* scip, /**< SCIP data structure */
3190  SCIP_PROP* prop, /**< propagator */
3191  SCIP_DECL_PROPCOPY ((*propcopy)) /**< copy method of propagator or NULL if you don't want to copy your plugin into sub-SCIPs */
3192  );
3193 
3194 /** sets destructor method of propagator */
3195 extern
3197  SCIP* scip, /**< SCIP data structure */
3198  SCIP_PROP* prop, /**< propagator */
3199  SCIP_DECL_PROPFREE ((*propfree)) /**< destructor of propagator */
3200  );
3201 
3202 /** sets initialization method of propagator */
3203 extern
3205  SCIP* scip, /**< SCIP data structure */
3206  SCIP_PROP* prop, /**< propagator */
3207  SCIP_DECL_PROPINIT ((*propinit)) /**< initialize propagator */
3208  );
3209 
3210 /** sets deinitialization method of propagator */
3211 extern
3213  SCIP* scip, /**< SCIP data structure */
3214  SCIP_PROP* prop, /**< propagator */
3215  SCIP_DECL_PROPEXIT ((*propexit)) /**< deinitialize propagator */
3216  );
3217 
3218 /** sets solving process initialization method of propagator */
3219 extern
3221  SCIP* scip, /**< SCIP data structure */
3222  SCIP_PROP* prop, /**< propagator */
3223  SCIP_DECL_PROPINITSOL((*propinitsol)) /**< solving process initialization method of propagator */
3224  );
3225 
3226 /** sets solving process deinitialization method of propagator */
3227 extern
3229  SCIP* scip, /**< SCIP data structure */
3230  SCIP_PROP* prop, /**< propagator */
3231  SCIP_DECL_PROPEXITSOL ((*propexitsol)) /**< solving process deinitialization method of propagator */
3232  );
3233 
3234 /** sets preprocessing initialization method of propagator */
3235 extern
3237  SCIP* scip, /**< SCIP data structure */
3238  SCIP_PROP* prop, /**< propagator */
3239  SCIP_DECL_PROPINITPRE((*propinitpre)) /**< preprocessing initialization method of propagator */
3240  );
3241 
3242 /** sets preprocessing deinitialization method of propagator */
3243 extern
3245  SCIP* scip, /**< SCIP data structure */
3246  SCIP_PROP* prop, /**< propagator */
3247  SCIP_DECL_PROPEXITPRE((*propexitpre)) /**< preprocessing deinitialization method of propagator */
3248  );
3249 
3250 /** sets presolving method of propagator */
3251 extern
3253  SCIP* scip, /**< SCIP data structure */
3254  SCIP_PROP* prop, /**< propagator */
3255  SCIP_DECL_PROPPRESOL((*proppresol)), /**< presolving method of propagator */
3256  int presolpriority, /**< presolving priority of the propagator (>= 0: before, < 0: after constraint handlers) */
3257  int presolmaxrounds, /**< maximal number of presolving rounds the propagator participates in (-1: no limit) */
3258  SCIP_Bool presoldelay /**< should presolving be delayed, if other presolvers found reductions? */
3259  );
3260 
3261 /** sets propagation conflict resolving callback of propagator */
3262 extern
3264  SCIP* scip, /**< SCIP data structure */
3265  SCIP_PROP* prop, /**< propagator */
3266  SCIP_DECL_PROPRESPROP ((*propresprop)) /**< propagation conflict resolving callback */
3267  );
3268 
3269 /** returns the propagator of the given name, or NULL if not existing */
3270 extern
3272  SCIP* scip, /**< SCIP data structure */
3273  const char* name /**< name of propagator */
3274  );
3275 
3276 /** returns the array of currently available propagators */
3277 extern
3279  SCIP* scip /**< SCIP data structure */
3280  );
3281 
3282 /** returns the number of currently available propagators */
3283 extern
3284 int SCIPgetNProps(
3285  SCIP* scip /**< SCIP data structure */
3286  );
3287 
3288 /** sets the priority of a propagator */
3289 extern
3291  SCIP* scip, /**< SCIP data structure */
3292  SCIP_PROP* prop, /**< propagator */
3293  int priority /**< new priority of the propagator */
3294  );
3295 
3296 /** sets the presolving priority of a propagator */
3297 extern
3299  SCIP* scip, /**< SCIP data structure */
3300  SCIP_PROP* prop, /**< propagator */
3301  int presolpriority /**< new presol priority of the propagator */
3302  );
3303 
3304 
3305 /** creates a primal heuristic and includes it in SCIP.
3306  *
3307  * @note method has all heuristic callbacks as arguments and is thus changed every time a new
3308  * callback is added in future releases; consider using SCIPincludeHeurBasic() and setter functions
3309  * if you seek for a method which is less likely to change in future releases
3310  */
3311 extern
3313  SCIP* scip, /**< SCIP data structure */
3314  const char* name, /**< name of primal heuristic */
3315  const char* desc, /**< description of primal heuristic */
3316  char dispchar, /**< display character of primal heuristic */
3317  int priority, /**< priority of the primal heuristic */
3318  int freq, /**< frequency for calling primal heuristic */
3319  int freqofs, /**< frequency offset for calling primal heuristic */
3320  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3321  unsigned int timingmask, /**< positions in the node solving loop where heuristic should be executed;
3322  * see definition of SCIP_HeurTiming for possible values */
3323  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3324  SCIP_DECL_HEURCOPY ((*heurcopy)), /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
3325  SCIP_DECL_HEURFREE ((*heurfree)), /**< destructor of primal heuristic */
3326  SCIP_DECL_HEURINIT ((*heurinit)), /**< initialize primal heuristic */
3327  SCIP_DECL_HEUREXIT ((*heurexit)), /**< deinitialize primal heuristic */
3328  SCIP_DECL_HEURINITSOL ((*heurinitsol)), /**< solving process initialization method of primal heuristic */
3329  SCIP_DECL_HEUREXITSOL ((*heurexitsol)), /**< solving process deinitialization method of primal heuristic */
3330  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
3331  SCIP_HEURDATA* heurdata /**< primal heuristic data */
3332  );
3333 
3334 /** creates a primal heuristic and includes it in SCIP with its most fundamental callbacks.
3335  * All non-fundamental (or optional) callbacks
3336  * as, e. g., init and exit callbacks, will be set to NULL.
3337  * Optional callbacks can be set via specific setter functions, see SCIPsetHeurCopy(), SCIPsetHeurFree(),
3338  * SCIPsetHeurInit(), SCIPsetHeurExit(), SCIPsetHeurInitsol(), and SCIPsetHeurExitsol()
3339  *
3340 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeHeur() instead
3341  */
3342 extern
3344  SCIP* scip, /**< SCIP data structure */
3345  SCIP_HEUR** heur, /**< pointer to the heuristic */
3346  const char* name, /**< name of primal heuristic */
3347  const char* desc, /**< description of primal heuristic */
3348  char dispchar, /**< display character of primal heuristic */
3349  int priority, /**< priority of the primal heuristic */
3350  int freq, /**< frequency for calling primal heuristic */
3351  int freqofs, /**< frequency offset for calling primal heuristic */
3352  int maxdepth, /**< maximal depth level to call heuristic at (-1: no limit) */
3353  unsigned int timingmask, /**< positions in the node solving loop where heuristic should be executed;
3354  * see definition of SCIP_HeurTiming for possible values */
3355  SCIP_Bool usessubscip, /**< does the heuristic use a secondary SCIP instance? */
3356  SCIP_DECL_HEUREXEC ((*heurexec)), /**< execution method of primal heuristic */
3357  SCIP_HEURDATA* heurdata /**< primal heuristic data */
3358  );
3359 
3360 /** sets copy method of primal heuristic */
3361 extern
3363  SCIP* scip, /**< SCIP data structure */
3364  SCIP_HEUR* heur, /**< primal heuristic */
3365  SCIP_DECL_HEURCOPY ((*heurcopy)) /**< copy method of primal heuristic or NULL if you don't want to copy your plugin into sub-SCIPs */
3366  );
3367 
3368 /** sets destructor method of primal heuristic */
3369 extern
3371  SCIP* scip, /**< SCIP data structure */
3372  SCIP_HEUR* heur, /**< primal heuristic */
3373  SCIP_DECL_HEURFREE ((*heurfree)) /**< destructor of primal heuristic */
3374  );
3375 
3376 /** sets initialization method of primal heuristic */
3377 extern
3379  SCIP* scip, /**< SCIP data structure */
3380  SCIP_HEUR* heur, /**< primal heuristic */
3381  SCIP_DECL_HEURINIT ((*heurinit)) /**< initialize primal heuristic */
3382  );
3383 
3384 /** sets deinitialization method of primal heuristic */
3385 extern
3387  SCIP* scip, /**< SCIP data structure */
3388  SCIP_HEUR* heur, /**< primal heuristic */
3389  SCIP_DECL_HEUREXIT ((*heurexit)) /**< deinitialize primal heuristic */
3390  );
3391 
3392 /** sets solving process initialization method of primal heuristic */
3393 extern
3395  SCIP* scip, /**< SCIP data structure */
3396  SCIP_HEUR* heur, /**< primal heuristic */
3397  SCIP_DECL_HEURINITSOL ((*heurinitsol)) /**< solving process initialization method of primal heuristic */
3398  );
3399 
3400 /** sets solving process deinitialization method of primal heuristic */
3401 extern
3403  SCIP* scip, /**< SCIP data structure */
3404  SCIP_HEUR* heur, /**< primal heuristic */
3405  SCIP_DECL_HEUREXITSOL ((*heurexitsol)) /**< solving process deinitialization method of primal heuristic */
3406  );
3407 
3408 /** returns the primal heuristic of the given name, or NULL if not existing */
3409 extern
3411  SCIP* scip, /**< SCIP data structure */
3412  const char* name /**< name of primal heuristic */
3413  );
3414 
3415 /** returns the array of currently available primal heuristics */
3416 extern
3418  SCIP* scip /**< SCIP data structure */
3419  );
3420 
3421 /** returns the number of currently available primal heuristics */
3422 extern
3423 int SCIPgetNHeurs(
3424  SCIP* scip /**< SCIP data structure */
3425  );
3426 
3427 /** sets the priority of a primal heuristic */
3428 extern
3430  SCIP* scip, /**< SCIP data structure */
3431  SCIP_HEUR* heur, /**< primal heuristic */
3432  int priority /**< new priority of the primal heuristic */
3433  );
3434 
3435 /** creates an event handler and includes it in SCIP
3436  *
3437  * @note method has all event handler callbacks as arguments and is thus changed every time a new
3438  * callback is added in future releases; consider using SCIPincludeEventhdlrBasic() and setter functions
3439  * if you seek for a method which is less likely to change in future releases
3440  */
3441 extern
3443  SCIP* scip, /**< SCIP data structure */
3444  const char* name, /**< name of event handler */
3445  const char* desc, /**< description of event handler */
3446  SCIP_DECL_EVENTCOPY ((*eventcopy)), /**< copy method of event handler or NULL if you don't want to copy your plugin into sub-SCIPs */
3447  SCIP_DECL_EVENTFREE ((*eventfree)), /**< destructor of event handler */
3448  SCIP_DECL_EVENTINIT ((*eventinit)), /**< initialize event handler */
3449  SCIP_DECL_EVENTEXIT ((*eventexit)), /**< deinitialize event handler */
3450  SCIP_DECL_EVENTINITSOL((*eventinitsol)), /**< solving process initialization method of event handler */
3451  SCIP_DECL_EVENTEXITSOL((*eventexitsol)), /**< solving process deinitialization method of event handler */
3452  SCIP_DECL_EVENTDELETE ((*eventdelete)), /**< free specific event data */
3453  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
3454  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
3455  );
3456 
3457 /** creates an event handler and includes it in SCIP with all its non-fundamental callbacks set
3458  * to NULL; if needed, non-fundamental callbacks can be set afterwards via setter functions
3459  * SCIPsetEventhdlrCopy(), SCIPsetEventhdlrFree(), SCIPsetEventhdlrInit(), SCIPsetEventhdlrExit(),
3460  * SCIPsetEventhdlrInitsol(), SCIPsetEventhdlrExitsol(), and SCIPsetEventhdlrDelete()
3461  *
3462  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeEventhdlr() instead
3463  */
3464 extern
3466  SCIP* scip, /**< SCIP data structure */
3467  SCIP_EVENTHDLR** eventhdlrptr, /**< reference to an event handler, or NULL */
3468  const char* name, /**< name of event handler */
3469  const char* desc, /**< description of event handler */
3470  SCIP_DECL_EVENTEXEC ((*eventexec)), /**< execute event handler */
3471  SCIP_EVENTHDLRDATA* eventhdlrdata /**< event handler data */
3472  );
3473 
3474 /** sets copy callback of the event handler */
3475 extern
3477  SCIP* scip, /**< scip instance */
3478  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3479  SCIP_DECL_EVENTCOPY ((*eventcopy)) /**< copy callback of the event handler */
3480  );
3481 
3482 /** sets deinitialization callback of the event handler */
3483 extern
3485  SCIP* scip, /**< scip instance */
3486  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3487  SCIP_DECL_EVENTFREE ((*eventfree)) /**< deinitialization callback of the event handler */
3488  );
3489 
3490 /** sets initialization callback of the event handler */
3491 extern
3493  SCIP* scip, /**< scip instance */
3494  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3495  SCIP_DECL_EVENTINIT ((*eventinit)) /**< initialize event handler */
3496  );
3497 
3498 /** sets deinitialization callback of the event handler */
3499 extern
3501  SCIP* scip, /**< scip instance */
3502  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3503  SCIP_DECL_EVENTEXIT ((*eventexit)) /**< deinitialize event handler */
3504  );
3505 
3506 /** sets solving process initialization callback of the event handler */
3507 extern
3509  SCIP* scip, /**< scip instance */
3510  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3511  SCIP_DECL_EVENTINITSOL((*eventinitsol)) /**< solving process initialization callback of event handler */
3512  );
3513 
3514 /** sets solving process deinitialization callback of the event handler */
3515 extern
3517  SCIP* scip, /**< scip instance */
3518  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3519  SCIP_DECL_EVENTEXITSOL((*eventexitsol)) /**< solving process deinitialization callback of event handler */
3520  );
3521 
3522 /** sets callback of the event handler to free specific event data */
3523 extern
3525  SCIP* scip, /**< scip instance */
3526  SCIP_EVENTHDLR* eventhdlr, /**< event handler */
3527  SCIP_DECL_EVENTDELETE ((*eventdelete)) /**< free specific event data */
3528  );
3529 
3530 /** returns the event handler of the given name, or NULL if not existing */
3531 extern
3533  SCIP* scip, /**< SCIP data structure */
3534  const char* name /**< name of event handler */
3535  );
3536 
3537 /** returns the array of currently available event handlers */
3538 extern
3540  SCIP* scip /**< SCIP data structure */
3541  );
3542 
3543 /** returns the number of currently available event handlers */
3544 extern
3545 int SCIPgetNEventhdlrs(
3546  SCIP* scip /**< SCIP data structure */
3547  );
3548 
3549 /** creates a node selector and includes it in SCIP.
3550  *
3551  * @note method has all node selector callbacks as arguments and is thus changed every time a new
3552  * callback is added in future releases; consider using SCIPincludeNodeselBasic() and setter functions
3553  * if you seek for a method which is less likely to change in future releases
3554  */
3555 extern
3557  SCIP* scip, /**< SCIP data structure */
3558  const char* name, /**< name of node selector */
3559  const char* desc, /**< description of node selector */
3560  int stdpriority, /**< priority of the node selector in standard mode */
3561  int memsavepriority, /**< priority of the node selector in memory saving mode */
3562  SCIP_DECL_NODESELCOPY ((*nodeselcopy)), /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
3563  SCIP_DECL_NODESELFREE ((*nodeselfree)), /**< destructor of node selector */
3564  SCIP_DECL_NODESELINIT ((*nodeselinit)), /**< initialize node selector */
3565  SCIP_DECL_NODESELEXIT ((*nodeselexit)), /**< deinitialize node selector */
3566  SCIP_DECL_NODESELINITSOL((*nodeselinitsol)),/**< solving process initialization method of node selector */
3567  SCIP_DECL_NODESELEXITSOL((*nodeselexitsol)),/**< solving process deinitialization method of node selector */
3568  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
3569  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
3570  SCIP_NODESELDATA* nodeseldata /**< node selector data */
3571  );
3572 
3573 /** Creates a node selector and includes it in SCIP with its most fundamental callbacks. All non-fundamental
3574  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
3575  * Optional callbacks can be set via specific setter functions, see SCIPsetNodeselCopy(), SCIPsetNodeselFree(),
3576  * SCIPsetNodeselInit(), SCIPsetNodeselExit(), SCIPsetNodeselInitsol(), and SCIPsetNodeselExitsol()
3577  *
3578  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeNodesel() instead
3579  */
3580 extern
3582  SCIP* scip, /**< SCIP data structure */
3583  SCIP_NODESEL** nodesel, /**< reference to a node selector, or NULL */
3584  const char* name, /**< name of node selector */
3585  const char* desc, /**< description of node selector */
3586  int stdpriority, /**< priority of the node selector in standard mode */
3587  int memsavepriority, /**< priority of the node selector in memory saving mode */
3588  SCIP_DECL_NODESELSELECT((*nodeselselect)),/**< node selection method */
3589  SCIP_DECL_NODESELCOMP ((*nodeselcomp)), /**< node comparison method */
3590  SCIP_NODESELDATA* nodeseldata /**< node selector data */
3591  );
3592 
3593 /** sets copy method of node selector */
3594 extern
3596  SCIP* scip, /**< SCIP data structure */
3597  SCIP_NODESEL* nodesel, /**< node selector */
3598  SCIP_DECL_NODESELCOPY ((*nodeselcopy)) /**< copy method of node selector or NULL if you don't want to copy your plugin into sub-SCIPs */
3599  );
3600 
3601 /** sets destructor method of node selector */
3602 extern
3604  SCIP* scip, /**< SCIP data structure */
3605  SCIP_NODESEL* nodesel, /**< node selector */
3606  SCIP_DECL_NODESELFREE ((*nodeselfree)) /**< destructor of node selector */
3607  );
3608 
3609 /** sets initialization method of node selector */
3610 extern
3612  SCIP* scip, /**< SCIP data structure */
3613  SCIP_NODESEL* nodesel, /**< node selector */
3614  SCIP_DECL_NODESELINIT ((*nodeselinit)) /**< initialize node selector */
3615  );
3616 
3617 /** sets deinitialization method of node selector */
3618 extern
3620  SCIP* scip, /**< SCIP data structure */
3621  SCIP_NODESEL* nodesel, /**< node selector */
3622  SCIP_DECL_NODESELEXIT ((*nodeselexit)) /**< deinitialize node selector */
3623  );
3624 
3625 /** sets solving process initialization method of node selector */
3626 extern
3628  SCIP* scip, /**< SCIP data structure */
3629  SCIP_NODESEL* nodesel, /**< node selector */
3630  SCIP_DECL_NODESELINITSOL ((*nodeselinitsol))/**< solving process initialization method of node selector */
3631  );
3632 
3633 /** sets solving process deinitialization method of node selector */
3634 extern
3636  SCIP* scip, /**< SCIP data structure */
3637  SCIP_NODESEL* nodesel, /**< node selector */
3638  SCIP_DECL_NODESELEXITSOL ((*nodeselexitsol))/**< solving process deinitialization method of node selector */
3639  );
3640 
3641 /** returns the node selector of the given name, or NULL if not existing */
3642 extern
3644  SCIP* scip, /**< SCIP data structure */
3645  const char* name /**< name of node selector */
3646  );
3647 
3648 /** returns the array of currently available node selectors */
3649 extern
3651  SCIP* scip /**< SCIP data structure */
3652  );
3653 
3654 /** returns the number of currently available node selectors */
3655 extern
3656 int SCIPgetNNodesels(
3657  SCIP* scip /**< SCIP data structure */
3658  );
3659 
3660 /** sets the priority of a node selector in standard mode */
3661 extern
3663  SCIP* scip, /**< SCIP data structure */
3664  SCIP_NODESEL* nodesel, /**< node selector */
3665  int priority /**< new standard priority of the node selector */
3666  );
3667 
3668 /** sets the priority of a node selector in memory saving mode */
3669 extern
3671  SCIP* scip, /**< SCIP data structure */
3672  SCIP_NODESEL* nodesel, /**< node selector */
3673  int priority /**< new memory saving priority of the node selector */
3674  );
3675 
3676 /** returns the currently used node selector */
3677 extern
3679  SCIP* scip /**< SCIP data structure */
3680  );
3681 
3682 /** creates a branching rule and includes it in SCIP
3683  *
3684  * @note method has all branching rule callbacks as arguments and is thus changed every time a new
3685  * callback is added in future releases; consider using SCIPincludeBranchruleBasic() and setter functions
3686  * if you seek for a method which is less likely to change in future releases
3687  */
3688 extern
3690  SCIP* scip, /**< SCIP data structure */
3691  const char* name, /**< name of branching rule */
3692  const char* desc, /**< description of branching rule */
3693  int priority, /**< priority of the branching rule */
3694  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
3695  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
3696  * compared to best node's dual bound for applying branching rule
3697  * (0.0: only on current best node, 1.0: on all nodes) */
3698  SCIP_DECL_BRANCHCOPY ((*branchcopy)), /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
3699  SCIP_DECL_BRANCHFREE ((*branchfree)), /**< destructor of branching rule */
3700  SCIP_DECL_BRANCHINIT ((*branchinit)), /**< initialize branching rule */
3701  SCIP_DECL_BRANCHEXIT ((*branchexit)), /**< deinitialize branching rule */
3702  SCIP_DECL_BRANCHINITSOL((*branchinitsol)),/**< solving process initialization method of branching rule */
3703  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)),/**< solving process deinitialization method of branching rule */
3704  SCIP_DECL_BRANCHEXECLP((*branchexeclp)), /**< branching execution method for fractional LP solutions */
3705  SCIP_DECL_BRANCHEXECEXT((*branchexecext)),/**< branching execution method for external candidates */
3706  SCIP_DECL_BRANCHEXECPS((*branchexecps)), /**< branching execution method for not completely fixed pseudo solutions */
3707  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
3708  );
3709 
3710 /** creates a branching rule and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
3711  * Optional callbacks can be set via specific setter functions, see SCIPsetBranchruleInit(), SCIPsetBranchruleExit(),
3712  * SCIPsetBranchruleCopy(), SCIPsetBranchruleFree(), SCIPsetBranchruleInitsol(), SCIPsetBranchruleExitsol(),
3713  * SCIPsetBranchruleExecLp(), SCIPsetBranchruleExecExt(), and SCIPsetBranchruleExecPs().
3714  *
3715  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeBranchrule() instead
3716  */
3717 extern
3719  SCIP* scip, /**< SCIP data structure */
3720  SCIP_BRANCHRULE** branchruleptr, /**< pointer to branching rule, or NULL */
3721  const char* name, /**< name of branching rule */
3722  const char* desc, /**< description of branching rule */
3723  int priority, /**< priority of the branching rule */
3724  int maxdepth, /**< maximal depth level, up to which this branching rule should be used (or -1) */
3725  SCIP_Real maxbounddist, /**< maximal relative distance from current node's dual bound to primal bound
3726  * compared to best node's dual bound for applying branching rule
3727  * (0.0: only on current best node, 1.0: on all nodes) */
3728  SCIP_BRANCHRULEDATA* branchruledata /**< branching rule data */
3729  );
3730 
3731 /** sets copy method of branching rule */
3732 extern
3734  SCIP* scip, /**< SCIP data structure */
3735  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3736  SCIP_DECL_BRANCHCOPY ((*branchcopy)) /**< copy method of branching rule or NULL if you don't want to copy your plugin into sub-SCIPs */
3737  );
3738 
3739 /** sets destructor method of branching rule */
3740 extern
3742  SCIP* scip, /**< SCIP data structure */
3743  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3744  SCIP_DECL_BRANCHFREE ((*branchfree)) /**< destructor of branching rule */
3745  );
3746 
3747 /** sets initialization method of branching rule */
3748 extern
3750  SCIP* scip, /**< SCIP data structure */
3751  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3752  SCIP_DECL_BRANCHINIT ((*branchinit)) /**< initialize branching rule */
3753  );
3754 
3755 /** sets deinitialization method of branching rule */
3756 extern
3758  SCIP* scip, /**< SCIP data structure */
3759  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3760  SCIP_DECL_BRANCHEXIT ((*branchexit)) /**< deinitialize branching rule */
3761  );
3762 
3763 /** sets solving process initialization method of branching rule */
3764 extern
3766  SCIP* scip, /**< SCIP data structure */
3767  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3768  SCIP_DECL_BRANCHINITSOL((*branchinitsol)) /**< solving process initialization method of branching rule */
3769  );
3770 
3771 /** sets solving process deinitialization method of branching rule */
3772 extern
3774  SCIP* scip, /**< SCIP data structure */
3775  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3776  SCIP_DECL_BRANCHEXITSOL((*branchexitsol)) /**< solving process deinitialization method of branching rule */
3777  );
3778 
3779 /** sets branching execution method for fractional LP solutions */
3780 extern
3782  SCIP* scip, /**< SCIP data structure */
3783  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3784  SCIP_DECL_BRANCHEXECLP((*branchexeclp)) /**< branching execution method for fractional LP solutions */
3785  );
3786 
3787 /** sets branching execution method for external candidates */
3788 extern
3790  SCIP* scip, /**< SCIP data structure */
3791  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3792  SCIP_DECL_BRANCHEXECEXT((*branchexecext)) /**< branching execution method for external candidates */
3793  );
3794 
3795 /** sets branching execution method for not completely fixed pseudo solutions */
3796 extern
3798  SCIP* scip, /**< SCIP data structure */
3799  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3800  SCIP_DECL_BRANCHEXECPS((*branchexecps)) /**< branching execution method for not completely fixed pseudo solutions */
3801  );
3802 
3803 /** returns the branching rule of the given name, or NULL if not existing */
3804 extern
3806  SCIP* scip, /**< SCIP data structure */
3807  const char* name /**< name of branching rule */
3808  );
3809 
3810 /** returns the array of currently available branching rules */
3811 extern
3813  SCIP* scip /**< SCIP data structure */
3814  );
3815 
3816 /** returns the number of currently available branching rules */
3817 extern
3819  SCIP* scip /**< SCIP data structure */
3820  );
3821 
3822 /** sets the priority of a branching rule */
3823 extern
3825  SCIP* scip, /**< SCIP data structure */
3826  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3827  int priority /**< new priority of the branching rule */
3828  );
3829 
3830 /** sets maximal depth level, up to which this branching rule should be used (-1 for no limit) */
3831 extern
3833  SCIP* scip, /**< SCIP data structure */
3834  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3835  int maxdepth /**< new maxdepth of the branching rule */
3836  );
3837 
3838 /** sets maximal relative distance from current node's dual bound to primal bound for applying branching rule */
3839 extern
3841  SCIP* scip, /**< SCIP data structure */
3842  SCIP_BRANCHRULE* branchrule, /**< branching rule */
3843  SCIP_Real maxbounddist /**< new maxbounddist of the branching rule */
3844  );
3845 
3846 /** creates a display column and includes it in SCIP */
3847 extern
3849  SCIP* scip, /**< SCIP data structure */
3850  const char* name, /**< name of display column */
3851  const char* desc, /**< description of display column */
3852  const char* header, /**< head line of display column */
3853  SCIP_DISPSTATUS dispstatus, /**< display activation status of display column */
3854  SCIP_DECL_DISPCOPY ((*dispcopy)), /**< copy method of display column or NULL if you don't want to copy your plugin into sub-SCIPs */
3855  SCIP_DECL_DISPFREE ((*dispfree)), /**< destructor of display column */
3856  SCIP_DECL_DISPINIT ((*dispinit)), /**< initialize display column */
3857  SCIP_DECL_DISPEXIT ((*dispexit)), /**< deinitialize display column */
3858  SCIP_DECL_DISPINITSOL ((*dispinitsol)), /**< solving process initialization method of display column */
3859  SCIP_DECL_DISPEXITSOL ((*dispexitsol)), /**< solving process deinitialization method of display column */
3860  SCIP_DECL_DISPOUTPUT ((*dispoutput)), /**< output method */
3861  SCIP_DISPDATA* dispdata, /**< display column data */
3862  int width, /**< width of display column (no. of chars used) */
3863  int priority, /**< priority of display column */
3864  int position, /**< relative position of display column */
3865  SCIP_Bool stripline /**< should the column be separated with a line from its right neighbor? */
3866  );
3867 
3868 /** returns the display column of the given name, or NULL if not existing */
3869 extern
3871  SCIP* scip, /**< SCIP data structure */
3872  const char* name /**< name of display column */
3873  );
3874 
3875 /** returns the array of currently available display columns */
3876 extern
3878  SCIP* scip /**< SCIP data structure */
3879  );
3880 
3881 /** returns the number of currently available display columns */
3882 extern
3883 int SCIPgetNDisps(
3884  SCIP* scip /**< SCIP data structure */
3885  );
3886 
3887 /** automatically selects display columns for being shown w.r.t. the display width parameter */
3888 extern
3890  SCIP* scip /**< SCIP data structure */
3891  );
3892 
3893 /** includes an NLPI in SCIP */
3894 extern
3896  SCIP* scip, /**< SCIP data structure */
3897  SCIP_NLPI* nlpi /**< NLPI data structure */
3898  );
3899 
3900 /** returns the NLPI of the given name, or NULL if not existing */
3901 extern
3903  SCIP* scip, /**< SCIP data structure */
3904  const char* name /**< name of NLPI */
3905  );
3906 
3907 /** returns the array of currently available NLPIs (sorted by priority) */
3908 extern
3910  SCIP* scip /**< SCIP data structure */
3911  );
3912 
3913 /** returns the number of currently available NLPIs */
3914 extern
3915 int SCIPgetNNlpis(
3916  SCIP* scip /**< SCIP data structure */
3917  );
3918 
3919 /** sets the priority of an NLPI */
3920 extern
3922  SCIP* scip, /**< SCIP data structure */
3923  SCIP_NLPI* nlpi, /**< NLPI */
3924  int priority /**< new priority of the NLPI */
3925  );
3926 
3927 /** includes information about an external code linked into the SCIP library */
3928 extern
3930  SCIP* scip, /**< SCIP data structure */
3931  const char* name, /**< name of external code */
3932  const char* description /**< description of external code, or NULL */
3933  );
3934 
3935 /** returns an array of names of currently included external codes */
3936 extern
3938  SCIP* scip /**< SCIP data structure */
3939  );
3940 
3941 /** returns an array of the descriptions of currently included external codes
3942  *
3943  * @note some descriptions may be NULL
3944  */
3945 extern
3947  SCIP* scip /**< SCIP data structure */
3948  );
3949 
3950 /** returns the number of currently included information on external codes */
3951 extern
3953  SCIP* scip /**< SCIP data structure */
3954  );
3955 
3956 /** prints information on external codes to a file stream via the message handler system
3957  *
3958  * @note If the message handler is set to a NULL pointer nothing will be printed
3959  */
3960 extern
3962  SCIP* scip, /**< SCIP data structure */
3963  FILE* file /**< output file (or NULL for standard output) */
3964  );
3965 
3966 /**@} */
3967 
3968 
3969 
3970 
3971 /*
3972  * user interactive dialog methods
3973  */
3974 
3975 /**@name User Interactive Dialog Methods */
3976 /**@{ */
3977 
3978 /** creates and includes dialog
3979  *
3980  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
3981  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
3982  */
3983 extern
3985  SCIP* scip, /**< SCIP data structure */
3986  SCIP_DIALOG** dialog, /**< pointer to store the dialog */
3987  SCIP_DECL_DIALOGCOPY ((*dialogcopy)), /**< copy method of dialog or NULL if you don't want to copy your plugin into sub-SCIPs */
3988  SCIP_DECL_DIALOGEXEC ((*dialogexec)), /**< execution method of dialog */
3989  SCIP_DECL_DIALOGDESC ((*dialogdesc)), /**< description output method of dialog, or NULL */
3990  SCIP_DECL_DIALOGFREE ((*dialogfree)), /**< destructor of dialog to free user data, or NULL */
3991  const char* name, /**< name of dialog: command name appearing in parent's dialog menu */
3992  const char* desc, /**< description of dialog used if description output method is NULL */
3993  SCIP_Bool issubmenu, /**< is the dialog a submenu? */
3994  SCIP_DIALOGDATA* dialogdata /**< user defined dialog data */
3995  );
3996 
3997 /** returns if the dialog already exists
3998  *
3999  * @return TRUE is returned if the dialog exits, otherwise FALSE.
4000  */
4001 extern
4003  SCIP* scip, /**< SCIP data structure */
4004  SCIP_DIALOG* dialog /**< dialog */
4005  );
4006 
4007 /** captures a dialog
4008  *
4009  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4010  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4011  */
4012 extern
4014  SCIP* scip, /**< SCIP data structure */
4015  SCIP_DIALOG* dialog /**< dialog */
4016  );
4017 
4018 /** releases a dialog
4019  *
4020  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4021  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4022  */
4023 extern
4025  SCIP* scip, /**< SCIP data structure */
4026  SCIP_DIALOG** dialog /**< pointer to the dialog */
4027  );
4028 
4029 /** makes given dialog the root dialog of SCIP's interactive user shell; captures dialog and releases former root dialog
4030  *
4031  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4032  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4033  */
4034 extern
4036  SCIP* scip, /**< SCIP data structure */
4037  SCIP_DIALOG* dialog /**< dialog to be the root */
4038  );
4039 
4040 /** returns the root dialog of SCIP's interactive user shell
4041  *
4042  * @return the root dialog of SCIP's interactive user shell is returned.
4043  */
4044 extern
4046  SCIP* scip /**< SCIP data structure */
4047  );
4048 
4049 /** adds a sub dialog to the given dialog as menu entry and captures it
4050  *
4051  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4052  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4053  */
4054 extern
4056  SCIP* scip, /**< SCIP data structure */
4057  SCIP_DIALOG* dialog, /**< dialog to extend, or NULL for root dialog */
4058  SCIP_DIALOG* subdialog /**< subdialog to add as menu entry in dialog */
4059  );
4060 
4061 /** adds a single line of input which is treated as if the user entered the command line
4062  *
4063  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4064  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4065  */
4066 extern
4068  SCIP* scip, /**< SCIP data structure */
4069  const char* inputline /**< input line to add */
4070  );
4071 
4072 /** adds a single line of input to the command history which can be accessed with the cursor keys
4073  *
4074  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4075  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4076  */
4077 extern
4079  SCIP* scip, /**< SCIP data structure */
4080  const char* inputline /**< input line to add */
4081  );
4082 
4083 /** starts interactive mode of SCIP by executing the root dialog
4084  *
4085  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4086  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4087  *
4088  * @pre This method can be called if @p scip is in one of the following stages:
4089  * - \ref SCIP_STAGE_INIT
4090  * - \ref SCIP_STAGE_FREE
4091  *
4092  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the
4093  * interactive shell was closed:
4094  * - \ref SCIP_STAGE_PROBLEM if the interactive shell was closed after the problem was created
4095  * - \ref SCIP_STAGE_TRANSFORMED if the interactive shell was closed after the problem was transformed
4096  * - \ref SCIP_STAGE_PRESOLVING if the interactive shell was closed during presolving
4097  * - \ref SCIP_STAGE_PRESOLVED if the interactive shell was closed after presolve
4098  * - \ref SCIP_STAGE_SOLVING if the interactive shell was closed during the tree search
4099  * - \ref SCIP_STAGE_SOLVED if the interactive shell was closed after the problem was solved
4100  * - \ref SCIP_STAGE_FREE if the interactive shell was closed after the problem was freed
4101  *
4102  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
4103  */
4104 extern
4106  SCIP* scip /**< SCIP data structure */
4107  );
4108 
4109 /**@} */
4110 
4111 
4112 
4113 
4114 /*
4115  * global problem methods
4116  */
4117 
4118 /**@name Global Problem Methods */
4119 /**@{ */
4120 
4121 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
4122  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
4123  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
4124  *
4125  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4126  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4127  *
4128  * @pre This method can be called if @p scip is in one of the following stages:
4129  * - \ref SCIP_STAGE_INIT
4130  * - \ref SCIP_STAGE_PROBLEM
4131  * - \ref SCIP_STAGE_TRANSFORMED
4132  * - \ref SCIP_STAGE_PRESOLVING
4133  * - \ref SCIP_STAGE_PRESOLVED
4134  * - \ref SCIP_STAGE_SOLVING
4135  * - \ref SCIP_STAGE_SOLVED
4136  * - \ref SCIP_STAGE_FREE
4137  *
4138  * @post After calling this method, \SCIP reaches the following stage:
4139  * - \ref SCIP_STAGE_PROBLEM
4140  */
4141 extern
4143  SCIP* scip, /**< SCIP data structure */
4144  const char* name, /**< problem name */
4145  SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
4146  SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
4147  SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
4148  SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
4149  SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
4150  SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
4151  SCIP_PROBDATA* probdata /**< user problem data set by the reader */
4152  );
4153 
4154 /** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
4155  * all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(),
4156  * SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and
4157  * SCIPsetProbCopy()
4158  * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
4159  * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
4160  *
4161  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4162  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4163  *
4164  * @pre This method can be called if @p scip is in one of the following stages:
4165  * - \ref SCIP_STAGE_INIT
4166  * - \ref SCIP_STAGE_PROBLEM
4167  * - \ref SCIP_STAGE_TRANSFORMED
4168  * - \ref SCIP_STAGE_PRESOLVING
4169  * - \ref SCIP_STAGE_PRESOLVED
4170  * - \ref SCIP_STAGE_SOLVING
4171  * - \ref SCIP_STAGE_SOLVED
4172  * - \ref SCIP_STAGE_FREE
4173  *
4174  * @post After calling this method, \SCIP reaches the following stage:
4175  * - \ref SCIP_STAGE_PROBLEM
4176  */
4177 extern
4179  SCIP* scip, /**< SCIP data structure */
4180  const char* name /**< problem name */
4181  );
4182 
4183 /** sets callback to free user data of original problem
4184  *
4185  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4186  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4187  *
4188  * @pre This method can be called if @p scip is in one of the following stages:
4189  * - \ref SCIP_STAGE_PROBLEM
4190  */
4192  SCIP* scip, /**< SCIP data structure */
4193  SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
4194  );
4195 
4196 /** sets callback to create user data of transformed problem by transforming original user data
4197  *
4198  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4199  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4200  *
4201  * @pre This method can be called if @p scip is in one of the following stages:
4202  * - \ref SCIP_STAGE_PROBLEM
4203  */
4204 extern
4206  SCIP* scip, /**< SCIP data structure */
4207  SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
4208  );
4209 
4210 /** sets callback to free user data of transformed problem
4211  *
4212  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4213  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4214  *
4215  * @pre This method can be called if @p scip is in one of the following stages:
4216  * - \ref SCIP_STAGE_PROBLEM
4217  */
4218 extern
4220  SCIP* scip, /**< SCIP data structure */
4221  SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
4222  );
4223 
4224 /** sets solving process initialization callback of transformed data
4225  *
4226  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4227  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4228  *
4229  * @pre This method can be called if @p scip is in one of the following stages:
4230  * - \ref SCIP_STAGE_PROBLEM
4231  */
4232 extern
4234  SCIP* scip, /**< SCIP data structure */
4235  SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization method of transformed data */
4236  );
4237 
4238 /** sets solving process deinitialization callback of transformed data
4239  *
4240  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4241  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4242  *
4243  * @pre This method can be called if @p scip is in one of the following stages:
4244  * - \ref SCIP_STAGE_PROBLEM
4245  */
4246 extern
4248  SCIP* scip, /**< SCIP data structure */
4249  SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization method of transformed data */
4250  );
4251 
4252 /** sets callback to copy user data to a subscip
4253  *
4254  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4255  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4256  *
4257  * @pre This method can be called if @p scip is in one of the following stages:
4258  * - \ref SCIP_STAGE_PROBLEM
4259  */
4260 extern
4262  SCIP* scip, /**< SCIP data structure */
4263  SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
4264  );
4265 
4266 /** reads problem from file and initializes all solving data structures
4267  *
4268  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4269  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4270  *
4271  * @pre This method can be called if @p scip is in one of the following stages:
4272  * - \ref SCIP_STAGE_INIT
4273  * - \ref SCIP_STAGE_PROBLEM
4274  * - \ref SCIP_STAGE_TRANSFORMED
4275  * - \ref SCIP_STAGE_INITPRESOLVE
4276  * - \ref SCIP_STAGE_PRESOLVING
4277  * - \ref SCIP_STAGE_EXITPRESOLVE
4278  * - \ref SCIP_STAGE_PRESOLVED
4279  * - \ref SCIP_STAGE_SOLVING
4280  * - \ref SCIP_STAGE_EXITSOLVE
4281  *
4282  * @post After the method was called, \SCIP is in one of the following stages:
4283  * -\ref SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
4284  * - ref SCIP_STAGE_PROBLEM if the problem file was successfully read
4285  */
4286 extern
4288  SCIP* scip, /**< SCIP data structure */
4289  const char* filename, /**< problem file name */
4290  const char* extension /**< extension of the desired file reader,
4291  * or NULL if file extension should be used */
4292  );
4293 
4294 /** writes original problem to file
4295  *
4296  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4297  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4298  *
4299  * @pre This method can be called if @p scip is in one of the following stages:
4300  * - \ref SCIP_STAGE_PROBLEM
4301  * - \ref SCIP_STAGE_TRANSFORMING
4302  * - \ref SCIP_STAGE_TRANSFORMED
4303  * - \ref SCIP_STAGE_INITPRESOLVE
4304  * - \ref SCIP_STAGE_PRESOLVING
4305  * - \ref SCIP_STAGE_EXITPRESOLVE
4306  * - \ref SCIP_STAGE_PRESOLVED
4307  * - \ref SCIP_STAGE_INITSOLVE
4308  * - \ref SCIP_STAGE_SOLVING
4309  * - \ref SCIP_STAGE_SOLVED
4310  * - \ref SCIP_STAGE_EXITSOLVE
4311  * - \ref SCIP_STAGE_FREETRANS
4312  */
4313 extern
4315  SCIP* scip, /**< SCIP data structure */
4316  const char* filename, /**< output file (or NULL for standard output) */
4317  const char* extension, /**< extension of the desired file reader,
4318  * or NULL if file extension should be used */
4319  SCIP_Bool genericnames /**< use generic variable and constraint names? */
4320  );
4321 
4322 /** writes transformed problem which are valid in the current node to file
4323  *
4324  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4325  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4326  *
4327  * @pre This method can be called if @p scip is in one of the following stages:
4328  * - \ref SCIP_STAGE_TRANSFORMED
4329  * - \ref SCIP_STAGE_INITPRESOLVE
4330  * - \ref SCIP_STAGE_PRESOLVING
4331  * - \ref SCIP_STAGE_EXITPRESOLVE
4332  * - \ref SCIP_STAGE_PRESOLVED
4333  * - \ref SCIP_STAGE_INITSOLVE
4334  * - \ref SCIP_STAGE_SOLVING
4335  * - \ref SCIP_STAGE_SOLVED
4336  * - \ref SCIP_STAGE_EXITSOLVE
4337  *
4338  * @note If you want the write all constraints (including the once which are redundant for example), you need to set
4339  * the parameter <write/allconss> to TRUE
4340  */
4341 extern
4343  SCIP* scip, /**< SCIP data structure */
4344  const char* filename, /**< output file (or NULL for standard output) */
4345  const char* extension, /**< extension of the desired file reader,
4346  * or NULL if file extension should be used */
4347  SCIP_Bool genericnames /**< using generic variable and constraint names? */
4348  );
4349 
4350 /** frees problem and solution process data
4351  *
4352  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4353  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4354  *
4355  * @pre This method can be called if @p scip is in one of the following stages:
4356  * - \ref SCIP_STAGE_INIT
4357  * - \ref SCIP_STAGE_PROBLEM
4358  * - \ref SCIP_STAGE_TRANSFORMED
4359  * - \ref SCIP_STAGE_PRESOLVING
4360  * - \ref SCIP_STAGE_PRESOLVED
4361  * - \ref SCIP_STAGE_SOLVING
4362  * - \ref SCIP_STAGE_SOLVED
4363  * - \ref SCIP_STAGE_FREE
4364  *
4365  * @post After this method was called, SCIP is in the following stage:
4366  * - \ref SCIP_STAGE_INIT
4367  */
4368 extern
4370  SCIP* scip /**< SCIP data structure */
4371  );
4372 
4373 /** permutes parts of the problem data structure
4374  *
4375  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4376  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4377  *
4378  * @pre This method can be called if @p scip is in one of the following stages:
4379  * - \ref SCIP_STAGE_PROBLEM
4380  * - \ref SCIP_STAGE_TRANSFORMED
4381  */
4382 extern
4384  SCIP* scip, /**< SCIP data structure */
4385  unsigned int randseed, /**< seed value for random generator */
4386  SCIP_Bool permuteconss, /**< should the list of constraints in each constraint handler be permuted? */
4387  SCIP_Bool permutebinvars, /**< should the list of binary variables be permuted? */
4388  SCIP_Bool permuteintvars, /**< should the list of integer variables be permuted? */
4389  SCIP_Bool permuteimplvars, /**< should the list of implicit integer variables be permuted? */
4390  SCIP_Bool permutecontvars /**< should the list of continuous integer variables be permuted? */
4391  );
4392 
4393 /** gets user problem data
4394  *
4395  * @return a SCIP_PROBDATA pointer, or NULL if no problem data was allocated
4396  *
4397  * @pre This method can be called if @p scip is in one of the following stages:
4398  * - \ref SCIP_STAGE_PROBLEM
4399  * - \ref SCIP_STAGE_TRANSFORMING
4400  * - \ref SCIP_STAGE_TRANSFORMED
4401  * - \ref SCIP_STAGE_INITPRESOLVE
4402  * - \ref SCIP_STAGE_PRESOLVING
4403  * - \ref SCIP_STAGE_EXITPRESOLVE
4404  * - \ref SCIP_STAGE_PRESOLVED
4405  * - \ref SCIP_STAGE_INITSOLVE
4406  * - \ref SCIP_STAGE_SOLVING
4407  * - \ref SCIP_STAGE_SOLVED
4408  * - \ref SCIP_STAGE_EXITSOLVE
4409  * - \ref SCIP_STAGE_FREETRANS
4410  */
4411 extern
4413  SCIP* scip /**< SCIP data structure */
4414  );
4415 
4416 /** sets user problem data
4417  *
4418  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4419  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4420  *
4421  * @pre This method can be called if @p scip is in one of the following stages:
4422  * - \ref SCIP_STAGE_PROBLEM
4423  * - \ref SCIP_STAGE_TRANSFORMING
4424  * - \ref SCIP_STAGE_TRANSFORMED
4425  * - \ref SCIP_STAGE_INITPRESOLVE
4426  * - \ref SCIP_STAGE_PRESOLVING
4427  * - \ref SCIP_STAGE_EXITPRESOLVE
4428  * - \ref SCIP_STAGE_PRESOLVED
4429  * - \ref SCIP_STAGE_INITSOLVE
4430  * - \ref SCIP_STAGE_SOLVING
4431  * - \ref SCIP_STAGE_SOLVED
4432  * - \ref SCIP_STAGE_EXITSOLVE
4433  * - \ref SCIP_STAGE_FREETRANS
4434  */
4435 extern
4437  SCIP* scip, /**< SCIP data structure */
4438  SCIP_PROBDATA* probdata /**< user problem data to use */
4439  );
4440 
4441 /** returns name of the current problem instance
4442  *
4443  * @return name of the current problem instance
4444  *
4445  * @pre This method can be called if @p scip is in one of the following stages:
4446  * - \ref SCIP_STAGE_PROBLEM
4447  * - \ref SCIP_STAGE_TRANSFORMING
4448  * - \ref SCIP_STAGE_TRANSFORMED
4449  * - \ref SCIP_STAGE_INITPRESOLVE
4450  * - \ref SCIP_STAGE_PRESOLVING
4451  * - \ref SCIP_STAGE_EXITPRESOLVE
4452  * - \ref SCIP_STAGE_PRESOLVED
4453  * - \ref SCIP_STAGE_INITSOLVE
4454  * - \ref SCIP_STAGE_SOLVING
4455  * - \ref SCIP_STAGE_SOLVED
4456  * - \ref SCIP_STAGE_EXITSOLVE
4457  * - \ref SCIP_STAGE_FREETRANS
4458  */
4459 extern
4460 const char* SCIPgetProbName(
4461  SCIP* scip /**< SCIP data structure */
4462  );
4463 
4464 /** sets name of the current problem instance
4465  *
4466  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4467  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4468  *
4469  * @pre This method can be called if @p scip is in one of the following stages:
4470  * - \ref SCIP_STAGE_PROBLEM
4471  * - \ref SCIP_STAGE_TRANSFORMING
4472  * - \ref SCIP_STAGE_TRANSFORMED
4473  * - \ref SCIP_STAGE_INITPRESOLVE
4474  * - \ref SCIP_STAGE_PRESOLVING
4475  * - \ref SCIP_STAGE_EXITPRESOLVE
4476  * - \ref SCIP_STAGE_PRESOLVED
4477  * - \ref SCIP_STAGE_INITSOLVE
4478  * - \ref SCIP_STAGE_SOLVING
4479  * - \ref SCIP_STAGE_SOLVED
4480  * - \ref SCIP_STAGE_EXITSOLVE
4481  * - \ref SCIP_STAGE_FREETRANS
4482  */
4483 extern
4485  SCIP* scip, /**< SCIP data structure */
4486  const char* name /**< name to be set */
4487  );
4488 
4489 /** returns objective sense of original problem
4490  *
4491  * @return objective sense of original problem
4492  *
4493  * @pre This method can be called if @p scip is in one of the following stages:
4494  * - \ref SCIP_STAGE_PROBLEM
4495  * - \ref SCIP_STAGE_TRANSFORMING
4496  * - \ref SCIP_STAGE_TRANSFORMED
4497  * - \ref SCIP_STAGE_INITPRESOLVE
4498  * - \ref SCIP_STAGE_PRESOLVING
4499  * - \ref SCIP_STAGE_EXITPRESOLVE
4500  * - \ref SCIP_STAGE_PRESOLVED
4501  * - \ref SCIP_STAGE_INITSOLVE
4502  * - \ref SCIP_STAGE_SOLVING
4503  * - \ref SCIP_STAGE_SOLVED
4504  * - \ref SCIP_STAGE_EXITSOLVE
4505  * - \ref SCIP_STAGE_FREETRANS
4506  */
4507 extern
4509  SCIP* scip /**< SCIP data structure */
4510  );
4511 
4512 /** sets objective sense of problem
4513  *
4514  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4515  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4516  *
4517  * @pre This method can be called if @p scip is in one of the following stages:
4518  * - \ref SCIP_STAGE_PROBLEM
4519  */
4520 extern
4522  SCIP* scip, /**< SCIP data structure */
4523  SCIP_OBJSENSE objsense /**< new objective sense */
4524  );
4525 
4526 /** adds offset of objective function
4527  *
4528  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4529  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4530  *
4531  * @pre This method can be called if @p scip is in one of the following stages:
4532  * - \ref SCIP_STAGE_PRESOLVING
4533  */
4534 extern
4536  SCIP* scip, /**< SCIP data structure */
4537  SCIP_Real addval /**< value to add to objective offset */
4538  );
4539 
4540 /** adds offset of objective function to original problem and to all existing solution in original space
4541  *
4542  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4543  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4544  *
4545  * @pre This method can be called if @p scip is in one of the following stages:
4546  * - \ref SCIP_STAGE_PROBLEM
4547  */
4548 extern
4550  SCIP* scip, /**< SCIP data structure */
4551  SCIP_Real addval /**< value to add to objective offset */
4552  );
4553 
4554 /** returns the objective offset of the original problem
4555  *
4556  * @return the objective offset of the original problem
4557  *
4558  * @pre This method can be called if @p scip is in one of the following stages:
4559  * - \ref SCIP_STAGE_PROBLEM
4560  * - \ref SCIP_STAGE_TRANSFORMING
4561  * - \ref SCIP_STAGE_TRANSFORMED
4562  * - \ref SCIP_STAGE_INITPRESOLVE
4563  * - \ref SCIP_STAGE_PRESOLVING
4564  * - \ref SCIP_STAGE_EXITPRESOLVE
4565  * - \ref SCIP_STAGE_PRESOLVED
4566  * - \ref SCIP_STAGE_INITSOLVE
4567  * - \ref SCIP_STAGE_SOLVING
4568  * - \ref SCIP_STAGE_SOLVED
4569  */
4570 extern
4572  SCIP* scip /**< SCIP data structure */
4573  );
4574 
4575 /** returns the objective scale of the original problem
4576  *
4577  * @return the objective scale of the original problem
4578  *
4579  * @pre This method can be called if @p scip is in one of the following stages:
4580  * - \ref SCIP_STAGE_PROBLEM
4581  * - \ref SCIP_STAGE_TRANSFORMING
4582  * - \ref SCIP_STAGE_TRANSFORMED
4583  * - \ref SCIP_STAGE_INITPRESOLVE
4584  * - \ref SCIP_STAGE_PRESOLVING
4585  * - \ref SCIP_STAGE_EXITPRESOLVE
4586  * - \ref SCIP_STAGE_PRESOLVED
4587  * - \ref SCIP_STAGE_INITSOLVE
4588  * - \ref SCIP_STAGE_SOLVING
4589  * - \ref SCIP_STAGE_SOLVED
4590  */
4591 extern
4593  SCIP* scip /**< SCIP data structure */
4594  );
4595 
4596 /** returns the objective offset of the transformed problem
4597  *
4598  * @return the objective offset of the transformed problem
4599  *
4600  * @pre This method can be called if @p scip is in one of the following stages:
4601  * - \ref SCIP_STAGE_TRANSFORMED
4602  * - \ref SCIP_STAGE_INITPRESOLVE
4603  * - \ref SCIP_STAGE_PRESOLVING
4604  * - \ref SCIP_STAGE_EXITPRESOLVE
4605  * - \ref SCIP_STAGE_PRESOLVED
4606  * - \ref SCIP_STAGE_INITSOLVE
4607  * - \ref SCIP_STAGE_SOLVING
4608  * - \ref SCIP_STAGE_SOLVED
4609  */
4610 extern
4612  SCIP* scip /**< SCIP data structure */
4613  );
4614 
4615 /** returns the objective scale of the transformed problem
4616  *
4617  * @return the objective scale of the transformed problem
4618  *
4619  * @pre This method can be called if @p scip is in one of the following stages:
4620  * - \ref SCIP_STAGE_TRANSFORMED
4621  * - \ref SCIP_STAGE_INITPRESOLVE
4622  * - \ref SCIP_STAGE_PRESOLVING
4623  * - \ref SCIP_STAGE_EXITPRESOLVE
4624  * - \ref SCIP_STAGE_PRESOLVED
4625  * - \ref SCIP_STAGE_INITSOLVE
4626  * - \ref SCIP_STAGE_SOLVING
4627  * - \ref SCIP_STAGE_SOLVED
4628  */
4629 extern
4631  SCIP* scip /**< SCIP data structure */
4632  );
4633 
4634 /** sets limit on objective function, such that only solutions better than this limit are accepted
4635  *
4636  * @note SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune
4637  * all branch-and-bound nodes with dual bound equal or worse to the objective limit.
4638  * However, SCIP will also collect solutions with objective value worse than the objective limit and
4639  * use them to run improvement heuristics on them.
4640  * @note If SCIP can prove that there exists no solution with a strictly better objective value, the solving status
4641  * will normally be infeasible (the objective limit is interpreted as part of the problem).
4642  * The only exception is that by chance, SCIP found a solution with the same objective value and thus
4643  * proved the optimality of this solution, resulting in solution status optimal.
4644  *
4645  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4646  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4647  *
4648  * @pre This method can be called if @p scip is in one of the following stages:
4649  * - \ref SCIP_STAGE_PROBLEM
4650  * - \ref SCIP_STAGE_TRANSFORMED
4651  * - \ref SCIP_STAGE_INITPRESOLVE
4652  * - \ref SCIP_STAGE_PRESOLVING
4653  * - \ref SCIP_STAGE_EXITPRESOLVE
4654  * - \ref SCIP_STAGE_PRESOLVED
4655  * - \ref SCIP_STAGE_SOLVING
4656  */
4657 extern
4659  SCIP* scip, /**< SCIP data structure */
4660  SCIP_Real objlimit /**< new primal objective limit */
4661  );
4662 
4663 /** returns current limit on objective function
4664  *
4665  * @return the current objective limit of the original problem
4666  *
4667  * @pre This method can be called if @p scip is in one of the following stages:
4668  * - \ref SCIP_STAGE_PROBLEM
4669  * - \ref SCIP_STAGE_TRANSFORMING
4670  * - \ref SCIP_STAGE_TRANSFORMED
4671  * - \ref SCIP_STAGE_INITPRESOLVE
4672  * - \ref SCIP_STAGE_PRESOLVING
4673  * - \ref SCIP_STAGE_EXITPRESOLVE
4674  * - \ref SCIP_STAGE_PRESOLVED
4675  * - \ref SCIP_STAGE_INITSOLVE
4676  * - \ref SCIP_STAGE_SOLVING
4677  * - \ref SCIP_STAGE_SOLVED
4678  */
4679 extern
4681  SCIP* scip /**< SCIP data structure */
4682  );
4683 
4684 /** informs SCIP, that the objective value is always integral in every feasible solution
4685  *
4686  * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
4687  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4688  *
4689  * @pre This method can be called if @p scip is in one of the following stages:
4690  * - \ref SCIP_STAGE_PROBLEM
4691  * - \ref SCIP_STAGE_TRANSFORMING
4692  * - \ref SCIP_STAGE_INITPRESOLVE
4693  * - \ref SCIP_STAGE_EXITPRESOLVE
4694  * - \ref SCIP_STAGE_SOLVING
4695  */
4696 extern
4698  SCIP* scip /**< SCIP data structure */
4699  );
4700 
4701 /** returns whether the objective value is known to be integral in every feasible solution
4702  *
4703  * @return TRUE, if objective value is known to be always integral, otherwise FALSE
4704  *
4705  * @pre This method can be called if @p scip is in one of the following stages:
4706  * - \ref SCIP_STAGE_PROBLEM
4707  * - \ref SCIP_STAGE_TRANSFORMING
4708  * - \ref SCIP_STAGE_INITPRESOLVE
4709  * - \ref SCIP_STAGE_PRESOLVING
4710  * - \ref SCIP_STAGE_EXITPRESOLVE
4711  * - \ref SCIP_STAGE_PRESOLVED
4712  * - \ref SCIP_STAGE_SOLVING
4713  */
4714 extern
4716  SCIP* scip /**< SCIP data structure */
4717  );
4718 
4719 /** returns the Euclidean norm of the objective function vector (available only for transformed problem)
4720  *
4721  * @return the Euclidean norm of the transformed objective function vector
4722  *
4723  * @pre This method can be called if @p scip is in one of the following stages:
4724  * - \ref SCIP_STAGE_TRANSFORMED
4725  * - \ref SCIP_STAGE_INITPRESOLVE
4726  * - \ref SCIP_STAGE_PRESOLVING
4727  * - \ref SCIP_STAGE_EXITPRESOLVE
4728  * - \ref SCIP_STAGE_PRESOLVED
4729  * - \ref SCIP_STAGE_INITSOLVE
4730  * - \ref SCIP_STAGE_SOLVING
4731  * - \ref SCIP_STAGE_SOLVED
4732  * - \ref SCIP_STAGE_EXITSOLVE
4733  */
4734 extern
4736  SCIP* scip /**< SCIP data structure */
4737  );
4738 
4739 /** adds variable to the problem
4740  *
4741  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4742  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4743  *
4744  * @pre This method can be called if @p scip is in one of the following stages:
4745  * - \ref SCIP_STAGE_PROBLEM
4746  * - \ref SCIP_STAGE_TRANSFORMING
4747  * - \ref SCIP_STAGE_INITPRESOLVE
4748  * - \ref SCIP_STAGE_PRESOLVING
4749  * - \ref SCIP_STAGE_EXITPRESOLVE
4750  * - \ref SCIP_STAGE_PRESOLVED
4751  * - \ref SCIP_STAGE_SOLVING
4752  */
4753 extern
4755  SCIP* scip, /**< SCIP data structure */
4756  SCIP_VAR* var /**< variable to add */
4757  );
4758 
4759 /** adds variable to the problem and uses it as pricing candidate to enter the LP
4760  *
4761  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4762  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4763  *
4764  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
4765  */
4766 extern
4768  SCIP* scip, /**< SCIP data structure */
4769  SCIP_VAR* var, /**< variable to add */
4770  SCIP_Real score /**< pricing score of variable (the larger, the better the variable) */
4771  );
4772 
4773 /** removes variable from the problem
4774  *
4775  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4776  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4777  *
4778  * @pre This method can be called if @p scip is in one of the following stages:
4779  * - \ref SCIP_STAGE_PROBLEM
4780  * - \ref SCIP_STAGE_TRANSFORMING
4781  * - \ref SCIP_STAGE_TRANSFORMED
4782  * - \ref SCIP_STAGE_PRESOLVING
4783  * - \ref SCIP_STAGE_PRESOLVED
4784  * - \ref SCIP_STAGE_SOLVING
4785  * - \ref SCIP_STAGE_EXITSOLVE
4786  * - \ref SCIP_STAGE_FREETRANS
4787  */
4788 extern
4790  SCIP* scip, /**< SCIP data structure */
4791  SCIP_VAR* var, /**< variable to delete */
4792  SCIP_Bool* deleted /**< pointer to store whether variable was successfully marked to be deleted */
4793  );
4794 
4795 /** gets variables of the problem along with the numbers of different variable types; data may become invalid after
4796  * calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
4797  *
4798  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
4799  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
4800  *
4801  * @pre This method can be called if @p scip is in one of the following stages:
4802  * - \ref SCIP_STAGE_PROBLEM
4803  * - \ref SCIP_STAGE_TRANSFORMED
4804  * - \ref SCIP_STAGE_INITPRESOLVE
4805  * - \ref SCIP_STAGE_PRESOLVING
4806  * - \ref SCIP_STAGE_EXITPRESOLVE
4807  * - \ref SCIP_STAGE_PRESOLVED
4808  * - \ref SCIP_STAGE_INITSOLVE
4809  * - \ref SCIP_STAGE_SOLVING
4810  * - \ref SCIP_STAGE_SOLVED
4811  * - \ref SCIP_STAGE_EXITSOLVE
4812  *
4813  * @note Variables in the vars array are ordered: binaries first, then integers, implicit integers and continuous last.
4814  */
4815 extern
4817  SCIP* scip, /**< SCIP data structure */
4818  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
4819  int* nvars, /**< pointer to store number of variables or NULL if not needed */
4820  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
4821  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
4822  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
4823  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
4824  );
4825 
4826 /** gets array with active problem variables
4827  *
4828  * @return array with active problem variables
4829  *
4830  * @pre This method can be called if @p scip is in one of the following stages:
4831  * - \ref SCIP_STAGE_PROBLEM
4832  * - \ref SCIP_STAGE_TRANSFORMED
4833  * - \ref SCIP_STAGE_INITPRESOLVE
4834  * - \ref SCIP_STAGE_PRESOLVING
4835  * - \ref SCIP_STAGE_EXITPRESOLVE
4836  * - \ref SCIP_STAGE_PRESOLVED
4837  * - \ref SCIP_STAGE_INITSOLVE
4838  * - \ref SCIP_STAGE_SOLVING
4839  * - \ref SCIP_STAGE_SOLVED
4840  * - \ref SCIP_STAGE_EXITSOLVE
4841  *
4842  * @warning If your are using the methods which add or change bound of variables (e.g., SCIPchgVarType(), SCIPfixVar(),
4843  * SCIPaggregateVars(), and SCIPmultiaggregateVar()), it can happen that the internal variable array (which is
4844  * accessed via this method) gets resized and/or resorted. This can invalid the data pointer which is returned
4845  * by this method.
4846  *
4847  * @note Variables in the array are ordered: binaries first, then integers, implicit integers and continuous last.
4848  */
4849 extern
4851  SCIP* scip /**< SCIP data structure */
4852  );
4853 
4854 /** gets number of active problem variables
4855  *
4856  * @return the number of active problem variables
4857  *
4858  * @pre This method can be called if @p scip is in one of the following stages:
4859  * - \ref SCIP_STAGE_PROBLEM
4860  * - \ref SCIP_STAGE_TRANSFORMED
4861  * - \ref SCIP_STAGE_INITPRESOLVE
4862  * - \ref SCIP_STAGE_PRESOLVING
4863  * - \ref SCIP_STAGE_EXITPRESOLVE
4864  * - \ref SCIP_STAGE_PRESOLVED
4865  * - \ref SCIP_STAGE_INITSOLVE
4866  * - \ref SCIP_STAGE_SOLVING
4867  * - \ref SCIP_STAGE_SOLVED
4868  * - \ref SCIP_STAGE_EXITSOLVE
4869  */
4870 extern
4871 int SCIPgetNVars(
4872  SCIP* scip /**< SCIP data structure */
4873  );
4874 
4875 /** gets number of binary active problem variables
4876  *
4877  * @return the number of binary active problem variables
4878  *
4879  * @pre This method can be called if @p scip is in one of the following stages:
4880  * - \ref SCIP_STAGE_PROBLEM
4881  * - \ref SCIP_STAGE_TRANSFORMED
4882  * - \ref SCIP_STAGE_INITPRESOLVE
4883  * - \ref SCIP_STAGE_PRESOLVING
4884  * - \ref SCIP_STAGE_EXITPRESOLVE
4885  * - \ref SCIP_STAGE_PRESOLVED
4886  * - \ref SCIP_STAGE_INITSOLVE
4887  * - \ref SCIP_STAGE_SOLVING
4888  * - \ref SCIP_STAGE_SOLVED
4889  * - \ref SCIP_STAGE_EXITSOLVE
4890  */
4891 extern
4892 int SCIPgetNBinVars(
4893  SCIP* scip /**< SCIP data structure */
4894  );
4895 
4896 /** gets number of integer active problem variables
4897  *
4898  * @return the number of integer active problem variables
4899  *
4900  * @pre This method can be called if @p scip is in one of the following stages:
4901  * - \ref SCIP_STAGE_PROBLEM
4902  * - \ref SCIP_STAGE_TRANSFORMED
4903  * - \ref SCIP_STAGE_INITPRESOLVE
4904  * - \ref SCIP_STAGE_PRESOLVING
4905  * - \ref SCIP_STAGE_EXITPRESOLVE
4906  * - \ref SCIP_STAGE_PRESOLVED
4907  * - \ref SCIP_STAGE_INITSOLVE
4908  * - \ref SCIP_STAGE_SOLVING
4909  * - \ref SCIP_STAGE_SOLVED
4910  * - \ref SCIP_STAGE_EXITSOLVE
4911  */
4912 extern
4913 int SCIPgetNIntVars(
4914  SCIP* scip /**< SCIP data structure */
4915  );
4916 
4917 /** gets number of implicit integer active problem variables
4918  *
4919  * @return the number of implicit integer active problem variables
4920  *
4921  * @pre This method can be called if @p scip is in one of the following stages:
4922  * - \ref SCIP_STAGE_PROBLEM
4923  * - \ref SCIP_STAGE_TRANSFORMED
4924  * - \ref SCIP_STAGE_INITPRESOLVE
4925  * - \ref SCIP_STAGE_PRESOLVING
4926  * - \ref SCIP_STAGE_EXITPRESOLVE
4927  * - \ref SCIP_STAGE_PRESOLVED
4928  * - \ref SCIP_STAGE_INITSOLVE
4929  * - \ref SCIP_STAGE_SOLVING
4930  * - \ref SCIP_STAGE_SOLVED
4931  * - \ref SCIP_STAGE_EXITSOLVE
4932  */
4933 extern
4934 int SCIPgetNImplVars(
4935  SCIP* scip /**< SCIP data structure */
4936  );
4937 
4938 /** gets number of continuous active problem variables
4939  *
4940  * @return the number of continuous active problem variables
4941  *
4942  * @pre This method can be called if @p scip is in one of the following stages:
4943  * - \ref SCIP_STAGE_PROBLEM
4944  * - \ref SCIP_STAGE_TRANSFORMED
4945  * - \ref SCIP_STAGE_INITPRESOLVE
4946  * - \ref SCIP_STAGE_PRESOLVING
4947  * - \ref SCIP_STAGE_EXITPRESOLVE
4948  * - \ref SCIP_STAGE_PRESOLVED
4949  * - \ref SCIP_STAGE_INITSOLVE
4950  * - \ref SCIP_STAGE_SOLVING
4951  * - \ref SCIP_STAGE_SOLVED
4952  * - \ref SCIP_STAGE_EXITSOLVE
4953  */
4954 extern
4955 int SCIPgetNContVars(
4956  SCIP* scip /**< SCIP data structure */
4957  );
4958 
4959 /** gets number of active problem variables with a non-zero objective coefficient
4960  *
4961  * @note In case of the original problem the number of variables is counted. In case of the transformed problem the
4962  * number of variables is just returned since it is stored internally
4963  *
4964  * @return the number of active problem variables with a non-zero objective coefficient
4965  *
4966  * @pre This method can be called if @p scip is in one of the following stages:
4967  * - \ref SCIP_STAGE_PROBLEM
4968  * - \ref SCIP_STAGE_TRANSFORMED
4969  * - \ref SCIP_STAGE_INITPRESOLVE
4970  * - \ref SCIP_STAGE_PRESOLVING
4971  * - \ref SCIP_STAGE_EXITPRESOLVE
4972  * - \ref SCIP_STAGE_PRESOLVED
4973  * - \ref SCIP_STAGE_INITSOLVE
4974  * - \ref SCIP_STAGE_SOLVING
4975  * - \ref SCIP_STAGE_SOLVED
4976  */
4977 extern
4978 int SCIPgetNObjVars(
4979  SCIP* scip /**< SCIP data structure */
4980  );
4981 
4982 /** gets array with fixed and aggregated problem variables; data may become invalid after
4983  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
4984  *
4985  * @return an array with fixed and aggregated problem variables; data may become invalid after
4986  * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
4987  *
4988  * @pre This method can be called if @p scip is in one of the following stages:
4989  * - \ref SCIP_STAGE_PROBLEM
4990  * - \ref SCIP_STAGE_TRANSFORMED
4991  * - \ref SCIP_STAGE_INITPRESOLVE
4992  * - \ref SCIP_STAGE_PRESOLVING
4993  * - \ref SCIP_STAGE_EXITPRESOLVE
4994  * - \ref SCIP_STAGE_PRESOLVED
4995  * - \ref SCIP_STAGE_INITSOLVE
4996  * - \ref SCIP_STAGE_SOLVING
4997  * - \ref SCIP_STAGE_SOLVED
4998  */
4999 extern
5001  SCIP* scip /**< SCIP data structure */
5002  );
5003 
5004 /** gets number of fixed or aggregated problem variables
5005  *
5006  * @return the number of fixed or aggregated problem variables
5007  *
5008  * @pre This method can be called if @p scip is in one of the following stages:
5009  * - \ref SCIP_STAGE_PROBLEM
5010  * - \ref SCIP_STAGE_TRANSFORMED
5011  * - \ref SCIP_STAGE_INITPRESOLVE
5012  * - \ref SCIP_STAGE_PRESOLVING
5013  * - \ref SCIP_STAGE_EXITPRESOLVE
5014  * - \ref SCIP_STAGE_PRESOLVED
5015  * - \ref SCIP_STAGE_INITSOLVE
5016  * - \ref SCIP_STAGE_SOLVING
5017  * - \ref SCIP_STAGE_SOLVED
5018  */
5019 extern
5020 int SCIPgetNFixedVars(
5021  SCIP* scip /**< SCIP data structure */
5022  );
5023 
5024 /** gets variables of the original problem along with the numbers of different variable types; data may become invalid
5025  * after a call to SCIPchgVarType()
5026  *
5027  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5028  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5029  *
5030  * @pre This method can be called if @p scip is in one of the following stages:
5031  * - \ref SCIP_STAGE_PROBLEM
5032  * - \ref SCIP_STAGE_TRANSFORMING
5033  * - \ref SCIP_STAGE_TRANSFORMED
5034  * - \ref SCIP_STAGE_INITPRESOLVE
5035  * - \ref SCIP_STAGE_PRESOLVING
5036  * - \ref SCIP_STAGE_EXITPRESOLVE
5037  * - \ref SCIP_STAGE_PRESOLVED
5038  * - \ref SCIP_STAGE_INITSOLVE
5039  * - \ref SCIP_STAGE_SOLVING
5040  * - \ref SCIP_STAGE_SOLVED
5041  * - \ref SCIP_STAGE_EXITSOLVE
5042  * - \ref SCIP_STAGE_FREETRANS
5043  */
5044 extern
5046  SCIP* scip, /**< SCIP data structure */
5047  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5048  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5049  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5050  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5051  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5052  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5053  );
5054 
5055 /** gets array with original problem variables; data may become invalid after
5056  * a call to SCIPchgVarType()
5057  *
5058  * @return an array with original problem variables; data may become invalid after
5059  * a call to SCIPchgVarType()
5060  *
5061  * @pre This method can be called if @p scip is in one of the following stages:
5062  * - \ref SCIP_STAGE_PROBLEM
5063  * - \ref SCIP_STAGE_TRANSFORMING
5064  * - \ref SCIP_STAGE_TRANSFORMED
5065  * - \ref SCIP_STAGE_INITPRESOLVE
5066  * - \ref SCIP_STAGE_PRESOLVING
5067  * - \ref SCIP_STAGE_EXITPRESOLVE
5068  * - \ref SCIP_STAGE_PRESOLVED
5069  * - \ref SCIP_STAGE_INITSOLVE
5070  * - \ref SCIP_STAGE_SOLVING
5071  * - \ref SCIP_STAGE_SOLVED
5072  * - \ref SCIP_STAGE_EXITSOLVE
5073  * - \ref SCIP_STAGE_FREETRANS
5074  */
5075 extern
5077  SCIP* scip /**< SCIP data structure */
5078  );
5079 
5080 /** gets number of original problem variables
5081  *
5082  * @return the number of original problem variables
5083  *
5084  * @pre This method can be called if @p scip is in one of the following stages:
5085  * - \ref SCIP_STAGE_PROBLEM
5086  * - \ref SCIP_STAGE_TRANSFORMING
5087  * - \ref SCIP_STAGE_TRANSFORMED
5088  * - \ref SCIP_STAGE_INITPRESOLVE
5089  * - \ref SCIP_STAGE_PRESOLVING
5090  * - \ref SCIP_STAGE_EXITPRESOLVE
5091  * - \ref SCIP_STAGE_PRESOLVED
5092  * - \ref SCIP_STAGE_INITSOLVE
5093  * - \ref SCIP_STAGE_SOLVING
5094  * - \ref SCIP_STAGE_SOLVED
5095  * - \ref SCIP_STAGE_EXITSOLVE
5096  * - \ref SCIP_STAGE_FREETRANS
5097  */
5098 extern
5099 int SCIPgetNOrigVars(
5100  SCIP* scip /**< SCIP data structure */
5101  );
5102 
5103 /** gets number of binary variables in the original problem
5104  *
5105  * @return the number of binary variables in the original problem
5106  *
5107  * @pre This method can be called if @p scip is in one of the following stages:
5108  * - \ref SCIP_STAGE_PROBLEM
5109  * - \ref SCIP_STAGE_TRANSFORMING
5110  * - \ref SCIP_STAGE_TRANSFORMED
5111  * - \ref SCIP_STAGE_INITPRESOLVE
5112  * - \ref SCIP_STAGE_PRESOLVING
5113  * - \ref SCIP_STAGE_EXITPRESOLVE
5114  * - \ref SCIP_STAGE_PRESOLVED
5115  * - \ref SCIP_STAGE_INITSOLVE
5116  * - \ref SCIP_STAGE_SOLVING
5117  * - \ref SCIP_STAGE_SOLVED
5118  * - \ref SCIP_STAGE_EXITSOLVE
5119  * - \ref SCIP_STAGE_FREETRANS
5120  */
5121 extern
5123  SCIP* scip /**< SCIP data structure */
5124  );
5125 
5126 /** gets the number of integer variables in the original problem
5127  *
5128  * @return the number of integer variables in the original problem
5129  *
5130  * @pre This method can be called if @p scip is in one of the following stages:
5131  * - \ref SCIP_STAGE_PROBLEM
5132  * - \ref SCIP_STAGE_TRANSFORMING
5133  * - \ref SCIP_STAGE_TRANSFORMED
5134  * - \ref SCIP_STAGE_INITPRESOLVE
5135  * - \ref SCIP_STAGE_PRESOLVING
5136  * - \ref SCIP_STAGE_EXITPRESOLVE
5137  * - \ref SCIP_STAGE_PRESOLVED
5138  * - \ref SCIP_STAGE_INITSOLVE
5139  * - \ref SCIP_STAGE_SOLVING
5140  * - \ref SCIP_STAGE_SOLVED
5141  * - \ref SCIP_STAGE_EXITSOLVE
5142  * - \ref SCIP_STAGE_FREETRANS
5143  */
5144 extern
5146  SCIP* scip /**< SCIP data structure */
5147  );
5148 
5149 /** gets number of implicit integer variables in the original problem
5150  *
5151  * @return the number of implicit integer variables in the original problem
5152  *
5153  * @pre This method can be called if @p scip is in one of the following stages:
5154  * - \ref SCIP_STAGE_PROBLEM
5155  * - \ref SCIP_STAGE_TRANSFORMING
5156  * - \ref SCIP_STAGE_TRANSFORMED
5157  * - \ref SCIP_STAGE_INITPRESOLVE
5158  * - \ref SCIP_STAGE_PRESOLVING
5159  * - \ref SCIP_STAGE_EXITPRESOLVE
5160  * - \ref SCIP_STAGE_PRESOLVED
5161  * - \ref SCIP_STAGE_INITSOLVE
5162  * - \ref SCIP_STAGE_SOLVING
5163  * - \ref SCIP_STAGE_SOLVED
5164  * - \ref SCIP_STAGE_EXITSOLVE
5165  * - \ref SCIP_STAGE_FREETRANS
5166  */
5167 extern
5169  SCIP* scip /**< SCIP data structure */
5170  );
5171 
5172 /** gets number of continuous variables in the original problem
5173  *
5174  * @return the number of continuous variables in the original problem
5175  *
5176  * @pre This method can be called if @p scip is in one of the following stages:
5177  * - \ref SCIP_STAGE_PROBLEM
5178  * - \ref SCIP_STAGE_TRANSFORMING
5179  * - \ref SCIP_STAGE_TRANSFORMED
5180  * - \ref SCIP_STAGE_INITPRESOLVE
5181  * - \ref SCIP_STAGE_PRESOLVING
5182  * - \ref SCIP_STAGE_EXITPRESOLVE
5183  * - \ref SCIP_STAGE_PRESOLVED
5184  * - \ref SCIP_STAGE_INITSOLVE
5185  * - \ref SCIP_STAGE_SOLVING
5186  * - \ref SCIP_STAGE_SOLVED
5187  * - \ref SCIP_STAGE_EXITSOLVE
5188  * - \ref SCIP_STAGE_FREETRANS
5189  */
5190 extern
5192  SCIP* scip /**< SCIP data structure */
5193  );
5194 
5195 /** gets number of all problem variables created during creation and solving of problem;
5196  * this includes also variables that were deleted in the meantime
5197  *
5198  * @return the number of all problem variables created during creation and solving of problem;
5199  * this includes also variables that were deleted in the meantime
5200  *
5201  * @pre This method can be called if @p scip is in one of the following stages:
5202  * - \ref SCIP_STAGE_PROBLEM
5203  * - \ref SCIP_STAGE_TRANSFORMING
5204  * - \ref SCIP_STAGE_TRANSFORMED
5205  * - \ref SCIP_STAGE_INITPRESOLVE
5206  * - \ref SCIP_STAGE_PRESOLVING
5207  * - \ref SCIP_STAGE_EXITPRESOLVE
5208  * - \ref SCIP_STAGE_PRESOLVED
5209  * - \ref SCIP_STAGE_INITSOLVE
5210  * - \ref SCIP_STAGE_SOLVING
5211  * - \ref SCIP_STAGE_SOLVED
5212  * - \ref SCIP_STAGE_EXITSOLVE
5213  * - \ref SCIP_STAGE_FREETRANS
5214  */
5215 extern
5216 int SCIPgetNTotalVars(
5217  SCIP* scip /**< SCIP data structure */
5218  );
5219 
5220 /** gets variables of the original or transformed problem along with the numbers of different variable types;
5221  * the returned problem space (original or transformed) corresponds to the given solution;
5222  * data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and
5223  * SCIPmultiaggregateVar()
5224  *
5225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5227  *
5228  * @pre This method can be called if @p scip is in one of the following stages:
5229  * - \ref SCIP_STAGE_PROBLEM
5230  * - \ref SCIP_STAGE_TRANSFORMED
5231  * - \ref SCIP_STAGE_INITPRESOLVE
5232  * - \ref SCIP_STAGE_PRESOLVING
5233  * - \ref SCIP_STAGE_EXITPRESOLVE
5234  * - \ref SCIP_STAGE_PRESOLVED
5235  * - \ref SCIP_STAGE_INITSOLVE
5236  * - \ref SCIP_STAGE_SOLVING
5237  * - \ref SCIP_STAGE_SOLVED
5238  */
5239 extern
5241  SCIP* scip, /**< SCIP data structure */
5242  SCIP_SOL* sol, /**< primal solution that selects the problem space, NULL for current solution */
5243  SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
5244  int* nvars, /**< pointer to store number of variables or NULL if not needed */
5245  int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
5246  int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
5247  int* nimplvars, /**< pointer to store number of implicit integral vars or NULL if not needed */
5248  int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
5249  );
5250 
5251 /** returns variable of given name in the problem, or NULL if not existing
5252  *
5253  * @return variable of given name in the problem, or NULL if not existing
5254  *
5255  * @pre This method can be called if @p scip is in one of the following stages:
5256  * - \ref SCIP_STAGE_PROBLEM
5257  * - \ref SCIP_STAGE_TRANSFORMING
5258  * - \ref SCIP_STAGE_TRANSFORMED
5259  * - \ref SCIP_STAGE_INITPRESOLVE
5260  * - \ref SCIP_STAGE_PRESOLVING
5261  * - \ref SCIP_STAGE_EXITPRESOLVE
5262  * - \ref SCIP_STAGE_PRESOLVED
5263  * - \ref SCIP_STAGE_INITSOLVE
5264  * - \ref SCIP_STAGE_SOLVING
5265  * - \ref SCIP_STAGE_SOLVED
5266  * - \ref SCIP_STAGE_EXITSOLVE
5267  * - \ref SCIP_STAGE_FREETRANS
5268  */
5269 extern
5271  SCIP* scip, /**< SCIP data structure */
5272  const char* name /**< name of variable to find */
5273  );
5274 
5275 /** returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables,
5276  * that will be added in pricing and improve the objective value
5277  *
5278  * @return TRUE, if all potential variables exist in the problem; FALSE, otherwise
5279  *
5280  * @pre This method can be called if @p scip is in one of the following stages:
5281  * - \ref SCIP_STAGE_TRANSFORMING
5282  * - \ref SCIP_STAGE_TRANSFORMED
5283  * - \ref SCIP_STAGE_INITPRESOLVE
5284  * - \ref SCIP_STAGE_PRESOLVING
5285  * - \ref SCIP_STAGE_EXITPRESOLVE
5286  * - \ref SCIP_STAGE_PRESOLVED
5287  * - \ref SCIP_STAGE_INITSOLVE
5288  * - \ref SCIP_STAGE_SOLVING
5289  * - \ref SCIP_STAGE_SOLVED
5290  * - \ref SCIP_STAGE_EXITSOLVE
5291  * - \ref SCIP_STAGE_FREETRANS
5292  */
5293 extern
5295  SCIP* scip /**< SCIP data structure */
5296  );
5297 
5298 /** adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the
5299  * current node (and all of its subnodes); otherwise it is added to the global problem;
5300  * if a local constraint is added at the root node, it is automatically upgraded into a global constraint
5301  *
5302  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5303  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5304  *
5305  * @pre This method can be called if @p scip is in one of the following stages:
5306  * - \ref SCIP_STAGE_PROBLEM
5307  * - \ref SCIP_STAGE_INITPRESOLVE
5308  * - \ref SCIP_STAGE_PRESOLVING
5309  * - \ref SCIP_STAGE_EXITPRESOLVE
5310  * - \ref SCIP_STAGE_PRESOLVED
5311  * - \ref SCIP_STAGE_INITSOLVE
5312  * - \ref SCIP_STAGE_SOLVING
5313  * - \ref SCIP_STAGE_EXITSOLVE
5314  */
5315 extern
5317  SCIP* scip, /**< SCIP data structure */
5318  SCIP_CONS* cons /**< constraint to add */
5319  );
5320 
5321 /** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
5322  * node, where it was added, or from the problem, if it was a problem constraint
5323  *
5324  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5325  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5326  *
5327  * @pre This method can be called if @p scip is in one of the following stages:
5328  * - \ref SCIP_STAGE_PROBLEM
5329  * - \ref SCIP_STAGE_INITPRESOLVE
5330  * - \ref SCIP_STAGE_PRESOLVING
5331  * - \ref SCIP_STAGE_EXITPRESOLVE
5332  * - \ref SCIP_STAGE_INITSOLVE
5333  * - \ref SCIP_STAGE_SOLVING
5334  */
5335 extern
5337  SCIP* scip, /**< SCIP data structure */
5338  SCIP_CONS* cons /**< constraint to delete */
5339  );
5340 
5341 /** returns original constraint of given name in the problem, or NULL if not existing
5342  *
5343  * @return original constraint of given name in the problem, or NULL if not existing
5344  *
5345  * @pre This method can be called if @p scip is in one of the following stages:
5346  * - \ref SCIP_STAGE_PROBLEM
5347  * - \ref SCIP_STAGE_TRANSFORMING
5348  * - \ref SCIP_STAGE_TRANSFORMED
5349  * - \ref SCIP_STAGE_INITPRESOLVE
5350  * - \ref SCIP_STAGE_PRESOLVING
5351  * - \ref SCIP_STAGE_EXITPRESOLVE
5352  * - \ref SCIP_STAGE_INITSOLVE
5353  * - \ref SCIP_STAGE_SOLVING
5354  * - \ref SCIP_STAGE_SOLVED
5355  * - \ref SCIP_STAGE_EXITSOLVE
5356  * - \ref SCIP_STAGE_FREETRANS */
5357 extern
5359  SCIP* scip, /**< SCIP data structure */
5360  const char* name /**< name of constraint to find */
5361  );
5362 
5363 /** returns constraint of given name in the problem, or NULL if not existing
5364  *
5365  * @return constraint of given name in the problem, or NULL if not existing
5366  *
5367  * @pre This method can be called if @p scip is in one of the following stages:
5368  * - \ref SCIP_STAGE_PROBLEM
5369  * - \ref SCIP_STAGE_TRANSFORMING
5370  * - \ref SCIP_STAGE_TRANSFORMED
5371  * - \ref SCIP_STAGE_INITPRESOLVE
5372  * - \ref SCIP_STAGE_PRESOLVING
5373  * - \ref SCIP_STAGE_EXITPRESOLVE
5374  * - \ref SCIP_STAGE_PRESOLVED
5375  * - \ref SCIP_STAGE_INITSOLVE
5376  * - \ref SCIP_STAGE_SOLVING
5377  * - \ref SCIP_STAGE_SOLVED
5378  * - \ref SCIP_STAGE_EXITSOLVE
5379  * - \ref SCIP_STAGE_FREETRANS
5380  */
5381 extern
5383  SCIP* scip, /**< SCIP data structure */
5384  const char* name /**< name of constraint to find */
5385  );
5386 
5387 /** gets number of upgraded constraints
5388  *
5389  * @return number of upgraded constraints
5390  *
5391  * @pre This method can be called if @p scip is in one of the following stages:
5392  * - \ref SCIP_STAGE_PROBLEM
5393  * - \ref SCIP_STAGE_TRANSFORMED
5394  * - \ref SCIP_STAGE_INITPRESOLVE
5395  * - \ref SCIP_STAGE_PRESOLVING
5396  * - \ref SCIP_STAGE_PRESOLVED
5397  * - \ref SCIP_STAGE_EXITPRESOLVE
5398  * - \ref SCIP_STAGE_SOLVING
5399  * - \ref SCIP_STAGE_SOLVED
5400  */
5401 extern
5402 int SCIPgetNUpgrConss(
5403  SCIP* scip /**< SCIP data structure */
5404  );
5405 
5406 /** gets total number of globally valid constraints currently in the problem
5407  *
5408  * @return total number of globally valid constraints currently in the problem
5409  *
5410  * @pre This method can be called if @p scip is in one of the following stages:
5411  * - \ref SCIP_STAGE_PROBLEM
5412  * - \ref SCIP_STAGE_TRANSFORMED
5413  * - \ref SCIP_STAGE_INITPRESOLVE
5414  * - \ref SCIP_STAGE_PRESOLVING
5415  * - \ref SCIP_STAGE_EXITPRESOLVE
5416  * - \ref SCIP_STAGE_PRESOLVED
5417  * - \ref SCIP_STAGE_INITSOLVE
5418  * - \ref SCIP_STAGE_SOLVING
5419  * - \ref SCIP_STAGE_SOLVED
5420  */
5421 extern
5422 int SCIPgetNConss(
5423  SCIP* scip /**< SCIP data structure */
5424  );
5425 
5426 /** gets array of globally valid constraints currently in the problem
5427  *
5428  * @return array of globally valid constraints currently in the problem
5429  *
5430  * @pre This method can be called if @p scip is in one of the following stages:
5431  * - \ref SCIP_STAGE_PROBLEM
5432  * - \ref SCIP_STAGE_TRANSFORMED
5433  * - \ref SCIP_STAGE_INITPRESOLVE
5434  * - \ref SCIP_STAGE_PRESOLVING
5435  * - \ref SCIP_STAGE_EXITPRESOLVE
5436  * - \ref SCIP_STAGE_PRESOLVED
5437  * - \ref SCIP_STAGE_SOLVING
5438  * - \ref SCIP_STAGE_SOLVED
5439  *
5440  * @warning If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is
5441  * accessed via this method) gets resized. This can invalid the pointer which is returned by this method.
5442  */
5443 extern
5445  SCIP* scip /**< SCIP data structure */
5446  );
5447 
5448 /** gets total number of constraints in the original problem
5449  *
5450  * @return total number of constraints in the original problem
5451  *
5452  * @pre This method can be called if @p scip is in one of the following stages:
5453  * - \ref SCIP_STAGE_PROBLEM
5454  * - \ref SCIP_STAGE_TRANSFORMING
5455  * - \ref SCIP_STAGE_TRANSFORMED
5456  * - \ref SCIP_STAGE_INITPRESOLVE
5457  * - \ref SCIP_STAGE_PRESOLVING
5458  * - \ref SCIP_STAGE_EXITPRESOLVE
5459  * - \ref SCIP_STAGE_PRESOLVED
5460  * - \ref SCIP_STAGE_INITSOLVE
5461  * - \ref SCIP_STAGE_SOLVING
5462  * - \ref SCIP_STAGE_SOLVED
5463  * - \ref SCIP_STAGE_EXITSOLVE
5464  * - \ref SCIP_STAGE_FREETRANS
5465  */
5466 extern
5467 int SCIPgetNOrigConss(
5468  SCIP* scip /**< SCIP data structure */
5469  );
5470 
5471 /** gets array of constraints in the original problem
5472  *
5473  * @return array of constraints in the original problem
5474  *
5475  * @pre This method can be called if @p scip is in one of the following stages:
5476  * - \ref SCIP_STAGE_PROBLEM
5477  * - \ref SCIP_STAGE_TRANSFORMING
5478  * - \ref SCIP_STAGE_TRANSFORMED
5479  * - \ref SCIP_STAGE_INITPRESOLVE
5480  * - \ref SCIP_STAGE_PRESOLVING
5481  * - \ref SCIP_STAGE_EXITPRESOLVE
5482  * - \ref SCIP_STAGE_PRESOLVED
5483  * - \ref SCIP_STAGE_INITSOLVE
5484  * - \ref SCIP_STAGE_SOLVING
5485  * - \ref SCIP_STAGE_SOLVED
5486  * - \ref SCIP_STAGE_EXITSOLVE
5487  * - \ref SCIP_STAGE_FREETRANS
5488  */
5489 extern
5491  SCIP* scip /**< SCIP data structure */
5492  );
5493 
5494 /** computes the number of check constraint in the current node (loop over all constraint handler and cumulates the
5495  * number of check constraints)
5496  *
5497  * @return returns the number of check constraints
5498  *
5499  * @pre This method can be called if @p scip is in one of the following stages:
5500  * - \ref SCIP_STAGE_TRANSFORMED
5501  * - \ref SCIP_STAGE_INITPRESOLVE
5502  * - \ref SCIP_STAGE_PRESOLVING
5503  * - \ref SCIP_STAGE_EXITPRESOLVE
5504  * - \ref SCIP_STAGE_PRESOLVED
5505  * - \ref SCIP_STAGE_INITSOLVE
5506  * - \ref SCIP_STAGE_SOLVING
5507  */
5508 extern
5509 int SCIPgetNCheckConss(
5510  SCIP* scip /**< SCIP data structure */
5511  );
5512 
5513 /**@} */
5514 
5515 
5516 
5517 
5518 /*
5519  * local subproblem methods
5520  */
5521 
5522 /**@name Local Subproblem Methods */
5523 /**@{ */
5524 
5525 /** adds constraint to the given node (and all of its subnodes), even if it is a global constraint;
5526  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
5527  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
5528  * only active in a small part of the tree although it is valid in a larger part.
5529  * In this case, one should pass the more global node where the constraint is valid as "validnode".
5530  * Note that the same constraint cannot be added twice to the branching tree with different "validnode" parameters.
5531  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
5532  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
5533  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
5534  *
5535  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5537  *
5538  * @pre this method can be called in one of the following stages of the SCIP solving process:
5539  * - \ref SCIP_STAGE_INITPRESOLVE
5540  * - \ref SCIP_STAGE_PRESOLVING
5541  * - \ref SCIP_STAGE_EXITPRESOLVE
5542  * - \ref SCIP_STAGE_SOLVING
5543  */
5544 extern
5546  SCIP* scip, /**< SCIP data structure */
5547  SCIP_NODE* node, /**< node to add constraint to */
5548  SCIP_CONS* cons, /**< constraint to add */
5549  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
5550  );
5551 
5552 /** adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint;
5553  * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
5554  * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
5555  * only active in a small part of the tree although it is valid in a larger part.
5556  *
5557  * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
5558  * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
5559  * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
5560  *
5561  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5562  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5563  *
5564  * @pre this method can be called in one of the following stages of the SCIP solving process:
5565  * - \ref SCIP_STAGE_INITPRESOLVE
5566  * - \ref SCIP_STAGE_PRESOLVING
5567  * - \ref SCIP_STAGE_EXITPRESOLVE
5568  * - \ref SCIP_STAGE_SOLVING
5569  *
5570  * @note The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is
5571  * the case due internal data structures and performance issues. In such a case you should try to realize your
5572  * issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.
5573  */
5574 extern
5576  SCIP* scip, /**< SCIP data structure */
5577  SCIP_CONS* cons, /**< constraint to add */
5578  SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
5579  );
5580 
5581 /** disables constraint's separation, enforcing, and propagation capabilities at the given node (and all subnodes);
5582  * if the method is called at the root node, the constraint is globally deleted from the problem;
5583  * the constraint deletion is being remembered at the given node, s.t. after leaving the node's subtree, the constraint
5584  * is automatically enabled again, and after entering the node's subtree, it is automatically disabled;
5585  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
5586  * alternatively, use SCIPdisableCons()
5587  *
5588  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5589  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5590  *
5591  * @pre this method can be called in one of the following stages of the SCIP solving process:
5592  * - \ref SCIP_STAGE_INITPRESOLVE
5593  * - \ref SCIP_STAGE_PRESOLVING
5594  * - \ref SCIP_STAGE_EXITPRESOLVE
5595  * - \ref SCIP_STAGE_SOLVING
5596  */
5597 extern
5599  SCIP* scip, /**< SCIP data structure */
5600  SCIP_NODE* node, /**< node to disable constraint in */
5601  SCIP_CONS* cons /**< constraint to locally delete */
5602  );
5603 
5604 /** disables constraint's separation, enforcing, and propagation capabilities at the current node (and all subnodes);
5605  * if the method is called during problem modification or at the root node, the constraint is globally deleted from
5606  * the problem;
5607  * the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the
5608  * constraint is automatically enabled again, and after reentering the current node's subtree, it is automatically
5609  * disabled again;
5610  * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
5611  * alternatively, use SCIPdisableCons()
5612  *
5613  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5614  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5615  *
5616  * @pre this method can be called in one of the following stages of the SCIP solving process:
5617  * - \ref SCIP_STAGE_PROBLEM
5618  * - \ref SCIP_STAGE_INITPRESOLVE
5619  * - \ref SCIP_STAGE_PRESOLVING
5620  * - \ref SCIP_STAGE_EXITPRESOLVE
5621  * - \ref SCIP_STAGE_SOLVING
5622  */
5623 extern
5625  SCIP* scip, /**< SCIP data structure */
5626  SCIP_CONS* cons /**< constraint to locally delete */
5627  );
5628 
5629 /** gets estimate of best primal solution w.r.t. original problem contained in current subtree
5630  *
5631  * @return estimate of best primal solution w.r.t. original problem contained in current subtree
5632  *
5633  * @pre this method can be called in one of the following stages of the SCIP solving process:
5634  * - \ref SCIP_STAGE_SOLVING
5635  */
5636 extern
5638  SCIP* scip /**< SCIP data structure */
5639  );
5640 
5641 /** gets estimate of best primal solution w.r.t. transformed problem contained in current subtree
5642  *
5643  * @return estimate of best primal solution w.r.t. transformed problem contained in current subtree
5644  *
5645  * @pre this method can be called in one of the following stages of the SCIP solving process:
5646  * - \ref SCIP_STAGE_SOLVING
5647  */
5648 extern
5650  SCIP* scip /**< SCIP data structure */
5651  );
5652 
5653 /** gets dual bound of current node
5654  *
5655  * @return dual bound of current node
5656  *
5657  * @pre this method can be called in one of the following stages of the SCIP solving process:
5658  * - \ref SCIP_STAGE_SOLVING
5659  */
5660 extern
5662  SCIP* scip /**< SCIP data structure */
5663  );
5664 
5665 /** gets lower bound of current node in transformed problem
5666  *
5667  * @return lower bound of current node in transformed problem
5668  *
5669  * @pre this method can be called in one of the following stages of the SCIP solving process:
5670  * - \ref SCIP_STAGE_SOLVING
5671  */
5672 extern
5674  SCIP* scip /**< SCIP data structure */
5675  );
5676 
5677 /** gets dual bound of given node
5678  *
5679  * @return dual bound of a given node
5680  *
5681  * @pre this method can be called in one of the following stages of the SCIP solving process:
5682  * - \ref SCIP_STAGE_SOLVING
5683  */
5684 extern
5686  SCIP* scip, /**< SCIP data structure */
5687  SCIP_NODE* node /**< node to get dual bound for */
5688  );
5689 
5690 /** gets lower bound of given node in transformed problem
5691  *
5692  * @return lower bound of given node in transformed problem
5693  *
5694  * @pre this method can be called in one of the following stages of the SCIP solving process:
5695  * - \ref SCIP_STAGE_SOLVING
5696  */
5697 extern
5699  SCIP* scip, /**< SCIP data structure */
5700  SCIP_NODE* node /**< node to get dual bound for */
5701  );
5702 
5703 /** if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in
5704  * original problem space), sets the current node's dual bound to the new value
5705  *
5706  * @note the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.
5707  *
5708  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5709  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5710  *
5711  * @pre this method can be called in one of the following stages of the SCIP solving process:
5712  * - \ref SCIP_STAGE_PROBLEM
5713  * - \ref SCIP_STAGE_PRESOLVING
5714  * - \ref SCIP_STAGE_PRESOLVED
5715  * - \ref SCIP_STAGE_SOLVING
5716  */
5717 extern
5719  SCIP* scip, /**< SCIP data structure */
5720  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
5721  );
5722 
5723 /** if given value is larger than the current node's lower bound (in transformed problem), sets the current node's
5724  * lower bound to the new value
5725  *
5726  * @note the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.
5727  *
5728  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5729  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5730  *
5731  * @pre this method can be called in one of the following stages of the SCIP solving process:
5732  * - \ref SCIP_STAGE_PRESOLVING
5733  * - \ref SCIP_STAGE_PRESOLVED
5734  * - \ref SCIP_STAGE_SOLVING
5735  */
5736 extern
5738  SCIP* scip, /**< SCIP data structure */
5739  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
5740  );
5741 
5742 /** if given value is tighter (larger for minimization, smaller for maximization) than the node's dual bound,
5743  * sets the node's dual bound to the new value
5744  *
5745  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5746  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5747  *
5748  * @pre this method can be called in one of the following stages of the SCIP solving process:
5749  * - \ref SCIP_STAGE_SOLVING
5750  */
5751 extern
5753  SCIP* scip, /**< SCIP data structure */
5754  SCIP_NODE* node, /**< node to update dual bound for */
5755  SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
5756  );
5757 
5758 /** if given value is larger than the node's lower bound (in transformed problem), sets the node's lower bound
5759  * to the new value
5760  *
5761  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5762  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5763  *
5764  * @pre this method can be called in one of the following stages of the SCIP solving process:
5765  * - \ref SCIP_STAGE_SOLVING
5766  */
5767 extern
5769  SCIP* scip, /**< SCIP data structure */
5770  SCIP_NODE* node, /**< node to update lower bound for */
5771  SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
5772  );
5773 
5774 /** change the node selection priority of the given child
5775  *
5776  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5777  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5778  *
5779  * @pre this method can be called in one of the following stages of the SCIP solving process:
5780  * - \ref SCIP_STAGE_SOLVING
5781  */
5782 extern
5784  SCIP* scip, /**< SCIP data structure */
5785  SCIP_NODE* child, /**< child to update the node selection priority */
5786  SCIP_Real priority /**< node selection priority value */
5787  );
5788 
5789 /**@} */
5790 
5791 
5792 
5793 
5794 /*
5795  * solve methods
5796  */
5797 
5798 /**@name Solve Methods */
5799 /**@{ */
5800 
5801 /** initializes solving data structures and transforms problem
5802  *
5803  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5804  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5805  *
5806  * @pre This method can be called if @p scip is in one of the following stages:
5807  * - \ref SCIP_STAGE_PROBLEM
5808  * - \ref SCIP_STAGE_TRANSFORMED
5809  * - \ref SCIP_STAGE_INITPRESOLVE
5810  * - \ref SCIP_STAGE_PRESOLVING
5811  * - \ref SCIP_STAGE_EXITPRESOLVE
5812  * - \ref SCIP_STAGE_PRESOLVED
5813  * - \ref SCIP_STAGE_INITSOLVE
5814  * - \ref SCIP_STAGE_SOLVING
5815  * - \ref SCIP_STAGE_SOLVED
5816  * - \ref SCIP_STAGE_EXITSOLVE
5817  * - \ref SCIP_STAGE_FREETRANS
5818  * - \ref SCIP_STAGE_FREE
5819  *
5820  * @post When calling this method in the \ref SCIP_STAGE_PROBLEM stage, the \SCIP stage is changed to \ref
5821  * SCIP_STAGE_TRANSFORMED; otherwise, the stage is not changed
5822  *
5823  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
5824  */
5825 extern
5827  SCIP* scip /**< SCIP data structure */
5828  );
5829 
5830 /** transforms and presolves problem
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 if @p scip is in one of the following stages:
5836  * - \ref SCIP_STAGE_PROBLEM
5837  * - \ref SCIP_STAGE_TRANSFORMED
5838  * - \ref SCIP_STAGE_PRESOLVING
5839  * - \ref SCIP_STAGE_PRESOLVED
5840  *
5841  * @post After calling this method \SCIP reaches one of the following stages:
5842  * - \ref SCIP_STAGE_PRESOLVING if the presolving process was interrupted
5843  * - \ref SCIP_STAGE_PRESOLVED if the presolving process was finished and did not solve the problem
5844  * - \ref SCIP_STAGE_SOLVED if the problem was solved during presolving
5845  *
5846  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
5847  */
5848 extern
5850  SCIP* scip /**< SCIP data structure */
5851  );
5852 
5853 /** transforms, presolves, and solves problem
5854  *
5855  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5856  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5857  *
5858  * @pre This method can be called if @p scip is in one of the following stages:
5859  * - \ref SCIP_STAGE_PROBLEM
5860  * - \ref SCIP_STAGE_TRANSFORMED
5861  * - \ref SCIP_STAGE_PRESOLVING
5862  * - \ref SCIP_STAGE_PRESOLVED
5863  * - \ref SCIP_STAGE_SOLVING
5864  * - \ref SCIP_STAGE_SOLVED
5865  *
5866  * @post After calling this method \SCIP reaches one of the following stages depending on if and when the solution
5867  * process was interrupted:
5868 
5869  * - \ref SCIP_STAGE_PRESOLVING if the solution process was interrupted during presolving
5870  * - \ref SCIP_STAGE_SOLVING if the solution process was interrupted during the tree search
5871  * - \ref SCIP_STAGE_SOLVED if the solving process was not interrupted
5872  *
5873  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
5874  */
5875 extern
5877  SCIP* scip /**< SCIP data structure */
5878  );
5879 
5880 /** frees branch and bound tree and all solution process data; statistics, presolving data and transformed problem is
5881  * preserved
5882  *
5883  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5884  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5885  *
5886  * @pre This method can be called if @p scip is in one of the following stages:
5887  * - \ref SCIP_STAGE_INIT
5888  * - \ref SCIP_STAGE_PROBLEM
5889  * - \ref SCIP_STAGE_TRANSFORMED
5890  * - \ref SCIP_STAGE_PRESOLVING
5891  * - \ref SCIP_STAGE_PRESOLVED
5892  * - \ref SCIP_STAGE_SOLVING
5893  * - \ref SCIP_STAGE_SOLVED
5894  *
5895  * @post If this method is called in \SCIP stage \ref SCIP_STAGE_INIT or \ref SCIP_STAGE_PROBLEM, the stage of
5896  * \SCIP is not changed; otherwise, the \SCIP stage is changed to \ref SCIP_STAGE_TRANSFORMED
5897  *
5898  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
5899  */
5900 extern
5902  SCIP* scip, /**< SCIP data structure */
5903  SCIP_Bool restart /**< should certain data be preserved for improved restarting? */
5904  );
5905 
5906 /** frees all solution process data including presolving and transformed problem, only original problem is kept
5907  *
5908  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5909  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5910  *
5911  * @pre This method can be called if @p scip is in one of the following stages:
5912  * - \ref SCIP_STAGE_INIT
5913  * - \ref SCIP_STAGE_PROBLEM
5914  * - \ref SCIP_STAGE_TRANSFORMED
5915  * - \ref SCIP_STAGE_PRESOLVING
5916  * - \ref SCIP_STAGE_PRESOLVED
5917  * - \ref SCIP_STAGE_SOLVING
5918  * - \ref SCIP_STAGE_SOLVED
5919  *
5920  * @post After calling this method \SCIP reaches one of the following stages:
5921  * - \ref SCIP_STAGE_INIT if the method was called from \SCIP stage \ref SCIP_STAGE_INIT
5922  * - \ref SCIP_STAGE_PROBLEM if the method was called from any other of the allowed stages
5923  *
5924  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
5925  */
5926 extern
5928  SCIP* scip /**< SCIP data structure */
5929  );
5930 
5931 /** informs \SCIP that the solving process should be interrupted as soon as possible (e.g., after the current node has
5932  * been solved)
5933  *
5934  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5935  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5936  *
5937  * @pre This method can be called if @p scip is in one of the following stages:
5938  * - \ref SCIP_STAGE_PROBLEM
5939  * - \ref SCIP_STAGE_TRANSFORMING
5940  * - \ref SCIP_STAGE_TRANSFORMED
5941  * - \ref SCIP_STAGE_INITPRESOLVE
5942  * - \ref SCIP_STAGE_PRESOLVING
5943  * - \ref SCIP_STAGE_EXITPRESOLVE
5944  * - \ref SCIP_STAGE_PRESOLVED
5945  * - \ref SCIP_STAGE_SOLVING
5946  * - \ref SCIP_STAGE_SOLVED
5947  * - \ref SCIP_STAGE_EXITSOLVE
5948  * - \ref SCIP_STAGE_FREETRANS
5949  *
5950  * @note the \SCIP stage does not get changed
5951  */
5952 extern
5954  SCIP* scip /**< SCIP data structure */
5955  );
5956 
5957 /** informs SCIP that the solving process should be restarted as soon as possible (e.g., after the current node has
5958  * been solved)
5959  *
5960  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
5961  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
5962  *
5963  * @pre This method can be called if @p scip is in one of the following stages:
5964  * - \ref SCIP_STAGE_INITPRESOLVE
5965  * - \ref SCIP_STAGE_PRESOLVING
5966  * - \ref SCIP_STAGE_EXITPRESOLVE
5967  * - \ref SCIP_STAGE_SOLVING
5968  *
5969  * @note the \SCIP stage does not get changed
5970  */
5971 extern
5973  SCIP* scip /**< SCIP data structure */
5974  );
5975 
5976 /** returns whether we are in the restarting phase
5977  *
5978  * @return TRUE, if we are in the restarting phase; FALSE, otherwise
5979  *
5980  * @pre This method can be called if @p scip is in one of the following stages:
5981  * - \ref SCIP_STAGE_INITPRESOLVE
5982  * - \ref SCIP_STAGE_PRESOLVING
5983  * - \ref SCIP_STAGE_EXITPRESOLVE
5984  * - \ref SCIP_STAGE_PRESOLVED
5985  * - \ref SCIP_STAGE_INITSOLVE
5986  * - \ref SCIP_STAGE_SOLVING
5987  * - \ref SCIP_STAGE_SOLVED
5988  * - \ref SCIP_STAGE_EXITSOLVE
5989  * - \ref SCIP_STAGE_FREETRANS
5990  */
5991 extern
5993  SCIP* scip /**< SCIP data structure */
5994  );
5995 
5996 /**@} */
5997 
5998 
5999 
6000 
6001 /*
6002  * variable methods
6003  */
6004 
6005 /**@name Variable Methods */
6006 /**@{ */
6007 
6008 /** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded;
6009  * an integer variable with bounds zero and one is automatically converted into a binary variable;
6010  *
6011  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
6012  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
6013  * original objective function value of variables created during the solving process has to be multiplied by
6014  * -1, too.
6015  *
6016  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6017  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6018  *
6019  * @pre This method can be called if @p scip is in one of the following stages:
6020  * - \ref SCIP_STAGE_PROBLEM
6021  * - \ref SCIP_STAGE_TRANSFORMING
6022  * - \ref SCIP_STAGE_INITPRESOLVE
6023  * - \ref SCIP_STAGE_PRESOLVING
6024  * - \ref SCIP_STAGE_EXITPRESOLVE
6025  * - \ref SCIP_STAGE_PRESOLVED
6026  * - \ref SCIP_STAGE_SOLVING
6027  *
6028  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
6029  */
6030 extern
6032  SCIP* scip, /**< SCIP data structure */
6033  SCIP_VAR** var, /**< pointer to variable object */
6034  const char* name, /**< name of variable, or NULL for automatic name creation */
6035  SCIP_Real lb, /**< lower bound of variable */
6036  SCIP_Real ub, /**< upper bound of variable */
6037  SCIP_Real obj, /**< objective function value */
6038  SCIP_VARTYPE vartype, /**< type of variable */
6039  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
6040  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
6041  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
6042  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
6043  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
6044  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
6045  SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */
6046  );
6047 
6048 /** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set
6049  * afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(),
6050  * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE
6051  * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.;
6052  * if variable is of integral type, fractional bounds are automatically rounded;
6053  * an integer variable with bounds zero and one is automatically converted into a binary variable;
6054  *
6055  * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
6056  * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
6057  * original objective function value of variables created during the solving process has to be multiplied by
6058  * -1, too.
6059  *
6060  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6061  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6062  *
6063  * @pre This method can be called if @p scip is in one of the following stages:
6064  * - \ref SCIP_STAGE_PROBLEM
6065  * - \ref SCIP_STAGE_TRANSFORMING
6066  * - \ref SCIP_STAGE_INITPRESOLVE
6067  * - \ref SCIP_STAGE_PRESOLVING
6068  * - \ref SCIP_STAGE_EXITPRESOLVE
6069  * - \ref SCIP_STAGE_PRESOLVED
6070  * - \ref SCIP_STAGE_SOLVING
6071  *
6072  * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
6073  */
6074 extern
6076  SCIP* scip, /**< SCIP data structure */
6077  SCIP_VAR** var, /**< pointer to variable object */
6078  const char* name, /**< name of variable, or NULL for automatic name creation */
6079  SCIP_Real lb, /**< lower bound of variable */
6080  SCIP_Real ub, /**< upper bound of variable */
6081  SCIP_Real obj, /**< objective function value */
6082  SCIP_VARTYPE vartype /**< type of variable */
6083  );
6084 
6085 /** outputs the variable name to the file stream
6086  *
6087  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6088  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6089  *
6090  * @pre This method can be called if @p scip is in one of the following stages:
6091  * - \ref SCIP_STAGE_PROBLEM
6092  * - \ref SCIP_STAGE_TRANSFORMING
6093  * - \ref SCIP_STAGE_TRANSFORMED
6094  * - \ref SCIP_STAGE_INITPRESOLVE
6095  * - \ref SCIP_STAGE_PRESOLVING
6096  * - \ref SCIP_STAGE_EXITPRESOLVE
6097  * - \ref SCIP_STAGE_PRESOLVED
6098  * - \ref SCIP_STAGE_INITSOLVE
6099  * - \ref SCIP_STAGE_SOLVING
6100  * - \ref SCIP_STAGE_SOLVED
6101  * - \ref SCIP_STAGE_EXITSOLVE
6102  * - \ref SCIP_STAGE_FREETRANS
6103  */
6104 extern
6106  SCIP* scip, /**< SCIP data structure */
6107  FILE* file, /**< output file, or NULL for stdout */
6108  SCIP_VAR* var, /**< variable to output */
6109  SCIP_Bool type /**< should the variable type be also posted */
6110  );
6111 
6112 /** print the given list of variables to output stream separated by the given delimiter character;
6113  *
6114  * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
6115  *
6116  * the method SCIPparseVarsList() can parse such a string
6117  *
6118  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6119  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6120  *
6121  * @pre This method can be called if @p scip is in one of the following stages:
6122  * - \ref SCIP_STAGE_PROBLEM
6123  * - \ref SCIP_STAGE_TRANSFORMING
6124  * - \ref SCIP_STAGE_TRANSFORMED
6125  * - \ref SCIP_STAGE_INITPRESOLVE
6126  * - \ref SCIP_STAGE_PRESOLVING
6127  * - \ref SCIP_STAGE_EXITPRESOLVE
6128  * - \ref SCIP_STAGE_PRESOLVED
6129  * - \ref SCIP_STAGE_INITSOLVE
6130  * - \ref SCIP_STAGE_SOLVING
6131  * - \ref SCIP_STAGE_SOLVED
6132  * - \ref SCIP_STAGE_EXITSOLVE
6133  * - \ref SCIP_STAGE_FREETRANS
6134  *
6135  * @note The printing process is done via the message handler system.
6136  */
6137 extern
6139  SCIP* scip, /**< SCIP data structure */
6140  FILE* file, /**< output file, or NULL for stdout */
6141  SCIP_VAR** vars, /**< variable array to output */
6142  int nvars, /**< number of variables */
6143  SCIP_Bool type, /**< should the variable type be also posted */
6144  char delimiter /**< character which is used for delimitation */
6145  );
6146 
6147 /** print the given variables and coefficients as linear sum in the following form
6148  * c1 <x1> + c2 <x2> ... + cn <xn>
6149  *
6150  * This string can be parsed by the method SCIPparseVarsLinearsum().
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_TRANSFORMING
6158  * - \ref SCIP_STAGE_TRANSFORMED
6159  * - \ref SCIP_STAGE_INITPRESOLVE
6160  * - \ref SCIP_STAGE_PRESOLVING
6161  * - \ref SCIP_STAGE_EXITPRESOLVE
6162  * - \ref SCIP_STAGE_PRESOLVED
6163  * - \ref SCIP_STAGE_INITSOLVE
6164  * - \ref SCIP_STAGE_SOLVING
6165  * - \ref SCIP_STAGE_SOLVED
6166  * - \ref SCIP_STAGE_EXITSOLVE
6167  * - \ref SCIP_STAGE_FREETRANS
6168  *
6169  * @note The printing process is done via the message handler system.
6170  */
6171 extern
6173  SCIP* scip, /**< SCIP data structure */
6174  FILE* file, /**< output file, or NULL for stdout */
6175  SCIP_VAR** vars, /**< variable array to output */
6176  SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
6177  int nvars, /**< number of variables */
6178  SCIP_Bool type /**< should the variable type be also posted */
6179  );
6180 
6181 /** print the given monomials as polynomial in the following form
6182  * c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...
6183  *
6184  * This string can be parsed by the method SCIPparseVarsPolynomial().
6185  *
6186  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6187  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6188  *
6189  * @pre This method can be called if @p scip is in one of the following stages:
6190  * - \ref SCIP_STAGE_PROBLEM
6191  * - \ref SCIP_STAGE_TRANSFORMING
6192  * - \ref SCIP_STAGE_TRANSFORMED
6193  * - \ref SCIP_STAGE_INITPRESOLVE
6194  * - \ref SCIP_STAGE_PRESOLVING
6195  * - \ref SCIP_STAGE_EXITPRESOLVE
6196  * - \ref SCIP_STAGE_PRESOLVED
6197  * - \ref SCIP_STAGE_INITSOLVE
6198  * - \ref SCIP_STAGE_SOLVING
6199  * - \ref SCIP_STAGE_SOLVED
6200  * - \ref SCIP_STAGE_EXITSOLVE
6201  * - \ref SCIP_STAGE_FREETRANS
6202  *
6203  * @note The printing process is done via the message handler system.
6204  */
6205 extern
6207  SCIP* scip, /**< SCIP data structure */
6208  FILE* file, /**< output file, or NULL for stdout */
6209  SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */
6210  SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */
6211  SCIP_Real* monomialcoefs, /**< array with monomial coefficients */
6212  int* monomialnvars, /**< array with number of variables for each monomial */
6213  int nmonomials, /**< number of monomials */
6214  SCIP_Bool type /**< should the variable type be also posted */
6215  );
6216 
6217 /** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
6218  * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
6219  * variable with bounds zero and one is automatically converted into a binary variable
6220  *
6221  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6222  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6223  *
6224  * @pre This method can be called if @p scip is in one of the following stages:
6225  * - \ref SCIP_STAGE_PROBLEM
6226  * - \ref SCIP_STAGE_TRANSFORMING
6227  * - \ref SCIP_STAGE_INITPRESOLVE
6228  * - \ref SCIP_STAGE_PRESOLVING
6229  * - \ref SCIP_STAGE_EXITPRESOLVE
6230  * - \ref SCIP_STAGE_PRESOLVED
6231  * - \ref SCIP_STAGE_SOLVING
6232  */
6233 extern
6235  SCIP* scip, /**< SCIP data structure */
6236  SCIP_VAR** var, /**< pointer to store the problem variable */
6237  const char* str, /**< string to parse */
6238  SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
6239  SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
6240  SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
6241  SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
6242  SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
6243  SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
6244  SCIP_VARDATA* vardata, /**< user data for this specific variable */
6245  char** endptr, /**< pointer to store the final string position if successfully */
6246  SCIP_Bool* success /**< pointer store if the paring process was successful */
6247  );
6248 
6249 /** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
6250  * exits and returns the position where the parsing stopped
6251  *
6252  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6253  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6254  *
6255  * @pre This method can be called if @p scip is in one of the following stages:
6256  * - \ref SCIP_STAGE_PROBLEM
6257  * - \ref SCIP_STAGE_TRANSFORMING
6258  * - \ref SCIP_STAGE_INITPRESOLVE
6259  * - \ref SCIP_STAGE_PRESOLVING
6260  * - \ref SCIP_STAGE_EXITPRESOLVE
6261  * - \ref SCIP_STAGE_PRESOLVED
6262  * - \ref SCIP_STAGE_SOLVING
6263  */
6264 extern
6266  SCIP* scip, /**< SCIP data structure */
6267  const char* str, /**< string to parse */
6268  SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */
6269  char** endptr /**< pointer to store the final string position if successfully */
6270  );
6271 
6272 /** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
6273  * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
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  * - \ref SCIP_STAGE_TRANSFORMING
6281  * - \ref SCIP_STAGE_INITPRESOLVE
6282  * - \ref SCIP_STAGE_PRESOLVING
6283  * - \ref SCIP_STAGE_EXITPRESOLVE
6284  * - \ref SCIP_STAGE_PRESOLVED
6285  * - \ref SCIP_STAGE_SOLVING
6286  *
6287  * @note the pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist
6288  *
6289  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
6290  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
6291  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
6292  * memory functions).
6293  */
6294 extern
6296  SCIP* scip, /**< SCIP data structure */
6297  const char* str, /**< string to parse */
6298  SCIP_VAR** vars, /**< array to store the parsed variable */
6299  int* nvars, /**< pointer to store number of parsed variables */
6300  int varssize, /**< size of the variable array */
6301  int* requiredsize, /**< pointer to store the required array size for the active variables */
6302  char** endptr, /**< pointer to store the final string position if successfully */
6303  char delimiter, /**< character which is used for delimitation */
6304  SCIP_Bool* success /**< pointer to store the whether the parsing was successfully or not */
6305  );
6306 
6307 /** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
6308  * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
6309  *
6310  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6311  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6312  *
6313  * @pre This method can be called if @p scip is in one of the following stages:
6314  * - \ref SCIP_STAGE_PROBLEM
6315  * - \ref SCIP_STAGE_TRANSFORMING
6316  * - \ref SCIP_STAGE_INITPRESOLVE
6317  * - \ref SCIP_STAGE_PRESOLVING
6318  * - \ref SCIP_STAGE_EXITPRESOLVE
6319  * - \ref SCIP_STAGE_PRESOLVED
6320  * - \ref SCIP_STAGE_SOLVING
6321  *
6322  * @note the pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist
6323  *
6324  * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
6325  * except that the required size is stored in the corresponding integer; the reason for this approach is that we
6326  * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
6327  * memory functions).
6328  */
6329 extern
6331  SCIP* scip, /**< SCIP data structure */
6332  const char* str, /**< string to parse */
6333  SCIP_VAR** vars, /**< array to store the parsed variables */
6334  SCIP_Real* vals, /**< array to store the parsed coefficients */
6335  int* nvars, /**< pointer to store number of parsed variables */
6336  int varssize, /**< size of the variable array */
6337  int* requiredsize, /**< pointer to store the required array size for the active variables */
6338  char** endptr, /**< pointer to store the final string position if successfully */
6339  SCIP_Bool* success /**< pointer to store the whether the parsing was successfully or not */
6340  );
6341 
6342 /** parse the given string as polynomial of variables and coefficients
6343  * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
6344  * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
6345  *
6346  * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
6347  * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
6348  * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
6349  * they use buffer memory that is intended for short term use only.
6350  *
6351  * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
6352  * are recognized.
6353  *
6354  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6355  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6356  *
6357  * @pre This method can be called if @p scip is in one of the following stages:
6358  * - \ref SCIP_STAGE_PROBLEM
6359  * - \ref SCIP_STAGE_TRANSFORMING
6360  * - \ref SCIP_STAGE_INITPRESOLVE
6361  * - \ref SCIP_STAGE_PRESOLVING
6362  * - \ref SCIP_STAGE_EXITPRESOLVE
6363  * - \ref SCIP_STAGE_PRESOLVED
6364  * - \ref SCIP_STAGE_SOLVING
6365  */
6366 extern
6368  SCIP* scip, /**< SCIP data structure */
6369  const char* str, /**< string to parse */
6370  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
6371  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
6372  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
6373  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
6374  int* nmonomials, /**< pointer to store number of parsed monomials */
6375  char** endptr, /**< pointer to store the final string position if successfully */
6376  SCIP_Bool* success /**< pointer to store the whether the parsing was successfully or not */
6377  );
6378 
6379 /** frees memory allocated when parsing a polynomial from a string
6380  *
6381  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6382  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6383  *
6384  * @pre This method can be called if @p scip is in one of the following stages:
6385  * - \ref SCIP_STAGE_PROBLEM
6386  * - \ref SCIP_STAGE_TRANSFORMING
6387  * - \ref SCIP_STAGE_INITPRESOLVE
6388  * - \ref SCIP_STAGE_PRESOLVING
6389  * - \ref SCIP_STAGE_EXITPRESOLVE
6390  * - \ref SCIP_STAGE_PRESOLVED
6391  * - \ref SCIP_STAGE_SOLVING
6392  */
6393 extern
6395  SCIP* scip, /**< SCIP data structure */
6396  SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
6397  SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
6398  SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
6399  int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
6400  int nmonomials /**< pointer to store number of parsed monomials */
6401  );
6402 
6403 /** increases usage counter of variable
6404  *
6405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6407  *
6408  * @pre This method can be called if @p scip is in one of the following stages:
6409  * - \ref SCIP_STAGE_PROBLEM
6410  * - \ref SCIP_STAGE_TRANSFORMING
6411  * - \ref SCIP_STAGE_TRANSFORMED
6412  * - \ref SCIP_STAGE_INITPRESOLVE
6413  * - \ref SCIP_STAGE_PRESOLVING
6414  * - \ref SCIP_STAGE_EXITPRESOLVE
6415  * - \ref SCIP_STAGE_PRESOLVED
6416  * - \ref SCIP_STAGE_INITSOLVE
6417  * - \ref SCIP_STAGE_SOLVING
6418  * - \ref SCIP_STAGE_SOLVED
6419  * - \ref SCIP_STAGE_EXITSOLVE
6420  */
6421 extern
6423  SCIP* scip, /**< SCIP data structure */
6424  SCIP_VAR* var /**< variable to capture */
6425  );
6426 
6427 /** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
6428  *
6429  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6430  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6431  *
6432  * @pre This method can be called if @p scip is in one of the following stages:
6433  * - \ref SCIP_STAGE_PROBLEM
6434  * - \ref SCIP_STAGE_TRANSFORMING
6435  * - \ref SCIP_STAGE_TRANSFORMED
6436  * - \ref SCIP_STAGE_INITPRESOLVE
6437  * - \ref SCIP_STAGE_PRESOLVING
6438  * - \ref SCIP_STAGE_EXITPRESOLVE
6439  * - \ref SCIP_STAGE_PRESOLVED
6440  * - \ref SCIP_STAGE_INITSOLVE
6441  * - \ref SCIP_STAGE_SOLVING
6442  * - \ref SCIP_STAGE_SOLVED
6443  * - \ref SCIP_STAGE_EXITSOLVE
6444  * - \ref SCIP_STAGE_FREETRANS
6445  *
6446  * @note the pointer of the variable will be NULLed
6447  */
6448 extern
6450  SCIP* scip, /**< SCIP data structure */
6451  SCIP_VAR** var /**< pointer to variable */
6452  );
6453 
6454 /** changes the name of a variable
6455  *
6456  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6457  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6458  *
6459  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM
6460  *
6461  * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h
6462  */
6463 extern
6465  SCIP* scip, /**< SCIP data structure */
6466  SCIP_VAR* var, /**< variable */
6467  const char* name /**< new name of constraint */
6468  );
6469 
6470 /** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
6471  * a new transformed variable for this variable is created
6472  *
6473  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6474  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6475  *
6476  * @pre This method can be called if @p scip is in one of the following stages:
6477  * - \ref SCIP_STAGE_TRANSFORMING
6478  * - \ref SCIP_STAGE_TRANSFORMED
6479  * - \ref SCIP_STAGE_INITPRESOLVE
6480  * - \ref SCIP_STAGE_PRESOLVING
6481  * - \ref SCIP_STAGE_EXITPRESOLVE
6482  * - \ref SCIP_STAGE_PRESOLVED
6483  * - \ref SCIP_STAGE_INITSOLVE
6484  * - \ref SCIP_STAGE_SOLVING
6485  */
6486 extern
6488  SCIP* scip, /**< SCIP data structure */
6489  SCIP_VAR* var, /**< variable to get/create transformed variable for */
6490  SCIP_VAR** transvar /**< pointer to store the transformed variable */
6491  );
6492 
6493 /** gets and captures transformed variables for an array of variables;
6494  * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
6495  * it is possible to call this method with vars == transvars
6496  *
6497  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6498  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6499  *
6500  * @pre This method can be called if @p scip is in one of the following stages:
6501  * - \ref SCIP_STAGE_TRANSFORMING
6502  * - \ref SCIP_STAGE_TRANSFORMED
6503  * - \ref SCIP_STAGE_INITPRESOLVE
6504  * - \ref SCIP_STAGE_PRESOLVING
6505  * - \ref SCIP_STAGE_EXITPRESOLVE
6506  * - \ref SCIP_STAGE_PRESOLVED
6507  * - \ref SCIP_STAGE_INITSOLVE
6508  * - \ref SCIP_STAGE_SOLVING
6509  */
6510 extern
6512  SCIP* scip, /**< SCIP data structure */
6513  int nvars, /**< number of variables to get/create transformed variables for */
6514  SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */
6515  SCIP_VAR** transvars /**< array to store the transformed variables */
6516  );
6517 
6518 /** gets corresponding transformed variable of a given variable;
6519  * returns NULL as transvar, if transformed variable is not yet existing
6520  *
6521  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6522  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6523  *
6524  * @pre This method can be called if @p scip is in one of the following stages:
6525  * - \ref SCIP_STAGE_TRANSFORMING
6526  * - \ref SCIP_STAGE_TRANSFORMED
6527  * - \ref SCIP_STAGE_INITPRESOLVE
6528  * - \ref SCIP_STAGE_PRESOLVING
6529  * - \ref SCIP_STAGE_EXITPRESOLVE
6530  * - \ref SCIP_STAGE_PRESOLVED
6531  * - \ref SCIP_STAGE_INITSOLVE
6532  * - \ref SCIP_STAGE_SOLVING
6533  * - \ref SCIP_STAGE_SOLVED
6534  * - \ref SCIP_STAGE_EXITSOLVE
6535  * - \ref SCIP_STAGE_FREETRANS
6536  */
6537 extern
6539  SCIP* scip, /**< SCIP data structure */
6540  SCIP_VAR* var, /**< variable to get transformed variable for */
6541  SCIP_VAR** transvar /**< pointer to store the transformed variable */
6542  );
6543 
6544 /** gets corresponding transformed variables for an array of variables;
6545  * stores NULL in a transvars slot, if the transformed variable is not yet existing;
6546  * it is possible to call this method with vars == transvars, but remember that variables that are not
6547  * yet transformed will be replaced with NULL
6548  *
6549  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6550  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6551  *
6552  * @pre This method can be called if @p scip is in one of the following stages:
6553  * - \ref SCIP_STAGE_TRANSFORMING
6554  * - \ref SCIP_STAGE_TRANSFORMED
6555  * - \ref SCIP_STAGE_INITPRESOLVE
6556  * - \ref SCIP_STAGE_PRESOLVING
6557  * - \ref SCIP_STAGE_EXITPRESOLVE
6558  * - \ref SCIP_STAGE_PRESOLVED
6559  * - \ref SCIP_STAGE_INITSOLVE
6560  * - \ref SCIP_STAGE_SOLVING
6561  * - \ref SCIP_STAGE_SOLVED
6562  * - \ref SCIP_STAGE_EXITSOLVE
6563  * - \ref SCIP_STAGE_FREETRANS
6564  */
6565 extern
6567  SCIP* scip, /**< SCIP data structure */
6568  int nvars, /**< number of variables to get transformed variables for */
6569  SCIP_VAR** vars, /**< array with variables to get transformed variables for */
6570  SCIP_VAR** transvars /**< array to store the transformed variables */
6571  );
6572 
6573 /** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing
6574  *
6575  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6576  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6577  *
6578  * @pre This method can be called if @p scip is in one of the following stages:
6579  * - \ref SCIP_STAGE_PROBLEM
6580  * - \ref SCIP_STAGE_TRANSFORMING
6581  * - \ref SCIP_STAGE_TRANSFORMED
6582  * - \ref SCIP_STAGE_INITPRESOLVE
6583  * - \ref SCIP_STAGE_PRESOLVING
6584  * - \ref SCIP_STAGE_EXITPRESOLVE
6585  * - \ref SCIP_STAGE_PRESOLVED
6586  * - \ref SCIP_STAGE_INITSOLVE
6587  * - \ref SCIP_STAGE_SOLVING
6588  * - \ref SCIP_STAGE_SOLVED
6589  * - \ref SCIP_STAGE_EXITSOLVE
6590  * - \ref SCIP_STAGE_FREETRANS
6591  */
6592 extern
6594  SCIP* scip, /**< SCIP data structure */
6595  SCIP_VAR* var, /**< variable to get negated variable for */
6596  SCIP_VAR** negvar /**< pointer to store the negated variable */
6597  );
6598 
6599 /** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing
6600  *
6601  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6602  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6603  *
6604  * @pre This method can be called if @p scip is in one of the following stages:
6605  * - \ref SCIP_STAGE_PROBLEM
6606  * - \ref SCIP_STAGE_TRANSFORMING
6607  * - \ref SCIP_STAGE_TRANSFORMED
6608  * - \ref SCIP_STAGE_INITPRESOLVE
6609  * - \ref SCIP_STAGE_PRESOLVING
6610  * - \ref SCIP_STAGE_EXITPRESOLVE
6611  * - \ref SCIP_STAGE_PRESOLVED
6612  * - \ref SCIP_STAGE_INITSOLVE
6613  * - \ref SCIP_STAGE_SOLVING
6614  * - \ref SCIP_STAGE_SOLVED
6615  * - \ref SCIP_STAGE_EXITSOLVE
6616  * - \ref SCIP_STAGE_FREETRANS
6617  */
6618 extern
6620  SCIP* scip, /**< SCIP data structure */
6621  int nvars, /**< number of variables to get negated variables for */
6622  SCIP_VAR** vars, /**< array of variables to get negated variables for */
6623  SCIP_VAR** negvars /**< array to store the negated variables */
6624  );
6625 
6626 /** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
6627  * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
6628  *
6629  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6630  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6631  *
6632  * @pre This method can be called if @p scip is in one of the following stages:
6633  * - \ref SCIP_STAGE_PROBLEM
6634  * - \ref SCIP_STAGE_TRANSFORMED
6635  * - \ref SCIP_STAGE_INITPRESOLVE
6636  * - \ref SCIP_STAGE_PRESOLVING
6637  * - \ref SCIP_STAGE_EXITPRESOLVE
6638  * - \ref SCIP_STAGE_PRESOLVED
6639  * - \ref SCIP_STAGE_INITSOLVE
6640  * - \ref SCIP_STAGE_SOLVING
6641  * - \ref SCIP_STAGE_SOLVED
6642  * - \ref SCIP_STAGE_EXITSOLVE
6643  */
6644 extern
6646  SCIP* scip, /**< SCIP data structure */
6647  SCIP_VAR* var, /**< binary variable to get binary representative for */
6648  SCIP_VAR** repvar, /**< pointer to store the binary representative */
6649  SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
6650  );
6651 
6652 /** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
6653  * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
6654  *
6655  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6656  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6657  *
6658  * @pre This method can be called if @p scip is in one of the following stages:
6659  * - \ref SCIP_STAGE_PROBLEM
6660  * - \ref SCIP_STAGE_TRANSFORMED
6661  * - \ref SCIP_STAGE_INITPRESOLVE
6662  * - \ref SCIP_STAGE_PRESOLVING
6663  * - \ref SCIP_STAGE_EXITPRESOLVE
6664  * - \ref SCIP_STAGE_PRESOLVED
6665  * - \ref SCIP_STAGE_INITSOLVE
6666  * - \ref SCIP_STAGE_SOLVING
6667  * - \ref SCIP_STAGE_SOLVED
6668  * - \ref SCIP_STAGE_EXITSOLVE
6669  */
6670 extern
6672  SCIP* scip, /**< SCIP data structure */
6673  int nvars, /**< number of binary variables to get representatives for */
6674  SCIP_VAR** vars, /**< binary variables to get binary representatives for */
6675  SCIP_VAR** repvars, /**< array to store the binary representatives */
6676  SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
6677  );
6678 
6679 /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
6680  *
6681  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6682  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6683  *
6684  * @pre This method can be called if @p scip is in one of the following stages:
6685  * - \ref SCIP_STAGE_INITPRESOLVE
6686  * - \ref SCIP_STAGE_PRESOLVING
6687  * - \ref SCIP_STAGE_EXITPRESOLVE
6688  * - \ref SCIP_STAGE_PRESOLVED
6689  * - \ref SCIP_STAGE_INITSOLVE
6690  * - \ref SCIP_STAGE_SOLVING
6691  * - \ref SCIP_STAGE_SOLVED
6692  */
6693 extern
6695  SCIP* scip, /**< SCIP data structure */
6696  SCIP_VAR* var /**< problem variable */
6697  );
6698 
6699 /** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
6700  * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
6701  *
6702  * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
6703  * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
6704  * representation is stored in the variable array, scalar array and constant.
6705  *
6706  * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
6707  * allocated (e.g., by a C++ 'new' or SCIP functions).
6708  *
6709  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6710  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6711  *
6712  * @pre This method can be called if @p scip is in one of the following stages:
6713  * - \ref SCIP_STAGE_TRANSFORMED
6714  * - \ref SCIP_STAGE_INITPRESOLVE
6715  * - \ref SCIP_STAGE_PRESOLVING
6716  * - \ref SCIP_STAGE_EXITPRESOLVE
6717  * - \ref SCIP_STAGE_PRESOLVED
6718  * - \ref SCIP_STAGE_INITSOLVE
6719  * - \ref SCIP_STAGE_SOLVING
6720  * - \ref SCIP_STAGE_SOLVED
6721  * - \ref SCIP_STAGE_EXITSOLVE
6722  * - \ref SCIP_STAGE_FREETRANS
6723  *
6724  * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
6725  * given entries are overwritten.
6726  *
6727  * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
6728  * the method with the linear sum 1.0*x + 0.0.
6729  */
6730 extern
6732  SCIP* scip, /**< SCIP data structure */
6733  SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
6734  * overwritten by the variable array y_1, ..., y_m in the linear sum
6735  * w.r.t. active variables */
6736  SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
6737  * scalars b_1, ..., b_m in the linear sum of the active variables */
6738  int* nvars, /**< pointer to number of variables in the linear sum which will be
6739  * overwritten by the number of variables in the linear sum corresponding
6740  * to the active variables */
6741  int varssize, /**< available slots in vars and scalars array which is needed to check if
6742  * the array are large enough for the linear sum w.r.t. active
6743  * variables */
6744  SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
6745  * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
6746  * d w.r.t. the active variables */
6747  int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
6748  * active variables */
6749  SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
6750  );
6751 
6752 /** transforms given variable, scalar and constant to the corresponding active, fixed, or
6753  * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
6754  * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
6755  * with only one active variable (this can happen due to fixings after the multi-aggregation),
6756  * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
6757  *
6758  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6759  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6760  *
6761  * @pre This method can be called if @p scip is in one of the following stages:
6762  * - \ref SCIP_STAGE_TRANSFORMED
6763  * - \ref SCIP_STAGE_INITPRESOLVE
6764  * - \ref SCIP_STAGE_PRESOLVING
6765  * - \ref SCIP_STAGE_EXITPRESOLVE
6766  * - \ref SCIP_STAGE_PRESOLVED
6767  * - \ref SCIP_STAGE_INITSOLVE
6768  * - \ref SCIP_STAGE_SOLVING
6769  * - \ref SCIP_STAGE_SOLVED
6770  * - \ref SCIP_STAGE_EXITSOLVE
6771  * - \ref SCIP_STAGE_FREETRANS
6772  */
6773 extern
6775  SCIP* scip, /**< SCIP data structure */
6776  SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
6777  SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
6778  SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
6779  );
6780 
6781 /** return for given variables all their active counterparts; all active variables will be pairwise different
6782  * @note It does not hold that the first output variable is the active variable for the first input variable.
6783  *
6784  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6785  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6786  *
6787  * @pre This method can be called if @p scip is in one of the following stages:
6788  * - \ref SCIP_STAGE_TRANSFORMED
6789  * - \ref SCIP_STAGE_INITPRESOLVE
6790  * - \ref SCIP_STAGE_PRESOLVING
6791  * - \ref SCIP_STAGE_EXITPRESOLVE
6792  * - \ref SCIP_STAGE_PRESOLVED
6793  * - \ref SCIP_STAGE_INITSOLVE
6794  * - \ref SCIP_STAGE_SOLVING
6795  * - \ref SCIP_STAGE_SOLVED
6796  * - \ref SCIP_STAGE_EXITSOLVE
6797  * - \ref SCIP_STAGE_FREETRANS
6798  */
6799 extern
6801  SCIP* scip, /**< SCIP data structure */
6802  SCIP_VAR** vars, /**< variable array with given variables and as output all active
6803  * variables, if enough slots exist */
6804  int* nvars, /**< number of given variables, and as output number of active variables,
6805  * if enough slots exist */
6806  int varssize, /**< available slots in vars array */
6807  int* requiredsize /**< pointer to store the required array size for the active variables */
6808  );
6809 
6810 /** returns the reduced costs of the variable in the current node's LP relaxation;
6811  * the current node has to have a feasible LP.
6812  *
6813  * returns SCIP_INVALID if the variable is active but not in the current LP;
6814  * returns 0 if the variable has been aggregated out or fixed in presolving.
6815  *
6816  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
6817  */
6818 extern
6820  SCIP* scip, /**< SCIP data structure */
6821  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
6822  );
6823 
6824 /** returns the implied reduced costs of the variable in the current node's LP relaxation;
6825  * the current node has to have a feasible LP.
6826  *
6827  * returns SCIP_INVALID if the variable is active but not in the current LP;
6828  * returns 0 if the variable has been aggregated out or fixed in presolving.
6829  *
6830  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
6831  */
6832 extern
6834  SCIP* scip, /**< SCIP data structure */
6835  SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */
6836  SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */
6837  );
6838 
6839 /** returns the Farkas coefficient of the variable in the current node's LP relaxation;
6840  * the current node has to have an infeasible LP.
6841  *
6842  * returns SCIP_INVALID if the variable is active but not in the current LP;
6843  * returns 0 if the variable has been aggregated out or fixed in presolving.
6844  *
6845  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
6846  */
6847 extern
6849  SCIP* scip, /**< SCIP data structure */
6850  SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
6851  );
6852 
6853 /** gets solution value for variable in current node
6854  *
6855  * @return solution value for variable in current node
6856  *
6857  * @pre This method can be called if @p scip is in one of the following stages:
6858  * - \ref SCIP_STAGE_PRESOLVED
6859  * - \ref SCIP_STAGE_SOLVING
6860  */
6861 extern
6863  SCIP* scip, /**< SCIP data structure */
6864  SCIP_VAR* var /**< variable to get solution value for */
6865  );
6866 
6867 /** gets solution values of multiple variables in current node
6868  *
6869  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6870  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6871  *
6872  * @pre This method can be called if @p scip is in one of the following stages:
6873  * - \ref SCIP_STAGE_PRESOLVED
6874  * - \ref SCIP_STAGE_SOLVING
6875  */
6876 extern
6878  SCIP* scip, /**< SCIP data structure */
6879  int nvars, /**< number of variables to get solution value for */
6880  SCIP_VAR** vars, /**< array with variables to get value for */
6881  SCIP_Real* vals /**< array to store solution values of variables */
6882  );
6883 
6884 /** sets the solution value of all variables in the global relaxation solution to zero
6885  *
6886  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6887  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6888  *
6889  * @pre This method can be called if @p scip is in one of the following stages:
6890  * - \ref SCIP_STAGE_PRESOLVED
6891  * - \ref SCIP_STAGE_SOLVING
6892  */
6893 extern
6895  SCIP* scip /**< SCIP data structure */
6896  );
6897 
6898 /** sets the value of the given variable in the global relaxation solution;
6899  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
6900  * You can use SCIPclearRelaxSolVals() to set all values to zero, initially;
6901  * after setting all solution values, you have to call SCIPmarkRelaxSolValid()
6902  * to inform SCIP that the stored solution is valid
6903  *
6904  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6905  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6906  *
6907  * @pre This method can be called if @p scip is in one of the following stages:
6908  * - \ref SCIP_STAGE_PRESOLVED
6909  * - \ref SCIP_STAGE_SOLVING
6910  */
6911 extern
6913  SCIP* scip, /**< SCIP data structure */
6914  SCIP_VAR* var, /**< variable to set value for */
6915  SCIP_Real val /**< solution value of variable */
6916  );
6917 
6918 /** sets the values of the given variables in the global relaxation solution;
6919  * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
6920  * the solution is automatically cleared, s.t. all other variables get value 0.0
6921  *
6922  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6923  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6924  *
6925  * @pre This method can be called if @p scip is in one of the following stages:
6926  * - \ref SCIP_STAGE_PRESOLVED
6927  * - \ref SCIP_STAGE_SOLVING
6928  */
6929 extern
6931  SCIP* scip, /**< SCIP data structure */
6932  int nvars, /**< number of variables to set relaxation solution value for */
6933  SCIP_VAR** vars, /**< array with variables to set value for */
6934  SCIP_Real* vals /**< array with solution values of variables */
6935  );
6936 
6937 /** sets the values of the variables in the global relaxation solution to the values
6938  * in the given primal solution; the relaxation solution can be filled by the relaxation hanlders
6939  * and might be used by heuristics and for separation
6940  *
6941  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6942  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6943  *
6944  * @pre This method can be called if @p scip is in one of the following stages:
6945  * - \ref SCIP_STAGE_PRESOLVED
6946  * - \ref SCIP_STAGE_SOLVING
6947  */
6948 extern
6950  SCIP* scip, /**< SCIP data structure */
6951  SCIP_SOL* sol /**< primal relaxation solution */
6952  );
6953 
6954 /** returns whether the relaxation solution is valid
6955  *
6956  * @return TRUE, if the relaxation solution is valid; FALSE, otherwise
6957  *
6958  * @pre This method can be called if @p scip is in one of the following stages:
6959  * - \ref SCIP_STAGE_PRESOLVED
6960  * - \ref SCIP_STAGE_SOLVING
6961  */
6962 extern
6964  SCIP* scip /**< SCIP data structure */
6965  );
6966 
6967 /** informs SCIP, that the relaxation solution is valid
6968  *
6969  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6970  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6971  *
6972  * @pre This method can be called if @p scip is in one of the following stages:
6973  * - \ref SCIP_STAGE_PRESOLVED
6974  * - \ref SCIP_STAGE_SOLVING
6975  */
6976 extern
6978  SCIP* scip /**< SCIP data structure */
6979  );
6980 
6981 /** informs SCIP, that the relaxation solution is invalid
6982  *
6983  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
6984  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
6985  *
6986  * @pre This method can be called if @p scip is in one of the following stages:
6987  * - \ref SCIP_STAGE_PRESOLVED
6988  * - \ref SCIP_STAGE_SOLVING
6989  */
6990 extern
6992  SCIP* scip /**< SCIP data structure */
6993  );
6994 
6995 /** gets the relaxation solution value of the given variable
6996  *
6997  * @return the relaxation solution value of the given variable
6998  *
6999  * @pre This method can be called if @p scip is in one of the following stages:
7000  * - \ref SCIP_STAGE_PRESOLVED
7001  * - \ref SCIP_STAGE_SOLVING
7002  */
7003 extern
7005  SCIP* scip, /**< SCIP data structure */
7006  SCIP_VAR* var /**< variable to get value for */
7007  );
7008 
7009 /** gets the relaxation solution objective value
7010  *
7011  * @return the objective value of the relaxation solution
7012  *
7013  * @pre This method can be called if @p scip is in one of the following stages:
7014  * - \ref SCIP_STAGE_PRESOLVED
7015  * - \ref SCIP_STAGE_SOLVING
7016  */
7017 extern
7019  SCIP* scip /**< SCIP data structure */
7020  );
7021 
7022 /** start strong branching - call before any strong branching
7023  *
7024  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7025  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7026  *
7027  * @pre This method can be called if @p scip is in one of the following stages:
7028  * - \ref SCIP_STAGE_PRESOLVED
7029  * - \ref SCIP_STAGE_SOLVING
7030  *
7031  * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
7032  * which allow to perform propagation but also creates some overhead
7033  */
7034 extern
7036  SCIP* scip, /**< SCIP data structure */
7037  SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
7038  );
7039 
7040 /** end strong branching - call after any strong branching
7041  *
7042  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7043  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7044  *
7045  * @pre This method can be called if @p scip is in one of the following stages:
7046  * - \ref SCIP_STAGE_PRESOLVED
7047  * - \ref SCIP_STAGE_SOLVING
7048  */
7049 extern
7051  SCIP* scip /**< SCIP data structure */
7052  );
7053 
7054 /** gets strong branching information on column variable with fractional value
7055  *
7056  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7057  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7058  *
7059  * @pre This method can be called if @p scip is in one of the following stages:
7060  * - \ref SCIP_STAGE_PRESOLVED
7061  * - \ref SCIP_STAGE_SOLVING
7062  */
7063 extern
7065  SCIP* scip, /**< SCIP data structure */
7066  SCIP_VAR* var, /**< variable to get strong branching values for */
7067  int itlim, /**< iteration limit for strong branchings */
7068  SCIP_Real* down, /**< stores dual bound after branching column down */
7069  SCIP_Real* up, /**< stores dual bound after branching column up */
7070  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
7071  * otherwise, it can only be used as an estimate value */
7072  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
7073  * otherwise, it can only be used as an estimate value */
7074  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
7075  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
7076  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
7077  * infeasible downwards branch, or NULL */
7078  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
7079  * infeasible upwards branch, or NULL */
7080  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
7081  * solving process should be stopped (e.g., due to a time limit) */
7082  );
7083 
7084 /** gets strong branching information with previous domain propagation on column variable
7085  *
7086  * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
7087  * after strong branching was done for all candidate variables, the strong branching mode must be ended by
7088  * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
7089  * enabled in the SCIPstartStrongbranch() call.
7090  *
7091  * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
7092  * can be specified by the parameter @p maxproprounds.
7093  *
7094  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7095  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7096  *
7097  * @pre This method can be called if @p scip is in one of the following stages:
7098  * - \ref SCIP_STAGE_PRESOLVED
7099  * - \ref SCIP_STAGE_SOLVING
7100  *
7101  * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
7102  * they are updated w.r.t. the strong branching LP solution.
7103  */
7104 extern
7106  SCIP* scip, /**< SCIP data structure */
7107  SCIP_VAR* var, /**< variable to get strong branching values for */
7108  SCIP_Real solval, /**< value of the variable in the current LP solution */
7109  SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
7110  int itlim, /**< iteration limit for strong branchings */
7111  int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
7112  * settings) */
7113  SCIP_Real* down, /**< stores dual bound after branching column down */
7114  SCIP_Real* up, /**< stores dual bound after branching column up */
7115  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
7116  * otherwise, it can only be used as an estimate value */
7117  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
7118  * otherwise, it can only be used as an estimate value */
7119  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
7120  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
7121  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
7122  * infeasible downwards branch, or NULL */
7123  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
7124  * infeasible upwards branch, or NULL */
7125  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
7126  * solving process should be stopped (e.g., due to a time limit) */
7127  SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
7128  SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
7129  );
7130 
7131 /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
7132  * is (val -1.0) and the up brach ins (val +1.0)
7133  *
7134  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7135  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7136  *
7137  * @pre This method can be called if @p scip is in one of the following stages:
7138  * - \ref SCIP_STAGE_PRESOLVED
7139  * - \ref SCIP_STAGE_SOLVING
7140  *
7141  * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
7142  * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
7143  */
7144 extern
7146  SCIP* scip, /**< SCIP data structure */
7147  SCIP_VAR* var, /**< variable to get strong branching values for */
7148  int itlim, /**< iteration limit for strong branchings */
7149  SCIP_Real* down, /**< stores dual bound after branching column down */
7150  SCIP_Real* up, /**< stores dual bound after branching column up */
7151  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
7152  * otherwise, it can only be used as an estimate value */
7153  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
7154  * otherwise, it can only be used as an estimate value */
7155  SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
7156  SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
7157  SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
7158  * infeasible downwards branch, or NULL */
7159  SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
7160  * infeasible upwards branch, or NULL */
7161  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
7162  * solving process should be stopped (e.g., due to a time limit) */
7163  );
7164 
7165 /** gets strong branching information on column variables with fractional values
7166  *
7167  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7168  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7169  *
7170  * @pre This method can be called if @p scip is in one of the following stages:
7171  * - \ref SCIP_STAGE_PRESOLVED
7172  * - \ref SCIP_STAGE_SOLVING
7173  */
7174 extern
7176  SCIP* scip, /**< SCIP data structure */
7177  SCIP_VAR** vars, /**< variables to get strong branching values for */
7178  int nvars, /**< number of variables */
7179  int itlim, /**< iteration limit for strong branchings */
7180  SCIP_Real* down, /**< stores dual bounds after branching variables down */
7181  SCIP_Real* up, /**< stores dual bounds after branching variables up */
7182  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
7183  * otherwise, they can only be used as an estimate value */
7184  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
7185  * otherwise, they can only be used as an estimate value */
7186  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
7187  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
7188  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
7189  * infeasible downward branches, or NULL */
7190  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
7191  * infeasible upward branches, or NULL */
7192  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
7193  * solving process should be stopped (e.g., due to a time limit) */
7194  );
7195 
7196 /** gets strong branching information on column variables with integral values
7197  *
7198  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7199  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7200  *
7201  * @pre This method can be called if @p scip is in one of the following stages:
7202  * - \ref SCIP_STAGE_PRESOLVED
7203  * - \ref SCIP_STAGE_SOLVING
7204  */
7205 extern
7207  SCIP* scip, /**< SCIP data structure */
7208  SCIP_VAR** vars, /**< variables to get strong branching values for */
7209  int nvars, /**< number of variables */
7210  int itlim, /**< iteration limit for strong branchings */
7211  SCIP_Real* down, /**< stores dual bounds after branching variables down */
7212  SCIP_Real* up, /**< stores dual bounds after branching variables up */
7213  SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
7214  * otherwise, they can only be used as an estimate value */
7215  SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
7216  * otherwise, they can only be used as an estimate value */
7217  SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
7218  SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
7219  SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
7220  * infeasible downward branches, or NULL */
7221  SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
7222  * infeasible upward branches, or NULL */
7223  SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
7224  * solving process should be stopped (e.g., due to a time limit) */
7225  );
7226 
7227 /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
7228  * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
7229  * keep in mind, that the returned old values may have nothing to do with the current LP solution
7230  *
7231  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7232  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7233  *
7234  * @pre This method can be called if @p scip is in one of the following stages:
7235  * - \ref SCIP_STAGE_SOLVING
7236  * - \ref SCIP_STAGE_SOLVED
7237  */
7238 extern
7240  SCIP* scip, /**< SCIP data structure */
7241  SCIP_VAR* var, /**< variable to get last strong branching values for */
7242  SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
7243  SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
7244  SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
7245  * otherwise, it can only be used as an estimate value */
7246  SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
7247  * otherwise, it can only be used as an estimate value */
7248  SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */
7249  SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
7250  );
7251 
7252 /** gets node number of the last node in current branch and bound run, where strong branching was used on the
7253  * given variable, or -1 if strong branching was never applied to the variable in current run
7254  *
7255  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7256  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7257  *
7258  * @pre This method can be called if @p scip is in one of the following stages:
7259  * - \ref SCIP_STAGE_TRANSFORMING
7260  * - \ref SCIP_STAGE_TRANSFORMED
7261  * - \ref SCIP_STAGE_INITPRESOLVE
7262  * - \ref SCIP_STAGE_PRESOLVING
7263  * - \ref SCIP_STAGE_EXITPRESOLVE
7264  * - \ref SCIP_STAGE_PRESOLVED
7265  * - \ref SCIP_STAGE_INITSOLVE
7266  * - \ref SCIP_STAGE_SOLVING
7267  * - \ref SCIP_STAGE_SOLVED
7268  * - \ref SCIP_STAGE_EXITSOLVE
7269  */
7270 extern
7272  SCIP* scip, /**< SCIP data structure */
7273  SCIP_VAR* var /**< variable to get last strong branching node for */
7274  );
7275 
7276 /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
7277  * the LP where the strong branching on this variable was applied;
7278  * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
7279  *
7280  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7281  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7282  *
7283  * @pre This method can be called if @p scip is in one of the following stages:
7284  * - \ref SCIP_STAGE_TRANSFORMING
7285  * - \ref SCIP_STAGE_TRANSFORMED
7286  * - \ref SCIP_STAGE_INITPRESOLVE
7287  * - \ref SCIP_STAGE_PRESOLVING
7288  * - \ref SCIP_STAGE_EXITPRESOLVE
7289  * - \ref SCIP_STAGE_PRESOLVED
7290  * - \ref SCIP_STAGE_INITSOLVE
7291  * - \ref SCIP_STAGE_SOLVING
7292  * - \ref SCIP_STAGE_SOLVED
7293  * - \ref SCIP_STAGE_EXITSOLVE
7294  */
7295 extern
7297  SCIP* scip, /**< SCIP data structure */
7298  SCIP_VAR* var /**< variable to get strong branching LP age for */
7299  );
7300 
7301 /** gets number of times, strong branching was applied in current run on the given variable
7302  *
7303  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7304  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7305  *
7306  * @pre This method can be called if @p scip is in one of the following stages:
7307  * - \ref SCIP_STAGE_TRANSFORMING
7308  * - \ref SCIP_STAGE_TRANSFORMED
7309  * - \ref SCIP_STAGE_INITPRESOLVE
7310  * - \ref SCIP_STAGE_PRESOLVING
7311  * - \ref SCIP_STAGE_EXITPRESOLVE
7312  * - \ref SCIP_STAGE_PRESOLVED
7313  * - \ref SCIP_STAGE_INITSOLVE
7314  * - \ref SCIP_STAGE_SOLVING
7315  * - \ref SCIP_STAGE_SOLVED
7316  * - \ref SCIP_STAGE_EXITSOLVE
7317  */
7318 extern
7320  SCIP* scip, /**< SCIP data structure */
7321  SCIP_VAR* var /**< variable to get last strong branching node for */
7322  );
7323 
7324 /** adds given values to lock numbers of variable for rounding
7325  *
7326  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7327  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7328  *
7329  * @pre This method can be called if @p scip is in one of the following stages:
7330  * - \ref SCIP_STAGE_PROBLEM
7331  * - \ref SCIP_STAGE_TRANSFORMING
7332  * - \ref SCIP_STAGE_TRANSFORMED
7333  * - \ref SCIP_STAGE_INITPRESOLVE
7334  * - \ref SCIP_STAGE_PRESOLVING
7335  * - \ref SCIP_STAGE_EXITPRESOLVE
7336  * - \ref SCIP_STAGE_PRESOLVED
7337  * - \ref SCIP_STAGE_INITSOLVE
7338  * - \ref SCIP_STAGE_SOLVING
7339  * - \ref SCIP_STAGE_EXITSOLVE
7340  * - \ref SCIP_STAGE_FREETRANS
7341  */
7342 extern
7344  SCIP* scip, /**< SCIP data structure */
7345  SCIP_VAR* var, /**< problem variable */
7346  int nlocksdown, /**< modification in number of rounding down locks */
7347  int nlocksup /**< modification in number of rounding up locks */
7348  );
7349 
7350 /** locks rounding of variable with respect to the lock status of the constraint and its negation;
7351  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
7352  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
7353  * added or removed
7354  *
7355  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7356  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7357  *
7358  * @pre This method can be called if @p scip is in one of the following stages:
7359  * - \ref SCIP_STAGE_PROBLEM
7360  * - \ref SCIP_STAGE_TRANSFORMING
7361  * - \ref SCIP_STAGE_INITPRESOLVE
7362  * - \ref SCIP_STAGE_PRESOLVING
7363  * - \ref SCIP_STAGE_EXITPRESOLVE
7364  * - \ref SCIP_STAGE_INITSOLVE
7365  * - \ref SCIP_STAGE_SOLVING
7366  * - \ref SCIP_STAGE_EXITSOLVE
7367  * - \ref SCIP_STAGE_FREETRANS
7368  */
7369 extern
7371  SCIP* scip, /**< SCIP data structure */
7372  SCIP_VAR* var, /**< problem variable */
7373  SCIP_CONS* cons, /**< constraint */
7374  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
7375  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
7376  );
7377 
7378 /** unlocks rounding of variable with respect to the lock status of the constraint and its negation;
7379  * this method should be called whenever the lock status of a variable in a constraint changes, for example if
7380  * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
7381  * added or removed
7382  *
7383  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7384  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7385  *
7386  * @pre This method can be called if @p scip is in one of the following stages:
7387  * - \ref SCIP_STAGE_PROBLEM
7388  * - \ref SCIP_STAGE_TRANSFORMING
7389  * - \ref SCIP_STAGE_INITPRESOLVE
7390  * - \ref SCIP_STAGE_PRESOLVING
7391  * - \ref SCIP_STAGE_EXITPRESOLVE
7392  * - \ref SCIP_STAGE_INITSOLVE
7393  * - \ref SCIP_STAGE_SOLVING
7394  * - \ref SCIP_STAGE_EXITSOLVE
7395  * - \ref SCIP_STAGE_FREETRANS
7396  */
7397 extern
7399  SCIP* scip, /**< SCIP data structure */
7400  SCIP_VAR* var, /**< problem variable */
7401  SCIP_CONS* cons, /**< constraint */
7402  SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
7403  SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
7404  );
7405 
7406 /** changes variable's objective value
7407  *
7408  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7409  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7410  *
7411  * @pre This method can be called if @p scip is in one of the following stages:
7412  * - \ref SCIP_STAGE_PROBLEM
7413  * - \ref SCIP_STAGE_TRANSFORMING
7414  * - \ref SCIP_STAGE_PRESOLVING
7415  */
7416 extern
7418  SCIP* scip, /**< SCIP data structure */
7419  SCIP_VAR* var, /**< variable to change the objective value for */
7420  SCIP_Real newobj /**< new objective value */
7421  );
7422 
7423 /** adds value to variable's objective value
7424  *
7425  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7426  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7427  *
7428  * @pre This method can be called if @p scip is in one of the following stages:
7429  * - \ref SCIP_STAGE_PROBLEM
7430  * - \ref SCIP_STAGE_TRANSFORMING
7431  * - \ref SCIP_STAGE_PRESOLVING
7432  */
7433 extern
7435  SCIP* scip, /**< SCIP data structure */
7436  SCIP_VAR* var, /**< variable to change the objective value for */
7437  SCIP_Real addobj /**< additional objective value */
7438  );
7439 
7440 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
7441  * does not change the bounds of the variable
7442  *
7443  * @return adjusted lower bound for the given variable; the bound of the variable is not changed
7444  *
7445  * @pre This method can be called if @p scip is in one of the following stages:
7446  * - \ref SCIP_STAGE_PROBLEM
7447  * - \ref SCIP_STAGE_TRANSFORMING
7448  * - \ref SCIP_STAGE_TRANSFORMED
7449  * - \ref SCIP_STAGE_INITPRESOLVE
7450  * - \ref SCIP_STAGE_PRESOLVING
7451  * - \ref SCIP_STAGE_EXITPRESOLVE
7452  * - \ref SCIP_STAGE_PRESOLVED
7453  * - \ref SCIP_STAGE_INITSOLVE
7454  * - \ref SCIP_STAGE_SOLVING
7455  * - \ref SCIP_STAGE_SOLVED
7456  * - \ref SCIP_STAGE_EXITSOLVE
7457  * - \ref SCIP_STAGE_FREETRANS
7458  */
7459 extern
7461  SCIP* scip, /**< SCIP data structure */
7462  SCIP_VAR* var, /**< variable to adjust the bound for */
7463  SCIP_Real lb /**< lower bound value to adjust */
7464  );
7465 
7466 /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
7467  * does not change the bounds of the variable
7468  *
7469  * @return adjusted upper bound for the given variable; the bound of the variable is not changed
7470  *
7471  * @pre This method can be called if @p scip is in one of the following stages:
7472  * - \ref SCIP_STAGE_PROBLEM
7473  * - \ref SCIP_STAGE_TRANSFORMING
7474  * - \ref SCIP_STAGE_TRANSFORMED
7475  * - \ref SCIP_STAGE_INITPRESOLVE
7476  * - \ref SCIP_STAGE_PRESOLVING
7477  * - \ref SCIP_STAGE_EXITPRESOLVE
7478  * - \ref SCIP_STAGE_PRESOLVED
7479  * - \ref SCIP_STAGE_INITSOLVE
7480  * - \ref SCIP_STAGE_SOLVING
7481  * - \ref SCIP_STAGE_SOLVED
7482  * - \ref SCIP_STAGE_EXITSOLVE
7483  * - \ref SCIP_STAGE_FREETRANS
7484  */
7485 extern
7487  SCIP* scip, /**< SCIP data structure */
7488  SCIP_VAR* var, /**< variable to adjust the bound for */
7489  SCIP_Real ub /**< upper bound value to adjust */
7490  );
7491 
7492 /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
7493  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
7494  * that in conflict analysis, this change is treated like a branching decision
7495  *
7496  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7497  * SCIPgetVars()) gets resorted.
7498  *
7499  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7500  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7501  *
7502  * @pre This method can be called if @p scip is in one of the following stages:
7503  * - \ref SCIP_STAGE_PROBLEM
7504  * - \ref SCIP_STAGE_TRANSFORMING
7505  * - \ref SCIP_STAGE_PRESOLVING
7506  * - \ref SCIP_STAGE_SOLVING
7507  *
7508  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7509  */
7510 extern
7512  SCIP* scip, /**< SCIP data structure */
7513  SCIP_VAR* var, /**< variable to change the bound for */
7514  SCIP_Real newbound /**< new value for bound */
7515  );
7516 
7517 /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
7518  * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
7519  * that in conflict analysis, this change is treated like a branching decision
7520  *
7521  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7522  * SCIPgetVars()) gets resorted.
7523  *
7524  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7525  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7526  *
7527  * @pre This method can be called if @p scip is in one of the following stages:
7528  * - \ref SCIP_STAGE_PROBLEM
7529  * - \ref SCIP_STAGE_TRANSFORMING
7530  * - \ref SCIP_STAGE_PRESOLVING
7531  * - \ref SCIP_STAGE_SOLVING
7532  *
7533  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7534  */
7535 extern
7537  SCIP* scip, /**< SCIP data structure */
7538  SCIP_VAR* var, /**< variable to change the bound for */
7539  SCIP_Real newbound /**< new value for bound */
7540  );
7541 
7542 /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
7543  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
7544  * decision
7545  *
7546  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7547  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7548  *
7549  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7550  */
7551 extern
7553  SCIP* scip, /**< SCIP data structure */
7554  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
7555  SCIP_VAR* var, /**< variable to change the bound for */
7556  SCIP_Real newbound /**< new value for bound */
7557  );
7558 
7559 /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
7560  * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
7561  * decision
7562  *
7563  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7564  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7565  *
7566  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
7567  */
7568 extern
7570  SCIP* scip, /**< SCIP data structure */
7571  SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
7572  SCIP_VAR* var, /**< variable to change the bound for */
7573  SCIP_Real newbound /**< new value for bound */
7574  );
7575 
7576 /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
7577  * if the global bound is better than the local bound
7578  *
7579  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7580  * SCIPgetVars()) gets resorted.
7581  *
7582  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7583  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7584  *
7585  * @pre This method can be called if @p scip is in one of the following stages:
7586  * - \ref SCIP_STAGE_PROBLEM
7587  * - \ref SCIP_STAGE_TRANSFORMING
7588  * - \ref SCIP_STAGE_PRESOLVING
7589  * - \ref SCIP_STAGE_SOLVING
7590  *
7591  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7592  */
7593 extern
7595  SCIP* scip, /**< SCIP data structure */
7596  SCIP_VAR* var, /**< variable to change the bound for */
7597  SCIP_Real newbound /**< new value for bound */
7598  );
7599 
7600 /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
7601  * if the global bound is better than the local bound
7602  *
7603  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7604  * SCIPgetVars()) gets resorted.
7605  *
7606  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7607  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7608  *
7609  * @pre This method can be called if @p scip is in one of the following stages:
7610  * - \ref SCIP_STAGE_PROBLEM
7611  * - \ref SCIP_STAGE_TRANSFORMING
7612  * - \ref SCIP_STAGE_PRESOLVING
7613  * - \ref SCIP_STAGE_SOLVING
7614  *
7615  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7616  */
7617 extern
7619  SCIP* scip, /**< SCIP data structure */
7620  SCIP_VAR* var, /**< variable to change the bound for */
7621  SCIP_Real newbound /**< new value for bound */
7622  );
7623 
7624 /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
7625  *
7626  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
7627  * to be put into the LP explicitly.
7628  *
7629  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7630  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7631  *
7632  * @pre This method can be called if @p scip is in one of the following stages:
7633  * - \ref SCIP_STAGE_PROBLEM
7634  * - \ref SCIP_STAGE_TRANSFORMING
7635  * - \ref SCIP_STAGE_TRANSFORMED
7636  * - \ref SCIP_STAGE_PRESOLVING
7637  * - \ref SCIP_STAGE_SOLVING
7638  *
7639  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
7640  */
7641 extern
7643  SCIP* scip, /**< SCIP data structure */
7644  SCIP_VAR* var, /**< problem variable */
7645  SCIP_Real lazylb /**< the lazy lower bound to be set */
7646  );
7647 
7648 /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
7649  *
7650  * lazy bounds are bounds, that are enforced by constraints and the objective function; hence, these bounds do not need
7651  * to be put into the LP explicitly.
7652  *
7653  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7654  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7655  *
7656  * @pre This method can be called if @p scip is in one of the following stages:
7657  * - \ref SCIP_STAGE_PROBLEM
7658  * - \ref SCIP_STAGE_TRANSFORMING
7659  * - \ref SCIP_STAGE_TRANSFORMED
7660  * - \ref SCIP_STAGE_PRESOLVING
7661  * - \ref SCIP_STAGE_SOLVING
7662  *
7663  * @note lazy bounds are useful for branch-and-price since the corresponding variable bounds are not part of the LP
7664  */
7665 extern
7667  SCIP* scip, /**< SCIP data structure */
7668  SCIP_VAR* var, /**< problem variable */
7669  SCIP_Real lazyub /**< the lazy lower bound to be set */
7670  );
7671 
7672 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
7673  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
7674  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
7675  * is treated like a branching decision
7676  *
7677  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7678  * SCIPgetVars()) gets resorted.
7679  *
7680  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7681  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7682  *
7683  * @pre This method can be called if @p scip is in one of the following stages:
7684  * - \ref SCIP_STAGE_PROBLEM
7685  * - \ref SCIP_STAGE_PRESOLVING
7686  * - \ref SCIP_STAGE_SOLVING
7687  *
7688  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7689  */
7690 extern
7692  SCIP* scip, /**< SCIP data structure */
7693  SCIP_VAR* var, /**< variable to change the bound for */
7694  SCIP_Real newbound, /**< new value for bound */
7695  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
7696  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
7697  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
7698  );
7699 
7700 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
7701  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
7702  * doesn't store any inference information in the bound change, such that in conflict analysis, this change
7703  * is treated like a branching decision
7704  *
7705  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7706  * SCIPgetVars()) gets resorted.
7707  *
7708  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7709  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7710  *
7711  * @pre This method can be called if @p scip is in one of the following stages:
7712  * - \ref SCIP_STAGE_PROBLEM
7713  * - \ref SCIP_STAGE_PRESOLVING
7714  * - \ref SCIP_STAGE_SOLVING
7715  *
7716  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7717  */
7718 extern
7720  SCIP* scip, /**< SCIP data structure */
7721  SCIP_VAR* var, /**< variable to change the bound for */
7722  SCIP_Real newbound, /**< new value for bound */
7723  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
7724  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
7725  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
7726  );
7727 
7728 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
7729  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
7730  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
7731  * for the deduction of the bound change
7732  *
7733  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7734  * SCIPgetVars()) gets resorted.
7735  *
7736  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7737  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7738  *
7739  * @pre This method can be called if @p scip is in one of the following stages:
7740  * - \ref SCIP_STAGE_PROBLEM
7741  * - \ref SCIP_STAGE_PRESOLVING
7742  * - \ref SCIP_STAGE_SOLVING
7743  *
7744  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7745  */
7746 extern
7748  SCIP* scip, /**< SCIP data structure */
7749  SCIP_VAR* var, /**< variable to change the bound for */
7750  SCIP_Real newbound, /**< new value for bound */
7751  SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
7752  int inferinfo, /**< user information for inference to help resolving the conflict */
7753  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
7754  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
7755  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
7756  );
7757 
7758 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
7759  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
7760  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
7761  * for the deduction of the bound change
7762  *
7763  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7764  * SCIPgetVars()) gets resorted.
7765  *
7766  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7767  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7768  *
7769  * @pre This method can be called if @p scip is in one of the following stages:
7770  * - \ref SCIP_STAGE_PROBLEM
7771  * - \ref SCIP_STAGE_PRESOLVING
7772  * - \ref SCIP_STAGE_SOLVING
7773  *
7774  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7775  */
7776 extern
7778  SCIP* scip, /**< SCIP data structure */
7779  SCIP_VAR* var, /**< variable to change the bound for */
7780  SCIP_Real newbound, /**< new value for bound */
7781  SCIP_CONS* infercons, /**< constraint that deduced the bound change */
7782  int inferinfo, /**< user information for inference to help resolving the conflict */
7783  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
7784  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
7785  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
7786  );
7787 
7788 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
7789  * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
7790  * deduction of the fixing
7791  *
7792  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7793  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7794  *
7795  * @pre This method can be called if @p scip is in one of the following stages:
7796  * - \ref SCIP_STAGE_PROBLEM
7797  * - \ref SCIP_STAGE_PRESOLVING
7798  * - \ref SCIP_STAGE_SOLVING
7799  */
7800 extern
7802  SCIP* scip, /**< SCIP data structure */
7803  SCIP_VAR* var, /**< binary variable to fix */
7804  SCIP_Bool fixedval, /**< value to fix binary variable to */
7805  SCIP_CONS* infercons, /**< constraint that deduced the fixing */
7806  int inferinfo, /**< user information for inference to help resolving the conflict */
7807  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
7808  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
7809  );
7810 
7811 /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
7812  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
7813  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
7814  * for the deduction of the bound change
7815  *
7816  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7817  * SCIPgetVars()) gets resorted.
7818  *
7819  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7820  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7821  *
7822  * @pre This method can be called if @p scip is in one of the following stages:
7823  * - \ref SCIP_STAGE_PROBLEM
7824  * - \ref SCIP_STAGE_PRESOLVING
7825  * - \ref SCIP_STAGE_SOLVING
7826  *
7827  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7828  */
7829 extern
7831  SCIP* scip, /**< SCIP data structure */
7832  SCIP_VAR* var, /**< variable to change the bound for */
7833  SCIP_Real newbound, /**< new value for bound */
7834  SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
7835  int inferinfo, /**< user information for inference to help resolving the conflict */
7836  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
7837  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
7838  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
7839  );
7840 
7841 /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
7842  * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
7843  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
7844  * for the deduction of the bound change
7845  *
7846  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7847  * SCIPgetVars()) gets resorted.
7848  *
7849  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7850  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7851  *
7852  * @pre This method can be called if @p scip is in one of the following stages:
7853  * - \ref SCIP_STAGE_PROBLEM
7854  * - \ref SCIP_STAGE_PRESOLVING
7855  * - \ref SCIP_STAGE_SOLVING
7856  *
7857  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7858  */
7859 extern
7861  SCIP* scip, /**< SCIP data structure */
7862  SCIP_VAR* var, /**< variable to change the bound for */
7863  SCIP_Real newbound, /**< new value for bound */
7864  SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
7865  int inferinfo, /**< user information for inference to help resolving the conflict */
7866  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
7867  SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
7868  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
7869  );
7870 
7871 /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
7872  * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
7873  * deduction of the fixing
7874  *
7875  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7876  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7877  *
7878  * @pre This method can be called if @p scip is in one of the following stages:
7879  * - \ref SCIP_STAGE_PROBLEM
7880  * - \ref SCIP_STAGE_PRESOLVING
7881  * - \ref SCIP_STAGE_PRESOLVED
7882  * - \ref SCIP_STAGE_SOLVING
7883  */
7884 extern
7886  SCIP* scip, /**< SCIP data structure */
7887  SCIP_VAR* var, /**< binary variable to fix */
7888  SCIP_Bool fixedval, /**< value to fix binary variable to */
7889  SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
7890  int inferinfo, /**< user information for inference to help resolving the conflict */
7891  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
7892  SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
7893  );
7894 
7895 /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
7896  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
7897  * also tightens the local bound, if the global bound is better than the local bound
7898  *
7899  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7900  * SCIPgetVars()) gets resorted.
7901  *
7902  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7903  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7904  *
7905  * @pre This method can be called if @p scip is in one of the following stages:
7906  * - \ref SCIP_STAGE_PROBLEM
7907  * - \ref SCIP_STAGE_TRANSFORMING
7908  * - \ref SCIP_STAGE_PRESOLVING
7909  * - \ref SCIP_STAGE_SOLVING
7910  *
7911  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7912  */
7913 extern
7915  SCIP* scip, /**< SCIP data structure */
7916  SCIP_VAR* var, /**< variable to change the bound for */
7917  SCIP_Real newbound, /**< new value for bound */
7918  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
7919  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
7920  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
7921  );
7922 
7923 /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
7924  * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
7925  * also tightens the local bound, if the global bound is better than the local bound
7926  *
7927  * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
7928  * SCIPgetVars()) gets resorted.
7929  *
7930  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
7931  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
7932  *
7933  * @pre This method can be called if @p scip is in one of the following stages:
7934  * - \ref SCIP_STAGE_PROBLEM
7935  * - \ref SCIP_STAGE_TRANSFORMING
7936  * - \ref SCIP_STAGE_PRESOLVING
7937  * - \ref SCIP_STAGE_SOLVING
7938  *
7939  * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
7940  */
7941 extern
7943  SCIP* scip, /**< SCIP data structure */
7944  SCIP_VAR* var, /**< variable to change the bound for */
7945  SCIP_Real newbound, /**< new value for bound */
7946  SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
7947  SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
7948  SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
7949  );
7950 
7951 /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
7952  * 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
7953  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal
7954  *
7955  * @return the global lower bound computed by adding the global bounds from all aggregation variables
7956  */
7957 extern
7959  SCIP* scip, /**< SCIP data structure */
7960  SCIP_VAR* var /**< variable to compute the bound for */
7961  );
7962 
7963 /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
7964  * 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
7965  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal
7966  *
7967  * @return the global upper bound computed by adding the global bounds from all aggregation variables
7968  */
7969 extern
7971  SCIP* scip, /**< SCIP data structure */
7972  SCIP_VAR* var /**< variable to compute the bound for */
7973  );
7974 
7975 /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
7976  * 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
7977  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal
7978  *
7979  * @return the local lower bound computed by adding the global bounds from all aggregation variables
7980  */
7981 extern
7983  SCIP* scip, /**< SCIP data structure */
7984  SCIP_VAR* var /**< variable to compute the bound for */
7985  );
7986 
7987 /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
7988  * 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
7989  * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal
7990  *
7991  * @return the local upper bound computed by adding the global bounds from all aggregation variables
7992  */
7993 extern
7995  SCIP* scip, /**< SCIP data structure */
7996  SCIP_VAR* var /**< variable to compute the bound for */
7997  );
7998 
7999 #ifdef NDEBUG
8000 
8001 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
8002  * speed up the algorithms.
8003  */
8004 
8005 #define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPvarGetMultaggrLbGlobal(var, (scip)->set) : SCIPvarGetLbGlobal(var))
8006 #define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPvarGetMultaggrUbGlobal(var, (scip)->set) : SCIPvarGetUbGlobal(var))
8007 #define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPvarGetMultaggrLbLocal(var, (scip)->set) : SCIPvarGetLbLocal(var))
8008 #define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPvarGetMultaggrUbLocal(var, (scip)->set) : SCIPvarGetUbLocal(var))
8009 
8010 #endif
8011 
8012 /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
8013  * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
8014  * available
8015  *
8016  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8017  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8018  *
8019  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8020  */
8021 extern
8023  SCIP* scip, /**< SCIP data structure */
8024  SCIP_VAR* var, /**< active problem variable */
8025  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
8026  SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
8027  int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
8028  );
8029 
8030 /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
8031  * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
8032  *
8033  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8034  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8035  *
8036  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
8037  */
8038 extern
8040  SCIP* scip, /**< SCIP data structure */
8041  SCIP_VAR* var, /**< active problem variable */
8042  SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
8043  SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
8044  int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
8045  );
8046 
8047 /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
8048  * if z is binary, the corresponding valid implication for z is also added;
8049  * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
8050  * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
8051  * improves the global bounds of the variable and the vlb variable if possible
8052  *
8053  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8054  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8055  *
8056  * @pre This method can be called if @p scip is in one of the following stages:
8057  * - \ref SCIP_STAGE_PRESOLVING
8058  * - \ref SCIP_STAGE_PRESOLVED
8059  * - \ref SCIP_STAGE_SOLVING
8060  */
8061 extern
8063  SCIP* scip, /**< SCIP data structure */
8064  SCIP_VAR* var, /**< problem variable */
8065  SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
8066  SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
8067  SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
8068  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
8069  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
8070  );
8071 
8072 
8073 /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
8074  * if z is binary, the corresponding valid implication for z is also added;
8075  * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
8076  * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
8077  * improves the global bounds of the variable and the vlb variable if possible
8078  *
8079  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8080  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8081  *
8082  * @pre This method can be called if @p scip is in one of the following stages:
8083  * - \ref SCIP_STAGE_PRESOLVING
8084  * - \ref SCIP_STAGE_PRESOLVED
8085  * - \ref SCIP_STAGE_SOLVING
8086  */
8087 extern
8089  SCIP* scip, /**< SCIP data structure */
8090  SCIP_VAR* var, /**< problem variable */
8091  SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
8092  SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
8093  SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
8094  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
8095  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
8096  );
8097 
8098 /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
8099  * also adds the corresponding implication or variable bound to the implied variable;
8100  * if the implication is conflicting, the variable is fixed to the opposite value;
8101  * if the variable is already fixed to the given value, the implication is performed immediately;
8102  * if the implication is redundant with respect to the variables' global bounds, it is ignored
8103  *
8104  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8105  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8106  *
8107  * @pre This method can be called if @p scip is in one of the following stages:
8108  * - \ref SCIP_STAGE_TRANSFORMED
8109  * - \ref SCIP_STAGE_PRESOLVING
8110  * - \ref SCIP_STAGE_PRESOLVED
8111  * - \ref SCIP_STAGE_SOLVING
8112  */
8113 extern
8115  SCIP* scip, /**< SCIP data structure */
8116  SCIP_VAR* var, /**< problem variable */
8117  SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
8118  SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
8119  SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
8120  * or y >= b (SCIP_BOUNDTYPE_LOWER) */
8121  SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
8122  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
8123  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
8124  );
8125 
8126 /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
8127  * if a variable appears twice in the same clique, the corresponding implications are performed
8128  *
8129  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8130  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8131  *
8132  * @pre This method can be called if @p scip is in one of the following stages:
8133  * - \ref SCIP_STAGE_TRANSFORMED
8134  * - \ref SCIP_STAGE_PRESOLVING
8135  * - \ref SCIP_STAGE_PRESOLVED
8136  * - \ref SCIP_STAGE_SOLVING
8137  */
8138 extern
8140  SCIP* scip, /**< SCIP data structure */
8141  SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
8142  SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
8143  int nvars, /**< number of variables in the clique */
8144  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
8145  int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
8146  );
8147 
8148 /** calculates a partition of the given set of binary variables into cliques;
8149  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
8150  * were assigned to the same clique;
8151  * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
8152  * the preceding variables was assigned to clique i-1;
8153  * for each clique at most 1 variables can be set to TRUE in a feasible solution;
8154  *
8155  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8156  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8157  *
8158  * @pre This method can be called if @p scip is in one of the following stages:
8159  * - \ref SCIP_STAGE_INITPRESOLVE
8160  * - \ref SCIP_STAGE_PRESOLVING
8161  * - \ref SCIP_STAGE_EXITPRESOLVE
8162  * - \ref SCIP_STAGE_PRESOLVED
8163  * - \ref SCIP_STAGE_SOLVING
8164  */
8165 extern
8167  SCIP*const scip, /**< SCIP data structure */
8168  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
8169  int const nvars, /**< number of variables in the clique */
8170  int*const cliquepartition, /**< array of length nvars to store the clique partition */
8171  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
8172  );
8173 
8174 /** calculates a partition of the given set of binary variables into negated cliques;
8175  * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
8176  * were assigned to the same negated clique;
8177  * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
8178  * the preceding variables was assigned to clique i-1;
8179  * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
8180  *
8181  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8182  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8183  *
8184  * @pre This method can be called if @p scip is in one of the following stages:
8185  * - \ref SCIP_STAGE_INITPRESOLVE
8186  * - \ref SCIP_STAGE_PRESOLVING
8187  * - \ref SCIP_STAGE_EXITPRESOLVE
8188  * - \ref SCIP_STAGE_PRESOLVED
8189  * - \ref SCIP_STAGE_SOLVING
8190  */
8191 extern
8193  SCIP*const scip, /**< SCIP data structure */
8194  SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */
8195  int const nvars, /**< number of variables in the clique */
8196  int*const cliquepartition, /**< array of length nvars to store the clique partition */
8197  int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */
8198  );
8199 
8200 /** gets the number of cliques in the clique table
8201  *
8202  * @return number of cliques in the clique table
8203  *
8204  * @pre This method can be called if @p scip is in one of the following stages:
8205  * - \ref SCIP_STAGE_TRANSFORMED
8206  * - \ref SCIP_STAGE_INITPRESOLVE
8207  * - \ref SCIP_STAGE_PRESOLVING
8208  * - \ref SCIP_STAGE_EXITPRESOLVE
8209  * - \ref SCIP_STAGE_PRESOLVED
8210  * - \ref SCIP_STAGE_INITSOLVE
8211  * - \ref SCIP_STAGE_SOLVING
8212  * - \ref SCIP_STAGE_SOLVED
8213  * - \ref SCIP_STAGE_EXITSOLVE
8214  */
8215 extern
8216 int SCIPgetNCliques(
8217  SCIP* scip /**< SCIP data structure */
8218  );
8219 
8220 /** gets the array of cliques in the clique table
8221  *
8222  * @return array of cliques in the clique table
8223  *
8224  * @pre This method can be called if @p scip is in one of the following stages:
8225  * - \ref SCIP_STAGE_TRANSFORMED
8226  * - \ref SCIP_STAGE_INITPRESOLVE
8227  * - \ref SCIP_STAGE_PRESOLVING
8228  * - \ref SCIP_STAGE_EXITPRESOLVE
8229  * - \ref SCIP_STAGE_PRESOLVED
8230  * - \ref SCIP_STAGE_INITSOLVE
8231  * - \ref SCIP_STAGE_SOLVING
8232  * - \ref SCIP_STAGE_SOLVED
8233  * - \ref SCIP_STAGE_EXITSOLVE
8234  */
8235 extern
8237  SCIP* scip /**< SCIP data structure */
8238  );
8239 
8240 /** returns whether there is a clique that contains both given variable/value pairs;
8241  * the variables must be active binary variables;
8242  * if regardimplics is FALSE, only the cliques in the clique table are looked at;
8243  * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
8244  *
8245  * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
8246  *
8247  * @pre This method can be called if @p scip is in one of the following stages:
8248  * - \ref SCIP_STAGE_TRANSFORMED
8249  * - \ref SCIP_STAGE_INITPRESOLVE
8250  * - \ref SCIP_STAGE_PRESOLVING
8251  * - \ref SCIP_STAGE_EXITPRESOLVE
8252  * - \ref SCIP_STAGE_PRESOLVED
8253  * - \ref SCIP_STAGE_INITSOLVE
8254  * - \ref SCIP_STAGE_SOLVING
8255  * - \ref SCIP_STAGE_SOLVED
8256  * - \ref SCIP_STAGE_EXITSOLVE
8257  *
8258  * @note a variable with it's negated variable are NOT! in a clique
8259  * @note a variable with itself are in a clique
8260  */
8261 extern
8263  SCIP* scip, /**< SCIP data structure */
8264  SCIP_VAR* var1, /**< first variable */
8265  SCIP_Bool value1, /**< value of first variable */
8266  SCIP_VAR* var2, /**< second variable */
8267  SCIP_Bool value2, /**< value of second variable */
8268  SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
8269  );
8270 
8271 /** writes the clique graph to a gml file
8272  *
8273  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8274  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8275  *
8276  * @pre This method can be called if @p scip is in one of the following stages:
8277  * - \ref SCIP_STAGE_TRANSFORMED
8278  * - \ref SCIP_STAGE_INITPRESOLVE
8279  * - \ref SCIP_STAGE_PRESOLVING
8280  * - \ref SCIP_STAGE_EXITPRESOLVE
8281  * - \ref SCIP_STAGE_PRESOLVED
8282  * - \ref SCIP_STAGE_INITSOLVE
8283  * - \ref SCIP_STAGE_SOLVING
8284  * - \ref SCIP_STAGE_SOLVED
8285  * - \ref SCIP_STAGE_EXITSOLVE
8286  *
8287  * @note there can be duplicated arcs in the output file
8288  *
8289  * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
8290  * between such nodes are written.
8291  */
8292 extern
8294  SCIP* scip, /**< SCIP data structure */
8295  const char* fname, /**< name of file */
8296  SCIP_Bool writeimplications, /**< should we write the binary implications? */
8297  SCIP_Bool writenodeweights /**< should we write weights of nodes? */
8298  );
8299 
8300 /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
8301  * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
8302  *
8303  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8304  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8305  *
8306  * @pre This method can be called if @p scip is in one of the following stages:
8307  * - \ref SCIP_STAGE_PROBLEM
8308  * - \ref SCIP_STAGE_TRANSFORMING
8309  * - \ref SCIP_STAGE_TRANSFORMED
8310  * - \ref SCIP_STAGE_INITPRESOLVE
8311  * - \ref SCIP_STAGE_PRESOLVING
8312  * - \ref SCIP_STAGE_EXITPRESOLVE
8313  * - \ref SCIP_STAGE_PRESOLVED
8314  * - \ref SCIP_STAGE_SOLVING
8315  */
8316 extern
8318  SCIP* scip, /**< SCIP data structure */
8319  SCIP_VAR* var, /**< problem variable */
8320  SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
8321  );
8322 
8323 /** scales the branch factor of the variable with the given value
8324  *
8325  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8326  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8327  *
8328  * @pre This method can be called if @p scip is in one of the following stages:
8329  * - \ref SCIP_STAGE_PROBLEM
8330  * - \ref SCIP_STAGE_TRANSFORMING
8331  * - \ref SCIP_STAGE_TRANSFORMED
8332  * - \ref SCIP_STAGE_INITPRESOLVE
8333  * - \ref SCIP_STAGE_PRESOLVING
8334  * - \ref SCIP_STAGE_EXITPRESOLVE
8335  * - \ref SCIP_STAGE_PRESOLVED
8336  * - \ref SCIP_STAGE_SOLVING
8337  */
8338 extern
8340  SCIP* scip, /**< SCIP data structure */
8341  SCIP_VAR* var, /**< problem variable */
8342  SCIP_Real scale /**< factor to scale variable's branching factor with */
8343  );
8344 
8345 /** adds the given value to the branch factor of the variable
8346  *
8347  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8348  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8349  *
8350  * @pre This method can be called if @p scip is in one of the following stages:
8351  * - \ref SCIP_STAGE_PROBLEM
8352  * - \ref SCIP_STAGE_TRANSFORMING
8353  * - \ref SCIP_STAGE_TRANSFORMED
8354  * - \ref SCIP_STAGE_INITPRESOLVE
8355  * - \ref SCIP_STAGE_PRESOLVING
8356  * - \ref SCIP_STAGE_EXITPRESOLVE
8357  * - \ref SCIP_STAGE_PRESOLVED
8358  * - \ref SCIP_STAGE_SOLVING
8359  */
8360 extern
8362  SCIP* scip, /**< SCIP data structure */
8363  SCIP_VAR* var, /**< problem variable */
8364  SCIP_Real addfactor /**< value to add to the branch factor of the variable */
8365  );
8366 
8367 /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
8368  * with lower priority in selection of branching variable
8369  *
8370  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8371  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8372  *
8373  * @pre This method can be called if @p scip is in one of the following stages:
8374  * - \ref SCIP_STAGE_PROBLEM
8375  * - \ref SCIP_STAGE_TRANSFORMING
8376  * - \ref SCIP_STAGE_TRANSFORMED
8377  * - \ref SCIP_STAGE_INITPRESOLVE
8378  * - \ref SCIP_STAGE_PRESOLVING
8379  * - \ref SCIP_STAGE_EXITPRESOLVE
8380  * - \ref SCIP_STAGE_PRESOLVED
8381  * - \ref SCIP_STAGE_SOLVING
8382  *
8383  * @note the default branching priority is 0
8384  */
8385 extern
8387  SCIP* scip, /**< SCIP data structure */
8388  SCIP_VAR* var, /**< problem variable */
8389  int branchpriority /**< branch priority of the variable */
8390  );
8391 
8392 /** changes the branch priority of the variable to the given value, if it is larger than the current priority
8393  *
8394  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8395  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8396  *
8397  * @pre This method can be called if @p scip is in one of the following stages:
8398  * - \ref SCIP_STAGE_PROBLEM
8399  * - \ref SCIP_STAGE_TRANSFORMING
8400  * - \ref SCIP_STAGE_TRANSFORMED
8401  * - \ref SCIP_STAGE_INITPRESOLVE
8402  * - \ref SCIP_STAGE_PRESOLVING
8403  * - \ref SCIP_STAGE_EXITPRESOLVE
8404  * - \ref SCIP_STAGE_PRESOLVED
8405  * - \ref SCIP_STAGE_SOLVING
8406  */
8407 extern
8409  SCIP* scip, /**< SCIP data structure */
8410  SCIP_VAR* var, /**< problem variable */
8411  int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
8412  );
8413 
8414 /** adds the given value to the branch priority of the variable
8415  *
8416  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8417  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8418  *
8419  * @pre This method can be called if @p scip is in one of the following stages:
8420  * - \ref SCIP_STAGE_PROBLEM
8421  * - \ref SCIP_STAGE_TRANSFORMING
8422  * - \ref SCIP_STAGE_TRANSFORMED
8423  * - \ref SCIP_STAGE_INITPRESOLVE
8424  * - \ref SCIP_STAGE_PRESOLVING
8425  * - \ref SCIP_STAGE_EXITPRESOLVE
8426  * - \ref SCIP_STAGE_PRESOLVED
8427  * - \ref SCIP_STAGE_SOLVING
8428  */
8429 extern
8431  SCIP* scip, /**< SCIP data structure */
8432  SCIP_VAR* var, /**< problem variable */
8433  int addpriority /**< value to add to the branch priority of the variable */
8434  );
8435 
8436 /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
8437  * branch)
8438  *
8439  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8440  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8441  *
8442  * @pre This method can be called if @p scip is in one of the following stages:
8443  * - \ref SCIP_STAGE_PROBLEM
8444  * - \ref SCIP_STAGE_TRANSFORMING
8445  * - \ref SCIP_STAGE_TRANSFORMED
8446  * - \ref SCIP_STAGE_INITPRESOLVE
8447  * - \ref SCIP_STAGE_PRESOLVING
8448  * - \ref SCIP_STAGE_EXITPRESOLVE
8449  * - \ref SCIP_STAGE_PRESOLVED
8450  * - \ref SCIP_STAGE_SOLVING
8451  */
8452 extern
8454  SCIP* scip, /**< SCIP data structure */
8455  SCIP_VAR* var, /**< problem variable */
8456  SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
8457  );
8458 
8459 /** changes type of variable in the problem;
8460  *
8461  * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
8462  *
8463  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8464  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8465  *
8466  * @pre This method can be called if @p scip is in one of the following stages:
8467  * - \ref SCIP_STAGE_PROBLEM
8468  * - \ref SCIP_STAGE_TRANSFORMING
8469  * - \ref SCIP_STAGE_PRESOLVING
8470  *
8471  * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
8472  * corresponding transformed variable is changed; the type of the original variable does not change
8473  *
8474  * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
8475  * adjusted w.r.t. to integrality information
8476  */
8477 extern
8479  SCIP* scip, /**< SCIP data structure */
8480  SCIP_VAR* var, /**< variable to change the bound for */
8481  SCIP_VARTYPE vartype, /**< new type of variable */
8482  SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
8483  * integrality condition of the new variable type) */
8484  );
8485 
8486 /** in problem creation and solving stage, both bounds of the variable are set to the given value;
8487  * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
8488  * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
8489  * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
8490  *
8491  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8492  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8493  *
8494  * @pre This method can be called if @p scip is in one of the following stages:
8495  * - \ref SCIP_STAGE_PROBLEM
8496  * - \ref SCIP_STAGE_PRESOLVING
8497  * - \ref SCIP_STAGE_PRESOLVED
8498  * - \ref SCIP_STAGE_SOLVING
8499  */
8500 extern
8502  SCIP* scip, /**< SCIP data structure */
8503  SCIP_VAR* var, /**< variable to fix */
8504  SCIP_Real fixedval, /**< value to fix variable to */
8505  SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
8506  SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
8507  );
8508 
8509 /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
8510  * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
8511  * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
8512  * In the first step, the equality is transformed into an equality with active problem variables
8513  * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
8514  * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
8515  * infeasibility) otherwise.
8516  * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
8517  * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
8518  * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
8519  * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
8520  * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
8521  * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
8522  *
8523  * The output flags have the following meaning:
8524  * - infeasible: the problem is infeasible
8525  * - redundant: the equality can be deleted from the constraint set
8526  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
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_PRESOLVING
8532  */
8533 extern
8535  SCIP* scip, /**< SCIP data structure */
8536  SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
8537  SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
8538  SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
8539  SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
8540  SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
8541  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
8542  SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
8543  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
8544  );
8545 
8546 /** converts variable into multi-aggregated variable; this changes the variable array returned from
8547  * SCIPgetVars() and SCIPgetVarsData();
8548  *
8549  * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
8550  * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
8551  * implies integrality on the aggregated variable.
8552  *
8553  * The output flags have the following meaning:
8554  * - infeasible: the problem is infeasible
8555  * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
8556  *
8557  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8558  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8559  *
8560  * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
8561  */
8562 extern
8564  SCIP* scip, /**< SCIP data structure */
8565  SCIP_VAR* var, /**< variable x to aggregate */
8566  int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8567  SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8568  SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8569  SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
8570  SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
8571  SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
8572  );
8573 
8574 /** returns whether aggregation of variables is not allowed */
8575 extern
8577  SCIP* scip /**< SCIP data structure */
8578  );
8579 
8580 /** returns whether multi-aggregation is disabled */
8581 extern
8583  SCIP* scip /**< SCIP data structure */
8584  );
8585 
8586 /** returns whether variable is not allowed to be multi-aggregated */
8587 extern
8589  SCIP* scip, /**< SCIP data structure */
8590  SCIP_VAR* var /**< variable x to aggregate */
8591  );
8592 
8593 /** marks the variable that it must not be multi-aggregated
8594  *
8595  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8596  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8597  *
8598  * @pre This method can be called if @p scip is in one of the following stages:
8599  * - \ref SCIP_STAGE_INIT
8600  * - \ref SCIP_STAGE_PROBLEM
8601  * - \ref SCIP_STAGE_TRANSFORMING
8602  * - \ref SCIP_STAGE_TRANSFORMED
8603  * - \ref SCIP_STAGE_INITPRESOLVE
8604  * - \ref SCIP_STAGE_PRESOLVING
8605  * - \ref SCIP_STAGE_EXITPRESOLVE
8606  *
8607  * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
8608  * multi-aggregated that this is will be the case.
8609  */
8610 extern
8612  SCIP* scip, /**< SCIP data structure */
8613  SCIP_VAR* var /**< variable to delete */
8614  );
8615 
8616 /** enables the collection of statistics for a variable
8617  *
8618  * @pre This method can be called if @p scip is in one of the following stages:
8619  * - \ref SCIP_STAGE_PROBLEM
8620  * - \ref SCIP_STAGE_INITPRESOLVE
8621  * - \ref SCIP_STAGE_PRESOLVING
8622  * - \ref SCIP_STAGE_EXITPRESOLVE
8623  * - \ref SCIP_STAGE_SOLVING
8624  * - \ref SCIP_STAGE_SOLVED
8625  */
8626 extern
8628  SCIP* scip /**< SCIP data structure */
8629  );
8630 
8631 /** disables the collection of any statistic for a variable
8632  *
8633  * @pre This method can be called if @p scip is in one of the following stages:
8634  * - \ref SCIP_STAGE_PROBLEM
8635  * - \ref SCIP_STAGE_INITPRESOLVE
8636  * - \ref SCIP_STAGE_PRESOLVING
8637  * - \ref SCIP_STAGE_EXITPRESOLVE
8638  * - \ref SCIP_STAGE_SOLVING
8639  * - \ref SCIP_STAGE_SOLVED
8640  */
8641 extern
8643  SCIP* scip /**< SCIP data structure */
8644  );
8645 
8646 /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
8647  * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
8648  * the update is ignored, if the objective value difference is infinite
8649  *
8650  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
8651  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
8652  *
8653  * @pre This method can be called if @p scip is in one of the following stages:
8654  * - \ref SCIP_STAGE_SOLVING
8655  * - \ref SCIP_STAGE_SOLVED
8656  */
8657 extern
8659  SCIP* scip, /**< SCIP data structure */
8660  SCIP_VAR* var, /**< problem variable */
8661  SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
8662  SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
8663  SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
8664  );
8665 
8666 /** gets the variable's pseudo cost value for the given change of the variable's LP value
8667  *
8668  * @return the variable's pseudo cost value for the given change of the variable's LP value
8669  *
8670  * @pre This method can be called if @p scip is in one of the following stages:
8671  * - \ref SCIP_STAGE_INITPRESOLVE
8672  * - \ref SCIP_STAGE_PRESOLVING
8673  * - \ref SCIP_STAGE_EXITPRESOLVE
8674  * - \ref SCIP_STAGE_PRESOLVED
8675  * - \ref SCIP_STAGE_INITSOLVE
8676  * - \ref SCIP_STAGE_SOLVING
8677  * - \ref SCIP_STAGE_SOLVED
8678  */
8679 extern
8681  SCIP* scip, /**< SCIP data structure */
8682  SCIP_VAR* var, /**< problem variable */
8683  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
8684  );
8685 
8686 /** gets the variable's pseudo cost value for the given change of the variable's LP value,
8687  * only using the pseudo cost information of the current run
8688  *
8689  * @return the variable's pseudo cost value for the given change of the variable's LP value,
8690  * only using the pseudo cost information of the current run
8691  *
8692  * @pre This method can be called if @p scip is in one of the following stages:
8693  * - \ref SCIP_STAGE_INITPRESOLVE
8694  * - \ref SCIP_STAGE_PRESOLVING
8695  * - \ref SCIP_STAGE_EXITPRESOLVE
8696  * - \ref SCIP_STAGE_PRESOLVED
8697  * - \ref SCIP_STAGE_INITSOLVE
8698  * - \ref SCIP_STAGE_SOLVING
8699  * - \ref SCIP_STAGE_SOLVED
8700  */
8701 extern
8703  SCIP* scip, /**< SCIP data structure */
8704  SCIP_VAR* var, /**< problem variable */
8705  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
8706  );
8707 
8708 /** gets the variable's pseudo cost value for the given direction
8709  *
8710  * @return the variable's pseudo cost value for the given direction
8711  *
8712  * @pre This method can be called if @p scip is in one of the following stages:
8713  * - \ref SCIP_STAGE_INITPRESOLVE
8714  * - \ref SCIP_STAGE_PRESOLVING
8715  * - \ref SCIP_STAGE_EXITPRESOLVE
8716  * - \ref SCIP_STAGE_PRESOLVED
8717  * - \ref SCIP_STAGE_INITSOLVE
8718  * - \ref SCIP_STAGE_SOLVING
8719  * - \ref SCIP_STAGE_SOLVED
8720  */
8721 extern
8723  SCIP* scip, /**< SCIP data structure */
8724  SCIP_VAR* var, /**< problem variable */
8725  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8726  );
8727 
8728 /** gets the variable's pseudo cost value for the given direction,
8729  * only using the pseudo cost information of the current run
8730  *
8731  * @return the variable's pseudo cost value for the given direction,
8732  * only using the pseudo cost information of the current run
8733  *
8734  * @pre This method can be called if @p scip is in one of the following stages:
8735  * - \ref SCIP_STAGE_INITPRESOLVE
8736  * - \ref SCIP_STAGE_PRESOLVING
8737  * - \ref SCIP_STAGE_EXITPRESOLVE
8738  * - \ref SCIP_STAGE_PRESOLVED
8739  * - \ref SCIP_STAGE_INITSOLVE
8740  * - \ref SCIP_STAGE_SOLVING
8741  * - \ref SCIP_STAGE_SOLVED
8742  */
8743 extern
8745  SCIP* scip, /**< SCIP data structure */
8746  SCIP_VAR* var, /**< problem variable */
8747  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8748  );
8749 
8750 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
8751  *
8752  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
8753  *
8754  * @pre This method can be called if @p scip is in one of the following stages:
8755  * - \ref SCIP_STAGE_INITPRESOLVE
8756  * - \ref SCIP_STAGE_PRESOLVING
8757  * - \ref SCIP_STAGE_EXITPRESOLVE
8758  * - \ref SCIP_STAGE_PRESOLVED
8759  * - \ref SCIP_STAGE_INITSOLVE
8760  * - \ref SCIP_STAGE_SOLVING
8761  * - \ref SCIP_STAGE_SOLVED
8762  */
8763 extern
8765  SCIP* scip, /**< SCIP data structure */
8766  SCIP_VAR* var, /**< problem variable */
8767  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8768  );
8769 
8770 /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
8771  * only using the pseudo cost information of the current run
8772  *
8773  * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
8774  * only using the pseudo cost information of the current run
8775  *
8776  * @pre This method can be called if @p scip is in one of the following stages:
8777  * - \ref SCIP_STAGE_INITPRESOLVE
8778  * - \ref SCIP_STAGE_PRESOLVING
8779  * - \ref SCIP_STAGE_EXITPRESOLVE
8780  * - \ref SCIP_STAGE_PRESOLVED
8781  * - \ref SCIP_STAGE_INITSOLVE
8782  * - \ref SCIP_STAGE_SOLVING
8783  * - \ref SCIP_STAGE_SOLVED
8784  */
8785 extern
8787  SCIP* scip, /**< SCIP data structure */
8788  SCIP_VAR* var, /**< problem variable */
8789  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8790  );
8791 
8792 /** gets the variable's pseudo cost score value for the given LP solution value
8793  *
8794  * @return the variable's pseudo cost score value for the given LP solution value
8795  *
8796  * @pre This method can be called if @p scip is in one of the following stages:
8797  * - \ref SCIP_STAGE_INITPRESOLVE
8798  * - \ref SCIP_STAGE_PRESOLVING
8799  * - \ref SCIP_STAGE_EXITPRESOLVE
8800  * - \ref SCIP_STAGE_PRESOLVED
8801  * - \ref SCIP_STAGE_INITSOLVE
8802  * - \ref SCIP_STAGE_SOLVING
8803  * - \ref SCIP_STAGE_SOLVED
8804  */
8805 extern
8807  SCIP* scip, /**< SCIP data structure */
8808  SCIP_VAR* var, /**< problem variable */
8809  SCIP_Real solval /**< variable's LP solution value */
8810  );
8811 
8812 /** gets the variable's pseudo cost score value for the given LP solution value,
8813  * only using the pseudo cost information of the current run
8814  *
8815  * @return the variable's pseudo cost score value for the given LP solution value,
8816  * only using the pseudo cost information of the current run
8817  *
8818  * @pre This method can be called if @p scip is in one of the following stages:
8819  * - \ref SCIP_STAGE_INITPRESOLVE
8820  * - \ref SCIP_STAGE_PRESOLVING
8821  * - \ref SCIP_STAGE_EXITPRESOLVE
8822  * - \ref SCIP_STAGE_PRESOLVED
8823  * - \ref SCIP_STAGE_INITSOLVE
8824  * - \ref SCIP_STAGE_SOLVING
8825  * - \ref SCIP_STAGE_SOLVED
8826  */
8827 extern
8829  SCIP* scip, /**< SCIP data structure */
8830  SCIP_VAR* var, /**< problem variable */
8831  SCIP_Real solval /**< variable's LP solution value */
8832  );
8833 
8834 /** returns the variable's VSIDS value
8835  *
8836  * @return the variable's VSIDS value
8837  *
8838  * @pre This method can be called if @p scip is in one of the following stages:
8839  * - \ref SCIP_STAGE_INITPRESOLVE
8840  * - \ref SCIP_STAGE_PRESOLVING
8841  * - \ref SCIP_STAGE_EXITPRESOLVE
8842  * - \ref SCIP_STAGE_PRESOLVED
8843  * - \ref SCIP_STAGE_INITSOLVE
8844  * - \ref SCIP_STAGE_SOLVING
8845  * - \ref SCIP_STAGE_SOLVED
8846  */
8847 extern
8849  SCIP* scip, /**< SCIP data structure */
8850  SCIP_VAR* var, /**< problem variable */
8851  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8852  );
8853 
8854 /** returns the variable's VSIDS value only using conflicts of the current run
8855  *
8856  * @return the variable's VSIDS value only using conflicts of the current run
8857  *
8858  * @pre This method can be called if @p scip is in one of the following stages:
8859  * - \ref SCIP_STAGE_INITPRESOLVE
8860  * - \ref SCIP_STAGE_PRESOLVING
8861  * - \ref SCIP_STAGE_EXITPRESOLVE
8862  * - \ref SCIP_STAGE_PRESOLVED
8863  * - \ref SCIP_STAGE_INITSOLVE
8864  * - \ref SCIP_STAGE_SOLVING
8865  * - \ref SCIP_STAGE_SOLVED
8866  */
8867 extern
8869  SCIP* scip, /**< SCIP data structure */
8870  SCIP_VAR* var, /**< problem variable */
8871  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8872  );
8873 
8874 /** returns the variable's conflict score value
8875  *
8876  * @return the variable's conflict score value
8877  *
8878  * @pre This method can be called if @p scip is in one of the following stages:
8879  * - \ref SCIP_STAGE_INITPRESOLVE
8880  * - \ref SCIP_STAGE_PRESOLVING
8881  * - \ref SCIP_STAGE_EXITPRESOLVE
8882  * - \ref SCIP_STAGE_PRESOLVED
8883  * - \ref SCIP_STAGE_INITSOLVE
8884  * - \ref SCIP_STAGE_SOLVING
8885  * - \ref SCIP_STAGE_SOLVED
8886  */
8887 extern
8889  SCIP* scip, /**< SCIP data structure */
8890  SCIP_VAR* var /**< problem variable */
8891  );
8892 
8893 /** returns the variable's conflict score value only using conflicts of the current run
8894  *
8895  * @return the variable's conflict score value only using conflicts of the current run
8896  *
8897  * @pre This method can be called if @p scip is in one of the following stages:
8898  * - \ref SCIP_STAGE_INITPRESOLVE
8899  * - \ref SCIP_STAGE_PRESOLVING
8900  * - \ref SCIP_STAGE_EXITPRESOLVE
8901  * - \ref SCIP_STAGE_PRESOLVED
8902  * - \ref SCIP_STAGE_INITSOLVE
8903  * - \ref SCIP_STAGE_SOLVING
8904  * - \ref SCIP_STAGE_SOLVED
8905  */
8906 extern
8908  SCIP* scip, /**< SCIP data structure */
8909  SCIP_VAR* var /**< problem variable */
8910  );
8911 
8912 /** returns the variable's conflict length score
8913  *
8914  * @return the variable's conflict length score
8915  *
8916  * @pre This method can be called if @p scip is in one of the following stages:
8917  * - \ref SCIP_STAGE_INITPRESOLVE
8918  * - \ref SCIP_STAGE_PRESOLVING
8919  * - \ref SCIP_STAGE_EXITPRESOLVE
8920  * - \ref SCIP_STAGE_PRESOLVED
8921  * - \ref SCIP_STAGE_INITSOLVE
8922  * - \ref SCIP_STAGE_SOLVING
8923  * - \ref SCIP_STAGE_SOLVED
8924  */
8925 extern
8927  SCIP* scip, /**< SCIP data structure */
8928  SCIP_VAR* var /**< problem variable */
8929  );
8930 
8931 /** returns the variable's conflict length score only using conflicts of the current run
8932  *
8933  * @return the variable's conflict length score only using conflicts of the current run
8934  *
8935  * @pre This method can be called if @p scip is in one of the following stages:
8936  * - \ref SCIP_STAGE_INITPRESOLVE
8937  * - \ref SCIP_STAGE_PRESOLVING
8938  * - \ref SCIP_STAGE_EXITPRESOLVE
8939  * - \ref SCIP_STAGE_PRESOLVED
8940  * - \ref SCIP_STAGE_INITSOLVE
8941  * - \ref SCIP_STAGE_SOLVING
8942  * - \ref SCIP_STAGE_SOLVED
8943  */
8944 extern
8946  SCIP* scip, /**< SCIP data structure */
8947  SCIP_VAR* var /**< problem variable */
8948  );
8949 
8950 /** returns the variable's average conflict length
8951  *
8952  * @return the variable's average conflict length
8953  *
8954  * @pre This method can be called if @p scip is in one of the following stages:
8955  * - \ref SCIP_STAGE_INITPRESOLVE
8956  * - \ref SCIP_STAGE_PRESOLVING
8957  * - \ref SCIP_STAGE_EXITPRESOLVE
8958  * - \ref SCIP_STAGE_PRESOLVED
8959  * - \ref SCIP_STAGE_INITSOLVE
8960  * - \ref SCIP_STAGE_SOLVING
8961  * - \ref SCIP_STAGE_SOLVED
8962  */
8963 extern
8965  SCIP* scip, /**< SCIP data structure */
8966  SCIP_VAR* var, /**< problem variable */
8967  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8968  );
8969 
8970 /** returns the variable's average conflict length only using conflicts of the current run
8971  *
8972  * @return the variable's average conflict length only using conflicts of the current run
8973  *
8974  * @pre This method can be called if @p scip is in one of the following stages:
8975  * - \ref SCIP_STAGE_INITPRESOLVE
8976  * - \ref SCIP_STAGE_PRESOLVING
8977  * - \ref SCIP_STAGE_EXITPRESOLVE
8978  * - \ref SCIP_STAGE_PRESOLVED
8979  * - \ref SCIP_STAGE_INITSOLVE
8980  * - \ref SCIP_STAGE_SOLVING
8981  * - \ref SCIP_STAGE_SOLVED
8982  */
8983 extern
8985  SCIP* scip, /**< SCIP data structure */
8986  SCIP_VAR* var, /**< problem variable */
8987  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
8988  );
8989 
8990 /** returns the average number of inferences found after branching on the variable in given direction;
8991  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
8992  * over all variables for branching in the given direction is returned
8993  *
8994  * @return the average number of inferences found after branching on the variable in given direction
8995  *
8996  * @pre This method can be called if @p scip is in one of the following stages:
8997  * - \ref SCIP_STAGE_INITPRESOLVE
8998  * - \ref SCIP_STAGE_PRESOLVING
8999  * - \ref SCIP_STAGE_EXITPRESOLVE
9000  * - \ref SCIP_STAGE_PRESOLVED
9001  * - \ref SCIP_STAGE_INITSOLVE
9002  * - \ref SCIP_STAGE_SOLVING
9003  * - \ref SCIP_STAGE_SOLVED
9004  */
9005 extern
9007  SCIP* scip, /**< SCIP data structure */
9008  SCIP_VAR* var, /**< problem variable */
9009  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9010  );
9011 
9012 /** returns the average number of inferences found after branching on the variable in given direction in the current run;
9013  * if branching on the variable in the given direction was yet evaluated, the average number of inferences
9014  * over all variables for branching in the given direction is returned
9015  *
9016  * @return the average number of inferences found after branching on the variable in given direction in the current run
9017  *
9018  * @pre This method can be called if @p scip is in one of the following stages:
9019  * - \ref SCIP_STAGE_INITPRESOLVE
9020  * - \ref SCIP_STAGE_PRESOLVING
9021  * - \ref SCIP_STAGE_EXITPRESOLVE
9022  * - \ref SCIP_STAGE_PRESOLVED
9023  * - \ref SCIP_STAGE_INITSOLVE
9024  * - \ref SCIP_STAGE_SOLVING
9025  * - \ref SCIP_STAGE_SOLVED
9026  */
9027 extern
9029  SCIP* scip, /**< SCIP data structure */
9030  SCIP_VAR* var, /**< problem variable */
9031  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9032  );
9033 
9034 /** returns the variable's average inference score value
9035  *
9036  * @return the variable's average inference score value
9037  *
9038  * @pre This method can be called if @p scip is in one of the following stages:
9039  * - \ref SCIP_STAGE_INITPRESOLVE
9040  * - \ref SCIP_STAGE_PRESOLVING
9041  * - \ref SCIP_STAGE_EXITPRESOLVE
9042  * - \ref SCIP_STAGE_PRESOLVED
9043  * - \ref SCIP_STAGE_INITSOLVE
9044  * - \ref SCIP_STAGE_SOLVING
9045  * - \ref SCIP_STAGE_SOLVED
9046  */
9047 extern
9049  SCIP* scip, /**< SCIP data structure */
9050  SCIP_VAR* var /**< problem variable */
9051  );
9052 
9053 /** returns the variable's average inference score value only using inferences of the current run
9054  *
9055  * @return the variable's average inference score value only using inferences of the current run
9056  *
9057  * @pre This method can be called if @p scip is in one of the following stages:
9058  * - \ref SCIP_STAGE_INITPRESOLVE
9059  * - \ref SCIP_STAGE_PRESOLVING
9060  * - \ref SCIP_STAGE_EXITPRESOLVE
9061  * - \ref SCIP_STAGE_PRESOLVED
9062  * - \ref SCIP_STAGE_INITSOLVE
9063  * - \ref SCIP_STAGE_SOLVING
9064  * - \ref SCIP_STAGE_SOLVED
9065  */
9066 extern
9068  SCIP* scip, /**< SCIP data structure */
9069  SCIP_VAR* var /**< problem variable */
9070  );
9071 
9072 /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
9073  * of a variable to the given values
9074  *
9075  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9076  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9077  *
9078  * @pre This method can be called if @p scip is in one of the following stages:
9079  * - \ref SCIP_STAGE_TRANSFORMED
9080  * - \ref SCIP_STAGE_INITPRESOLVE
9081  * - \ref SCIP_STAGE_PRESOLVING
9082  * - \ref SCIP_STAGE_EXITPRESOLVE
9083  * - \ref SCIP_STAGE_PRESOLVED
9084  * - \ref SCIP_STAGE_INITSOLVE
9085  * - \ref SCIP_STAGE_SOLVING
9086  */
9087 extern
9089  SCIP* scip, /**< SCIP data structure */
9090  SCIP_VAR* var, /**< variable which should be initialized */
9091  SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
9092  SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
9093  SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
9094  SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
9095  SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
9096  SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
9097  SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
9098  SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
9099  SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
9100  SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
9101  );
9102 
9103 /** returns the average number of cutoffs found after branching on the variable in given direction;
9104  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
9105  * over all variables for branching in the given direction is returned
9106  *
9107  * @return the average number of cutoffs found after branching on the variable in given direction
9108  *
9109  * @pre This method can be called if @p scip is in one of the following stages:
9110  * - \ref SCIP_STAGE_INITPRESOLVE
9111  * - \ref SCIP_STAGE_PRESOLVING
9112  * - \ref SCIP_STAGE_EXITPRESOLVE
9113  * - \ref SCIP_STAGE_PRESOLVED
9114  * - \ref SCIP_STAGE_INITSOLVE
9115  * - \ref SCIP_STAGE_SOLVING
9116  * - \ref SCIP_STAGE_SOLVED
9117  */
9118 extern
9120  SCIP* scip, /**< SCIP data structure */
9121  SCIP_VAR* var, /**< problem variable */
9122  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9123  );
9124 
9125 /** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
9126  * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
9127  * over all variables for branching in the given direction is returned
9128  *
9129  * @return the average number of cutoffs found after branching on the variable in given direction in the current run
9130  *
9131  * @pre This method can be called if @p scip is in one of the following stages:
9132  * - \ref SCIP_STAGE_INITPRESOLVE
9133  * - \ref SCIP_STAGE_PRESOLVING
9134  * - \ref SCIP_STAGE_EXITPRESOLVE
9135  * - \ref SCIP_STAGE_PRESOLVED
9136  * - \ref SCIP_STAGE_INITSOLVE
9137  * - \ref SCIP_STAGE_SOLVING
9138  * - \ref SCIP_STAGE_SOLVED
9139  */
9140 extern
9142  SCIP* scip, /**< SCIP data structure */
9143  SCIP_VAR* var, /**< problem variable */
9144  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
9145  );
9146 
9147 /** returns the variable's average cutoff score value
9148  *
9149  * @return the variable's average cutoff score value
9150  *
9151  * @pre This method can be called if @p scip is in one of the following stages:
9152  * - \ref SCIP_STAGE_INITPRESOLVE
9153  * - \ref SCIP_STAGE_PRESOLVING
9154  * - \ref SCIP_STAGE_EXITPRESOLVE
9155  * - \ref SCIP_STAGE_PRESOLVED
9156  * - \ref SCIP_STAGE_INITSOLVE
9157  * - \ref SCIP_STAGE_SOLVING
9158  * - \ref SCIP_STAGE_SOLVED
9159  */
9160 extern
9162  SCIP* scip, /**< SCIP data structure */
9163  SCIP_VAR* var /**< problem variable */
9164  );
9165 
9166 /** returns the variable's average cutoff score value, only using cutoffs of the current run
9167  *
9168  * @return the variable's average cutoff score value, only using cutoffs of the current run
9169  *
9170  * @pre This method can be called if @p scip is in one of the following stages:
9171  * - \ref SCIP_STAGE_INITPRESOLVE
9172  * - \ref SCIP_STAGE_PRESOLVING
9173  * - \ref SCIP_STAGE_EXITPRESOLVE
9174  * - \ref SCIP_STAGE_PRESOLVED
9175  * - \ref SCIP_STAGE_INITSOLVE
9176  * - \ref SCIP_STAGE_SOLVING
9177  * - \ref SCIP_STAGE_SOLVED
9178  */
9179 extern
9181  SCIP* scip, /**< SCIP data structure */
9182  SCIP_VAR* var /**< problem variable */
9183  );
9184 
9185 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
9186  * factor
9187  *
9188  * @return the variable's average inference/cutoff score value
9189  *
9190  * @pre This method can be called if @p scip is in one of the following stages:
9191  * - \ref SCIP_STAGE_INITPRESOLVE
9192  * - \ref SCIP_STAGE_PRESOLVING
9193  * - \ref SCIP_STAGE_EXITPRESOLVE
9194  * - \ref SCIP_STAGE_PRESOLVED
9195  * - \ref SCIP_STAGE_INITSOLVE
9196  * - \ref SCIP_STAGE_SOLVING
9197  * - \ref SCIP_STAGE_SOLVED
9198  */
9199 extern
9201  SCIP* scip, /**< SCIP data structure */
9202  SCIP_VAR* var, /**< problem variable */
9203  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
9204  );
9205 
9206 /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
9207  * factor, only using inferences and cutoffs of the current run
9208  *
9209  * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
9210  *
9211  * @pre This method can be called if @p scip is in one of the following stages:
9212  * - \ref SCIP_STAGE_INITPRESOLVE
9213  * - \ref SCIP_STAGE_PRESOLVING
9214  * - \ref SCIP_STAGE_EXITPRESOLVE
9215  * - \ref SCIP_STAGE_PRESOLVED
9216  * - \ref SCIP_STAGE_INITSOLVE
9217  * - \ref SCIP_STAGE_SOLVING
9218  * - \ref SCIP_STAGE_SOLVED
9219  */
9220 extern
9222  SCIP* scip, /**< SCIP data structure */
9223  SCIP_VAR* var, /**< problem variable */
9224  SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
9225  );
9226 
9227 /** outputs variable information to file stream via the message system
9228  *
9229  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9230  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9231  *
9232  * @pre This method can be called if @p scip is in one of the following stages:
9233  * - \ref SCIP_STAGE_PROBLEM
9234  * - \ref SCIP_STAGE_TRANSFORMING
9235  * - \ref SCIP_STAGE_TRANSFORMED
9236  * - \ref SCIP_STAGE_INITPRESOLVE
9237  * - \ref SCIP_STAGE_PRESOLVING
9238  * - \ref SCIP_STAGE_EXITPRESOLVE
9239  * - \ref SCIP_STAGE_PRESOLVED
9240  * - \ref SCIP_STAGE_INITSOLVE
9241  * - \ref SCIP_STAGE_SOLVING
9242  * - \ref SCIP_STAGE_SOLVED
9243  * - \ref SCIP_STAGE_EXITSOLVE
9244  * - \ref SCIP_STAGE_FREETRANS
9245  *
9246  * @note If the message handler is set to a NULL pointer nothing will be printed
9247  */
9248 extern
9250  SCIP* scip, /**< SCIP data structure */
9251  SCIP_VAR* var, /**< problem variable */
9252  FILE* file /**< output file (or NULL for standard output) */
9253  );
9254 
9255 /**@} */
9256 
9257 
9258 
9259 
9260 /*
9261  * conflict analysis methods
9262  */
9263 
9264 /**@name Conflict Analysis Methods */
9265 /**@{ */
9266 
9267 /** return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
9268  * conflict analysis since it will not be applied
9269  *
9270  * @return return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
9271  * conflict analysis since it will not be applied
9272  *
9273  * @pre This method can be called if SCIP is in one of the following stages:
9274  * - \ref SCIP_STAGE_INITPRESOLVE
9275  * - \ref SCIP_STAGE_PRESOLVING
9276  * - \ref SCIP_STAGE_EXITPRESOLVE
9277  * - \ref SCIP_STAGE_SOLVING
9278  *
9279  * @note SCIP stage does not get changed
9280  */
9281 extern
9283  SCIP* scip /**< SCIP data structure */
9284  );
9285 
9286 /** initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you
9287  * enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
9288  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
9289  *
9290  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9291  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9292  *
9293  * @pre This method can be called if SCIP is in one of the following stages:
9294  * - \ref SCIP_STAGE_PRESOLVING
9295  * - \ref SCIP_STAGE_SOLVING
9296  *
9297  * @note SCIP stage does not get changed
9298  */
9299 extern
9301  SCIP* scip /**< SCIP data structure */
9302  );
9303 
9304 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
9305  * this method should be called in one of the following two cases:
9306  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound
9307  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
9308  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called
9309  * for each lower bound, whose current assignment led to the deduction of the given conflict bound.
9310  *
9311  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9312  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9313  *
9314  * @pre This method can be called if SCIP is in one of the following stages:
9315  * - \ref SCIP_STAGE_PRESOLVING
9316  * - \ref SCIP_STAGE_SOLVING
9317  *
9318  * @note SCIP stage does not get changed
9319  */
9320 extern
9322  SCIP* scip, /**< SCIP data structure */
9323  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
9324  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
9325  * conflicting bound was valid, NULL for current local bound */
9326  );
9327 
9328 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
9329  * with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough
9330  * to explain a certain bound change;
9331  * this method should be called in one of the following two cases:
9332  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound
9333  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
9334  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called
9335  * for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.
9336  *
9337  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9338  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9339  *
9340  * @pre This method can be called if SCIP is in one of the following stages:
9341  * - \ref SCIP_STAGE_PRESOLVING
9342  * - \ref SCIP_STAGE_SOLVING
9343  *
9344  * @note SCIP stage does not get changed
9345  */
9346 extern
9348  SCIP* scip, /**< SCIP data structure */
9349  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
9350  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
9351  * conflicting bound was valid, NULL for current local bound */
9352  SCIP_Real relaxedlb /**< the relaxed lower bound */
9353  );
9354 
9355 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
9356  * this method should be called in one of the following two cases:
9357  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that
9358  * led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
9359  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for
9360  * each upper bound, whose current assignment led to the deduction of the given conflict bound.
9361  *
9362  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9363  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9364  *
9365  * @pre This method can be called if SCIP is in one of the following stages:
9366  * - \ref SCIP_STAGE_PRESOLVING
9367  * - \ref SCIP_STAGE_SOLVING
9368  *
9369  * @note SCIP stage does not get changed
9370  */
9371 extern
9373  SCIP* scip, /**< SCIP data structure */
9374  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
9375  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
9376  * conflicting bound was valid, NULL for current local bound */
9377  );
9378 
9379 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
9380  * with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough
9381  * to explain a certain bound change;
9382  * this method should be called in one of the following two cases:
9383  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper
9384  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
9385  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be
9386  * called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict
9387  * bound.
9388  *
9389  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9390  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9391  *
9392  * @pre This method can be called if SCIP is in one of the following stages:
9393  * - \ref SCIP_STAGE_PRESOLVING
9394  * - \ref SCIP_STAGE_SOLVING
9395  *
9396  * @note SCIP stage does not get changed
9397  */
9398 extern
9400  SCIP* scip, /**< SCIP data structure */
9401  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
9402  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
9403  * conflicting bound was valid, NULL for current local bound */
9404  SCIP_Real relaxedub /**< the relaxed upper bound */
9405  );
9406 
9407 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate
9408  * storage; this method should be called in one of the following two cases:
9409  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound
9410  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
9411  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called
9412  * for each bound, whose current assignment led to the deduction of the given conflict bound.
9413  *
9414  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9415  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9416  *
9417  * @pre This method can be called if SCIP is in one of the following stages:
9418  * - \ref SCIP_STAGE_PRESOLVING
9419  * - \ref SCIP_STAGE_SOLVING
9420  *
9421  * @note SCIP stage does not get changed
9422  */
9423 extern
9425  SCIP* scip, /**< SCIP data structure */
9426  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
9427  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
9428  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
9429  * conflicting bound was valid, NULL for current local bound */
9430  );
9431 
9432 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis'
9433  * candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one
9434  * which would be enough to explain a certain bound change;
9435  * this method should be called in one of the following two cases:
9436  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed)
9437  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
9438  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be
9439  * called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.
9440  *
9441  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9442  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9443  *
9444  * @pre This method can be called if SCIP is in one of the following stages:
9445  * - \ref SCIP_STAGE_PRESOLVING
9446  * - \ref SCIP_STAGE_SOLVING
9447  *
9448  * @note SCIP stage does not get changed
9449  */
9450 extern
9452  SCIP* scip, /**< SCIP data structure */
9453  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
9454  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
9455  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
9456  * conflicting bound was valid, NULL for current local bound */
9457  SCIP_Real relaxedbd /**< the relaxed bound */
9458  );
9459 
9460 /** adds changed bound of fixed binary variable to the conflict analysis' candidate storage;
9461  * this method should be called in one of the following two cases:
9462  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary
9463  * variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
9464  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called
9465  * for each binary variable, whose current fixing led to the deduction of the given conflict bound.
9466  *
9467  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9468  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9469  *
9470  * @pre This method can be called if SCIP is in one of the following stages:
9471  * - \ref SCIP_STAGE_PRESOLVING
9472  * - \ref SCIP_STAGE_SOLVING
9473  *
9474  * @note SCIP stage does not get changed
9475  */
9476 extern
9478  SCIP* scip, /**< SCIP data structure */
9479  SCIP_VAR* var /**< binary variable whose changed bound should be added to conflict queue */
9480  );
9481 
9482 /** checks if the given variable is already part of the current conflict set or queued for resolving with the same or
9483  * even stronger bound
9484  *
9485  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9486  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9487  *
9488  * @pre This method can be called if SCIP is in one of the following stages:
9489  * - \ref SCIP_STAGE_PRESOLVING
9490  * - \ref SCIP_STAGE_SOLVING
9491  *
9492  * @note SCIP stage does not get changed
9493  */
9494 extern
9496  SCIP* scip, /**< SCIP data structure */
9497  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
9498  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
9499  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
9500  * conflicting bound was valid, NULL for current local bound */
9501  SCIP_Bool* used /**< pointer to store if the variable is already used */
9502  );
9503 
9504 /** returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
9505  * bound
9506  *
9507  * @return returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
9508  * bound
9509  *
9510  * @pre This method can be called if SCIP is in one of the following stages:
9511  * - \ref SCIP_STAGE_PRESOLVING
9512  * - \ref SCIP_STAGE_SOLVING
9513  *
9514  * @note SCIP stage does not get changed
9515  */
9516 extern
9518  SCIP* scip, /**< SCIP data structure */
9519  SCIP_VAR* var /**< problem variable */
9520  );
9521 
9522 /** returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
9523  * upper bound
9524  *
9525  * @return returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
9526  * upper bound
9527  *
9528  * @pre This method can be called if SCIP is in one of the following stages:
9529  * - \ref SCIP_STAGE_PRESOLVING
9530  * - \ref SCIP_STAGE_SOLVING
9531  *
9532  * @note SCIP stage does not get changed
9533  */
9534 extern
9536  SCIP* scip, /**< SCIP data structure */
9537  SCIP_VAR* var /**< problem variable */
9538  );
9539 
9540 /** analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to
9541  * SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
9542  * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict
9543  * handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth
9544  * level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
9545  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is
9546  * valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons()
9547  * instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used
9548  *
9549  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9550  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9551  *
9552  * @pre This method can be called if SCIP is in one of the following stages:
9553  * - \ref SCIP_STAGE_PRESOLVING
9554  * - \ref SCIP_STAGE_SOLVING
9555  *
9556  * @note SCIP stage does not get changed
9557  */
9558 extern
9560  SCIP* scip, /**< SCIP data structure */
9561  int validdepth, /**< minimal depth level at which the initial conflict set is valid */
9562  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
9563  );
9564 
9565 /** analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(),
9566  * SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or
9567  * SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the
9568  * resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint
9569  * that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(),
9570  * SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(),
9571  * SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())
9572  *
9573  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9574  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9575  *
9576  * @pre This method can be called if SCIP is in one of the following stages:
9577  * - \ref SCIP_STAGE_PRESOLVING
9578  * - \ref SCIP_STAGE_SOLVING
9579  *
9580  * @note SCIP stage does not get changed
9581  */
9582 extern
9584  SCIP* scip, /**< SCIP data structure */
9585  SCIP_CONS* cons, /**< constraint that detected the conflict */
9586  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
9587  );
9588 
9589 /**@} */
9590 
9591 
9592 
9593 
9594 /*
9595  * constraint methods
9596  */
9597 
9598 /**@name Constraint Methods */
9599 /**@{ */
9600 
9601 /** creates and captures a constraint of the given constraint handler
9602  *
9603  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
9604  * be declared feasible even if it violates this particular constraint. This constellation should only be
9605  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
9606  * to the variable's local bounds.
9607  *
9608  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9609  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9610  *
9611  * @pre This method can be called if @p scip is in one of the following stages:
9612  * - \ref SCIP_STAGE_PROBLEM
9613  * - \ref SCIP_STAGE_TRANSFORMING
9614  * - \ref SCIP_STAGE_INITPRESOLVE
9615  * - \ref SCIP_STAGE_PRESOLVING
9616  * - \ref SCIP_STAGE_EXITPRESOLVE
9617  * - \ref SCIP_STAGE_PRESOLVED
9618  * - \ref SCIP_STAGE_INITSOLVE
9619  * - \ref SCIP_STAGE_SOLVING
9620  * - \ref SCIP_STAGE_EXITSOLVE
9621  *
9622  * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
9623  */
9624 extern
9626  SCIP* scip, /**< SCIP data structure */
9627  SCIP_CONS** cons, /**< pointer to constraint */
9628  const char* name, /**< name of constraint */
9629  SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
9630  SCIP_CONSDATA* consdata, /**< data for this specific constraint */
9631  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
9632  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
9633  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
9634  * Usually set to TRUE. */
9635  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
9636  * TRUE for model constraints, FALSE for additional, redundant constraints. */
9637  SCIP_Bool check, /**< should the constraint be checked for feasibility?
9638  * TRUE for model constraints, FALSE for additional, redundant constraints. */
9639  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
9640  * Usually set to TRUE. */
9641  SCIP_Bool local, /**< is constraint only valid locally?
9642  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
9643  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
9644  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
9645  * adds coefficients to this constraint. */
9646  SCIP_Bool dynamic, /**< is constraint subject to aging?
9647  * Usually set to FALSE. Set to TRUE for own cuts which
9648  * are separated as constraints. */
9649  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
9650  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
9651  SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
9652  * if it may be moved to a more global node?
9653  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
9654  );
9655 
9656 /** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
9657  * creates and captures;
9658  *
9659  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9660  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9661  *
9662  * @pre This method can be called if @p scip is in one of the following stages:
9663  * - \ref SCIP_STAGE_PROBLEM
9664  * - \ref SCIP_STAGE_TRANSFORMING
9665  * - \ref SCIP_STAGE_INITPRESOLVE
9666  * - \ref SCIP_STAGE_PRESOLVING
9667  * - \ref SCIP_STAGE_EXITPRESOLVE
9668  * - \ref SCIP_STAGE_PRESOLVED
9669  * - \ref SCIP_STAGE_SOLVING
9670  * - \ref SCIP_STAGE_EXITSOLVE
9671  *
9672  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
9673  * be declared feasible even if it violates this particular constraint. This constellation should only be
9674  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
9675  * to the variable's local bounds.
9676  */
9677 extern
9679  SCIP* scip, /**< SCIP data structure */
9680  SCIP_CONS** cons, /**< pointer to store constraint */
9681  const char* str, /**< string to parse for constraint */
9682  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
9683  * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
9684  SCIP_Bool separate, /**< should the constraint be separated during LP processing?
9685  * Usually set to TRUE. */
9686  SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
9687  * TRUE for model constraints, FALSE for additional, redundant constraints. */
9688  SCIP_Bool check, /**< should the constraint be checked for feasibility?
9689  * TRUE for model constraints, FALSE for additional, redundant constraints. */
9690  SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
9691  * Usually set to TRUE. */
9692  SCIP_Bool local, /**< is constraint only valid locally?
9693  * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
9694  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
9695  * Usually set to FALSE. In column generation applications, set to TRUE if pricing
9696  * adds coefficients to this constraint. */
9697  SCIP_Bool dynamic, /**< is constraint subject to aging?
9698  * Usually set to FALSE. Set to TRUE for own cuts which
9699  * are separated as constraints. */
9700  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
9701  * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
9702  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
9703  * if it may be moved to a more global node?
9704  * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
9705  SCIP_Bool* success /**< pointer to store if the paring process was successful */
9706  );
9707 
9708 /** increases usage counter of constraint
9709  *
9710  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9711  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9712  *
9713  * @pre This method can be called if @p scip is in one of the following stages:
9714  * - \ref SCIP_STAGE_PROBLEM
9715  * - \ref SCIP_STAGE_TRANSFORMING
9716  * - \ref SCIP_STAGE_TRANSFORMED
9717  * - \ref SCIP_STAGE_INITPRESOLVE
9718  * - \ref SCIP_STAGE_PRESOLVING
9719  * - \ref SCIP_STAGE_EXITPRESOLVE
9720  * - \ref SCIP_STAGE_PRESOLVED
9721  * - \ref SCIP_STAGE_INITSOLVE
9722  * - \ref SCIP_STAGE_SOLVING
9723  * - \ref SCIP_STAGE_SOLVED
9724  */
9725 extern
9727  SCIP* scip, /**< SCIP data structure */
9728  SCIP_CONS* cons /**< constraint to capture */
9729  );
9730 
9731 /** decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
9732  *
9733  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9734  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9735  *
9736  * @pre This method can be called if @p scip is in one of the following stages:
9737  * - \ref SCIP_STAGE_PROBLEM
9738  * - \ref SCIP_STAGE_TRANSFORMING
9739  * - \ref SCIP_STAGE_TRANSFORMED
9740  * - \ref SCIP_STAGE_INITPRESOLVE
9741  * - \ref SCIP_STAGE_PRESOLVING
9742  * - \ref SCIP_STAGE_EXITPRESOLVE
9743  * - \ref SCIP_STAGE_PRESOLVED
9744  * - \ref SCIP_STAGE_INITSOLVE
9745  * - \ref SCIP_STAGE_SOLVING
9746  * - \ref SCIP_STAGE_SOLVED
9747  * - \ref SCIP_STAGE_EXITSOLVE
9748  * - \ref SCIP_STAGE_FREETRANS
9749  *
9750  * @note the pointer of the constraint will be NULLed
9751  */
9752 extern
9754  SCIP* scip, /**< SCIP data structure */
9755  SCIP_CONS** cons /**< pointer to constraint */
9756  );
9757 
9758 /** change constraint name
9759  *
9760  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9761  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9762  *
9763  * @pre This method can be called if @p scip is in one of the following stages:
9764  * - \ref SCIP_STAGE_PROBLEM
9765  *
9766  * @note to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h
9767  */
9768 extern
9770  SCIP* scip, /**< SCIP data structure */
9771  SCIP_CONS* cons, /**< constraint */
9772  const char* name /**< new name of constraint */
9773  );
9774 
9775 /** sets the initial flag of the given constraint
9776  *
9777  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9778  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9779  *
9780  * @pre This method can be called if @p scip is in one of the following stages:
9781  * - \ref SCIP_STAGE_PROBLEM
9782  * - \ref SCIP_STAGE_TRANSFORMING
9783  * - \ref SCIP_STAGE_PRESOLVING
9784  * - \ref SCIP_STAGE_PRESOLVED
9785  * - \ref SCIP_STAGE_SOLVING
9786  */
9787 extern
9789  SCIP* scip, /**< SCIP data structure */
9790  SCIP_CONS* cons, /**< constraint */
9791  SCIP_Bool initial /**< new value */
9792  );
9793 
9794 /** sets the separate flag of the given constraint
9795  *
9796  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9797  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9798  *
9799  * @pre This method can be called if @p scip is in one of the following stages:
9800  * - \ref SCIP_STAGE_PROBLEM
9801  * - \ref SCIP_STAGE_TRANSFORMING
9802  * - \ref SCIP_STAGE_PRESOLVING
9803  * - \ref SCIP_STAGE_PRESOLVED
9804  * - \ref SCIP_STAGE_SOLVING
9805  */
9806 extern
9808  SCIP* scip, /**< SCIP data structure */
9809  SCIP_CONS* cons, /**< constraint */
9810  SCIP_Bool separate /**< new value */
9811  );
9812 
9813 /** sets the enforce flag of the given constraint
9814  *
9815  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9816  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9817  *
9818  * @pre This method can be called if @p scip is in one of the following stages:
9819  * - \ref SCIP_STAGE_PROBLEM
9820  * - \ref SCIP_STAGE_TRANSFORMING
9821  * - \ref SCIP_STAGE_PRESOLVING
9822  * - \ref SCIP_STAGE_PRESOLVED
9823  * - \ref SCIP_STAGE_SOLVING
9824  */
9825 extern
9827  SCIP* scip, /**< SCIP data structure */
9828  SCIP_CONS* cons, /**< constraint */
9829  SCIP_Bool enforce /**< new value */
9830  );
9831 
9832 /** sets the check flag of the given constraint
9833  *
9834  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9835  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9836  *
9837  * @pre This method can be called if @p scip is in one of the following stages:
9838  * - \ref SCIP_STAGE_PROBLEM
9839  * - \ref SCIP_STAGE_TRANSFORMING
9840  * - \ref SCIP_STAGE_PRESOLVING
9841  * - \ref SCIP_STAGE_PRESOLVED
9842  * - \ref SCIP_STAGE_SOLVING
9843  */
9844 extern
9846  SCIP* scip, /**< SCIP data structure */
9847  SCIP_CONS* cons, /**< constraint */
9848  SCIP_Bool check /**< new value */
9849  );
9850 
9851 /** sets the propagate flag of the given constraint
9852  *
9853  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9854  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9855  *
9856  * @pre This method can be called if @p scip is in one of the following stages:
9857  * - \ref SCIP_STAGE_PROBLEM
9858  * - \ref SCIP_STAGE_TRANSFORMING
9859  * - \ref SCIP_STAGE_PRESOLVING
9860  * - \ref SCIP_STAGE_PRESOLVED
9861  * - \ref SCIP_STAGE_SOLVING
9862  */
9863 extern
9865  SCIP* scip, /**< SCIP data structure */
9866  SCIP_CONS* cons, /**< constraint */
9867  SCIP_Bool propagate /**< new value */
9868  );
9869 
9870 /** sets the local flag of the given constraint
9871  *
9872  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9873  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9874  *
9875  * @pre This method can be called if @p scip is in one of the following stages:
9876  * - \ref SCIP_STAGE_PROBLEM
9877  * - \ref SCIP_STAGE_TRANSFORMING
9878  * - \ref SCIP_STAGE_INITPRESOLVE
9879  * - \ref SCIP_STAGE_PRESOLVING
9880  * - \ref SCIP_STAGE_PRESOLVED
9881  * - \ref SCIP_STAGE_INITSOLVE
9882  * - \ref SCIP_STAGE_SOLVING
9883  */
9884 extern
9886  SCIP* scip, /**< SCIP data structure */
9887  SCIP_CONS* cons, /**< constraint */
9888  SCIP_Bool local /**< new value */
9889  );
9890 
9891 /** sets the modifiable flag of the given constraint
9892  *
9893  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9894  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9895  *
9896  * @pre This method can be called if @p scip is in one of the following stages:
9897  * - \ref SCIP_STAGE_PROBLEM
9898  * - \ref SCIP_STAGE_TRANSFORMING
9899  * - \ref SCIP_STAGE_PRESOLVING
9900  * - \ref SCIP_STAGE_PRESOLVED
9901  * - \ref SCIP_STAGE_SOLVING
9902  * - \ref SCIP_STAGE_EXITSOLVE
9903  */
9904 extern
9906  SCIP* scip, /**< SCIP data structure */
9907  SCIP_CONS* cons, /**< constraint */
9908  SCIP_Bool modifiable /**< new value */
9909  );
9910 
9911 /** sets the dynamic flag of the given constraint
9912  *
9913  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9914  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9915  *
9916  * @pre This method can be called if @p scip is in one of the following stages:
9917  * - \ref SCIP_STAGE_PROBLEM
9918  * - \ref SCIP_STAGE_TRANSFORMING
9919  * - \ref SCIP_STAGE_PRESOLVING
9920  * - \ref SCIP_STAGE_PRESOLVED
9921  * - \ref SCIP_STAGE_SOLVING
9922  */
9923 extern
9925  SCIP* scip, /**< SCIP data structure */
9926  SCIP_CONS* cons, /**< constraint */
9927  SCIP_Bool dynamic /**< new value */
9928  );
9929 
9930 /** sets the removable flag of the given constraint
9931  *
9932  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9933  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9934  *
9935  * @pre This method can be called if @p scip is in one of the following stages:
9936  * - \ref SCIP_STAGE_PROBLEM
9937  * - \ref SCIP_STAGE_TRANSFORMING
9938  * - \ref SCIP_STAGE_PRESOLVING
9939  * - \ref SCIP_STAGE_PRESOLVED
9940  * - \ref SCIP_STAGE_SOLVING
9941  */
9942 extern
9944  SCIP* scip, /**< SCIP data structure */
9945  SCIP_CONS* cons, /**< constraint */
9946  SCIP_Bool removable /**< new value */
9947  );
9948 
9949 /** sets the stickingatnode flag of the given constraint
9950  *
9951  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9952  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9953  *
9954  * @pre This method can be called if @p scip is in one of the following stages:
9955  * - \ref SCIP_STAGE_PROBLEM
9956  * - \ref SCIP_STAGE_TRANSFORMING
9957  * - \ref SCIP_STAGE_PRESOLVING
9958  * - \ref SCIP_STAGE_PRESOLVED
9959  * - \ref SCIP_STAGE_SOLVING
9960  */
9961 extern
9963  SCIP* scip, /**< SCIP data structure */
9964  SCIP_CONS* cons, /**< constraint */
9965  SCIP_Bool stickingatnode /**< new value */
9966  );
9967 
9968 /** updates the flags of the first constraint according to the ones of the second constraint
9969  *
9970  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9971  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9972  *
9973  * @pre This method can be called if @p scip is in one of the following stages:
9974  * - \ref SCIP_STAGE_PROBLEM
9975  * - \ref SCIP_STAGE_TRANSFORMING
9976  * - \ref SCIP_STAGE_PRESOLVING
9977  * - \ref SCIP_STAGE_PRESOLVED
9978  * - \ref SCIP_STAGE_SOLVING
9979  */
9980 extern
9982  SCIP* scip, /**< SCIP data structure */
9983  SCIP_CONS* cons0, /**< constraint that should stay */
9984  SCIP_CONS* cons1 /**< constraint that should be deleted */
9985  );
9986 
9987 /** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
9988  * a new transformed constraint for this constraint is created
9989  *
9990  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
9991  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
9992  *
9993  * @pre This method can be called if @p scip is in one of the following stages:
9994  * - \ref SCIP_STAGE_TRANSFORMING
9995  * - \ref SCIP_STAGE_TRANSFORMED
9996  * - \ref SCIP_STAGE_INITPRESOLVE
9997  * - \ref SCIP_STAGE_PRESOLVING
9998  * - \ref SCIP_STAGE_EXITPRESOLVE
9999  * - \ref SCIP_STAGE_PRESOLVED
10000  * - \ref SCIP_STAGE_INITSOLVE
10001  * - \ref SCIP_STAGE_SOLVING
10002  */
10003 extern
10005  SCIP* scip, /**< SCIP data structure */
10006  SCIP_CONS* cons, /**< constraint to get/create transformed constraint for */
10007  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
10008  );
10009 
10010 /** gets and captures transformed constraints for an array of constraints;
10011  * if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created;
10012  * it is possible to call this method with conss == transconss
10013  *
10014  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10015  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10016  *
10017  * @pre This method can be called if @p scip is in one of the following stages:
10018  * - \ref SCIP_STAGE_TRANSFORMING
10019  * - \ref SCIP_STAGE_TRANSFORMED
10020  * - \ref SCIP_STAGE_INITPRESOLVE
10021  * - \ref SCIP_STAGE_PRESOLVING
10022  * - \ref SCIP_STAGE_EXITPRESOLVE
10023  * - \ref SCIP_STAGE_PRESOLVED
10024  * - \ref SCIP_STAGE_INITSOLVE
10025  * - \ref SCIP_STAGE_SOLVING
10026  */
10027 extern
10029  SCIP* scip, /**< SCIP data structure */
10030  int nconss, /**< number of constraints to get/create transformed constraints for */
10031  SCIP_CONS** conss, /**< array with constraints to get/create transformed constraints for */
10032  SCIP_CONS** transconss /**< array to store the transformed constraints */
10033  );
10034 
10035 /** gets corresponding transformed constraint of a given constraint;
10036  * returns NULL as transcons, if transformed constraint is not yet existing
10037  *
10038  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10039  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10040  *
10041  * @pre This method can be called if @p scip is in one of the following stages:
10042  * - \ref SCIP_STAGE_TRANSFORMING
10043  * - \ref SCIP_STAGE_TRANSFORMED
10044  * - \ref SCIP_STAGE_INITPRESOLVE
10045  * - \ref SCIP_STAGE_PRESOLVING
10046  * - \ref SCIP_STAGE_EXITPRESOLVE
10047  * - \ref SCIP_STAGE_PRESOLVED
10048  * - \ref SCIP_STAGE_INITSOLVE
10049  * - \ref SCIP_STAGE_SOLVING
10050  * - \ref SCIP_STAGE_SOLVED
10051  * - \ref SCIP_STAGE_EXITSOLVE
10052  * - \ref SCIP_STAGE_FREETRANS
10053  */
10054 extern
10056  SCIP* scip, /**< SCIP data structure */
10057  SCIP_CONS* cons, /**< constraint to get the transformed constraint for */
10058  SCIP_CONS** transcons /**< pointer to store the transformed constraint */
10059  );
10060 
10061 /** gets corresponding transformed constraints for an array of constraints;
10062  * stores NULL in a transconss slot, if the transformed constraint is not yet existing;
10063  * it is possible to call this method with conss == transconss, but remember that constraints that are not
10064  * yet transformed will be replaced with NULL
10065  *
10066  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10067  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10068  *
10069  * @pre This method can be called if @p scip is in one of the following stages:
10070  * - \ref SCIP_STAGE_TRANSFORMING
10071  * - \ref SCIP_STAGE_TRANSFORMED
10072  * - \ref SCIP_STAGE_INITPRESOLVE
10073  * - \ref SCIP_STAGE_PRESOLVING
10074  * - \ref SCIP_STAGE_EXITPRESOLVE
10075  * - \ref SCIP_STAGE_PRESOLVED
10076  * - \ref SCIP_STAGE_INITSOLVE
10077  * - \ref SCIP_STAGE_SOLVING
10078  * - \ref SCIP_STAGE_SOLVED
10079  * - \ref SCIP_STAGE_EXITSOLVE
10080  * - \ref SCIP_STAGE_FREETRANS
10081  */
10082 extern
10084  SCIP* scip, /**< SCIP data structure */
10085  int nconss, /**< number of constraints to get the transformed constraints for */
10086  SCIP_CONS** conss, /**< constraints to get the transformed constraints for */
10087  SCIP_CONS** transconss /**< array to store the transformed constraints */
10088  );
10089 
10090 /** adds given value to age of constraint, but age can never become negative;
10091  * should be called
10092  * - in constraint separation, if no cut was found for this constraint,
10093  * - in constraint enforcing, if constraint was feasible, and
10094  * - in constraint propagation, if no domain reduction was deduced;
10095  *
10096  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10097  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10098  *
10099  * @pre This method can be called if @p scip is in one of the following stages:
10100  * - \ref SCIP_STAGE_TRANSFORMED
10101  * - \ref SCIP_STAGE_PRESOLVING
10102  * - \ref SCIP_STAGE_PRESOLVED
10103  * - \ref SCIP_STAGE_SOLVING
10104  * - \ref SCIP_STAGE_SOLVED
10105  */
10106 extern
10108  SCIP* scip, /**< SCIP data structure */
10109  SCIP_CONS* cons, /**< constraint */
10110  SCIP_Real deltaage /**< value to add to the constraint's age */
10111  );
10112 
10113 /** increases age of constraint by 1.0;
10114  * should be called
10115  * - in constraint separation, if no cut was found for this constraint,
10116  * - in constraint enforcing, if constraint was feasible, and
10117  * - in constraint propagation, if no domain reduction was deduced;
10118  *
10119  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10120  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10121  *
10122  * @pre This method can be called if @p scip is in one of the following stages:
10123  * - \ref SCIP_STAGE_TRANSFORMED
10124  * - \ref SCIP_STAGE_PRESOLVING
10125  * - \ref SCIP_STAGE_PRESOLVED
10126  * - \ref SCIP_STAGE_SOLVING
10127  * - \ref SCIP_STAGE_SOLVED
10128  */
10129 extern
10131  SCIP* scip, /**< SCIP data structure */
10132  SCIP_CONS* cons /**< constraint */
10133  );
10134 
10135 /** resets age of constraint to zero;
10136  * should be called
10137  * - in constraint separation, if a cut was found for this constraint,
10138  * - in constraint enforcing, if the constraint was violated, and
10139  * - in constraint propagation, if a domain reduction was deduced;
10140  *
10141  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10142  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10143  *
10144  * @pre This method can be called if @p scip is in one of the following stages:
10145  * - \ref SCIP_STAGE_TRANSFORMED
10146  * - \ref SCIP_STAGE_PRESOLVING
10147  * - \ref SCIP_STAGE_PRESOLVED
10148  * - \ref SCIP_STAGE_SOLVING
10149  * - \ref SCIP_STAGE_SOLVED
10150  */
10151 extern
10153  SCIP* scip, /**< SCIP data structure */
10154  SCIP_CONS* cons /**< constraint */
10155  );
10156 
10157 /** enables constraint's separation, propagation, and enforcing capabilities
10158  *
10159  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10160  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10161  *
10162  * @pre This method can be called if @p scip is in one of the following stages:
10163  * - \ref SCIP_STAGE_TRANSFORMED
10164  * - \ref SCIP_STAGE_PRESOLVING
10165  * - \ref SCIP_STAGE_PRESOLVED
10166  * - \ref SCIP_STAGE_INITSOLVE
10167  * - \ref SCIP_STAGE_SOLVING
10168  * - \ref SCIP_STAGE_SOLVED
10169  */
10170 extern
10172  SCIP* scip, /**< SCIP data structure */
10173  SCIP_CONS* cons /**< constraint */
10174  );
10175 
10176 /** disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated,
10177  * separated, and enforced anymore until it is enabled again with a call to SCIPenableCons();
10178  * in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and
10179  * does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor
10180  * automatically disabled again on entering the node again;
10181  * note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint
10182  * is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree,
10183  * and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using
10184  * an appropriate event handler that watches the corresponding variables' domain changes)
10185  *
10186  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10187  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10188  *
10189  * @pre This method can be called if @p scip is in one of the following stages:
10190  * - \ref SCIP_STAGE_TRANSFORMED
10191  * - \ref SCIP_STAGE_INITPRESOLVE
10192  * - \ref SCIP_STAGE_PRESOLVING
10193  * - \ref SCIP_STAGE_PRESOLVED
10194  * - \ref SCIP_STAGE_INITSOLVE
10195  * - \ref SCIP_STAGE_SOLVING
10196  * - \ref SCIP_STAGE_SOLVED
10197  */
10198 extern
10200  SCIP* scip, /**< SCIP data structure */
10201  SCIP_CONS* cons /**< constraint */
10202  );
10203 
10204 /** enables constraint's separation capabilities
10205  *
10206  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10207  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10208  *
10209  * @pre This method can be called if @p scip is in one of the following stages:
10210  * - \ref SCIP_STAGE_TRANSFORMED
10211  * - \ref SCIP_STAGE_PRESOLVING
10212  * - \ref SCIP_STAGE_PRESOLVED
10213  * - \ref SCIP_STAGE_INITSOLVE
10214  * - \ref SCIP_STAGE_SOLVING
10215  * - \ref SCIP_STAGE_SOLVED
10216  */
10217 extern
10219  SCIP* scip, /**< SCIP data structure */
10220  SCIP_CONS* cons /**< constraint */
10221  );
10222 
10223 /** disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation
10224  * is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
10225  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
10226  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
10227  *
10228  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10229  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10230  *
10231  * @pre This method can be called if @p scip is in one of the following stages:
10232  * - \ref SCIP_STAGE_TRANSFORMED
10233  * - \ref SCIP_STAGE_PRESOLVING
10234  * - \ref SCIP_STAGE_PRESOLVED
10235  * - \ref SCIP_STAGE_INITSOLVE
10236  * - \ref SCIP_STAGE_SOLVING
10237  * - \ref SCIP_STAGE_SOLVED
10238  */
10239 extern
10241  SCIP* scip, /**< SCIP data structure */
10242  SCIP_CONS* cons /**< constraint */
10243  );
10244 
10245 /** enables constraint's propagation capabilities
10246  *
10247  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10248  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10249  *
10250  * @pre This method can be called if @p scip is in one of the following stages:
10251  * - \ref SCIP_STAGE_TRANSFORMED
10252  * - \ref SCIP_STAGE_INITPRESOLVE
10253  * - \ref SCIP_STAGE_PRESOLVING
10254  * - \ref SCIP_STAGE_EXITPRESOLVE
10255  * - \ref SCIP_STAGE_PRESOLVED
10256  * - \ref SCIP_STAGE_INITSOLVE
10257  * - \ref SCIP_STAGE_SOLVING
10258  * - \ref SCIP_STAGE_SOLVED
10259  */
10260 extern
10262  SCIP* scip, /**< SCIP data structure */
10263  SCIP_CONS* cons /**< constraint */
10264  );
10265 
10266 /** disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation
10267  * is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
10268  * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
10269  * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
10270  *
10271  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10272  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10273  *
10274  * @pre This method can be called if @p scip is in one of the following stages:
10275  * - \ref SCIP_STAGE_TRANSFORMED
10276  * - \ref SCIP_STAGE_INITPRESOLVE
10277  * - \ref SCIP_STAGE_PRESOLVING
10278  * - \ref SCIP_STAGE_EXITPRESOLVE
10279  * - \ref SCIP_STAGE_PRESOLVED
10280  * - \ref SCIP_STAGE_INITSOLVE
10281  * - \ref SCIP_STAGE_SOLVING
10282  * - \ref SCIP_STAGE_SOLVED
10283  */
10284 extern
10286  SCIP* scip, /**< SCIP data structure */
10287  SCIP_CONS* cons /**< constraint */
10288  );
10289 
10290 
10291 /** marks constraint to be propagated
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_TRANSFORMED
10298  * - \ref SCIP_STAGE_PRESOLVING
10299  * - \ref SCIP_STAGE_EXITPRESOLVE
10300  * - \ref SCIP_STAGE_PRESOLVED
10301  * - \ref SCIP_STAGE_INITSOLVE
10302  * - \ref SCIP_STAGE_SOLVING
10303  * - \ref SCIP_STAGE_SOLVED
10304  *
10305  * @note if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation
10306  */
10307 extern
10309  SCIP* scip, /**< SCIP data structure */
10310  SCIP_CONS* cons /**< constraint */
10311  );
10312 
10313 /** unmarks the constraint to be propagated
10314  *
10315  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10316  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10317  *
10318  * @pre This method can be called if @p scip is in one of the following stages:
10319  * - \ref SCIP_STAGE_TRANSFORMED
10320  * - \ref SCIP_STAGE_PRESOLVING
10321  * - \ref SCIP_STAGE_EXITPRESOLVE
10322  * - \ref SCIP_STAGE_PRESOLVED
10323  * - \ref SCIP_STAGE_INITSOLVE
10324  * - \ref SCIP_STAGE_SOLVING
10325  * - \ref SCIP_STAGE_SOLVED
10326  */
10327 extern
10329  SCIP* scip, /**< SCIP data structure */
10330  SCIP_CONS* cons /**< constraint */
10331  );
10332 
10333 /** adds given values to lock status of the constraint and updates the rounding locks of the involved variables
10334  *
10335  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10336  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10337  *
10338  * @pre This method can be called if @p scip is in one of the following stages:
10339  * - \ref SCIP_STAGE_PROBLEM
10340  * - \ref SCIP_STAGE_TRANSFORMING
10341  * - \ref SCIP_STAGE_INITPRESOLVE
10342  * - \ref SCIP_STAGE_PRESOLVING
10343  * - \ref SCIP_STAGE_EXITPRESOLVE
10344  * - \ref SCIP_STAGE_INITSOLVE
10345  * - \ref SCIP_STAGE_SOLVING
10346  * - \ref SCIP_STAGE_EXITSOLVE
10347  * - \ref SCIP_STAGE_FREETRANS
10348  */
10349 extern
10351  SCIP* scip, /**< SCIP data structure */
10352  SCIP_CONS* cons, /**< constraint */
10353  int nlockspos, /**< increase in number of rounding locks for constraint */
10354  int nlocksneg /**< increase in number of rounding locks for constraint's negation */
10355  );
10356 
10357 /** checks single constraint for feasibility of the given solution
10358  *
10359  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10360  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10361  *
10362  * @pre This method can be called if @p scip is in one of the following stages:
10363  * - \ref SCIP_STAGE_TRANSFORMED
10364  * - \ref SCIP_STAGE_INITPRESOLVE
10365  * - \ref SCIP_STAGE_PRESOLVING
10366  * - \ref SCIP_STAGE_EXITPRESOLVE
10367  * - \ref SCIP_STAGE_PRESOLVED
10368  * - \ref SCIP_STAGE_INITSOLVE
10369  * - \ref SCIP_STAGE_SOLVING
10370  * - \ref SCIP_STAGE_SOLVED
10371  */
10372 extern
10374  SCIP* scip, /**< SCIP data structure */
10375  SCIP_CONS* cons, /**< constraint to check */
10376  SCIP_SOL* sol, /**< primal CIP solution */
10377  SCIP_Bool checkintegrality, /**< has integrality to be checked? */
10378  SCIP_Bool checklprows, /**< have current LP rows (both local and global) to be checked? */
10379  SCIP_Bool printreason, /**< should the reason for the violation be printed? */
10380  SCIP_RESULT* result /**< pointer to store the result of the callback method */
10381  );
10382 
10383 /** enforces single constraint for a given pseudo solution
10384  *
10385  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10386  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10387  *
10388  * @pre This method can be called if @p scip is in one of the following stages:
10389  * - \ref SCIP_STAGE_SOLVING
10390  *
10391  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
10392  * added to SCIP beforehand.
10393  */
10394 extern
10396  SCIP* scip, /**< SCIP data structure */
10397  SCIP_CONS* cons, /**< constraint to enforce */
10398  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
10399  SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
10400  SCIP_RESULT* result /**< pointer to store the result of the callback method */
10401  );
10402 
10403 /** enforces single constraint for a given LP solution
10404  *
10405  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10406  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10407  *
10408  * @pre This method can be called if @p scip is in one of the following stages:
10409  * - \ref SCIP_STAGE_SOLVING
10410  *
10411  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
10412  * added to SCIP beforehand.
10413  */
10414 extern
10416  SCIP* scip, /**< SCIP data structure */
10417  SCIP_CONS* cons, /**< constraint to enforce */
10418  SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
10419  SCIP_RESULT* result /**< pointer to store the result of the callback method */
10420  );
10421 
10422 /** calls LP initialization method for single constraint
10423  *
10424  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10425  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10426  *
10427  * @pre This method can be called if @p scip is in one of the following stages:
10428  * - \ref SCIP_STAGE_SOLVING
10429  *
10430  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
10431  * added to SCIP beforehand.
10432  */
10433 extern
10435  SCIP* scip, /**< SCIP data structure */
10436  SCIP_CONS* cons /**< constraint to initialize */
10437  );
10438 
10439 /** calls separation method of single constraint for LP solution
10440  *
10441  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10442  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10443  *
10444  * @pre This method can be called if @p scip is in one of the following stages:
10445  * - \ref SCIP_STAGE_SOLVING
10446  *
10447  * @note This is an advanced method and should be used with caution.
10448  */
10449 extern
10451  SCIP* scip, /**< SCIP data structure */
10452  SCIP_CONS* cons, /**< constraint to separate */
10453  SCIP_RESULT* result /**< pointer to store the result of the separation call */
10454  );
10455 
10456 /** calls separation method of single constraint for given primal solution
10457  *
10458  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10459  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10460  *
10461  * @pre This method can be called if @p scip is in one of the following stages:
10462  * - \ref SCIP_STAGE_SOLVING
10463  *
10464  * @note This is an advanced method and should be used with caution.
10465  */
10466 extern
10468  SCIP* scip, /**< SCIP data structure */
10469  SCIP_CONS* cons, /**< constraint to separate */
10470  SCIP_SOL* sol, /**< primal solution that should be separated*/
10471  SCIP_RESULT* result /**< pointer to store the result of the separation call */
10472  );
10473 
10474 /** calls domain propagation method of single constraint
10475  *
10476  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10477  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10478  *
10479  * @pre This method can be called if @p scip is in one of the following stages:
10480  * - \ref SCIP_STAGE_PRESOLVING
10481  * - \ref SCIP_STAGE_SOLVING
10482  *
10483  * @note This is an advanced method and should be used with caution.
10484  */
10485 extern
10487  SCIP* scip, /**< SCIP data structure */
10488  SCIP_CONS* cons, /**< constraint to propagate */
10489  SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
10490  SCIP_RESULT* result /**< pointer to store the result of the callback method */
10491  );
10492 
10493 /** resolves propagation conflict of single constraint
10494  *
10495  *
10496  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10497  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10498  *
10499  * @pre This method can be called if @p scip is in one of the following stages:
10500  * - \ref SCIP_STAGE_PRESOLVING
10501  * - \ref SCIP_STAGE_SOLVING
10502  *
10503  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
10504  * added to SCIP beforehand.
10505  */
10506 extern
10508  SCIP* scip, /**< SCIP data structure */
10509  SCIP_CONS* cons, /**< constraint to resolve conflict for */
10510  SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
10511  int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
10512  SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
10513  SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
10514  SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
10515  SCIP_RESULT* result /**< pointer to store the result of the callback method */
10516  );
10517 
10518 /** presolves of single constraint
10519  *
10520  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10521  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10522  *
10523  * @pre This method can be called if @p scip is in one of the following stages:
10524  * - \ref SCIP_STAGE_PRESOLVING
10525  *
10526  * @note This is an advanced method and should be used with caution.
10527  */
10528 extern
10530  SCIP* scip, /**< SCIP data structure */
10531  SCIP_CONS* cons, /**< constraint to presolve */
10532  int nrounds, /**< number of presolving rounds already done */
10533  int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
10534  int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
10535  int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
10536  int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
10537  int nnewholes, /**< number of domain holes added since the last call to the presolving method */
10538  int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
10539  int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
10540  int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
10541  int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
10542  int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
10543  int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
10544  int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
10545  int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
10546  int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
10547  int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
10548  int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
10549  int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
10550  int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
10551  int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
10552  int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
10553  SCIP_RESULT* result /**< pointer to store the result of the callback method */
10554  );
10555 
10556 /** calls constraint activation notification method of single constraint
10557  *
10558  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10559  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10560  *
10561  * @pre This method can be called if @p scip is in one of the following stages:
10562  * - \ref SCIP_STAGE_TRANSFORMING
10563  *
10564  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
10565  * added to SCIP beforehand.
10566  */
10567 extern
10569  SCIP* scip, /**< SCIP data structure */
10570  SCIP_CONS* cons /**< constraint to notify */
10571  );
10572 
10573 /** calls constraint deactivation notification method of single constraint
10574  *
10575  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10576  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10577  *
10578  * @pre This method can be called if @p scip is in one of the following stages:
10579  * - \ref SCIP_STAGE_PRESOLVING
10580  * - \ref SCIP_STAGE_SOLVING
10581  *
10582  * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
10583  * added to SCIP beforehand.
10584  */
10585 extern
10587  SCIP* scip, /**< SCIP data structure */
10588  SCIP_CONS* cons /**< constraint to notify */
10589  );
10590 
10591 /** outputs constraint information to file stream via the message handler system
10592  *
10593  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10594  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10595  *
10596  * @pre This method can be called if @p scip is in one of the following stages:
10597  * - \ref SCIP_STAGE_PROBLEM
10598  * - \ref SCIP_STAGE_TRANSFORMING
10599  * - \ref SCIP_STAGE_TRANSFORMED
10600  * - \ref SCIP_STAGE_INITPRESOLVE
10601  * - \ref SCIP_STAGE_PRESOLVING
10602  * - \ref SCIP_STAGE_EXITPRESOLVE
10603  * - \ref SCIP_STAGE_PRESOLVED
10604  * - \ref SCIP_STAGE_INITSOLVE
10605  * - \ref SCIP_STAGE_SOLVING
10606  * - \ref SCIP_STAGE_SOLVED
10607  * - \ref SCIP_STAGE_EXITSOLVE
10608  * - \ref SCIP_STAGE_FREETRANS
10609  *
10610  * @note If the message handler is set to a NULL pointer nothing will be printed.
10611  * @note The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a
10612  * newline character.
10613  */
10614 extern
10616  SCIP* scip, /**< SCIP data structure */
10617  SCIP_CONS* cons, /**< constraint */
10618  FILE* file /**< output file (or NULL for standard output) */
10619  );
10620 
10621 /** method to collect the variables of a constraint
10622  *
10623  * If the number of variables is greater than the available slots in the variable array, nothing happens except that
10624  * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
10625  * a constraint has in its scope.
10626  *
10627  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10628  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10629  *
10630  * @pre This method can be called if @p scip is in one of the following stages:
10631  * - \ref SCIP_STAGE_PROBLEM
10632  * - \ref SCIP_STAGE_TRANSFORMING
10633  * - \ref SCIP_STAGE_TRANSFORMED
10634  * - \ref SCIP_STAGE_INITPRESOLVE
10635  * - \ref SCIP_STAGE_PRESOLVING
10636  * - \ref SCIP_STAGE_EXITPRESOLVE
10637  * - \ref SCIP_STAGE_PRESOLVED
10638  * - \ref SCIP_STAGE_INITSOLVE
10639  * - \ref SCIP_STAGE_SOLVING
10640  * - \ref SCIP_STAGE_SOLVED
10641  * - \ref SCIP_STAGE_EXITSOLVE
10642  * - \ref SCIP_STAGE_FREETRANS
10643  *
10644  * @note The success pointer indicates if all variables were copied into the vars arrray.
10645  *
10646  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
10647  * set to FALSE.
10648  */
10649 extern
10651  SCIP* scip, /**< SCIP data structure */
10652  SCIP_CONS* cons, /**< constraint for which the variables are wanted */
10653  SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
10654  int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
10655  SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
10656  );
10657 
10658 /** methed to collect the number of variables of a constraint
10659  *
10660  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10661  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10662  *
10663  * @pre This method can be called if @p scip is in one of the following stages:
10664  * - \ref SCIP_STAGE_PROBLEM
10665  * - \ref SCIP_STAGE_TRANSFORMING
10666  * - \ref SCIP_STAGE_TRANSFORMED
10667  * - \ref SCIP_STAGE_INITPRESOLVE
10668  * - \ref SCIP_STAGE_PRESOLVING
10669  * - \ref SCIP_STAGE_EXITPRESOLVE
10670  * - \ref SCIP_STAGE_PRESOLVED
10671  * - \ref SCIP_STAGE_INITSOLVE
10672  * - \ref SCIP_STAGE_SOLVING
10673  * - \ref SCIP_STAGE_SOLVED
10674  * - \ref SCIP_STAGE_EXITSOLVE
10675  * - \ref SCIP_STAGE_FREETRANS
10676  *
10677  * @note The success pointer indicates if the contraint handler was able to return the number of variables
10678  *
10679  * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
10680  * set to FALSE
10681  */
10682 extern
10684  SCIP* scip, /**< SCIP data structure */
10685  SCIP_CONS* cons, /**< constraint for which the number of variables is wanted */
10686  int* nvars, /**< pointer to store the number of variables */
10687  SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
10688  );
10689 
10690 /**@} */
10691 
10692 
10693 
10694 
10695 /*
10696  * LP methods
10697  */
10698 
10699 /**@name LP Methods */
10700 /**@{ */
10701 
10702 /** returns, whether the LP was or is to be solved in the current node
10703  *
10704  * @return whether the LP was or is to be solved in the current node.
10705  *
10706  * @pre This method can be called if @p scip is in one of the following stages:
10707  * - \ref SCIP_STAGE_SOLVING
10708  *
10709  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10710  */
10711 extern
10713  SCIP* scip /**< SCIP data structure */
10714  );
10715 
10716 /** returns, whether the LP of the current node is already constructed
10717  *
10718  * @return whether the LP of the current node is already constructed.
10719  *
10720  * @pre This method can be called if @p scip is in one of the following stages:
10721  * - \ref SCIP_STAGE_SOLVING
10722  *
10723  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10724  */
10725 extern
10727  SCIP* scip /**< SCIP data structure */
10728  );
10729 
10730 /** makes sure that the LP of the current node is loaded and may be accessed through the LP information methods
10731  *
10732  * @warning Contructing the LP might change the amount of variables known in the transformed problem and therefore also
10733  * the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to
10734  * call one of the later method after this one
10735  *
10736  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10737  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10738  *
10739  * @pre This method can be called if @p scip is in one of the following stages:
10740  * - \ref SCIP_STAGE_SOLVING
10741  *
10742  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10743  */
10744 extern
10746  SCIP* scip, /**< SCIP data structure */
10747  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
10748  );
10749 
10750 /** makes sure that the LP of the current node is flushed
10751  *
10752  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10753  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10754  *
10755  * @pre This method can be called if @p scip is in one of the following stages:
10756  * - \ref SCIP_STAGE_SOLVING
10757  *
10758  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10759  */
10760 extern
10762  SCIP* scip /**< SCIP data structure */
10763  );
10764 
10765 /** gets solution status of current LP
10766  *
10767  * @return the solution status of current LP.
10768  *
10769  * @pre This method can be called if @p scip is in one of the following stages:
10770  * - \ref SCIP_STAGE_SOLVING
10771  *
10772  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10773  */
10774 extern
10776  SCIP* scip /**< SCIP data structure */
10777  );
10778 
10779 /** returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound
10780  *
10781  * @return whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound.
10782  *
10783  * @pre This method can be called if @p scip is in one of the following stages:
10784  * - \ref SCIP_STAGE_SOLVING
10785  *
10786  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10787  */
10788 extern
10790  SCIP* scip /**< SCIP data structure */
10791  );
10792 
10793 /** gets objective value of current LP (which is the sum of column and loose objective value)
10794  *
10795  * @return the objective value of current LP (which is the sum of column and loose objective value).
10796  *
10797  * @pre This method can be called if @p scip is in one of the following stages:
10798  * - \ref SCIP_STAGE_SOLVING
10799  *
10800  * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible
10801  * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by
10802  * SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT.
10803  *
10804  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10805  */
10806 extern
10808  SCIP* scip /**< SCIP data structure */
10809  );
10810 
10811 /** gets part of objective value of current LP that results from COLUMN variables only
10812  *
10813  * @return the part of objective value of current LP that results from COLUMN variables only.
10814  *
10815  * @pre This method can be called if @p scip is in one of the following stages:
10816  * - \ref SCIP_STAGE_SOLVING
10817  *
10818  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10819  */
10820 extern
10822  SCIP* scip /**< SCIP data structure */
10823  );
10824 
10825 /** gets part of objective value of current LP that results from LOOSE variables only
10826  *
10827  * @return part of objective value of current LP that results from LOOSE variables only.
10828  *
10829  * @pre This method can be called if @p scip is in one of the following stages:
10830  * - \ref SCIP_STAGE_SOLVING
10831  *
10832  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10833  */
10834 extern
10836  SCIP* scip /**< SCIP data structure */
10837  );
10838 
10839 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
10840  * function) global bound
10841  *
10842  * @return the global pseudo objective value; that is all variables set to their best (w.r.t. the objective
10843  * function) global bound.
10844  *
10845  * @pre This method can be called if @p scip is in one of the following stages:
10846  * - \ref SCIP_STAGE_INITPRESOLVE
10847  * - \ref SCIP_STAGE_PRESOLVING
10848  * - \ref SCIP_STAGE_EXITPRESOLVE
10849  * - \ref SCIP_STAGE_PRESOLVED
10850  * - \ref SCIP_STAGE_INITSOLVE
10851  * - \ref SCIP_STAGE_SOLVING
10852  *
10853  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10854  */
10855 extern
10857  SCIP* scip /**< SCIP data structure */
10858  );
10859 
10860 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
10861  * objective function) local bound
10862  *
10863  * @return the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the
10864  * objective function) local bound.
10865  *
10866  * @pre This method can be called if @p scip is in one of the following stages:
10867  * - \ref SCIP_STAGE_INITPRESOLVE
10868  * - \ref SCIP_STAGE_PRESOLVING
10869  * - \ref SCIP_STAGE_EXITPRESOLVE
10870  * - \ref SCIP_STAGE_PRESOLVED
10871  * - \ref SCIP_STAGE_INITSOLVE
10872  * - \ref SCIP_STAGE_SOLVING
10873  *
10874  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10875  */
10876 extern
10878  SCIP* scip /**< SCIP data structure */
10879  );
10880 
10881 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound
10882  *
10883  * @return whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound.
10884  *
10885  * @pre This method can be called if @p scip is in one of the following stages:
10886  * - \ref SCIP_STAGE_SOLVING
10887  *
10888  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10889  */
10890 extern
10892  SCIP* scip /**< SCIP data structure */
10893  );
10894 
10895 /** gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved
10896  *
10897  * @return the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved.
10898  *
10899  * @pre This method can be called if @p scip is in one of the following stages:
10900  * - \ref SCIP_STAGE_INITPRESOLVE
10901  * - \ref SCIP_STAGE_PRESOLVING
10902  * - \ref SCIP_STAGE_EXITPRESOLVE
10903  * - \ref SCIP_STAGE_SOLVING
10904  *
10905  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10906  */
10907 extern
10909  SCIP* scip /**< SCIP data structure */
10910  );
10911 
10912 /** gets part of the objective value of the root node LP that results from COLUMN variables only;
10913  * returns SCIP_INVALID if the root node LP was not (yet) solved
10914  *
10915  * @return the part of the objective value of the root node LP that results from COLUMN variables only;
10916  * or SCIP_INVALID if the root node LP was not (yet) solved.
10917  *
10918  * @pre This method can be called if @p scip is in one of the following stages:
10919  * - \ref SCIP_STAGE_INITPRESOLVE
10920  * - \ref SCIP_STAGE_PRESOLVING
10921  * - \ref SCIP_STAGE_EXITPRESOLVE
10922  * - \ref SCIP_STAGE_SOLVING
10923  *
10924  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10925  */
10926 extern
10928  SCIP* scip /**< SCIP data structure */
10929  );
10930 
10931 /** gets part of the objective value of the root node LP that results from LOOSE variables only;
10932  * returns SCIP_INVALID if the root node LP was not (yet) solved
10933  *
10934  * @return the part of the objective value of the root node LP that results from LOOSE variables only;
10935  * or SCIP_INVALID if the root node LP was not (yet) solved.
10936  *
10937  * @pre This method can be called if @p scip is in one of the following stages:
10938  * - \ref SCIP_STAGE_INITPRESOLVE
10939  * - \ref SCIP_STAGE_PRESOLVING
10940  * - \ref SCIP_STAGE_EXITPRESOLVE
10941  * - \ref SCIP_STAGE_SOLVING
10942  *
10943  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10944  */
10945 extern
10947  SCIP* scip /**< SCIP data structure */
10948  );
10949 
10950 /** gets current LP columns along with the current number of LP columns
10951  *
10952  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10953  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10954  *
10955  * @pre This method can be called if @p scip is in one of the following stages:
10956  * - \ref SCIP_STAGE_SOLVING
10957  *
10958  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10959  */
10960 extern
10962  SCIP* scip, /**< SCIP data structure */
10963  SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */
10964  int* ncols /**< pointer to store the number of LP columns, or NULL */
10965  );
10966 
10967 /** gets current LP columns
10968  *
10969  * @return the current LP columns.
10970  *
10971  * @pre This method can be called if @p scip is in one of the following stages:
10972  * - \ref SCIP_STAGE_SOLVING
10973  *
10974  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10975  */
10976 extern
10978  SCIP* scip /**< SCIP data structure */
10979  );
10980 
10981 /** gets current number of LP columns
10982  *
10983  * @return the current number of LP columns.
10984  *
10985  * @pre This method can be called if @p scip is in one of the following stages:
10986  * - \ref SCIP_STAGE_SOLVING
10987  *
10988  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
10989  */
10990 extern
10991 int SCIPgetNLPCols(
10992  SCIP* scip /**< SCIP data structure */
10993  );
10994 
10995 /** gets current LP rows along with the current number of LP rows
10996  *
10997  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
10998  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
10999  *
11000  * @pre This method can be called if @p scip is in one of the following stages:
11001  * - \ref SCIP_STAGE_SOLVING
11002  *
11003  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11004  */
11005 extern
11007  SCIP* scip, /**< SCIP data structure */
11008  SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */
11009  int* nrows /**< pointer to store the number of LP rows, or NULL */
11010  );
11011 
11012 /** gets current LP rows
11013  *
11014  * @return the current LP rows.
11015  *
11016  * @pre This method can be called if @p scip is in one of the following stages:
11017  * - \ref SCIP_STAGE_SOLVING
11018  *
11019  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11020  */
11021 extern
11023  SCIP* scip /**< SCIP data structure */
11024  );
11025 
11026 /** gets current number of LP rows
11027  *
11028  * @return the current number of LP rows.
11029  *
11030  * @pre This method can be called if @p scip is in one of the following stages:
11031  * - \ref SCIP_STAGE_SOLVING
11032  *
11033  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11034  */
11035 extern
11036 int SCIPgetNLPRows(
11037  SCIP* scip /**< SCIP data structure */
11038  );
11039 
11040 /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
11041  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
11042  *
11043  * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
11044  * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing.
11045  *
11046  * @pre This method can be called if @p scip is in one of the following stages:
11047  * - \ref SCIP_STAGE_SOLVING
11048  *
11049  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11050  */
11051 extern
11053  SCIP* scip /**< SCIP data structure */
11054  );
11055 
11056 /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis
11057  *
11058  * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis.
11059  *
11060  * @pre This method can be called if @p scip is in one of the following stages:
11061  * - \ref SCIP_STAGE_SOLVING
11062  *
11063  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11064  */
11065 extern
11067  SCIP* scip /**< SCIP data structure */
11068  );
11069 
11070 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1
11071  *
11072  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11073  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11074  *
11075  * @pre This method can be called if @p scip is in one of the following stages:
11076  * - \ref SCIP_STAGE_SOLVING
11077  *
11078  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11079  */
11080 extern
11082  SCIP* scip, /**< SCIP data structure */
11083  int* basisind /**< pointer to store basis indices ready to keep number of rows entries */
11084  );
11085 
11086 /** gets a row from the inverse basis matrix B^-1
11087  *
11088  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11089  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11090  *
11091  * @pre This method can be called if @p scip is in one of the following stages:
11092  * - \ref SCIP_STAGE_SOLVING
11093  *
11094  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11095  */
11096 extern
11098  SCIP* scip, /**< SCIP data structure */
11099  int r, /**< row number */
11100  SCIP_Real* coef /**< pointer to store the coefficients of the row */
11101  );
11102 
11103 /** gets a column from the inverse basis matrix B^-1
11104  *
11105  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11106  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11107  *
11108  * @pre This method can be called if @p scip is in one of the following stages:
11109  * - \ref SCIP_STAGE_SOLVING
11110  *
11111  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11112  */
11113 extern
11115  SCIP* scip, /**< SCIP data structure */
11116  int c, /**< column number of B^-1; this is NOT the number of the column in the LP
11117  * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd()
11118  * to get the array which links the B^-1 column numbers to the row and
11119  * column numbers of the LP! c must be between 0 and nrows-1, since the
11120  * basis has the size nrows * nrows */
11121  SCIP_Real* coef /**< pointer to store the coefficients of the column */
11122  );
11123 
11124 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A)
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  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11133  */
11134 extern
11136  SCIP* scip, /**< SCIP data structure */
11137  int r, /**< row number */
11138  SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */
11139  SCIP_Real* coef /**< pointer to store the coefficients of the row */
11140  );
11141 
11142 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A),
11143  * i.e., it computes B^-1 * A_c with A_c being the c'th column of A
11144  *
11145  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11146  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11147  *
11148  * @pre This method can be called if @p scip is in one of the following stages:
11149  * - \ref SCIP_STAGE_SOLVING
11150  *
11151  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11152  */
11153 extern
11155  SCIP* scip, /**< SCIP data structure */
11156  int c, /**< column number which can be accessed by SCIPcolGetLPPos() */
11157  SCIP_Real* coef /**< pointer to store the coefficients of the column */
11158  );
11159 
11160 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding
11161  * LP row are swapped in the summation
11162  *
11163  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11164  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11165  *
11166  * @pre This method can be called if @p scip is in one of the following stages:
11167  * - \ref SCIP_STAGE_SOLVING
11168  *
11169  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11170  */
11171 extern
11173  SCIP* scip, /**< SCIP data structure */
11174  SCIP_Real* weights, /**< row weights in row summation */
11175  SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */
11176  SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */
11177  SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */
11178  );
11179 
11180 /** calculates a MIR cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these
11181  * rows cannot participate in a MIR cut.
11182  *
11183  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11184  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11185  *
11186  * @pre This method can be called if @p scip is in one of the following stages:
11187  * - \ref SCIP_STAGE_SOLVING
11188  *
11189  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11190  */
11191 extern
11193  SCIP* scip, /**< SCIP data structure */
11194  SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
11195  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
11196  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
11197  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
11198  SCIP_Bool fixintegralrhs, /**< should complementation tried to be adjusted such that rhs gets fractional? */
11199  int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx,
11200  * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound;
11201  * NULL for using closest bound for all variables */
11202  SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables;
11203  * NULL for using closest bound for all variables */
11204  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
11205  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
11206  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */
11207  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */
11208  SCIP_Real* weights, /**< row weights in row summation; some weights might be set to zero */
11209  int* sidetypes, /**< specify row side type (-1 = lhs, 0 = unkown, 1 = rhs) or NULL for automatic choices */
11210  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
11211  SCIP_Real* mksetcoefs, /**< array to store mixed knapsack set coefficients: size nvars; or NULL */
11212  SCIP_Bool* mksetcoefsvalid, /**< pointer to store whether mixed knapsack set coefficients are valid; or NULL */
11213  SCIP_Real* mircoef, /**< array to store MIR coefficients: must be of size SCIPgetNVars() */
11214  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the MIR row */
11215  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
11216  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid MIR cut */
11217  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
11218  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
11219  );
11220 
11221 /** 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
11222  * rows cannot participate in a MIR cut.
11223  *
11224  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11225  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11226  *
11227  * @pre This method can be called if @p scip is in one of the following stages:
11228  * - \ref SCIP_STAGE_SOLVING
11229  *
11230  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11231  */
11232 extern
11234  SCIP* scip, /**< SCIP data structure */
11235  SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */
11236  SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */
11237  SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */
11238  int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */
11239  SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */
11240  SCIP_Real minfrac, /**< minimal fractionality of rhs to produce strong CG cut for */
11241  SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce strong CG cut for */
11242  SCIP_Real* weights, /**< row weights in row summation; some weights might be set to zero */
11243  SCIP_Real scale, /**< additional scaling factor multiplied to all rows */
11244  SCIP_Real* mircoef, /**< array to store strong CG coefficients: must be of size SCIPgetNVars() */
11245  SCIP_Real* mirrhs, /**< pointer to store the right hand side of the strong CG row */
11246  SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */
11247  SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid strong CG cut */
11248  SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */
11249  int* cutrank /**< pointer to store the rank of the returned cut; or NULL */
11250  );
11251 
11252 /** writes current LP to a file
11253  *
11254  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11255  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11256  *
11257  * @pre This method can be called if @p scip is in one of the following stages:
11258  * - \ref SCIP_STAGE_SOLVING
11259  *
11260  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11261  */
11262 extern
11264  SCIP* scip, /**< SCIP data structure */
11265  const char* filename /**< file name */
11266  );
11267 
11268 /** writes MIP relaxation of the current branch-and-bound node to a file
11269  *
11270  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11271  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11272  *
11273  * @pre This method can be called if @p scip is in one of the following stages:
11274  * - \ref SCIP_STAGE_SOLVING
11275  *
11276  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11277  */
11278 extern
11280  SCIP* scip, /**< SCIP data structure */
11281  const char* filename, /**< file name */
11282  SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid
11283  * troubles with reserved symbols? */
11284  SCIP_Bool origobj, /**< should the original objective function be used? */
11285  SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */
11286  );
11287 
11288 /** gets the LP interface of SCIP;
11289  * with the LPI you can use all of the methods defined in lpi/lpi.h;
11290  *
11291  * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely
11292  * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution
11293  * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in
11294  * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make
11295  * sure, the internal solution status is recovered completely at the end of your method. This can be achieved
11296  * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it
11297  * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the
11298  * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status.
11299  *
11300  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
11301  *
11302  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11303  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11304  *
11305  * @pre This method can be called if @p scip is in one of the following stages:
11306  * - \ref SCIP_STAGE_TRANSFORMED
11307  * - \ref SCIP_STAGE_INITPRESOLVE
11308  * - \ref SCIP_STAGE_PRESOLVING
11309  * - \ref SCIP_STAGE_EXITPRESOLVE
11310  * - \ref SCIP_STAGE_PRESOLVED
11311  * - \ref SCIP_STAGE_INITSOLVE
11312  * - \ref SCIP_STAGE_SOLVING
11313  * - \ref SCIP_STAGE_SOLVED
11314  * - \ref SCIP_STAGE_EXITSOLVE
11315  *
11316  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11317  */
11318 extern
11320  SCIP* scip, /**< SCIP data structure */
11321  SCIP_LPI** lpi /**< pointer to store the LP interface */
11322  );
11323 
11324 /** Displays quality information about the current LP solution. An LP solution need to be available. Information printed
11325  * is subject to what the LP solver supports
11326  *
11327  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11328  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11329  *
11330  * @pre This method can be called if @p scip is in one of the following stages:
11331  * - \ref SCIP_STAGE_INIT
11332  * - \ref SCIP_STAGE_PROBLEM
11333  * - \ref SCIP_STAGE_TRANSFORMED
11334  * - \ref SCIP_STAGE_INITPRESOLVE
11335  * - \ref SCIP_STAGE_PRESOLVING
11336  * - \ref SCIP_STAGE_EXITPRESOLVE
11337  * - \ref SCIP_STAGE_PRESOLVED
11338  * - \ref SCIP_STAGE_SOLVING
11339  * - \ref SCIP_STAGE_SOLVED
11340  * - \ref SCIP_STAGE_FREE
11341  *
11342  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11343  *
11344  * @note The printing process is done via the message handler system.
11345  */
11346 extern
11348  SCIP* scip, /**< SCIP data structure */
11349  FILE* file /**< output file (or NULL for standard output) */
11350  );
11351 
11352 /** compute relative interior point to current LP
11353  * @see SCIPlpComputeRelIntPoint
11354  *
11355  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11356  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11357  *
11358  * @pre This method can be called if @p scip is in one of the following stages:
11359  * - \ref SCIP_STAGE_TRANSFORMED
11360  * - \ref SCIP_STAGE_INITPRESOLVE
11361  * - \ref SCIP_STAGE_PRESOLVING
11362  * - \ref SCIP_STAGE_EXITPRESOLVE
11363  * - \ref SCIP_STAGE_PRESOLVED
11364  * - \ref SCIP_STAGE_SOLVING
11365  * - \ref SCIP_STAGE_SOLVED
11366  *
11367  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
11368  */
11369 extern
11371  SCIP* scip, /**< SCIP data structure */
11372  SCIP_Bool relaxrows, /**< should the rows be relaxed */
11373  SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */
11374  SCIP_Real timelimit, /**< time limit for LP solver */
11375  int iterlimit, /**< iteration limit for LP solver */
11376  SCIP_SOL** point /**< relative interior point on exit */
11377  );
11378 
11379 /**@} */
11380 
11381 
11382 
11383 /*
11384  * LP column methods
11385  */
11386 
11387 /**@name LP Column Methods */
11388 /**@{ */
11389 
11390 /** returns the reduced costs of a column in the last (feasible) LP
11391  *
11392  * @return the reduced costs of a column in the last (feasible) LP
11393  *
11394  * @pre this method can be called in one of the following stages of the SCIP solving process:
11395  * - \ref SCIP_STAGE_SOLVING
11396  */
11397 extern
11399  SCIP* scip, /**< SCIP data structure */
11400  SCIP_COL* col /**< LP column */
11401  );
11402 
11403 /** returns the Farkas coefficient of a column in the last (infeasible) LP
11404  *
11405  * @return the Farkas coefficient of a column in the last (infeasible) LP
11406  *
11407  * @pre this method can be called in one of the following stages of the SCIP solving process:
11408  * - \ref SCIP_STAGE_SOLVING
11409  */
11410 extern
11412  SCIP* scip, /**< SCIP data structure */
11413  SCIP_COL* col /**< LP column */
11414  );
11415 
11416 /** marks a column to be not removable from the LP in the current node
11417  *
11418  * @pre this method can be called in the following stage of the SCIP solving process:
11419  * - \ref SCIP_STAGE_SOLVING
11420  */
11421 extern
11423  SCIP* scip, /**< SCIP data structure */
11424  SCIP_COL* col /**< LP column */
11425  );
11426 
11427 /**@} */
11428 
11429 
11430 
11431 
11432 /*
11433  * LP row methods
11434  */
11435 
11436 /**@name LP Row Methods */
11437 /**@{ */
11438 
11439 /** creates and captures an LP row from a constraint handler
11440  *
11441  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11442  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11443  *
11444  * @pre this method can be called in one of the following stages of the SCIP solving process:
11445  * - \ref SCIP_STAGE_INITSOLVE
11446  * - \ref SCIP_STAGE_SOLVING
11447  */
11448 extern
11450  SCIP* scip, /**< SCIP data structure */
11451  SCIP_ROW** row, /**< pointer to row */
11452  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
11453  const char* name, /**< name of row */
11454  int len, /**< number of nonzeros in the row */
11455  SCIP_COL** cols, /**< array with columns of row entries */
11456  SCIP_Real* vals, /**< array with coefficients of row entries */
11457  SCIP_Real lhs, /**< left hand side of row */
11458  SCIP_Real rhs, /**< right hand side of row */
11459  SCIP_Bool local, /**< is row only valid locally? */
11460  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
11461  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
11462  );
11463 
11464 /** creates and captures an LP row from a separator
11465  *
11466  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11467  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11468  *
11469  * @pre this method can be called in one of the following stages of the SCIP solving process:
11470  * - \ref SCIP_STAGE_INITSOLVE
11471  * - \ref SCIP_STAGE_SOLVING
11472  */
11473 extern
11475  SCIP* scip, /**< SCIP data structure */
11476  SCIP_ROW** row, /**< pointer to row */
11477  SCIP_SEPA* sepa, /**< separator that creates the row */
11478  const char* name, /**< name of row */
11479  int len, /**< number of nonzeros in the row */
11480  SCIP_COL** cols, /**< array with columns of row entries */
11481  SCIP_Real* vals, /**< array with coefficients of row entries */
11482  SCIP_Real lhs, /**< left hand side of row */
11483  SCIP_Real rhs, /**< right hand side of row */
11484  SCIP_Bool local, /**< is row only valid locally? */
11485  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
11486  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
11487  );
11488 
11489 /** creates and captures an LP row from an unspecified source
11490  *
11491  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11492  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11493  *
11494  * @pre this method can be called in one of the following stages of the SCIP solving process:
11495  * - \ref SCIP_STAGE_INITSOLVE
11496  * - \ref SCIP_STAGE_SOLVING
11497  */
11498 extern
11500  SCIP* scip, /**< SCIP data structure */
11501  SCIP_ROW** row, /**< pointer to row */
11502  const char* name, /**< name of row */
11503  int len, /**< number of nonzeros in the row */
11504  SCIP_COL** cols, /**< array with columns of row entries */
11505  SCIP_Real* vals, /**< array with coefficients of row entries */
11506  SCIP_Real lhs, /**< left hand side of row */
11507  SCIP_Real rhs, /**< right hand side of row */
11508  SCIP_Bool local, /**< is row only valid locally? */
11509  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
11510  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
11511  );
11512 
11513 /** creates and captures an LP row
11514  *
11515  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11516  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11517  *
11518  * @pre this method can be called in one of the following stages of the SCIP solving process:
11519  * - \ref SCIP_STAGE_INITSOLVE
11520  * - \ref SCIP_STAGE_SOLVING
11521  *
11522  * @deprecated Please use SCIPcreateRowCons() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order
11523  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec().
11524  */
11525 extern
11527  SCIP* scip, /**< SCIP data structure */
11528  SCIP_ROW** row, /**< pointer to row */
11529  const char* name, /**< name of row */
11530  int len, /**< number of nonzeros in the row */
11531  SCIP_COL** cols, /**< array with columns of row entries */
11532  SCIP_Real* vals, /**< array with coefficients of row entries */
11533  SCIP_Real lhs, /**< left hand side of row */
11534  SCIP_Real rhs, /**< right hand side of row */
11535  SCIP_Bool local, /**< is row only valid locally? */
11536  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
11537  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
11538  );
11539 
11540 /** creates and captures an LP row without any coefficients from a constraint handler
11541  *
11542  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11543  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11544  *
11545  * @pre this method can be called in one of the following stages of the SCIP solving process:
11546  * - \ref SCIP_STAGE_INITSOLVE
11547  * - \ref SCIP_STAGE_SOLVING
11548  */
11549 extern
11551  SCIP* scip, /**< SCIP data structure */
11552  SCIP_ROW** row, /**< pointer to row */
11553  SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */
11554  const char* name, /**< name of row */
11555  SCIP_Real lhs, /**< left hand side of row */
11556  SCIP_Real rhs, /**< right hand side of row */
11557  SCIP_Bool local, /**< is row only valid locally? */
11558  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
11559  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
11560  );
11561 
11562 /** creates and captures an LP row without any coefficients from a separator
11563  *
11564  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11565  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11566  *
11567  * @pre this method can be called in one of the following stages of the SCIP solving process:
11568  * - \ref SCIP_STAGE_INITSOLVE
11569  * - \ref SCIP_STAGE_SOLVING
11570  */
11571 extern
11573  SCIP* scip, /**< SCIP data structure */
11574  SCIP_ROW** row, /**< pointer to row */
11575  SCIP_SEPA* sepa, /**< separator that creates the row */
11576  const char* name, /**< name of row */
11577  SCIP_Real lhs, /**< left hand side of row */
11578  SCIP_Real rhs, /**< right hand side of row */
11579  SCIP_Bool local, /**< is row only valid locally? */
11580  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
11581  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
11582  );
11583 
11584 /** creates and captures an LP row without any coefficients from an unspecified source
11585  *
11586  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11587  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11588  *
11589  * @pre this method can be called in one of the following stages of the SCIP solving process:
11590  * - \ref SCIP_STAGE_INITSOLVE
11591  * - \ref SCIP_STAGE_SOLVING
11592  */
11593 extern
11595  SCIP* scip, /**< SCIP data structure */
11596  SCIP_ROW** row, /**< pointer to row */
11597  const char* name, /**< name of row */
11598  SCIP_Real lhs, /**< left hand side of row */
11599  SCIP_Real rhs, /**< right hand side of row */
11600  SCIP_Bool local, /**< is row only valid locally? */
11601  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
11602  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
11603  );
11604 
11605 /** creates and captures an LP row without any coefficients
11606  *
11607  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11608  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11609  *
11610  * @pre this method can be called in one of the following stages of the SCIP solving process:
11611  * - \ref SCIP_STAGE_INITSOLVE
11612  * - \ref SCIP_STAGE_SOLVING
11613  *
11614  * @deprecated Please use SCIPcreateEmptyRowCons() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order
11615  * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec().
11616  */
11617 extern
11619  SCIP* scip, /**< SCIP data structure */
11620  SCIP_ROW** row, /**< pointer to row */
11621  const char* name, /**< name of row */
11622  SCIP_Real lhs, /**< left hand side of row */
11623  SCIP_Real rhs, /**< right hand side of row */
11624  SCIP_Bool local, /**< is row only valid locally? */
11625  SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */
11626  SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */
11627  );
11628 
11629 /** increases usage counter of LP row
11630  *
11631  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11632  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11633  *
11634  * @pre this method can be called in one of the following stages of the SCIP solving process:
11635  * - \ref SCIP_STAGE_INITSOLVE
11636  * - \ref SCIP_STAGE_SOLVING
11637  */
11638 extern
11640  SCIP* scip, /**< SCIP data structure */
11641  SCIP_ROW* row /**< row to capture */
11642  );
11643 
11644 /** decreases usage counter of LP row, and frees memory if necessary
11645  *
11646  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11647  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11648  *
11649  * @pre this method can be called in one of the following stages of the SCIP solving process:
11650  * - \ref SCIP_STAGE_INITSOLVE
11651  * - \ref SCIP_STAGE_SOLVING
11652  * - \ref SCIP_STAGE_EXITSOLVE
11653  */
11654 extern
11656  SCIP* scip, /**< SCIP data structure */
11657  SCIP_ROW** row /**< pointer to LP row */
11658  );
11659 
11660 /** changes left hand side of LP row
11661  *
11662  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11663  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11664  *
11665  * @pre this method can be called in one of the following stages of the SCIP solving process:
11666  * - \ref SCIP_STAGE_INITSOLVE
11667  * - \ref SCIP_STAGE_SOLVING
11668  */
11669 extern
11671  SCIP* scip, /**< SCIP data structure */
11672  SCIP_ROW* row, /**< LP row */
11673  SCIP_Real lhs /**< new left hand side */
11674  );
11675 
11676 /** changes right hand side of LP row
11677  *
11678  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11679  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11680  *
11681  * @pre this method can be called in one of the following stages of the SCIP solving process:
11682  * - \ref SCIP_STAGE_INITSOLVE
11683  * - \ref SCIP_STAGE_SOLVING
11684  */
11685 extern
11687  SCIP* scip, /**< SCIP data structure */
11688  SCIP_ROW* row, /**< LP row */
11689  SCIP_Real rhs /**< new right hand side */
11690  );
11691 
11692 /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
11693  * after all additions were applied, SCIPflushRowExtensions() must be called;
11694  * while the caching of row extensions is activated, information methods of the row give invalid results;
11695  * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase
11696  * the performance
11697  *
11698  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11699  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11700  *
11701  * @pre this method can be called in one of the following stages of the SCIP solving process:
11702  * - \ref SCIP_STAGE_INITSOLVE
11703  * - \ref SCIP_STAGE_SOLVING
11704  */
11705 extern
11707  SCIP* scip, /**< SCIP data structure */
11708  SCIP_ROW* row /**< LP row */
11709  );
11710 
11711 /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with
11712  * equal columns into a single coefficient
11713  *
11714  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11715  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11716  *
11717  * @pre this method can be called in one of the following stages of the SCIP solving process:
11718  * - \ref SCIP_STAGE_INITSOLVE
11719  * - \ref SCIP_STAGE_SOLVING
11720  */
11721 extern
11723  SCIP* scip, /**< SCIP data structure */
11724  SCIP_ROW* row /**< LP row */
11725  );
11726 
11727 /** resolves variable to columns and adds them with the coefficient to the row
11728  *
11729  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11730  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11731  *
11732  * @pre this method can be called in one of the following stages of the SCIP solving process:
11733  * - \ref SCIP_STAGE_INITSOLVE
11734  * - \ref SCIP_STAGE_SOLVING
11735  *
11736  * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables,
11737  * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP.
11738  * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution
11739  * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but
11740  * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the
11741  * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was
11742  * violated, the linear relaxation might not be violated anymore.)
11743  */
11744 extern
11746  SCIP* scip, /**< SCIP data structure */
11747  SCIP_ROW* row, /**< LP row */
11748  SCIP_VAR* var, /**< problem variable */
11749  SCIP_Real val /**< value of coefficient */
11750  );
11751 
11752 /** resolves variables to columns and adds them with the coefficients to the row;
11753  * this method caches the row extensions and flushes them afterwards to gain better performance
11754  *
11755  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11756  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11757  *
11758  * @pre this method can be called in one of the following stages of the SCIP solving process:
11759  * - \ref SCIP_STAGE_INITSOLVE
11760  * - \ref SCIP_STAGE_SOLVING
11761  */
11762 extern
11764  SCIP* scip, /**< SCIP data structure */
11765  SCIP_ROW* row, /**< LP row */
11766  int nvars, /**< number of variables to add to the row */
11767  SCIP_VAR** vars, /**< problem variables to add */
11768  SCIP_Real* vals /**< values of coefficients */
11769  );
11770 
11771 /** resolves variables to columns and adds them with the same single coefficient to the row;
11772  * this method caches the row extensions and flushes them afterwards to gain better performance
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 in one of the following stages of the SCIP solving process:
11778  * - \ref SCIP_STAGE_INITSOLVE
11779  * - \ref SCIP_STAGE_SOLVING
11780  */
11781 extern
11783  SCIP* scip, /**< SCIP data structure */
11784  SCIP_ROW* row, /**< LP row */
11785  int nvars, /**< number of variables to add to the row */
11786  SCIP_VAR** vars, /**< problem variables to add */
11787  SCIP_Real val /**< unique value of all coefficients */
11788  );
11789 
11790 /** tries to find a value, such that all row coefficients, if scaled with this value become integral
11791  *
11792  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11793  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11794  *
11795  * @pre this method can be called in one of the following stages of the SCIP solving process:
11796  * - \ref SCIP_STAGE_INITSOLVE
11797  * - \ref SCIP_STAGE_SOLVING
11798  */
11799 extern
11801  SCIP* scip, /**< SCIP data structure */
11802  SCIP_ROW* row, /**< LP row */
11803  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
11804  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
11805  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
11806  SCIP_Real maxscale, /**< maximal allowed scalar */
11807  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
11808  SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */
11809  SCIP_Bool* success /**< stores whether returned value is valid */
11810  );
11811 
11812 /** tries to scale row, s.t. all coefficients (of integer variables) become integral
11813  *
11814  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11815  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11816  *
11817  * @pre this method can be called in one of the following stages of the SCIP solving process:
11818  * - \ref SCIP_STAGE_INITSOLVE
11819  * - \ref SCIP_STAGE_SOLVING
11820  */
11821 extern
11823  SCIP* scip, /**< SCIP data structure */
11824  SCIP_ROW* row, /**< LP row */
11825  SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */
11826  SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */
11827  SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */
11828  SCIP_Real maxscale, /**< maximal value to scale row with */
11829  SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */
11830  SCIP_Bool* success /**< stores whether row could be made rational */
11831  );
11832 
11833 /** marks a row to be not removable from the LP in the current node
11834  *
11835  * @pre this method can be called in the following stage of the SCIP solving process:
11836  * - \ref SCIP_STAGE_SOLVING
11837  */
11838 extern
11840  SCIP* scip, /**< SCIP data structure */
11841  SCIP_ROW* row /**< LP row */
11842  );
11843 
11844 /** returns minimal absolute value of row vector's non-zero coefficients
11845  *
11846  * @return minimal absolute value of row vector's non-zero coefficients
11847  *
11848  * @pre this method can be called in one of the following stages of the SCIP solving process:
11849  * - \ref SCIP_STAGE_INITSOLVE
11850  * - \ref SCIP_STAGE_SOLVING
11851  */
11852 extern
11854  SCIP* scip, /**< SCIP data structure */
11855  SCIP_ROW* row /**< LP row */
11856  );
11857 
11858 /** returns maximal absolute value of row vector's non-zero coefficients
11859  *
11860  * @return maximal absolute value of row vector's non-zero coefficients
11861  *
11862  * @pre this method can be called in one of the following stages of the SCIP solving process:
11863  * - \ref SCIP_STAGE_INITSOLVE
11864  * - \ref SCIP_STAGE_SOLVING
11865  */
11866 extern
11868  SCIP* scip, /**< SCIP data structure */
11869  SCIP_ROW* row /**< LP row */
11870  );
11871 
11872 /** returns the minimal activity of a row w.r.t. the column's bounds
11873  *
11874  * @return the minimal activity of a row w.r.t. the column's bounds
11875  *
11876  * @pre this method can be called in one of the following stages of the SCIP solving process:
11877  * - \ref SCIP_STAGE_SOLVING
11878  */
11879 extern
11881  SCIP* scip, /**< SCIP data structure */
11882  SCIP_ROW* row /**< LP row */
11883  );
11884 
11885 /** returns the maximal activity of a row w.r.t. the column's bounds
11886  *
11887  * @return the maximal activity of a row w.r.t. the column's bounds
11888  *
11889  * @pre this method can be called in one of the following stages of the SCIP solving process:
11890  * - \ref SCIP_STAGE_SOLVING
11891  */
11892 extern
11894  SCIP* scip, /**< SCIP data structure */
11895  SCIP_ROW* row /**< LP row */
11896  );
11897 
11898 /** recalculates the activity of a row in the last LP solution
11899  *
11900  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11901  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11902  *
11903  * @pre this method can be called in one of the following stages of the SCIP solving process:
11904  * - \ref SCIP_STAGE_SOLVING
11905  */
11906 extern
11908  SCIP* scip, /**< SCIP data structure */
11909  SCIP_ROW* row /**< LP row */
11910  );
11911 
11912 /** returns the activity of a row in the last LP solution
11913  *
11914  * @return activity of a row in the last LP solution
11915  *
11916  * @pre this method can be called in one of the following stages of the SCIP solving process:
11917  * - \ref SCIP_STAGE_SOLVING
11918  */
11919 extern
11921  SCIP* scip, /**< SCIP data structure */
11922  SCIP_ROW* row /**< LP row */
11923  );
11924 
11925 /** returns the feasibility of a row in the last LP solution
11926  *
11927  * @return the feasibility of a row in the last LP solution: negative value means infeasibility
11928  *
11929  * @pre this method can be called in one of the following stages of the SCIP solving process:
11930  * - \ref SCIP_STAGE_SOLVING
11931  */
11932 extern
11934  SCIP* scip, /**< SCIP data structure */
11935  SCIP_ROW* row /**< LP row */
11936  );
11937 
11938 /** recalculates the activity of a row for the current pseudo solution
11939  *
11940  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11941  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11942  *
11943  * @pre this method can be called in one of the following stages of the SCIP solving process:
11944  * - \ref SCIP_STAGE_SOLVING
11945  */
11946 extern
11948  SCIP* scip, /**< SCIP data structure */
11949  SCIP_ROW* row /**< LP row */
11950  );
11951 
11952 /** returns the activity of a row for the current pseudo solution
11953  *
11954  * @return the activity of a row for the current pseudo solution
11955  *
11956  * @pre this method can be called in one of the following stages of the SCIP solving process:
11957  * - \ref SCIP_STAGE_SOLVING
11958  */
11959 extern
11961  SCIP* scip, /**< SCIP data structure */
11962  SCIP_ROW* row /**< LP row */
11963  );
11964 
11965 /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility
11966  *
11967  * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility
11968  *
11969  * @pre this method can be called in one of the following stages of the SCIP solving process:
11970  * - \ref SCIP_STAGE_SOLVING
11971  */
11972 extern
11974  SCIP* scip, /**< SCIP data structure */
11975  SCIP_ROW* row /**< LP row */
11976  );
11977 
11978 /** recalculates the activity of a row in the last LP or pseudo solution
11979  *
11980  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
11981  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
11982  *
11983  * @pre this method can be called in one of the following stages of the SCIP solving process:
11984  * - \ref SCIP_STAGE_SOLVING
11985  */
11986 extern
11988  SCIP* scip, /**< SCIP data structure */
11989  SCIP_ROW* row /**< LP row */
11990  );
11991 
11992 /** returns the activity of a row in the last LP or pseudo solution
11993  *
11994  * @return the activity of a row in the last LP or pseudo solution
11995  *
11996  * @pre this method can be called in one of the following stages of the SCIP solving process:
11997  * - \ref SCIP_STAGE_SOLVING
11998  */
11999 extern
12001  SCIP* scip, /**< SCIP data structure */
12002  SCIP_ROW* row /**< LP row */
12003  );
12004 
12005 /** returns the feasibility of a row in the last LP or pseudo solution
12006  *
12007  * @return the feasibility of a row in the last LP or pseudo solution
12008  *
12009  * @pre this method can be called in one of the following stages of the SCIP solving process:
12010  * - \ref SCIP_STAGE_SOLVING
12011  */
12012 extern
12014  SCIP* scip, /**< SCIP data structure */
12015  SCIP_ROW* row /**< LP row */
12016  );
12017 
12018 /** returns the activity of a row for the given primal solution
12019  *
12020  * @return the activitiy of a row for the given primal solution
12021  *
12022  * @pre this method can be called in one of the following stages of the SCIP solving process:
12023  * - \ref SCIP_STAGE_SOLVING
12024  */
12025 extern
12027  SCIP* scip, /**< SCIP data structure */
12028  SCIP_ROW* row, /**< LP row */
12029  SCIP_SOL* sol /**< primal CIP solution */
12030  );
12031 
12032 /** returns the feasibility of a row for the given primal solution
12033  *
12034  * @return the feasibility of a row for the given primal solution
12035  *
12036  * @pre this method can be called in one of the following stages of the SCIP solving process:
12037  * - \ref SCIP_STAGE_SOLVING
12038  */
12039 extern
12041  SCIP* scip, /**< SCIP data structure */
12042  SCIP_ROW* row, /**< LP row */
12043  SCIP_SOL* sol /**< primal CIP solution */
12044  );
12045 
12046 /** output row to file stream via the message handler system
12047  *
12048  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12049  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12050  *
12051  * @pre this method can be called in one of the following stages of the SCIP solving process:
12052  * - \ref SCIP_STAGE_INITSOLVE
12053  * - \ref SCIP_STAGE_SOLVING
12054  * - \ref SCIP_STAGE_SOLVED
12055  * - \ref SCIP_STAGE_EXITSOLVE
12056  */
12057 extern
12059  SCIP* scip, /**< SCIP data structure */
12060  SCIP_ROW* row, /**< LP row */
12061  FILE* file /**< output file (or NULL for standard output) */
12062  );
12063 
12064 /**@} */
12065 
12066 
12067 /*
12068  * NLP methods
12069  */
12070 
12071 /**@name NLP Methods */
12072 /**@{ */
12073 
12074 /** returns whether the NLP relaxation has been enabled
12075  *
12076  * If the NLP relaxation is enabled, then SCIP will construct the NLP relaxation when the solving process is about to begin.
12077  * To check whether an NLP is existing, use SCIPisNLPConstructed().
12078  *
12079  * @pre This method can be called if SCIP is in one of the following stages:
12080  * - \ref SCIP_STAGE_INITPRESOLVE
12081  * - \ref SCIP_STAGE_PRESOLVING
12082  * - \ref SCIP_STAGE_EXITPRESOLVE
12083  * - \ref SCIP_STAGE_PRESOLVED
12084  * - \ref SCIP_STAGE_INITSOLVE
12085  * - \ref SCIP_STAGE_SOLVING
12086  *
12087  * @see SCIPenableNLP
12088  */
12089 extern
12091  SCIP* scip /**< SCIP data structure */
12092  );
12093 
12094 /** marks that there are constraints that are representable by nonlinear rows
12095  *
12096  * This method should be called by a constraint handler if it has constraints that have a representation as nonlinear rows.
12097  *
12098  * The function should be called before the branch-and-bound process is initialized, e.g., when presolve is exiting.
12099  *
12100  * @pre This method can be called if SCIP is in one of the following stages:
12101  * - \ref SCIP_STAGE_INITPRESOLVE
12102  * - \ref SCIP_STAGE_PRESOLVING
12103  * - \ref SCIP_STAGE_EXITPRESOLVE
12104  * - \ref SCIP_STAGE_PRESOLVED
12105  * - \ref SCIP_STAGE_INITSOLVE
12106  * - \ref SCIP_STAGE_SOLVING
12107  */
12108 extern
12109 void SCIPenableNLP(
12110  SCIP* scip /**< SCIP data structure */
12111  );
12112 
12113 /** returns, whether an NLP has been constructed
12114  *
12115  * @pre This method can be called if SCIP is in one of the following stages:
12116  * - \ref SCIP_STAGE_INITSOLVE
12117  * - \ref SCIP_STAGE_SOLVING
12118  */
12119 extern
12121  SCIP* scip /**< SCIP data structure */
12122  );
12123 
12124 /** returns whether the NLP has a continuous variable in a nonlinear term
12125  *
12126  * @pre This method can be called if SCIP is in one of the following stages:
12127  * - \ref SCIP_STAGE_INITSOLVE
12128  * - \ref SCIP_STAGE_SOLVING
12129  */
12130 extern
12132  SCIP* scip /**< SCIP data structure */
12133  );
12134 
12135 /** gets current NLP variables along with the current number of NLP variables
12136  *
12137  * @pre This method can be called if SCIP is in one of the following stages:
12138  * - \ref SCIP_STAGE_INITSOLVE
12139  * - \ref SCIP_STAGE_SOLVING
12140  */
12141 extern
12143  SCIP* scip, /**< SCIP data structure */
12144  SCIP_VAR*** vars, /**< pointer to store the array of NLP variables, or NULL */
12145  int* nvars /**< pointer to store the number of NLP variables, or NULL */
12146  );
12147 
12148 /** gets array with variables of the NLP
12149  *
12150  * @pre This method can be called if SCIP is in one of the following stages:
12151  * - \ref SCIP_STAGE_INITSOLVE
12152  * - \ref SCIP_STAGE_SOLVING
12153  */
12154 extern
12156  SCIP* scip /**< SCIP data structure */
12157  );
12158 
12159 /** gets current number of variables in NLP
12160  *
12161  * @pre This method can be called if SCIP is in one of the following stages:
12162  * - \ref SCIP_STAGE_INITSOLVE
12163  * - \ref SCIP_STAGE_SOLVING
12164  */
12165 extern
12166 int SCIPgetNNLPVars(
12167  SCIP* scip /**< SCIP data structure */
12168  );
12169 
12170 /** computes for each variables the number of NLP rows in which the variable appears in a nonlinear var
12171  *
12172  * @pre This method can be called if SCIP is in one of the following stages:
12173  * - \ref SCIP_STAGE_INITSOLVE
12174  * - \ref SCIP_STAGE_SOLVING
12175  */
12176 extern
12178  SCIP* scip, /**< SCIP data structure */
12179  int* nlcount /**< an array of length at least SCIPnlpGetNVars() to store nonlinearity counts of variables */
12180  );
12181 
12182 /** returns dual solution values associated with lower bounds of NLP variables
12183  *
12184  * @pre This method can be called if SCIP is in one of the following stages:
12185  * - \ref SCIP_STAGE_INITSOLVE
12186  * - \ref SCIP_STAGE_SOLVING
12187  */
12188 extern
12190  SCIP* scip /**< SCIP data structure */
12191  );
12192 
12193 /** returns dual solution values associated with upper bounds of NLP variables
12194  *
12195  * @pre This method can be called if SCIP is in one of the following stages:
12196  * - \ref SCIP_STAGE_INITSOLVE
12197  * - \ref SCIP_STAGE_SOLVING
12198  */
12199 extern
12201  SCIP* scip /**< SCIP data structure */
12202  );
12203 
12204 /** gets current NLP nonlinear rows along with the current number of NLP nonlinear rows
12205  *
12206  * @pre This method can be called if SCIP is in one of the following stages:
12207  * - \ref SCIP_STAGE_INITSOLVE
12208  * - \ref SCIP_STAGE_SOLVING
12209  */
12210 extern
12212  SCIP* scip, /**< SCIP data structure */
12213  SCIP_NLROW*** nlrows, /**< pointer to store the array of NLP nonlinear rows, or NULL */
12214  int* nnlrows /**< pointer to store the number of NLP nonlinear rows, or NULL */
12215  );
12216 
12217 /** gets array with nonlinear rows of the NLP
12218  *
12219  * @pre This method can be called if SCIP is in one of the following stages:
12220  * - \ref SCIP_STAGE_INITSOLVE
12221  * - \ref SCIP_STAGE_SOLVING
12222  */
12223 extern
12225  SCIP* scip /**< SCIP data structure */
12226  );
12227 
12228 /** gets current number of nonlinear rows in NLP
12229  *
12230  * @pre This method can be called if SCIP is in one of the following stages:
12231  * - \ref SCIP_STAGE_INITSOLVE
12232  * - \ref SCIP_STAGE_SOLVING
12233  */
12234 extern
12235 int SCIPgetNNLPNlRows(
12236  SCIP* scip /**< SCIP data structure */
12237  );
12238 
12239 /** adds a nonlinear row to the NLP. This row is captured by the NLP.
12240  *
12241  * @pre This method can be called if SCIP is in one of the following stages:
12242  * - \ref SCIP_STAGE_INITSOLVE
12243  * - \ref SCIP_STAGE_SOLVING
12244  */
12245 extern
12247  SCIP* scip, /**< SCIP data structure */
12248  SCIP_NLROW* nlrow /**< nonlinear row to add to NLP */
12249  );
12250 
12251 /** makes sure that the NLP of the current node is flushed
12252  *
12253  * @pre This method can be called if SCIP is in one of the following stages:
12254  * - \ref SCIP_STAGE_INITSOLVE
12255  * - \ref SCIP_STAGE_SOLVING
12256  */
12257 extern
12259  SCIP* scip /**< SCIP data structure */
12260  );
12261 
12262 /** sets or clears initial primal guess for NLP solution (start point for NLP solver)
12263  *
12264  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12265  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12266  *
12267  * @pre This method can be called if SCIP is in one of the following stages:
12268  * - \ref SCIP_STAGE_INITSOLVE
12269  * - \ref SCIP_STAGE_SOLVING
12270  */
12271 extern
12273  SCIP* scip, /**< SCIP data structure */
12274  SCIP_Real* initialguess /**< values of initial guess (corresponding to variables from SCIPgetNLPVarsData), or NULL to use no start point */
12275  );
12276 
12277 /** sets initial primal guess for NLP solution (start point for NLP solver)
12278  *
12279  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12280  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12281  *
12282  * @pre This method can be called if SCIP is in one of the following stages:
12283  * - \ref SCIP_STAGE_INITSOLVE
12284  * - \ref SCIP_STAGE_SOLVING
12285  */
12286 extern
12288  SCIP* scip, /**< SCIP data structure */
12289  SCIP_SOL* sol /**< solution which values should be taken as initial guess, or NULL for LP solution */
12290  );
12291 
12292 /** solves the current NLP
12293  *
12294  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12295  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12296  *
12297  * @pre This method can be called if SCIP is in one of the following stages:
12298  * - \ref SCIP_STAGE_INITSOLVE
12299  * - \ref SCIP_STAGE_SOLVING
12300  */
12301 extern
12303  SCIP* scip /**< SCIP data structure */
12304  );
12305 
12306 /** gets solution status of current NLP
12307  *
12308  * @pre This method can be called if SCIP is in one of the following stages:
12309  * - \ref SCIP_STAGE_INITSOLVE
12310  * - \ref SCIP_STAGE_SOLVING
12311  */
12312 extern
12314  SCIP* scip /**< SCIP data structure */
12315  );
12316 
12317 /** gets termination status of last NLP solve
12318  *
12319  * @pre This method can be called if SCIP is in one of the following stages:
12320  * - \ref SCIP_STAGE_INITSOLVE
12321  * - \ref SCIP_STAGE_SOLVING
12322  */
12323 extern
12325  SCIP* scip /**< SCIP data structure */
12326  );
12327 
12328 /** gives statistics (number of iterations, solving time, ...) of last NLP solve
12329  *
12330  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12331  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12332  *
12333  * @pre This method can be called if SCIP is in one of the following stages:
12334  * - \ref SCIP_STAGE_INITSOLVE
12335  * - \ref SCIP_STAGE_SOLVING
12336  */
12337 extern
12339  SCIP* scip, /**< SCIP data structure */
12340  SCIP_NLPSTATISTICS* statistics /**< pointer to store statistics */
12341  );
12342 
12343 /** gets objective value of current NLP
12344  *
12345  * @pre This method can be called if SCIP is in one of the following stages:
12346  * - \ref SCIP_STAGE_INITSOLVE
12347  * - \ref SCIP_STAGE_SOLVING
12348  */
12349 extern
12351  SCIP* scip /**< SCIP data structure */
12352  );
12353 
12354 /** indicates whether a feasible solution for the current NLP is available
12355  * thus, returns whether the solution status <= feasible
12356  *
12357  * @pre This method can be called if SCIP is in one of the following stages:
12358  * - \ref SCIP_STAGE_INITSOLVE
12359  * - \ref SCIP_STAGE_SOLVING
12360  */
12361 extern
12363  SCIP* scip /**< SCIP data structure */
12364  );
12365 
12366 /** gets fractional variables of last NLP solution along with solution values and fractionalities
12367  *
12368  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12369  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12370  *
12371  * @pre This method can be called if SCIP is in one of the following stages:
12372  * - \ref SCIP_STAGE_INITSOLVE
12373  * - \ref SCIP_STAGE_SOLVING
12374  */
12375 extern
12377  SCIP* scip, /**< SCIP data structure */
12378  SCIP_VAR*** fracvars, /**< pointer to store the array of NLP fractional variables, or NULL */
12379  SCIP_Real** fracvarssol, /**< pointer to store the array of NLP fractional variables solution values, or NULL */
12380  SCIP_Real** fracvarsfrac, /**< pointer to store the array of NLP fractional variables fractionalities, or NULL */
12381  int* nfracvars, /**< pointer to store the number of NLP fractional variables , or NULL */
12382  int* npriofracvars /**< pointer to store the number of NLP fractional variables with maximal branching priority, or NULL */
12383  );
12384 
12385 /** gets integer parameter of NLP
12386  *
12387  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12388  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12389  *
12390  * @pre This method can be called if SCIP is in one of the following stages:
12391  * - \ref SCIP_STAGE_INITSOLVE
12392  * - \ref SCIP_STAGE_SOLVING
12393  */
12394 extern
12396  SCIP* scip, /**< SCIP data structure */
12397  SCIP_NLPPARAM type, /**< parameter number */
12398  int* ival /**< pointer to store the parameter value */
12399  );
12400 
12401 /** sets integer parameter of NLP
12402  *
12403  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12404  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12405  *
12406  * @pre This method can be called if SCIP is in one of the following stages:
12407  * - \ref SCIP_STAGE_INITSOLVE
12408  * - \ref SCIP_STAGE_SOLVING
12409  */
12410 extern
12412  SCIP* scip, /**< SCIP data structure */
12413  SCIP_NLPPARAM type, /**< parameter number */
12414  int ival /**< parameter value */
12415  );
12416 
12417 /** gets floating point parameter of NLP
12418  *
12419  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12420  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12421  *
12422  * @pre This method can be called if SCIP is in one of the following stages:
12423  * - \ref SCIP_STAGE_INITSOLVE
12424  * - \ref SCIP_STAGE_SOLVING
12425  */
12426 extern
12428  SCIP* scip, /**< SCIP data structure */
12429  SCIP_NLPPARAM type, /**< parameter number */
12430  SCIP_Real* dval /**< pointer to store the parameter value */
12431  );
12432 
12433 /** sets floating point parameter of NLP
12434  *
12435  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12436  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12437  *
12438  * @pre This method can be called if SCIP is in one of the following stages:
12439  * - \ref SCIP_STAGE_INITSOLVE
12440  * - \ref SCIP_STAGE_SOLVING
12441  */
12442 extern
12444  SCIP* scip, /**< SCIP data structure */
12445  SCIP_NLPPARAM type, /**< parameter number */
12446  SCIP_Real dval /**< parameter value */
12447  );
12448 
12449 /** gets string parameter of NLP
12450  *
12451  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12452  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12453  *
12454  * @pre This method can be called if SCIP is in one of the following stages:
12455  * - \ref SCIP_STAGE_INITSOLVE
12456  * - \ref SCIP_STAGE_SOLVING
12457  */
12458 extern
12460  SCIP* scip, /**< SCIP data structure */
12461  SCIP_NLPPARAM type, /**< parameter number */
12462  const char** sval /**< pointer to store the parameter value */
12463  );
12464 
12465 /** sets string parameter of NLP
12466  *
12467  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12468  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12469  *
12470  * @pre This method can be called if SCIP is in one of the following stages:
12471  * - \ref SCIP_STAGE_INITSOLVE
12472  * - \ref SCIP_STAGE_SOLVING
12473  */
12474 extern
12476  SCIP* scip, /**< SCIP data structure */
12477  SCIP_NLPPARAM type, /**< parameter number */
12478  const char* sval /**< parameter value */
12479  );
12480 
12481 /** writes current NLP to a file
12482  *
12483  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12484  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12485  *
12486  * @pre This method can be called if SCIP is in one of the following stages:
12487  * - \ref SCIP_STAGE_INITSOLVE
12488  * - \ref SCIP_STAGE_SOLVING
12489  */
12490 extern
12492  SCIP* scip, /**< SCIP data structure */
12493  const char* filename /**< file name */
12494  );
12495 
12496 /** gets the NLP interface and problem used by the SCIP NLP;
12497  * with the NLPI and its problem you can use all of the methods defined in nlpi/nlpi.h;
12498  *
12499  * @warning You have to make sure, that the full internal state of the NLPI does not change or is recovered completely
12500  * after the end of the method that uses the NLPI. In particular, if you manipulate the NLP or its solution
12501  * (e.g. by calling one of the SCIPnlpiAdd...() or the SCIPnlpiSolve() method), you have to check in advance
12502  * whether the NLP is currently solved. If this is the case, you have to make sure, the internal solution
12503  * status is recovered completely at the end of your method. Additionally you have to resolve the NLP with
12504  * SCIPnlpiSolve() in order to reinstall the internal solution status.
12505  *
12506  * @warning Make also sure, that all parameter values that you have changed are set back to their original values.
12507  *
12508  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12509  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12510  *
12511  * @pre This method can be called if SCIP is in one of the following stages:
12512  * - \ref SCIP_STAGE_INITSOLVE
12513  * - \ref SCIP_STAGE_SOLVING
12514  */
12515 extern
12517  SCIP* scip, /**< SCIP data structure */
12518  SCIP_NLPI** nlpi, /**< pointer to store the NLP solver interface */
12519  SCIP_NLPIPROBLEM** nlpiproblem /**< pointer to store the NLP solver interface problem */
12520  );
12521 
12522 /**@} */
12523 
12524 
12525 /*
12526  * NLP diving methods
12527  */
12528 
12529 /**@name NLP Diving Methods */
12530 /**@{ */
12531 
12532 /** initiates NLP diving
12533  * making methods SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), SCIPchgVarsBoundsDiveNLP(), and SCIPsolveDiveNLP() available
12534  *
12535  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12536  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12537  *
12538  * @pre This method can be called if SCIP is in one of the following stages:
12539  * - \ref SCIP_STAGE_INITSOLVE
12540  * - \ref SCIP_STAGE_SOLVING
12541  */
12542 extern
12544  SCIP* scip /**< SCIP data structure */
12545  );
12546 
12547 /** ends NLP diving
12548  * resets changes made by SCIPchgVarObjDiveNLP(), SCIPchgVarBoundsDiveNLP(), and SCIPchgVarsBoundsDiveNLP()
12549  *
12550  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12551  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12552  *
12553  * @pre This method can be called if SCIP is in one of the following stages:
12554  * - \ref SCIP_STAGE_INITSOLVE
12555  * - \ref SCIP_STAGE_SOLVING
12556  */
12557 extern
12559  SCIP* scip /**< SCIP data structure */
12560  );
12561 
12562 /** changes linear objective coefficient of a variable in diving NLP
12563  *
12564  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12565  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12566  *
12567  * @pre This method can be called if SCIP is in one of the following stages:
12568  * - \ref SCIP_STAGE_INITSOLVE
12569  * - \ref SCIP_STAGE_SOLVING
12570  */
12571 extern
12573  SCIP* scip, /**< SCIP data structure */
12574  SCIP_VAR* var, /**< variable which coefficient to change */
12575  SCIP_Real coef /**< new value for coefficient */
12576  );
12577 
12578 /** changes bounds of a variable in diving NLP
12579  *
12580  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12581  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12582  *
12583  * @pre This method can be called if SCIP is in one of the following stages:
12584  * - \ref SCIP_STAGE_INITSOLVE
12585  * - \ref SCIP_STAGE_SOLVING
12586  */
12587 extern
12589  SCIP* scip, /**< SCIP data structure */
12590  SCIP_VAR* var, /**< variable which bounds to change */
12591  SCIP_Real lb, /**< new lower bound */
12592  SCIP_Real ub /**< new upper bound */
12593  );
12594 
12595 /** changes bounds of a set of variables in diving NLP
12596  *
12597  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12598  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12599  *
12600  * @pre This method can be called if SCIP is in one of the following stages:
12601  * - \ref SCIP_STAGE_INITSOLVE
12602  * - \ref SCIP_STAGE_SOLVING
12603  */
12604 extern
12606  SCIP* scip, /**< SCIP data structure */
12607  int nvars, /**< number of variables which bounds to changes */
12608  SCIP_VAR** vars, /**< variables which bounds to change */
12609  SCIP_Real* lbs, /**< new lower bounds */
12610  SCIP_Real* ubs /**< new upper bounds */
12611  );
12612 
12613 /** solves diving NLP
12614  *
12615  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12616  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12617  *
12618  * @pre This method can be called if SCIP is in one of the following stages:
12619  * - \ref SCIP_STAGE_INITSOLVE
12620  * - \ref SCIP_STAGE_SOLVING
12621  */
12622 extern
12624  SCIP* scip /**< SCIP data structure */
12625  );
12626 
12627 /**@} */
12628 
12629 
12630 /*
12631  * NLP nonlinear row methods
12632  */
12633 
12634 /**@name NLP Nonlinear Row Methods */
12635 /**@{ */
12636 
12637 /** creates and captures an NLP row
12638  *
12639  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12640  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12641  *
12642  * @pre This method can be called if SCIP is in one of the following stages:
12643  * - \ref SCIP_STAGE_PRESOLVED
12644  * - \ref SCIP_STAGE_INITSOLVE
12645  * - \ref SCIP_STAGE_SOLVING
12646  */
12647 extern
12649  SCIP* scip, /**< SCIP data structure */
12650  SCIP_NLROW** nlrow, /**< buffer to store pointer to nonlinear row */
12651  const char* name, /**< name of nonlinear row */
12652  SCIP_Real constant, /**< constant */
12653  int nlinvars, /**< number of linear variables */
12654  SCIP_VAR** linvars, /**< linear variables, or NULL if nlinvars == 0 */
12655  SCIP_Real* lincoefs, /**< linear coefficients, or NULL if nlinvars == 0 */
12656  int nquadvars, /**< number of variables in quadratic term */
12657  SCIP_VAR** quadvars, /**< variables in quadratic terms, or NULL if nquadvars == 0 */
12658  int nquadelems, /**< number of elements in quadratic term */
12659  SCIP_QUADELEM* quadelems, /**< elements (i.e., monomials) in quadratic term, or NULL if nquadelems == 0 */
12660  SCIP_EXPRTREE* expression, /**< nonlinear expression, or NULL */
12661  SCIP_Real lhs, /**< left hand side */
12662  SCIP_Real rhs /**< right hand side */
12663  );
12664 
12665 /** creates and captures an NLP nonlinear row without any coefficients
12666  *
12667  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12668  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12669  *
12670  * @pre This method can be called if SCIP is in one of the following stages:
12671  * - \ref SCIP_STAGE_PRESOLVED
12672  * - \ref SCIP_STAGE_INITSOLVE
12673  * - \ref SCIP_STAGE_SOLVING
12674  */
12675 extern
12677  SCIP* scip, /**< SCIP data structure */
12678  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
12679  const char* name, /**< name of nonlinear row */
12680  SCIP_Real lhs, /**< left hand side */
12681  SCIP_Real rhs /**< right hand side */
12682  );
12683 
12684 /** creates and captures an NLP row from a linear row
12685  *
12686  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12687  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12688  *
12689  * @pre This method can be called if SCIP is in one of the following stages:
12690  * - \ref SCIP_STAGE_PRESOLVED
12691  * - \ref SCIP_STAGE_INITSOLVE
12692  * - \ref SCIP_STAGE_SOLVING
12693  */
12694 extern
12696  SCIP* scip, /**< SCIP data structure */
12697  SCIP_NLROW** nlrow, /**< pointer to nonlinear row */
12698  SCIP_ROW* row /**< the linear row to copy */
12699  );
12700 
12701 /** increases usage counter of NLP nonlinear row
12702  *
12703  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12704  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12705  *
12706  * @pre This method can be called if SCIP is in one of the following stages:
12707  * - \ref SCIP_STAGE_PRESOLVED
12708  * - \ref SCIP_STAGE_INITSOLVE
12709  * - \ref SCIP_STAGE_SOLVING
12710  */
12711 extern
12713  SCIP* scip, /**< SCIP data structure */
12714  SCIP_NLROW* nlrow /**< nonlinear row to capture */
12715  );
12716 
12717 /** decreases usage counter of NLP nonlinear row, and frees memory if necessary
12718  *
12719  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12720  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12721  *
12722  * @pre This method can be called if SCIP is in one of the following stages:
12723  * - \ref SCIP_STAGE_PRESOLVED
12724  * - \ref SCIP_STAGE_INITSOLVE
12725  * - \ref SCIP_STAGE_SOLVING
12726  * - \ref SCIP_STAGE_EXITSOLVE
12727  */
12728 extern
12730  SCIP* scip, /**< SCIP data structure */
12731  SCIP_NLROW** nlrow /**< pointer to nonlinear row */
12732  );
12733 
12734 /** changes left hand side of NLP nonlinear row
12735  *
12736  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12737  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12738  *
12739  * @pre This method can be called if SCIP is in one of the following stages:
12740  * - \ref SCIP_STAGE_PRESOLVED
12741  * - \ref SCIP_STAGE_INITSOLVE
12742  * - \ref SCIP_STAGE_SOLVING
12743  */
12744 extern
12746  SCIP* scip, /**< SCIP data structure */
12747  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
12748  SCIP_Real lhs /**< new left hand side */
12749  );
12750 
12751 /** changes right hand side of NLP nonlinear row
12752  *
12753  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12754  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12755  *
12756  * @pre This method can be called if SCIP is in one of the following stages:
12757  * - \ref SCIP_STAGE_PRESOLVED
12758  * - \ref SCIP_STAGE_INITSOLVE
12759  * - \ref SCIP_STAGE_SOLVING
12760  */
12761 extern
12763  SCIP* scip, /**< SCIP data structure */
12764  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
12765  SCIP_Real rhs /**< new right hand side */
12766  );
12767 
12768 /** changes constant of NLP nonlinear row
12769  *
12770  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12771  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12772  *
12773  * @pre This method can be called if SCIP is in one of the following stages:
12774  * - \ref SCIP_STAGE_PRESOLVED
12775  * - \ref SCIP_STAGE_INITSOLVE
12776  * - \ref SCIP_STAGE_SOLVING
12777  */
12778 extern
12780  SCIP* scip, /**< SCIP data structure */
12781  SCIP_NLROW* nlrow, /**< NLP row */
12782  SCIP_Real constant /**< new value for constant */
12783  );
12784 
12785 /** adds variable with a linear coefficient to the nonlinear row
12786  *
12787  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12788  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12789  *
12790  * @pre This method can be called if SCIP is in one of the following stages:
12791  * - \ref SCIP_STAGE_PRESOLVED
12792  * - \ref SCIP_STAGE_INITSOLVE
12793  * - \ref SCIP_STAGE_SOLVING
12794  */
12795 extern
12797  SCIP* scip, /**< SCIP data structure */
12798  SCIP_NLROW* nlrow, /**< NLP row */
12799  SCIP_VAR* var, /**< problem variable */
12800  SCIP_Real val /**< value of coefficient in linear part of row */
12801  );
12802 
12803 /** adds variables with linear coefficients to the row
12804  *
12805  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12806  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12807  *
12808  * @pre This method can be called if SCIP is in one of the following stages:
12809  * - \ref SCIP_STAGE_PRESOLVED
12810  * - \ref SCIP_STAGE_INITSOLVE
12811  * - \ref SCIP_STAGE_SOLVING
12812  */
12813 extern
12815  SCIP* scip, /**< SCIP data structure */
12816  SCIP_NLROW* nlrow, /**< NLP row */
12817  int nvars, /**< number of variables to add to the row */
12818  SCIP_VAR** vars, /**< problem variables to add */
12819  SCIP_Real* vals /**< values of coefficients in linear part of row */
12820  );
12821 
12822 /** changes linear coefficient of a variables in a row
12823  * setting the coefficient to 0.0 means that it is removed from the row
12824  * the variable does not need to exists before
12825  *
12826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12828  *
12829  * @pre This method can be called if SCIP is in one of the following stages:
12830  * - \ref SCIP_STAGE_PRESOLVED
12831  * - \ref SCIP_STAGE_INITSOLVE
12832  * - \ref SCIP_STAGE_SOLVING
12833  */
12834 extern
12836  SCIP* scip, /**< SCIP data structure */
12837  SCIP_NLROW* nlrow, /**< NLP row */
12838  SCIP_VAR* var, /**< variable */
12839  SCIP_Real coef /**< new value of coefficient */
12840  );
12841 
12842 /** adds quadratic variable to the nonlinear row
12843  * after adding a quadratic variable, it can be used to add quadratic elements
12844  *
12845  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12846  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12847  *
12848  * @pre This method can be called if SCIP is in one of the following stages:
12849  * - \ref SCIP_STAGE_PRESOLVED
12850  * - \ref SCIP_STAGE_INITSOLVE
12851  * - \ref SCIP_STAGE_SOLVING
12852  */
12853 extern
12855  SCIP* scip, /**< SCIP data structure */
12856  SCIP_NLROW* nlrow, /**< NLP row */
12857  SCIP_VAR* var /**< problem variable */
12858  );
12859 
12860 /** adds quadratic variables to the nonlinear row
12861  * after adding quadratic variables, they can be used to add quadratic elements
12862  *
12863  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12864  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12865  *
12866  * @pre This method can be called if SCIP is in one of the following stages:
12867  * - \ref SCIP_STAGE_PRESOLVED
12868  * - \ref SCIP_STAGE_INITSOLVE
12869  * - \ref SCIP_STAGE_SOLVING
12870  */
12871 extern
12873  SCIP* scip, /**< SCIP data structure */
12874  SCIP_NLROW* nlrow, /**< NLP row */
12875  int nvars, /**< number of problem variables */
12876  SCIP_VAR** vars /**< problem variables */
12877  );
12878 
12879 /** add a quadratic element to the nonlinear row
12880  * variable indices of the quadratic element need to be relative to quadratic variables array of row
12881  *
12882  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12883  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12884  *
12885  * @pre This method can be called if SCIP is in one of the following stages:
12886  * - \ref SCIP_STAGE_PRESOLVED
12887  * - \ref SCIP_STAGE_INITSOLVE
12888  * - \ref SCIP_STAGE_SOLVING
12889  */
12890 extern
12892  SCIP* scip, /**< SCIP data structure */
12893  SCIP_NLROW* nlrow, /**< NLP row */
12894  SCIP_QUADELEM quadelem /**< quadratic element */
12895  );
12896 
12897 /** adds quadratic elements to the nonlinear row
12898  * variable indices of the quadratic elements need to be relative to quadratic variables array of row
12899  *
12900  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12901  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12902  *
12903  * @pre This method can be called if SCIP is in one of the following stages:
12904  * - \ref SCIP_STAGE_PRESOLVED
12905  * - \ref SCIP_STAGE_INITSOLVE
12906  * - \ref SCIP_STAGE_SOLVING
12907  */
12908 extern
12910  SCIP* scip, /**< SCIP data structure */
12911  SCIP_NLROW* nlrow, /**< NLP row */
12912  int nquadelems, /**< number of quadratic elements */
12913  SCIP_QUADELEM* quadelems /**< quadratic elements */
12914  );
12915 
12916 /** changes coefficient in quadratic part of a row
12917  * setting the coefficient in the quadelement to 0.0 means that it is removed from the row
12918  * the element does not need to exists before
12919  *
12920  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12921  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12922  *
12923  * @pre This method can be called if SCIP is in one of the following stages:
12924  * - \ref SCIP_STAGE_PRESOLVED
12925  * - \ref SCIP_STAGE_INITSOLVE
12926  * - \ref SCIP_STAGE_SOLVING
12927  */
12928 extern
12930  SCIP* scip, /**< SCIP data structure */
12931  SCIP_NLROW* nlrow, /**< NLP row */
12932  SCIP_QUADELEM quadelement /**< new quadratic element, or update for existing one */
12933  );
12934 
12935 /** sets or deletes expression tree in the nonlinear row
12936  *
12937  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12938  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12939  *
12940  * @pre This method can be called if SCIP is in one of the following stages:
12941  * - \ref SCIP_STAGE_PRESOLVED
12942  * - \ref SCIP_STAGE_INITSOLVE
12943  * - \ref SCIP_STAGE_SOLVING
12944  */
12945 extern
12947  SCIP* scip, /**< SCIP data structure */
12948  SCIP_NLROW* nlrow, /**< NLP row */
12949  SCIP_EXPRTREE* exprtree /**< expression tree, or NULL */
12950  );
12951 
12952 /** sets a parameter of expression tree in the nonlinear row
12953  *
12954  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12955  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12956  *
12957  * @pre This method can be called if SCIP is in one of the following stages:
12958  * - \ref SCIP_STAGE_PRESOLVED
12959  * - \ref SCIP_STAGE_INITSOLVE
12960  * - \ref SCIP_STAGE_SOLVING
12961  */
12962 extern
12964  SCIP* scip, /**< SCIP data structure */
12965  SCIP_NLROW* nlrow, /**< NLP row */
12966  int paramidx, /**< index of parameter in expression tree */
12967  SCIP_Real paramval /**< new value of parameter in expression tree */
12968  );
12969 
12970 /** sets parameters of expression tree in the nonlinear row
12971  *
12972  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12973  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12974  *
12975  * @pre This method can be called if SCIP is in one of the following stages:
12976  * - \ref SCIP_STAGE_PRESOLVED
12977  * - \ref SCIP_STAGE_INITSOLVE
12978  * - \ref SCIP_STAGE_SOLVING
12979  */
12980 extern
12982  SCIP* scip, /**< SCIP data structure */
12983  SCIP_NLROW* nlrow, /**< NLP row */
12984  SCIP_Real* paramvals /**< new values of parameter in expression tree */
12985  );
12986 
12987 /** recalculates the activity of a nonlinear row in the last NLP solution
12988  *
12989  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
12990  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
12991  *
12992  * @pre This method can be called if SCIP is in one of the following stages:
12993  * - \ref SCIP_STAGE_PRESOLVED
12994  * - \ref SCIP_STAGE_INITSOLVE
12995  * - \ref SCIP_STAGE_SOLVING
12996  */
12997 extern
12999  SCIP* scip, /**< SCIP data structure */
13000  SCIP_NLROW* nlrow /**< NLP nonlinear row */
13001  );
13002 
13003 /** returns the activity of a nonlinear row in the last NLP solution
13004  *
13005  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13006  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13007  *
13008  * @pre This method can be called if SCIP is in one of the following stages:
13009  * - \ref SCIP_STAGE_INITSOLVE
13010  * - \ref SCIP_STAGE_SOLVING
13011  */
13012 extern
13014  SCIP* scip, /**< SCIP data structure */
13015  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13016  SCIP_Real* activity /**< pointer to store activity value */
13017  );
13018 
13019 /** gives the feasibility of a nonlinear row in the last NLP solution: negative value means infeasibility
13020  *
13021  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13022  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13023  *
13024  * @pre This method can be called if SCIP is in one of the following stages:
13025  * - \ref SCIP_STAGE_INITSOLVE
13026  * - \ref SCIP_STAGE_SOLVING
13027  */
13028 extern
13030  SCIP* scip, /**< SCIP data structure */
13031  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13032  SCIP_Real* feasibility /**< pointer to store feasibility value */
13033  );
13034 
13035 /** recalculates the activity of a nonlinear row for the current pseudo solution
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_NLROW* nlrow /**< NLP nonlinear row */
13048  );
13049 
13050 /** gives the activity of a nonlinear row for the current pseudo solution
13051  *
13052  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13053  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13054  *
13055  * @pre This method can be called if SCIP is in one of the following stages:
13056  * - \ref SCIP_STAGE_INITSOLVE
13057  * - \ref SCIP_STAGE_SOLVING
13058  */
13059 extern
13061  SCIP* scip, /**< SCIP data structure */
13062  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13063  SCIP_Real* pseudoactivity /**< pointer to store pseudo activity value */
13064  );
13065 
13066 /** gives the feasibility of a nonlinear row for the current pseudo solution: negative value means infeasibility
13067  *
13068  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13069  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13070  *
13071  * @pre This method can be called if SCIP is in one of the following stages:
13072  * - \ref SCIP_STAGE_INITSOLVE
13073  * - \ref SCIP_STAGE_SOLVING
13074  */
13075 extern
13077  SCIP* scip, /**< SCIP data structure */
13078  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13079  SCIP_Real* pseudofeasibility /**< pointer to store pseudo feasibility value */
13080  );
13081 
13082 /** recalculates the activity of a nonlinear row in the last NLP or pseudo solution
13083  *
13084  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13085  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13086  *
13087  * @pre This method can be called if SCIP is in one of the following stages:
13088  * - \ref SCIP_STAGE_INITSOLVE
13089  * - \ref SCIP_STAGE_SOLVING
13090  */
13091 extern
13093  SCIP* scip, /**< SCIP data structure */
13094  SCIP_NLROW* nlrow /**< NLP nonlinear row */
13095  );
13096 
13097 /** gives the activity of a nonlinear row in the last NLP or pseudo solution
13098  *
13099  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13100  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13101  *
13102  * @pre This method can be called if SCIP is in one of the following stages:
13103  * - \ref SCIP_STAGE_INITSOLVE
13104  * - \ref SCIP_STAGE_SOLVING
13105  */
13106 extern
13108  SCIP* scip, /**< SCIP data structure */
13109  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13110  SCIP_Real* activity /**< pointer to store activity value */
13111  );
13112 
13113 /** gives the feasibility of a nonlinear row in the last NLP or pseudo solution
13114  *
13115  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13116  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13117  *
13118  * @pre This method can be called if SCIP is in one of the following stages:
13119  * - \ref SCIP_STAGE_INITSOLVE
13120  * - \ref SCIP_STAGE_SOLVING
13121  */
13122 extern
13124  SCIP* scip, /**< SCIP data structure */
13125  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13126  SCIP_Real* feasibility /**< pointer to store feasibility value */
13127  );
13128 
13129 /** gives the activity of a nonlinear row for the given primal solution or NLP solution or pseudo solution
13130  *
13131  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13132  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13133  *
13134  * @pre This method can be called if SCIP is in one of the following stages:
13135  * - \ref SCIP_STAGE_INITSOLVE
13136  * - \ref SCIP_STAGE_SOLVING
13137  */
13138 extern
13140  SCIP* scip, /**< SCIP data structure */
13141  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13142  SCIP_SOL* sol, /**< primal CIP solution, or NULL for NLP solution of pseudo solution */
13143  SCIP_Real* activity /**< pointer to store activity value */
13144  );
13145 
13146 /** gives the feasibility of a nonlinear row for the given primal solution
13147  *
13148  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13149  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13150  *
13151  * @pre This method can be called if SCIP is in one of the following stages:
13152  * - \ref SCIP_STAGE_INITSOLVE
13153  * - \ref SCIP_STAGE_SOLVING
13154  */
13155 extern
13157  SCIP* scip, /**< SCIP data structure */
13158  SCIP_NLROW* nlrow, /**< NLP nonlinear row */
13159  SCIP_SOL* sol, /**< primal CIP solution */
13160  SCIP_Real* feasibility /**< pointer to store feasibility value */
13161  );
13162 
13163 /** gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds
13164  *
13165  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13166  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13167  *
13168  * @pre This method can be called if SCIP is in one of the following stages:
13169  * - \ref SCIP_STAGE_PRESOLVED
13170  * - \ref SCIP_STAGE_INITSOLVE
13171  * - \ref SCIP_STAGE_SOLVING
13172  */
13173 extern
13175  SCIP* scip, /**< SCIP data structure */
13176  SCIP_NLROW* nlrow, /**< NLP row */
13177  SCIP_Real* minactivity, /**< buffer to store minimal activity, or NULL */
13178  SCIP_Real* maxactivity /**< buffer to store maximal activity, or NULL */
13179  );
13180 
13181 /** output nonlinear row to file stream
13182  *
13183  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13184  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13185  *
13186  * @pre This method can be called if SCIP is in one of the following stages:
13187  * - \ref SCIP_STAGE_PRESOLVED
13188  * - \ref SCIP_STAGE_INITSOLVE
13189  * - \ref SCIP_STAGE_SOLVING
13190  */
13191 extern
13193  SCIP* scip, /**< SCIP data structure */
13194  SCIP_NLROW* nlrow, /**< NLP row */
13195  FILE* file /**< output file (or NULL for standard output) */
13196  );
13197 
13198 /**@} */
13199 
13200 /**@name Expression tree methods */
13201 /**@{ */
13202 
13203 /** replaces array of variables in expression tree by corresponding transformed variables
13204  *
13205  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13206  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13207  *
13208  * @pre This method can be called if @p scip is in one of the following stages:
13209  * - \ref SCIP_STAGE_TRANSFORMING
13210  * - \ref SCIP_STAGE_TRANSFORMED
13211  * - \ref SCIP_STAGE_INITPRESOLVE
13212  * - \ref SCIP_STAGE_PRESOLVING
13213  * - \ref SCIP_STAGE_EXITPRESOLVE
13214  * - \ref SCIP_STAGE_PRESOLVED
13215  * - \ref SCIP_STAGE_INITSOLVE
13216  * - \ref SCIP_STAGE_SOLVING
13217  * - \ref SCIP_STAGE_SOLVED
13218  * - \ref SCIP_STAGE_EXITSOLVE
13219  * - \ref SCIP_STAGE_FREETRANS
13220  *
13221  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13222  */
13223 extern
13225  SCIP* scip, /**< SCIP data structure */
13226  SCIP_EXPRTREE* tree /**< expression tree */
13227  );
13228 
13229 /** evaluates an expression tree for a primal solution or LP solution
13230  *
13231  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13232  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13233  *
13234  * @pre This method can be called if @p scip is in one of the following stages:
13235  * - \ref SCIP_STAGE_PROBLEM
13236  * - \ref SCIP_STAGE_TRANSFORMING
13237  * - \ref SCIP_STAGE_TRANSFORMED
13238  * - \ref SCIP_STAGE_INITPRESOLVE
13239  * - \ref SCIP_STAGE_PRESOLVING
13240  * - \ref SCIP_STAGE_EXITPRESOLVE
13241  * - \ref SCIP_STAGE_PRESOLVED
13242  * - \ref SCIP_STAGE_INITSOLVE
13243  * - \ref SCIP_STAGE_SOLVING
13244  * - \ref SCIP_STAGE_SOLVED
13245  * - \ref SCIP_STAGE_EXITSOLVE
13246  * - \ref SCIP_STAGE_FREETRANS
13247  *
13248  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13249  */
13250 extern
13252  SCIP* scip, /**< SCIP data structure */
13253  SCIP_EXPRTREE* tree, /**< expression tree */
13254  SCIP_SOL* sol, /**< a solution, or NULL for current LP solution */
13255  SCIP_Real* val /**< buffer to store value */
13256  );
13257 
13258 /** evaluates an expression tree w.r.t. current global bounds
13259  *
13260  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13261  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13262  *
13263  * @pre This method can be called if @p scip is in one of the following stages:
13264  * - \ref SCIP_STAGE_PROBLEM
13265  * - \ref SCIP_STAGE_TRANSFORMING
13266  * - \ref SCIP_STAGE_TRANSFORMED
13267  * - \ref SCIP_STAGE_INITPRESOLVE
13268  * - \ref SCIP_STAGE_PRESOLVING
13269  * - \ref SCIP_STAGE_EXITPRESOLVE
13270  * - \ref SCIP_STAGE_PRESOLVED
13271  * - \ref SCIP_STAGE_INITSOLVE
13272  * - \ref SCIP_STAGE_SOLVING
13273  * - \ref SCIP_STAGE_SOLVED
13274  * - \ref SCIP_STAGE_EXITSOLVE
13275  * - \ref SCIP_STAGE_FREETRANS
13276  *
13277  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13278  */
13279 extern
13281  SCIP* scip, /**< SCIP data structure */
13282  SCIP_EXPRTREE* tree, /**< expression tree */
13283  SCIP_Real infinity, /**< value to use for infinity */
13284  SCIP_INTERVAL* val /**< buffer to store result */
13285  );
13286 
13287 /** evaluates an expression tree w.r.t. current local bounds
13288  *
13289  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13290  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13291  *
13292  * @pre This method can be called if @p scip is in one of the following stages:
13293  * - \ref SCIP_STAGE_PROBLEM
13294  * - \ref SCIP_STAGE_TRANSFORMING
13295  * - \ref SCIP_STAGE_TRANSFORMED
13296  * - \ref SCIP_STAGE_INITPRESOLVE
13297  * - \ref SCIP_STAGE_PRESOLVING
13298  * - \ref SCIP_STAGE_EXITPRESOLVE
13299  * - \ref SCIP_STAGE_PRESOLVED
13300  * - \ref SCIP_STAGE_INITSOLVE
13301  * - \ref SCIP_STAGE_SOLVING
13302  * - \ref SCIP_STAGE_SOLVED
13303  * - \ref SCIP_STAGE_EXITSOLVE
13304  * - \ref SCIP_STAGE_FREETRANS
13305  *
13306  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13307  */
13308 extern
13310  SCIP* scip, /**< SCIP data structure */
13311  SCIP_EXPRTREE* tree, /**< expression tree */
13312  SCIP_Real infinity, /**< value to use for infinity */
13313  SCIP_INTERVAL* val /**< buffer to store result */
13314  );
13315 
13316 /**@} */
13317 
13318 
13319 /*
13320  * cutting plane methods
13321  */
13322 
13323 /**@name Cutting Plane Methods */
13324 /**@{ */
13325 
13326 /** returns efficacy of the cut with respect to the given primal solution or the current LP solution:
13327  * e = -feasibility/norm
13328  *
13329  * @return the efficacy of the cut with respect to the given primal solution or the current LP solution:
13330  * e = -feasibility/norm
13331  *
13332  * @pre This method can be called if @p scip is in one of the following stages:
13333  * - \ref SCIP_STAGE_SOLVING
13334  */
13335 extern
13337  SCIP* scip, /**< SCIP data structure */
13338  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
13339  SCIP_ROW* cut /**< separated cut */
13340  );
13341 
13342 /** returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater
13343  * than the minimal cut efficacy
13344  *
13345  * @return TRUE if the cut's efficacy with respect to the given primal solution or the current LP solution is greater
13346  * than the minimal cut efficacy, otherwise FALSE
13347  *
13348  * @pre This method can be called if @p scip is in one of the following stages:
13349  * - \ref SCIP_STAGE_SOLVING
13350  */
13351 extern
13353  SCIP* scip, /**< SCIP data structure */
13354  SCIP_SOL* sol, /**< primal CIP solution, or NULL for current LP solution */
13355  SCIP_ROW* cut /**< separated cut */
13356  );
13357 
13358 /** checks, if the given cut's efficacy is larger than the minimal cut efficacy
13359  *
13360  * @return TRUE if the given cut's efficacy is larger than the minimal cut efficacy, otherwise FALSE
13361  */
13362 extern
13364  SCIP* scip, /**< SCIP data structure */
13365  SCIP_Real efficacy /**< efficacy of the cut */
13366  );
13367 
13368 /** calculates the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
13369  *
13370  * @return the efficacy norm of the given vector, which depends on the "separating/efficacynorm" parameter
13371  */
13372 extern
13374  SCIP* scip, /**< SCIP data structure */
13375  SCIP_Real* vals, /**< array of values */
13376  int nvals /**< number of values */
13377  );
13378 
13379 /** indicates whether a cut is applicable
13380  *
13381  * If the cut has only one variable and this method returns FALSE, it may
13382  * still be possible that the cut can be added to the LP (as a row instead
13383  * of a boundchange), but it will be a very weak cut. The user is asked
13384  * to avoid such cuts.
13385  *
13386  * @pre This method can be called if @p scip is in one of the following stages:
13387  * - \ref SCIP_STAGE_SOLVING
13388  *
13389  * @return whether the cut is modifiable, not a bound change, or a bound change that changes bounds by at least epsilon
13390  */
13391 extern
13393  SCIP* scip, /**< SCIP data structure */
13394  SCIP_ROW* cut /**< separated cut */
13395  );
13396 
13397 /** adds cut to separation storage
13398  *
13399  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13400  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13401  *
13402  * @pre This method can be called if @p scip is in one of the following stages:
13403  * - \ref SCIP_STAGE_SOLVING
13404  */
13405 extern
13407  SCIP* scip, /**< SCIP data structure */
13408  SCIP_SOL* sol, /**< primal solution that was separated, or NULL for LP solution */
13409  SCIP_ROW* cut, /**< separated cut */
13410  SCIP_Bool forcecut, /**< should the cut be forced to enter the LP? */
13411  SCIP_Bool* infeasible /**< pointer to store whether cut has been detected to be infeasible for local bounds */
13412  );
13413 
13414 /** if not already existing, adds row to global cut pool
13415  *
13416  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13417  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13418  *
13419  * @pre This method can be called if @p scip is in one of the following stages:
13420  * - \ref SCIP_STAGE_SOLVING
13421  */
13422 extern
13424  SCIP* scip, /**< SCIP data structure */
13425  SCIP_ROW* row /**< cutting plane to add */
13426  );
13427 
13428 /** removes the row from the global cut pool
13429  *
13430  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13431  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13432  *
13433  * @pre This method can be called if @p scip is in one of the following stages:
13434  * - \ref SCIP_STAGE_SOLVING
13435  */
13436 extern
13438  SCIP* scip, /**< SCIP data structure */
13439  SCIP_ROW* row /**< cutting plane to add */
13440  );
13441 
13442 /** gets current cuts in the global cut pool
13443  *
13444  * @return the current cuts in the global cut pool
13445  *
13446  * @pre This method can be called if @p scip is in one of the following stages:
13447  * - \ref SCIP_STAGE_SOLVING
13448  * - \ref SCIP_STAGE_SOLVED
13449  * - \ref SCIP_STAGE_EXITSOLVE
13450  */
13451 extern
13453  SCIP* scip /**< SCIP data structure */
13454  );
13455 
13456 /** gets current number of rows in the global cut pool
13457  *
13458  * @return the current number of rows in the global cut pool
13459  *
13460  * @pre This method can be called if @p scip is in one of the following stages:
13461  * - \ref SCIP_STAGE_SOLVING
13462  * - \ref SCIP_STAGE_SOLVED
13463  * - \ref SCIP_STAGE_EXITSOLVE
13464  */
13465 extern
13466 int SCIPgetNPoolCuts(
13467  SCIP* scip /**< SCIP data structure */
13468  );
13469 
13470 /** gets the global cut pool used by SCIP
13471  *
13472  * @return the global cut pool used by SCIP
13473  *
13474  * @pre This method can be called if @p scip is in one of the following stages:
13475  * - \ref SCIP_STAGE_SOLVING
13476  * - \ref SCIP_STAGE_SOLVED
13477  * - \ref SCIP_STAGE_EXITSOLVE
13478  */
13479 extern
13481  SCIP* scip /**< SCIP data structure */
13482  );
13483 
13484 /** creates a cut pool
13485  *
13486  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13487  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13488  *
13489  * @pre This method can be called if @p scip is in one of the following stages:
13490  * - \ref SCIP_STAGE_TRANSFORMING
13491  * - \ref SCIP_STAGE_TRANSFORMED
13492  * - \ref SCIP_STAGE_INITPRESOLVE
13493  * - \ref SCIP_STAGE_PRESOLVING
13494  * - \ref SCIP_STAGE_EXITPRESOLVE
13495  * - \ref SCIP_STAGE_PRESOLVED
13496  * - \ref SCIP_STAGE_INITSOLVE
13497  * - \ref SCIP_STAGE_SOLVING
13498  */
13499 extern
13501  SCIP* scip, /**< SCIP data structure */
13502  SCIP_CUTPOOL** cutpool, /**< pointer to store cut pool */
13503  int agelimit /**< maximum age a cut can reach before it is deleted from the pool */
13504  );
13505 
13506 /** frees a cut pool
13507  *
13508  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13509  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13510  *
13511  * @pre This method can be called if @p scip is in one of the following stages:
13512  * - \ref SCIP_STAGE_TRANSFORMING
13513  * - \ref SCIP_STAGE_TRANSFORMED
13514  * - \ref SCIP_STAGE_INITPRESOLVE
13515  * - \ref SCIP_STAGE_PRESOLVING
13516  * - \ref SCIP_STAGE_EXITPRESOLVE
13517  * - \ref SCIP_STAGE_PRESOLVED
13518  * - \ref SCIP_STAGE_INITSOLVE
13519  * - \ref SCIP_STAGE_SOLVING
13520  * - \ref SCIP_STAGE_SOLVED
13521  * - \ref SCIP_STAGE_EXITSOLVE
13522  * - \ref SCIP_STAGE_FREETRANS
13523  */
13524 extern
13526  SCIP* scip, /**< SCIP data structure */
13527  SCIP_CUTPOOL** cutpool /**< pointer to store cut pool */
13528  );
13529 
13530 /** if not already existing, adds row to a cut pool and captures it
13531  *
13532  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13533  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13534  *
13535  * @pre This method can be called if @p scip is in one of the following stages:
13536  * - \ref SCIP_STAGE_INITSOLVE
13537  * - \ref SCIP_STAGE_SOLVING
13538  */
13539 extern
13541  SCIP* scip, /**< SCIP data structure */
13542  SCIP_CUTPOOL* cutpool, /**< cut pool */
13543  SCIP_ROW* row /**< cutting plane to add */
13544  );
13545 
13546 /** adds row to a cut pool and captures it; doesn't check for multiple cuts
13547  *
13548  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13549  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13550  *
13551  * @pre This method can be called if @p scip is in one of the following stages:
13552  * - \ref SCIP_STAGE_INITSOLVE
13553  * - \ref SCIP_STAGE_SOLVING
13554  */
13555 extern
13557  SCIP* scip, /**< SCIP data structure */
13558  SCIP_CUTPOOL* cutpool, /**< cut pool */
13559  SCIP_ROW* row /**< cutting plane to add */
13560  );
13561 
13562 /** removes the LP row from a cut pool
13563  *
13564  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13565  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13566  *
13567  * @pre This method can be called if @p scip is in one of the following stages:
13568  * - \ref SCIP_STAGE_INITSOLVE
13569  * - \ref SCIP_STAGE_SOLVING
13570  * - \ref SCIP_STAGE_SOLVED
13571  */
13572 extern
13574  SCIP* scip, /**< SCIP data structure */
13575  SCIP_CUTPOOL* cutpool, /**< cut pool */
13576  SCIP_ROW* row /**< row to remove */
13577  );
13578 
13579 /** separates cuts from a cut pool
13580  *
13581  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13582  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13583  *
13584  * @pre This method can be called if @p scip is in one of the following stages:
13585  * - \ref SCIP_STAGE_SOLVING
13586  */
13587 extern
13589  SCIP* scip, /**< SCIP data structure */
13590  SCIP_CUTPOOL* cutpool, /**< cut pool */
13591  SCIP_RESULT* result /**< pointer to store the result of the separation call */
13592  );
13593 
13594 /** separates cuts w.r.t. given solution from a cut pool
13595  *
13596  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13597  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13598  *
13599  * @pre This method can be called if @p scip is in one of the following stages:
13600  * - \ref SCIP_STAGE_SOLVING
13601  */
13602 extern
13604  SCIP* scip, /**< SCIP data structure */
13605  SCIP_CUTPOOL* cutpool, /**< cut pool */
13606  SCIP_SOL* sol, /**< solution to be separated */
13607  SCIP_RESULT* result /**< pointer to store the result of the separation call */
13608  );
13609 
13610 /** if not already existing, adds row to the delayed global cut pool
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 @p scip is the stages \ref SCIP_STAGE_SOLVING
13616  */
13617 extern
13619  SCIP* scip, /**< SCIP data structure */
13620  SCIP_ROW* row /**< cutting plane to add */
13621  );
13622 
13623 /** removes the row from the delayed global cut pool
13624  *
13625  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13626  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13627  *
13628  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
13629  */
13630 extern
13632  SCIP* scip, /**< SCIP data structure */
13633  SCIP_ROW* row /**< cutting plane to add */
13634  );
13635 
13636 /** gets current cuts in the delayed global cut pool
13637  *
13638  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13639  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13640  *
13641  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
13642  */
13643 extern
13645  SCIP* scip /**< SCIP data structure */
13646  );
13647 
13648 /** gets current number of rows in the delayed global cut pool
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 @p scip is the stages \ref SCIP_STAGE_SOLVING
13654  */
13655 extern
13657  SCIP* scip /**< SCIP data structure */
13658  );
13659 
13660 /** gets the delayed global cut pool used by SCIP
13661  *
13662  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13663  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13664  *
13665  * @pre This method can be called if @p scip is the stages \ref SCIP_STAGE_SOLVING
13666  */
13667 extern
13669  SCIP* scip /**< SCIP data structure */
13670  );
13671 
13672 /** separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
13673  * separation methods;
13674  * the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
13675  * SCIPgetNCuts();
13676  * after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
13677  * separation storage;
13678  * it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
13679  * afterwards
13680  *
13681  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13682  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13683  *
13684  * @pre This method can be called if @p scip is in one of the following stages:
13685  * - \ref SCIP_STAGE_SOLVING
13686  */
13687 extern
13689  SCIP* scip, /**< SCIP data structure */
13690  SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */
13691  SCIP_Bool pretendroot, /**< should the cut separators be called as if we are at the root node? */
13692  SCIP_Bool onlydelayed, /**< should only separators be called that were delayed in the previous round? */
13693  SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */
13694  SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */
13695  );
13696 
13697 /** gets the array of cuts currently stored in the separation storage
13698  *
13699  * @return the array of cuts currently stored in the separation storage
13700  *
13701  * @pre This method can be called if @p scip is in one of the following stages:
13702  * - \ref SCIP_STAGE_PRESOLVED
13703  * - \ref SCIP_STAGE_SOLVING
13704  * - \ref SCIP_STAGE_SOLVED
13705  */
13706 extern
13708  SCIP* scip /**< SCIP data structure */
13709  );
13710 
13711 /** get current number of cuts in the separation storage
13712  *
13713  * @return the current number of cuts in the separation storage
13714  *
13715  * @pre This method can be called if @p scip is in one of the following stages:
13716  * - \ref SCIP_STAGE_PRESOLVED
13717  * - \ref SCIP_STAGE_SOLVING
13718  * - \ref SCIP_STAGE_SOLVED
13719  */
13720 extern
13721 int SCIPgetNCuts(
13722  SCIP* scip /**< SCIP data structure */
13723  );
13724 
13725 /** clears the separation storage
13726  *
13727  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13728  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13729  *
13730  * @pre This method can be called if @p scip is in one of the following stages:
13731  * - \ref SCIP_STAGE_SOLVING
13732  */
13733 extern
13735  SCIP* scip /**< SCIP data structure */
13736  );
13737 
13738 /** removes cuts that are inefficacious w.r.t. the current LP solution from separation storage without adding the cuts to the LP
13739  *
13740  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13741  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13742  *
13743  * @pre This method can be called if @p scip is in one of the following stages:
13744  * - \ref SCIP_STAGE_SOLVING
13745  */
13746 extern
13748  SCIP* scip /**< SCIP data structure */
13749  );
13750 
13751 /** returns current factor on cut infeasibility to limit feasibility tolerance for relaxation solver
13752  *
13753  * Gives value of separating/feastolfac parameter.
13754  *
13755  * @return factor on cut infeasibility to limit feasibility tolerance for relaxation solver
13756  *
13757  * @pre This method can be called if @p scip is in one of the following stages:
13758  * - \ref SCIP_STAGE_SOLVING
13759  */
13760 extern
13762  SCIP* scip /**< SCIP data structure */
13763  );
13764 
13765 /**@} */
13766 
13767 
13768 
13769 
13770 /*
13771  * LP diving methods
13772  */
13773 
13774 /**@name LP Diving Methods */
13775 /**@{ */
13776 
13777 /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available
13778  *
13779  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13780  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13781  *
13782  * @pre This method can be called if @p scip is in one of the following stages:
13783  * - \ref SCIP_STAGE_SOLVING
13784  *
13785  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13786  *
13787  * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware
13788  * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from
13789  * numerical troubles during the last LP solve; because of this, most users will want to call this method only if
13790  * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL
13791  */
13792 extern
13794  SCIP* scip /**< SCIP data structure */
13795  );
13796 
13797 /** quits LP diving and resets bounds and objective values of columns to the current node's values
13798  *
13799  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13800  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13801  *
13802  * @pre This method can be called if @p scip is in one of the following stages:
13803  * - \ref SCIP_STAGE_SOLVING
13804  *
13805  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13806  */
13807 extern
13809  SCIP* scip /**< SCIP data structure */
13810  );
13811 
13812 /** changes cutoffbound in current dive
13813  *
13814  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13815  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13816  *
13817  * @pre This method can be called if @p scip is in one of the following stages:
13818  * - \ref SCIP_STAGE_SOLVING
13819  *
13820  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13821  */
13822 extern
13824  SCIP* scip, /**< SCIP data structure */
13825  SCIP_Real newcutoffbound /**< new cutoffbound */
13826  );
13827 
13828 /** changes variable's objective value in current dive
13829  *
13830  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13831  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13832  *
13833  * @pre This method can be called if @p scip is in one of the following stages:
13834  * - \ref SCIP_STAGE_SOLVING
13835  *
13836  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13837  */
13838 extern
13840  SCIP* scip, /**< SCIP data structure */
13841  SCIP_VAR* var, /**< variable to change the objective value for */
13842  SCIP_Real newobj /**< new objective value */
13843  );
13844 
13845 /** changes variable's lower bound in current dive
13846  *
13847  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13848  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13849  *
13850  * @pre This method can be called if @p scip is in one of the following stages:
13851  * - \ref SCIP_STAGE_SOLVING
13852  *
13853  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13854  */
13855 extern
13857  SCIP* scip, /**< SCIP data structure */
13858  SCIP_VAR* var, /**< variable to change the bound for */
13859  SCIP_Real newbound /**< new value for bound */
13860  );
13861 
13862 /** changes variable's upper bound in current dive
13863  *
13864  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13865  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13866  *
13867  * @pre This method can be called if @p scip is in one of the following stages:
13868  * - \ref SCIP_STAGE_SOLVING
13869  *
13870  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13871  */
13872 extern
13874  SCIP* scip, /**< SCIP data structure */
13875  SCIP_VAR* var, /**< variable to change the bound for */
13876  SCIP_Real newbound /**< new value for bound */
13877  );
13878 
13879 /** adds a row to the LP in current dive
13880  *
13881  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13882  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13883  *
13884  * @pre This method can be called if @p scip is in one of the following stages:
13885  * - \ref SCIP_STAGE_SOLVING
13886  *
13887  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13888  */
13889 extern
13891  SCIP* scip, /**< SCIP data structure */
13892  SCIP_ROW* row /**< row to be added */
13893  );
13894 
13895 /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs()
13896  *
13897  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13898  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13899  *
13900  * @pre This method can be called if @p scip is in one of the following stages:
13901  * - \ref SCIP_STAGE_SOLVING
13902  *
13903  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13904  */
13905 extern
13907  SCIP* scip, /**< SCIP data structure */
13908  SCIP_ROW* row, /**< row to change the lhs for */
13909  SCIP_Real newlhs /**< new value for lhs */
13910  );
13911 
13912 /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs()
13913  *
13914  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13915  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13916  *
13917  * @pre This method can be called if @p scip is in one of the following stages:
13918  * - \ref SCIP_STAGE_SOLVING
13919  *
13920  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13921  */
13922 extern
13924  SCIP* scip, /**< SCIP data structure */
13925  SCIP_ROW* row, /**< row to change the lhs for */
13926  SCIP_Real newrhs /**< new value for rhs */
13927  );
13928 
13929 /** gets variable's objective value in current dive
13930  *
13931  * @return the variable's objective value in current dive.
13932  *
13933  * @pre This method can be called if @p scip is in one of the following stages:
13934  * - \ref SCIP_STAGE_SOLVING
13935  *
13936  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13937  */
13938 extern
13940  SCIP* scip, /**< SCIP data structure */
13941  SCIP_VAR* var /**< variable to get the bound for */
13942  );
13943 
13944 /** gets variable's lower bound in current dive
13945  *
13946  * @return the variable's lower bound in current dive.
13947  *
13948  * @pre This method can be called if @p scip is in one of the following stages:
13949  * - \ref SCIP_STAGE_SOLVING
13950  *
13951  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13952  */
13953 extern
13955  SCIP* scip, /**< SCIP data structure */
13956  SCIP_VAR* var /**< variable to get the bound for */
13957  );
13958 
13959 /** gets variable's upper bound in current dive
13960  *
13961  * @return the variable's upper bound in current dive.
13962  *
13963  * @pre This method can be called if @p scip is in one of the following stages:
13964  * - \ref SCIP_STAGE_SOLVING
13965  *
13966  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13967  */
13968 extern
13970  SCIP* scip, /**< SCIP data structure */
13971  SCIP_VAR* var /**< variable to get the bound for */
13972  );
13973 /** solves the LP of the current dive; no separation or pricing is applied
13974  *
13975  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
13976  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
13977  *
13978  * @pre This method can be called if @p scip is in one of the following stages:
13979  * - \ref SCIP_STAGE_SOLVING
13980  *
13981  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
13982  *
13983  * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL,
13984  * compare the explanation of SCIPstartDive()
13985  */
13986 extern
13988  SCIP* scip, /**< SCIP data structure */
13989  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
13990  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
13991  SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective
13992  * limit was reached (or NULL, if not needed) */
13993  );
13994 
13995 /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving
13996  * or probing mode
13997  *
13998  * @return the number of the node in the current branch and bound run, where the last LP was solved in diving
13999  * or probing mode.
14000  *
14001  * @pre This method can be called if @p scip is in one of the following stages:
14002  * - \ref SCIP_STAGE_TRANSFORMING
14003  * - \ref SCIP_STAGE_TRANSFORMED
14004  * - \ref SCIP_STAGE_INITPRESOLVE
14005  * - \ref SCIP_STAGE_PRESOLVING
14006  * - \ref SCIP_STAGE_EXITPRESOLVE
14007  * - \ref SCIP_STAGE_PRESOLVED
14008  * - \ref SCIP_STAGE_INITSOLVE
14009  * - \ref SCIP_STAGE_SOLVING
14010  * - \ref SCIP_STAGE_SOLVED
14011  * - \ref SCIP_STAGE_EXITSOLVE
14012  * - \ref SCIP_STAGE_FREETRANS
14013  *
14014  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14015  */
14016 extern
14018  SCIP* scip /**< SCIP data structure */
14019  );
14020 
14021 /** returns whether we are in diving mode
14022  *
14023  * @return whether we are in diving mode.
14024  *
14025  * @pre This method can be called if @p scip is in one of the following stages:
14026  * - \ref SCIP_STAGE_TRANSFORMING
14027  * - \ref SCIP_STAGE_TRANSFORMED
14028  * - \ref SCIP_STAGE_INITPRESOLVE
14029  * - \ref SCIP_STAGE_PRESOLVING
14030  * - \ref SCIP_STAGE_EXITPRESOLVE
14031  * - \ref SCIP_STAGE_PRESOLVED
14032  * - \ref SCIP_STAGE_INITSOLVE
14033  * - \ref SCIP_STAGE_SOLVING
14034  * - \ref SCIP_STAGE_SOLVED
14035  * - \ref SCIP_STAGE_EXITSOLVE
14036  * - \ref SCIP_STAGE_FREETRANS
14037  *
14038  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14039  */
14040 extern
14042  SCIP* scip /**< SCIP data structure */
14043  );
14044 
14045 /**@} */
14046 
14047 
14048 
14049 
14050 /*
14051  * probing methods
14052  */
14053 
14054 /**@name Probing Methods */
14055 /**@{ */
14056 
14057 /** returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped
14058  * via SCIPendProbing()
14059  *
14060  * @return TRUE, if SCIP is currently in probing mode, otherwise FALSE
14061  *
14062  * @pre This method can be called if @p scip is in one of the following stages:
14063  * - \ref SCIP_STAGE_TRANSFORMED
14064  * - \ref SCIP_STAGE_INITPRESOLVE
14065  * - \ref SCIP_STAGE_PRESOLVING
14066  * - \ref SCIP_STAGE_EXITPRESOLVE
14067  * - \ref SCIP_STAGE_PRESOLVED
14068  * - \ref SCIP_STAGE_INITSOLVE
14069  * - \ref SCIP_STAGE_SOLVING
14070  * - \ref SCIP_STAGE_SOLVED
14071  * - \ref SCIP_STAGE_EXITSOLVE
14072  */
14073 extern
14075  SCIP* scip /**< SCIP data structure */
14076  );
14077 
14078 /** initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),
14079  * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available
14080  *
14081  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14082  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14083  *
14084  * @pre This method can be called if @p scip is in one of the following stages:
14085  * - \ref SCIP_STAGE_PRESOLVING
14086  * - \ref SCIP_STAGE_SOLVING
14087  *
14088  * @note The collection of variable statistics is turned off during probing. If these statistics should be collected
14089  * during probing use the method SCIPenableVarHistory() to turn the collection explicitly on.
14090  */
14091 extern
14093  SCIP* scip /**< SCIP data structure */
14094  );
14095 
14096 /** creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path
14097  * with a call to SCIPbacktrackProbing();
14098  * using a sub node for each set of probing bound changes can improve conflict analysis
14099  *
14100  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14101  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14102  *
14103  * @pre This method can be called if @p scip is in one of the following stages:
14104  * - \ref SCIP_STAGE_PRESOLVING
14105  * - \ref SCIP_STAGE_SOLVING
14106  */
14107 extern
14109  SCIP* scip /**< SCIP data structure */
14110  );
14111 
14112 /** returns the current probing depth
14113  *
14114  * @return the probing depth, i.e. the number of probing sub nodes existing in the probing path
14115  *
14116  * @pre This method can be called if @p scip is in one of the following stages:
14117  * - \ref SCIP_STAGE_PRESOLVING
14118  * - \ref SCIP_STAGE_SOLVING
14119  */
14120 extern
14122  SCIP* scip /**< SCIP data structure */
14123  );
14124 
14125 /** undoes all changes to the problem applied in probing up to the given probing depth;
14126  * the changes of the probing node of the given probing depth are the last ones that remain active;
14127  * changes that were applied before calling SCIPnewProbingNode() cannot be undone
14128  *
14129  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14130  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14131  *
14132  * @pre This method can be called if @p scip is in one of the following stages:
14133  * - \ref SCIP_STAGE_PRESOLVING
14134  * - \ref SCIP_STAGE_SOLVING
14135  */
14136 extern
14138  SCIP* scip, /**< SCIP data structure */
14139  int probingdepth /**< probing depth of the node in the probing path that should be reactivated */
14140  );
14141 
14142 /** quits probing and resets bounds and constraints to the focus node's environment
14143  *
14144  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14145  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14146  *
14147  * @pre This method can be called if @p scip is in one of the following stages:
14148  * - \ref SCIP_STAGE_PRESOLVING
14149  * - \ref SCIP_STAGE_SOLVING
14150  */
14151 extern
14153  SCIP* scip /**< SCIP data structure */
14154  );
14155 
14156 /** injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to
14157  * SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
14158  *
14159  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14160  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14161  *
14162  * @pre This method can be called if @p scip is in one of the following stages:
14163  * - \ref SCIP_STAGE_PRESOLVING
14164  * - \ref SCIP_STAGE_SOLVING
14165  */
14166 extern
14168  SCIP* scip, /**< SCIP data structure */
14169  SCIP_VAR* var, /**< variable to change the bound for */
14170  SCIP_Real newbound /**< new value for bound */
14171  );
14172 
14173 /** injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to
14174  * SCIPchgVarUb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
14175  *
14176  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14177  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14178  *
14179  * @pre This method can be called if @p scip is in one of the following stages:
14180  * - \ref SCIP_STAGE_PRESOLVING
14181  * - \ref SCIP_STAGE_SOLVING
14182  */
14183 extern
14185  SCIP* scip, /**< SCIP data structure */
14186  SCIP_VAR* var, /**< variable to change the bound for */
14187  SCIP_Real newbound /**< new value for bound */
14188  );
14189 
14190 /** injects a change of variable's bounds into current probing node to fix the variable to the specified value;
14191  * the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated
14192  * like deductions instead of branching decisions
14193  *
14194  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14195  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14196  *
14197  * @pre This method can be called if @p scip is in one of the following stages:
14198  * - \ref SCIP_STAGE_PRESOLVING
14199  * - \ref SCIP_STAGE_SOLVING
14200  */
14201 extern
14203  SCIP* scip, /**< SCIP data structure */
14204  SCIP_VAR* var, /**< variable to change the bound for */
14205  SCIP_Real fixedval /**< value to fix variable to */
14206  );
14207 
14208 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
14209  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
14210  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
14211  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
14212  *
14213  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14214  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14215  *
14216  * @pre This method can be called if @p scip is in one of the following stages:
14217  * - \ref SCIP_STAGE_PRESOLVING
14218  * - \ref SCIP_STAGE_SOLVING
14219  */
14220 extern
14222  SCIP* scip, /**< SCIP data structure */
14223  int maxproprounds, /**< maximal number of propagation rounds (-1: no limit, 0: parameter settings) */
14224  SCIP_Bool* cutoff, /**< pointer to store whether the probing node can be cut off */
14225  SCIP_Longint* ndomredsfound /**< pointer to store the number of domain reductions found, or NULL */
14226  );
14227 
14228 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
14229  * only propagations of the binary variables fixed at the current probing node that are triggered by the implication
14230  * graph and the clique table are applied;
14231  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
14232  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
14233  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
14234  *
14235  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14236  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14237  *
14238  * @pre This method can be called if @p scip is in one of the following stages:
14239  * - \ref SCIP_STAGE_PRESOLVING
14240  * - \ref SCIP_STAGE_SOLVING
14241  */
14242 extern
14244  SCIP* scip, /**< SCIP data structure */
14245  SCIP_Bool* cutoff /**< pointer to store whether the probing node can be cut off */
14246  );
14247 
14248 /** solves the LP at the current probing node (cannot be applied at preprocessing stage);
14249  * no separation or pricing is applied
14250  *
14251  * The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()).
14252  *
14253  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14254  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14255  *
14256  * @pre This method can be called if @p scip is in one of the following stages:
14257  * - \ref SCIP_STAGE_SOLVING
14258  */
14259 extern
14261  SCIP* scip, /**< SCIP data structure */
14262  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
14263  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
14264  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
14265  * limit was reached (or NULL, if not needed) */
14266  );
14267 
14268 /** solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing
14269  * until the LP is solved to optimality; no separation is applied
14270  *
14271  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See \ref
14272  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14273  *
14274  * @pre This method can be called if @p scip is in one of the following stages:
14275  * - \ref SCIP_STAGE_SOLVING
14276  */
14277 extern
14279  SCIP* scip, /**< SCIP data structure */
14280  SCIP_Bool pretendroot, /**< should the pricers be called as if we are at the root node? */
14281  SCIP_Bool displayinfo, /**< should info lines be displayed after each pricing round? */
14282  int maxpricerounds, /**< maximal number of pricing rounds (-1: no limit);
14283  * a finite limit means that the LP might not be solved to optimality! */
14284  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
14285  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
14286  * limit was reached (or NULL, if not needed) */
14287 
14288  );
14289 
14290 /**@} */
14291 
14292 
14293 
14294 
14295 /*
14296  * branching methods
14297  */
14298 
14299 /**@name Branching Methods */
14300 /**@{ */
14301 
14302 /** gets branching candidates for LP solution branching (fractional variables) along with solution values,
14303  * fractionalities, and number of branching candidates; The number of branching candidates does NOT
14304  * account for fractional implicit integer variables which should not be used for branching decisions.
14305  *
14306  * Fractional implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1
14307  *
14308  * branching rules should always select the branching candidate among the first npriolpcands of the candidate
14309  * list
14310  *
14311  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14312  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14313  *
14314  * @pre This method can be called if @p scip is in one of the following stages:
14315  * - \ref SCIP_STAGE_SOLVING
14316  *
14317  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14318  */
14319 extern
14321  SCIP* scip, /**< SCIP data structure */
14322  SCIP_VAR*** lpcands, /**< pointer to store the array of LP branching candidates, or NULL */
14323  SCIP_Real** lpcandssol, /**< pointer to store the array of LP candidate solution values, or NULL */
14324  SCIP_Real** lpcandsfrac, /**< pointer to store the array of LP candidate fractionalities, or NULL */
14325  int* nlpcands, /**< pointer to store the number of LP branching candidates, or NULL */
14326  int* npriolpcands, /**< pointer to store the number of candidates with maximal priority, or NULL */
14327  int* nfracimplvars /**< pointer to store the number of fractional implicit integer variables, or NULL */
14328  );
14329 
14330 /** gets number of branching candidates for LP solution branching (number of fractional variables)
14331  *
14332  * @return the number of branching candidates for LP solution branching (number of fractional variables).
14333  *
14334  * @pre This method can be called if @p scip is in one of the following stages:
14335  * - \ref SCIP_STAGE_SOLVING
14336  *
14337  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14338  */
14339 extern
14341  SCIP* scip /**< SCIP data structure */
14342  );
14343 
14344 /** gets number of branching candidates with maximal priority for LP solution branching
14345  *
14346  * @return the number of branching candidates with maximal priority for LP solution branching.
14347  *
14348  * @pre This method can be called if @p scip is in one of the following stages:
14349  * - \ref SCIP_STAGE_SOLVING
14350  *
14351  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14352  */
14353 extern
14355  SCIP* scip /**< SCIP data structure */
14356  );
14357 
14358 /** gets external branching candidates along with solution values, scores, and number of branching candidates;
14359  * these branching candidates can be used by relaxations or nonlinear constraint handlers
14360  * branching rules should always select the branching candidate among the first nprioexterncands of the candidate
14361  * list
14362  *
14363  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14364  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14365  *
14366  * @pre This method can be called if @p scip is in one of the following stages:
14367  * - \ref SCIP_STAGE_SOLVING
14368  *
14369  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14370  *
14371  * @note Candidate variables with maximal priority are ordered: binaries first, then integers, implicit integers and
14372  * continuous last.
14373  */
14374 extern
14376  SCIP* scip, /**< SCIP data structure */
14377  SCIP_VAR*** externcands, /**< pointer to store the array of extern branching candidates, or NULL */
14378  SCIP_Real** externcandssol, /**< pointer to store the array of extern candidate solution values, or NULL */
14379  SCIP_Real** externcandsscore, /**< pointer to store the array of extern candidate scores, or NULL */
14380  int* nexterncands, /**< pointer to store the number of extern branching candidates, or NULL */
14381  int* nprioexterncands, /**< pointer to store the number of candidates with maximal priority, or NULL */
14382  int* nprioexternbins, /**< pointer to store the number of binary candidates with maximal priority, or NULL */
14383  int* nprioexternints, /**< pointer to store the number of integer candidates with maximal priority, or NULL */
14384  int* nprioexternimpls /**< pointer to store the number of implicit integer candidates with maximal priority,
14385  * or NULL */
14386  );
14387 
14388 /** gets number of external branching candidates
14389  *
14390  * @return the number of external branching candidates.
14391  *
14392  * @pre This method can be called if @p scip is in one of the following stages:
14393  * - \ref SCIP_STAGE_SOLVING
14394  *
14395  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14396  */
14397 extern
14399  SCIP* scip /**< SCIP data structure */
14400  );
14401 
14402 /** gets number of external branching candidates with maximal branch priority
14403  *
14404  * @return the number of external branching candidates with maximal branch priority.
14405  *
14406  * @pre This method can be called if @p scip is in one of the following stages:
14407  * - \ref SCIP_STAGE_SOLVING
14408  *
14409  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14410  */
14411 extern
14413  SCIP* scip /**< SCIP data structure */
14414  );
14415 
14416 /** gets number of binary external branching candidates with maximal branch priority
14417  *
14418  * @return the number of binary external branching candidates with maximal branch priority.
14419  *
14420  * @pre This method can be called if @p scip is in one of the following stages:
14421  * - \ref SCIP_STAGE_SOLVING
14422  *
14423  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14424  */
14425 extern
14427  SCIP* scip /**< SCIP data structure */
14428  );
14429 
14430 /** gets number of integer external branching candidates with maximal branch priority
14431  *
14432  * @return the number of integer external branching candidates with maximal branch priority.
14433  *
14434  * @pre This method can be called if @p scip is in one of the following stages:
14435  * - \ref SCIP_STAGE_SOLVING
14436  *
14437  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14438  */
14439 extern
14441  SCIP* scip /**< SCIP data structure */
14442  );
14443 
14444 /** gets number of implicit integer external branching candidates with maximal branch priority
14445  *
14446  * @return the number of implicit integer external branching candidates with maximal branch priority.
14447  *
14448  * @pre This method can be called if @p scip is in one of the following stages:
14449  * - \ref SCIP_STAGE_SOLVING
14450  *
14451  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14452  */
14453 extern
14455  SCIP* scip /**< SCIP data structure */
14456  );
14457 
14458 /** gets number of continuous external branching candidates with maximal branch priority
14459  *
14460  * @return the number of continuous external branching candidates with maximal branch priority.
14461  *
14462  * @pre This method can be called if @p scip is in one of the following stages:
14463  * - \ref SCIP_STAGE_SOLVING
14464  *
14465  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14466  */
14467 extern
14469  SCIP* scip /**< SCIP data structure */
14470  );
14471 
14472 /** insert variable, its score and its solution value into the external branching candidate storage
14473  * the relative difference of the current lower and upper bounds of a continuous variable must be at least epsilon
14474  *
14475  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14476  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14477  *
14478  * @pre This method can be called if @p scip is in one of the following stages:
14479  * - \ref SCIP_STAGE_SOLVING
14480  *
14481  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14482  */
14483 extern
14485  SCIP* scip, /**< SCIP data structure */
14486  SCIP_VAR* var, /**< variable to insert */
14487  SCIP_Real score, /**< score of external candidate, e.g. infeasibility */
14488  SCIP_Real solval /**< value of the variable in the current solution */
14489  );
14490 
14491 /** removes all external candidates from the storage for external branching
14492  *
14493  * @pre This method can be called if @p scip is in one of the following stages:
14494  * - \ref SCIP_STAGE_SOLVING
14495  *
14496  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14497  */
14498 extern
14500  SCIP* scip /**< SCIP data structure */
14501  );
14502 
14503 /** checks whether the given variable is contained in the candidate storage for external branching
14504  *
14505  * @return whether the given variable is contained in the candidate storage for external branching.
14506  *
14507  * @pre This method can be called if @p scip is in one of the following stages:
14508  * - \ref SCIP_STAGE_SOLVING
14509  *
14510  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14511  */
14512 extern
14514  SCIP* scip, /**< SCIP data structure */
14515  SCIP_VAR* var /**< variable to look for */
14516  );
14517 
14518 /** gets branching candidates for pseudo solution branching (non-fixed variables) along with the number of candidates
14519  *
14520  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14521  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14522  *
14523  * @pre This method can be called if @p scip is in one of the following stages:
14524  * - \ref SCIP_STAGE_PRESOLVING
14525  * - \ref SCIP_STAGE_SOLVING
14526  *
14527  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14528  */
14529 extern
14531  SCIP* scip, /**< SCIP data structure */
14532  SCIP_VAR*** pseudocands, /**< pointer to store the array of pseudo branching candidates, or NULL */
14533  int* npseudocands, /**< pointer to store the number of pseudo branching candidates, or NULL */
14534  int* npriopseudocands /**< pointer to store the number of candidates with maximal priority, or NULL */
14535  );
14536 
14537 /** gets number of branching candidates for pseudo solution branching (non-fixed variables)
14538  *
14539  * @return the number branching candidates for pseudo solution branching (non-fixed variables).
14540  *
14541  * @pre This method can be called if @p scip is in one of the following stages:
14542  * - \ref SCIP_STAGE_PRESOLVING
14543  * - \ref SCIP_STAGE_SOLVING
14544  *
14545  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14546  */
14547 extern
14549  SCIP* scip /**< SCIP data structure */
14550  );
14551 
14552 /** gets number of branching candidates with maximal branch priority for pseudo solution branching
14553  *
14554  * @return the number of branching candidates with maximal branch priority for pseudo solution branching.
14555  *
14556  * @pre This method can be called if @p scip is in one of the following stages:
14557  * - \ref SCIP_STAGE_PRESOLVING
14558  * - \ref SCIP_STAGE_SOLVING
14559  *
14560  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14561  */
14562 extern
14564  SCIP* scip /**< SCIP data structure */
14565  );
14566 
14567 /** gets number of binary branching candidates with maximal branch priority for pseudo solution branching
14568  *
14569  * @return the number of binary branching candidates with maximal branch priority for pseudo solution branching.
14570  *
14571  * @pre This method can be called if @p scip is in one of the following stages:
14572  * - \ref SCIP_STAGE_SOLVING
14573  *
14574  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14575  */
14576 extern
14578  SCIP* scip /**< SCIP data structure */
14579  );
14580 
14581 /** gets number of integer branching candidates with maximal branch priority for pseudo solution branching
14582  *
14583  * @return the number of integer branching candidates with maximal branch priority for pseudo solution branching.
14584  *
14585  * @pre This method can be called if @p scip is in one of the following stages:
14586  * - \ref SCIP_STAGE_SOLVING
14587  *
14588  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14589  */
14590 extern
14592  SCIP* scip /**< SCIP data structure */
14593  );
14594 
14595 /** gets number of implicit integer branching candidates with maximal branch priority for pseudo solution branching
14596  *
14597  * @return the number of implicit integer branching candidates with maximal branch priority for pseudo solution branching.
14598  *
14599  * @pre This method can be called if @p scip is in one of the following stages:
14600  * - \ref SCIP_STAGE_SOLVING
14601  *
14602  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14603  */
14604 extern
14606  SCIP* scip /**< SCIP data structure */
14607  );
14608 
14609 /** calculates the branching score out of the gain predictions for a binary branching
14610  *
14611  * @return the branching score out of the gain predictions for a binary branching.
14612  *
14613  * @pre This method can be called if @p scip is in one of the following stages:
14614  * - \ref SCIP_STAGE_SOLVING
14615  *
14616  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14617  */
14618 extern
14620  SCIP* scip, /**< SCIP data structure */
14621  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
14622  SCIP_Real downgain, /**< prediction of objective gain for rounding downwards */
14623  SCIP_Real upgain /**< prediction of objective gain for rounding upwards */
14624  );
14625 
14626 /** calculates the branching score out of the gain predictions for a branching with arbitrary many children
14627  *
14628  * @return the branching score out of the gain predictions for a branching with arbitrary many children.
14629  *
14630  * @pre This method can be called if @p scip is in one of the following stages:
14631  * - \ref SCIP_STAGE_SOLVING
14632  *
14633  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14634  */
14635 extern
14637  SCIP* scip, /**< SCIP data structure */
14638  SCIP_VAR* var, /**< variable, of which the branching factor should be applied, or NULL */
14639  int nchildren, /**< number of children that the branching will create */
14640  SCIP_Real* gains /**< prediction of objective gain for each child */
14641  );
14642 
14643 /** computes a branching point for a continuous or discrete variable
14644  * @see SCIPbranchGetBranchingPoint
14645  *
14646  * @return the branching point for a continuous or discrete variable.
14647  *
14648  * @pre This method can be called if @p scip is in one of the following stages:
14649  * - \ref SCIP_STAGE_SOLVING
14650  *
14651  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14652  */
14653 extern
14655  SCIP* scip, /**< SCIP data structure */
14656  SCIP_VAR* var, /**< variable, of which the branching point should be computed */
14657  SCIP_Real suggestion /**< suggestion for branching point, or SCIP_INVALID if no suggestion */
14658  );
14659 
14660 /** calculates the node selection priority for moving the given variable's LP value to the given target value;
14661  * this node selection priority can be given to the SCIPcreateChild() call
14662  *
14663  * @return the node selection priority for moving the given variable's LP value to the given target value.
14664  *
14665  * @pre This method can be called if @p scip is in one of the following stages:
14666  * - \ref SCIP_STAGE_SOLVING
14667  *
14668  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14669  */
14670 extern
14672  SCIP* scip, /**< SCIP data structure */
14673  SCIP_VAR* var, /**< variable on which the branching is applied */
14674  SCIP_BRANCHDIR branchdir, /**< type of branching that was performed: upwards, downwards, or fixed;
14675  * fixed should only be used, when both bounds changed
14676  */
14677  SCIP_Real targetvalue /**< new value of the variable in the child node */
14678  );
14679 
14680 /** calculates an estimate for the objective of the best feasible solution contained in the subtree after applying the given
14681  * branching; this estimate can be given to the SCIPcreateChild() call
14682  *
14683  * @return the estimate for the objective of the best feasible solution contained in the subtree after applying the given
14684  * branching.
14685  *
14686  * @pre This method can be called if @p scip is in one of the following stages:
14687  * - \ref SCIP_STAGE_SOLVING
14688  *
14689  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14690  */
14691 extern
14693  SCIP* scip, /**< SCIP data structure */
14694  SCIP_VAR* var, /**< variable on which the branching is applied */
14695  SCIP_Real targetvalue /**< new value of the variable in the child node */
14696  );
14697 
14698 /** creates a child node of the focus node
14699  *
14700  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14701  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14702  *
14703  * @pre This method can be called if @p scip is in one of the following stages:
14704  * - \ref SCIP_STAGE_SOLVING
14705  *
14706  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14707  */
14708 extern
14710  SCIP* scip, /**< SCIP data structure */
14711  SCIP_NODE** node, /**< pointer to node data structure */
14712  SCIP_Real nodeselprio, /**< node selection priority of new node */
14713  SCIP_Real estimate /**< estimate for (transformed) objective value of best feasible solution in subtree */
14714  );
14715 
14716 /** branches on a non-continuous variable v using the current LP or pseudo solution;
14717  * if solution value x' is fractional, two child nodes will be created
14718  * (x <= floor(x'), x >= ceil(x')),
14719  * if solution value is integral, the x' is equal to lower or upper bound of the branching
14720  * variable and the bounds of v are finite, then two child nodes will be created
14721  * (x <= x'', x >= x''+1 with x'' = floor((lb + ub)/2)),
14722  * otherwise (up to) three child nodes will be created
14723  * (x <= x'-1, x == x', x >= x'+1)
14724  *
14725  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14726  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14727  *
14728  * @pre This method can be called if @p scip is in one of the following stages:
14729  * - \ref SCIP_STAGE_SOLVING
14730  *
14731  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14732  */
14733 extern
14735  SCIP* scip, /**< SCIP data structure */
14736  SCIP_VAR* var, /**< variable to branch on */
14737  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
14738  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
14739  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
14740  );
14741 
14742 /** branches a variable x using a given domain hole; two child nodes (x <= left, x >= right) are created
14743  *
14744  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14745  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
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 branch on */
14756  SCIP_Real left, /**< left side of the domain hole */
14757  SCIP_Real right, /**< right side of the domain hole */
14758  SCIP_NODE** downchild, /**< pointer to return the left child (x <= left), or NULL */
14759  SCIP_NODE** upchild /**< pointer to return the right child (x >= right), or NULL */
14760  );
14761 
14762 /** branches on a variable x using a given value x';
14763  * for continuous variables with relative domain width larger epsilon, x' must not be one of the bounds;
14764  * two child nodes (x <= x', x >= x') are created;
14765  * for integer variables, if solution value x' is fractional, two child nodes are created
14766  * (x <= floor(x'), x >= ceil(x')),
14767  * if x' is integral, three child nodes are created
14768  * (x <= x'-1, x == x', x >= x'+1)
14769  *
14770  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14771  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14772  *
14773  * @pre This method can be called if @p scip is in one of the following stages:
14774  * - \ref SCIP_STAGE_SOLVING
14775  *
14776  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14777  */
14778 extern
14780  SCIP* scip, /**< SCIP data structure */
14781  SCIP_VAR* var, /**< variable to branch on */
14782  SCIP_Real val, /**< value to branch on */
14783  SCIP_NODE** downchild, /**< pointer to return the left child with variable rounded down, or NULL */
14784  SCIP_NODE** eqchild, /**< pointer to return the middle child with variable fixed, or NULL */
14785  SCIP_NODE** upchild /**< pointer to return the right child with variable rounded up, or NULL */
14786  );
14787 
14788 /** n-ary branching on a variable x using a given value
14789  * Branches on variable x such that up to n/2 children are created on each side of the usual branching value.
14790  * The branching value is selected as in SCIPbranchVarVal().
14791  * The parameters minwidth and widthfactor determine the domain width of the branching variable in the child nodes.
14792  * If n is odd, one child with domain width 'width' and having the branching value in the middle is created.
14793  * Otherwise, two children with domain width 'width' and being left and right of the branching value are created.
14794  * Next further nodes to the left and right are created, where width is multiplied by widthfactor with increasing distance from the first nodes.
14795  * The initial width is calculated such that n/2 nodes are created to the left and to the right of the branching value.
14796  * If this value is below minwidth, the initial width is set to minwidth, which may result in creating less than n nodes.
14797  *
14798  * Giving a large value for widthfactor results in creating children with small domain when close to the branching value
14799  * and large domain when closer to the current variable bounds. That is, setting widthfactor to a very large value and n to 3
14800  * results in a ternary branching where the branching variable is mostly fixed in the middle child.
14801  * Setting widthfactor to 1.0 results in children where the branching variable always has the same domain width
14802  * (except for one child if the branching value is not in the middle).
14803  *
14804  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14805  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14806  *
14807  * @pre This method can be called if @p scip is in one of the following stages:
14808  * - \ref SCIP_STAGE_SOLVING
14809  *
14810  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14811  */
14812 extern
14814  SCIP* scip, /**< SCIP data structure */
14815  SCIP_VAR* var, /**< variable to branch on */
14816  SCIP_Real val, /**< value to branch on */
14817  int n, /**< attempted number of children to be created, must be >= 2 */
14818  SCIP_Real minwidth, /**< minimal domain width in children */
14819  SCIP_Real widthfactor, /**< multiplier for children domain width with increasing distance from val, must be >= 1.0 */
14820  int* nchildren /**< pointer to store number of created children, or NULL */
14821  );
14822 
14823 /** calls branching rules to branch on an LP solution; if no fractional variables exist, the result is SCIP_DIDNOTRUN;
14824  * if the branch priority of an unfixed variable is larger than the maximal branch priority of the fractional
14825  * variables, pseudo solution branching is applied on the unfixed variables with maximal branch priority
14826  *
14827  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14828  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14829  *
14830  * @pre This method can be called if @p scip is in one of the following stages:
14831  * - \ref SCIP_STAGE_SOLVING
14832  *
14833  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14834  */
14835 extern
14837  SCIP* scip, /**< SCIP data structure */
14838  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
14839  );
14840 
14841 /** calls branching rules to branch on a external candidates; if no such candidates exist, the result is SCIP_DIDNOTRUN
14842  *
14843  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14844  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14845  *
14846  * @pre This method can be called if @p scip is in one of the following stages:
14847  * - \ref SCIP_STAGE_SOLVING
14848  *
14849  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14850  */
14851 extern
14853  SCIP* scip, /**< SCIP data structure */
14854  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
14855  );
14856 
14857 /** calls branching rules to branch on a pseudo solution; if no unfixed variables exist, the result is SCIP_DIDNOTRUN
14858  *
14859  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14860  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14861  *
14862  * @pre This method can be called if @p scip is in one of the following stages:
14863  * - \ref SCIP_STAGE_SOLVING
14864  *
14865  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
14866  */
14867 extern
14869  SCIP* scip, /**< SCIP data structure */
14870  SCIP_RESULT* result /**< pointer to store the result of the branching (s. branch.h) */
14871  );
14872 
14873 /**@} */
14874 
14875 
14876 
14877 
14878 /*
14879  * primal solutions
14880  */
14881 
14882 /**@name Primal Solution Methods */
14883 /**@{ */
14884 
14885 /** creates a primal solution, initialized to zero
14886  *
14887  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14888  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14889  *
14890  * @pre This method can be called if SCIP is in one of the following stages:
14891  * - \ref SCIP_STAGE_PROBLEM
14892  * - \ref SCIP_STAGE_TRANSFORMING
14893  * - \ref SCIP_STAGE_TRANSFORMED
14894  * - \ref SCIP_STAGE_INITPRESOLVE
14895  * - \ref SCIP_STAGE_PRESOLVING
14896  * - \ref SCIP_STAGE_EXITPRESOLVE
14897  * - \ref SCIP_STAGE_PRESOLVED
14898  * - \ref SCIP_STAGE_INITSOLVE
14899  * - \ref SCIP_STAGE_SOLVING
14900  */
14901 extern
14903  SCIP* scip, /**< SCIP data structure */
14904  SCIP_SOL** sol, /**< pointer to store the solution */
14905  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
14906  );
14907 
14908 /** creates a primal solution, initialized to the current LP solution
14909  *
14910  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14911  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14912  *
14913  * @pre This method can be called if SCIP is in one of the following stages:
14914  * - \ref SCIP_STAGE_SOLVING
14915  */
14916 extern
14918  SCIP* scip, /**< SCIP data structure */
14919  SCIP_SOL** sol, /**< pointer to store the solution */
14920  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
14921  );
14922 
14923 /** creates a primal solution, initialized to the current NLP solution
14924  *
14925  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14926  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14927  *
14928  * @pre This method can be called if SCIP is in one of the following stages:
14929  * - \ref SCIP_STAGE_SOLVING
14930  */
14931 extern
14933  SCIP* scip, /**< SCIP data structure */
14934  SCIP_SOL** sol, /**< pointer to store the solution */
14935  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
14936  );
14937 
14938 /** creates a primal solution, initialized to the current relaxation solution
14939  *
14940  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14941  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14942  *
14943  * @pre This method can be called if SCIP is in one of the following stages:
14944  * - \ref SCIP_STAGE_SOLVING
14945  */
14946 extern
14948  SCIP* scip, /**< SCIP data structure */
14949  SCIP_SOL** sol, /**< pointer to store the solution */
14950  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
14951  );
14952 
14953 /** creates a primal solution, initialized to the current pseudo solution
14954  *
14955  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14956  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14957  *
14958  * @pre This method can be called if SCIP is in one of the following stages:
14959  * - \ref SCIP_STAGE_SOLVING
14960  */
14961 extern
14963  SCIP* scip, /**< SCIP data structure */
14964  SCIP_SOL** sol, /**< pointer to store the solution */
14965  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
14966  );
14967 
14968 /** creates a primal solution, initialized to the current LP or pseudo solution, depending on whether the LP was solved
14969  * at the current node
14970  *
14971  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14972  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14973  *
14974  * @pre This method can be called if SCIP is in one of the following stages:
14975  * - \ref SCIP_STAGE_SOLVING
14976  */
14977 extern
14979  SCIP* scip, /**< SCIP data structure */
14980  SCIP_SOL** sol, /**< pointer to store the solution */
14981  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
14982  );
14983 
14984 /** creates a primal solution, initialized to unknown values
14985  *
14986  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
14987  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
14988  *
14989  * @pre This method can be called if SCIP is in one of the following stages:
14990  * - \ref SCIP_STAGE_TRANSFORMING
14991  * - \ref SCIP_STAGE_TRANSFORMED
14992  * - \ref SCIP_STAGE_INITPRESOLVE
14993  * - \ref SCIP_STAGE_PRESOLVING
14994  * - \ref SCIP_STAGE_EXITPRESOLVE
14995  * - \ref SCIP_STAGE_PRESOLVED
14996  * - \ref SCIP_STAGE_INITSOLVE
14997  * - \ref SCIP_STAGE_SOLVING
14998  */
14999 extern
15001  SCIP* scip, /**< SCIP data structure */
15002  SCIP_SOL** sol, /**< pointer to store the solution */
15003  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15004  );
15005 
15006 /** creates a primal solution living in the original problem space, initialized to zero;
15007  * a solution in original space allows to set original variables to values that would be invalid in the
15008  * transformed problem due to preprocessing fixings or aggregations
15009  *
15010  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15011  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15012  *
15013  * @pre This method can be called if SCIP is in one of the following stages:
15014  * - \ref SCIP_STAGE_PROBLEM
15015  * - \ref SCIP_STAGE_TRANSFORMING
15016  * - \ref SCIP_STAGE_TRANSFORMED
15017  * - \ref SCIP_STAGE_INITPRESOLVE
15018  * - \ref SCIP_STAGE_PRESOLVING
15019  * - \ref SCIP_STAGE_EXITPRESOLVE
15020  * - \ref SCIP_STAGE_PRESOLVED
15021  * - \ref SCIP_STAGE_INITSOLVE
15022  * - \ref SCIP_STAGE_SOLVING
15023  */
15024 extern
15026  SCIP* scip, /**< SCIP data structure */
15027  SCIP_SOL** sol, /**< pointer to store the solution */
15028  SCIP_HEUR* heur /**< heuristic that found the solution (or NULL if it's from the tree) */
15029  );
15030 
15031 /** creates a copy of a primal solution; note that a copy of a linked solution is also linked and needs to be unlinked
15032  * if it should stay unaffected from changes in the LP or pseudo solution
15033  *
15034  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15035  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15036  *
15037  * @pre This method can be called if SCIP is in one of the following stages:
15038  * - \ref SCIP_STAGE_PROBLEM
15039  * - \ref SCIP_STAGE_TRANSFORMING
15040  * - \ref SCIP_STAGE_TRANSFORMED
15041  * - \ref SCIP_STAGE_INITPRESOLVE
15042  * - \ref SCIP_STAGE_PRESOLVING
15043  * - \ref SCIP_STAGE_EXITPRESOLVE
15044  * - \ref SCIP_STAGE_PRESOLVED
15045  * - \ref SCIP_STAGE_INITSOLVE
15046  * - \ref SCIP_STAGE_SOLVING
15047  */
15048 extern
15050  SCIP* scip, /**< SCIP data structure */
15051  SCIP_SOL** sol, /**< pointer to store the solution */
15052  SCIP_SOL* sourcesol /**< primal CIP solution to copy */
15053  );
15054 
15055 /** creates a copy of a primal solution, thereby replacing infinite fixings of variables by finite values;
15056  * the copy is always defined in the original variable space;
15057  * success indicates whether the objective value of the solution was changed by removing infinite values
15058  *
15059  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15060  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15061  *
15062  * @pre This method can be called if SCIP is in one of the following stages:
15063  * - \ref SCIP_STAGE_PROBLEM
15064  * - \ref SCIP_STAGE_TRANSFORMING
15065  * - \ref SCIP_STAGE_TRANSFORMED
15066  * - \ref SCIP_STAGE_INITPRESOLVE
15067  * - \ref SCIP_STAGE_PRESOLVING
15068  * - \ref SCIP_STAGE_EXITPRESOLVE
15069  * - \ref SCIP_STAGE_PRESOLVED
15070  * - \ref SCIP_STAGE_INITSOLVE
15071  * - \ref SCIP_STAGE_SOLVING
15072  * - \ref SCIP_STAGE_SOLVED
15073  * - \ref SCIP_STAGE_EXITSOLVE
15074  */
15075 extern
15077  SCIP* scip, /**< SCIP data structure */
15078  SCIP_SOL** sol, /**< pointer to store the solution */
15079  SCIP_SOL* sourcesol, /**< primal CIP solution to copy */
15080  SCIP_Bool* success /**< does the finite solution have the same objective value? */
15081  );
15082 
15083 /** frees primal CIP solution
15084  *
15085  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15086  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15087  *
15088  * @pre This method can be called if SCIP is in one of the following stages:
15089  * - \ref SCIP_STAGE_PROBLEM
15090  * - \ref SCIP_STAGE_TRANSFORMING
15091  * - \ref SCIP_STAGE_TRANSFORMED
15092  * - \ref SCIP_STAGE_INITPRESOLVE
15093  * - \ref SCIP_STAGE_PRESOLVING
15094  * - \ref SCIP_STAGE_EXITPRESOLVE
15095  * - \ref SCIP_STAGE_PRESOLVED
15096  * - \ref SCIP_STAGE_INITSOLVE
15097  * - \ref SCIP_STAGE_SOLVING
15098  * - \ref SCIP_STAGE_SOLVED
15099  * - \ref SCIP_STAGE_EXITSOLVE
15100  * - \ref SCIP_STAGE_FREETRANS
15101  */
15102 extern
15104  SCIP* scip, /**< SCIP data structure */
15105  SCIP_SOL** sol /**< pointer to the solution */
15106  );
15107 
15108 /** links a primal solution to the current LP solution
15109  *
15110  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15111  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15112  *
15113  * @pre This method can be called if SCIP is in one of the following stages:
15114  * - \ref SCIP_STAGE_SOLVING
15115  */
15116 extern
15118  SCIP* scip, /**< SCIP data structure */
15119  SCIP_SOL* sol /**< primal solution */
15120  );
15121 
15122 /** links a primal solution to the current NLP solution
15123  *
15124  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15125  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15126  *
15127  * @pre This method can be called if SCIP is in one of the following stages:
15128  * - \ref SCIP_STAGE_SOLVING
15129  */
15130 extern
15132  SCIP* scip, /**< SCIP data structure */
15133  SCIP_SOL* sol /**< primal solution */
15134  );
15135 
15136 /** links a primal solution to the current relaxation solution
15137  *
15138  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15139  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15140  *
15141  * @pre This method can be called if SCIP is in one of the following stages:
15142  * - \ref SCIP_STAGE_SOLVING
15143  */
15144 extern
15146  SCIP* scip, /**< SCIP data structure */
15147  SCIP_SOL* sol /**< primal solution */
15148  );
15149 
15150 /** links a primal solution to the current pseudo solution
15151  *
15152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15154  *
15155  * @pre This method can be called if SCIP is in one of the following stages:
15156  * - \ref SCIP_STAGE_PRESOLVING
15157  * - \ref SCIP_STAGE_SOLVING
15158  */
15159 extern
15161  SCIP* scip, /**< SCIP data structure */
15162  SCIP_SOL* sol /**< primal solution */
15163  );
15164 
15165 /** links a primal solution to the current LP or pseudo solution
15166  *
15167  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15168  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15169  *
15170  * @pre This method can be called if SCIP is in one of the following stages:
15171  * - \ref SCIP_STAGE_SOLVING
15172  */
15173 extern
15175  SCIP* scip, /**< SCIP data structure */
15176  SCIP_SOL* sol /**< primal solution */
15177  );
15178 
15179 /** clears a primal solution
15180  *
15181  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15182  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15183  *
15184  * @pre This method can be called if SCIP is in one of the following stages:
15185  * - \ref SCIP_STAGE_PROBLEM
15186  * - \ref SCIP_STAGE_TRANSFORMING
15187  * - \ref SCIP_STAGE_TRANSFORMED
15188  * - \ref SCIP_STAGE_INITPRESOLVE
15189  * - \ref SCIP_STAGE_PRESOLVING
15190  * - \ref SCIP_STAGE_EXITPRESOLVE
15191  * - \ref SCIP_STAGE_PRESOLVED
15192  * - \ref SCIP_STAGE_INITSOLVE
15193  * - \ref SCIP_STAGE_SOLVING
15194  * - \ref SCIP_STAGE_SOLVED
15195  * - \ref SCIP_STAGE_EXITSOLVE
15196  * - \ref SCIP_STAGE_FREETRANS
15197  */
15198 extern
15200  SCIP* scip, /**< SCIP data structure */
15201  SCIP_SOL* sol /**< primal solution */
15202  );
15203 
15204 /** stores solution values of variables in solution's own array
15205  *
15206  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15207  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15208  *
15209  * @pre This method can be called if SCIP is in one of the following stages:
15210  * - \ref SCIP_STAGE_TRANSFORMING
15211  * - \ref SCIP_STAGE_TRANSFORMED
15212  * - \ref SCIP_STAGE_PRESOLVING
15213  * - \ref SCIP_STAGE_PRESOLVED
15214  * - \ref SCIP_STAGE_INITSOLVE
15215  * - \ref SCIP_STAGE_SOLVING
15216  * - \ref SCIP_STAGE_SOLVED
15217  * - \ref SCIP_STAGE_EXITSOLVE
15218  * - \ref SCIP_STAGE_FREETRANS
15219  */
15220 extern
15222  SCIP* scip, /**< SCIP data structure */
15223  SCIP_SOL* sol /**< primal solution */
15224  );
15225 
15226 /** sets value of variable in primal CIP solution
15227  *
15228  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15229  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15230  *
15231  * @pre This method can be called if SCIP is in one of the following stages:
15232  * - \ref SCIP_STAGE_PROBLEM
15233  * - \ref SCIP_STAGE_TRANSFORMING
15234  * - \ref SCIP_STAGE_TRANSFORMED
15235  * - \ref SCIP_STAGE_INITPRESOLVE
15236  * - \ref SCIP_STAGE_PRESOLVING
15237  * - \ref SCIP_STAGE_EXITPRESOLVE
15238  * - \ref SCIP_STAGE_PRESOLVED
15239  * - \ref SCIP_STAGE_INITSOLVE
15240  * - \ref SCIP_STAGE_SOLVING
15241  * - \ref SCIP_STAGE_SOLVED
15242  * - \ref SCIP_STAGE_EXITSOLVE
15243  * - \ref SCIP_STAGE_FREETRANS
15244  */
15245 extern
15247  SCIP* scip, /**< SCIP data structure */
15248  SCIP_SOL* sol, /**< primal solution */
15249  SCIP_VAR* var, /**< variable to add to solution */
15250  SCIP_Real val /**< solution value of variable */
15251  );
15252 
15253 /** sets values of multiple variables in primal CIP solution
15254  *
15255  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15256  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15257  *
15258  * @pre This method can be called if SCIP is in one of the following stages:
15259  * - \ref SCIP_STAGE_PROBLEM
15260  * - \ref SCIP_STAGE_TRANSFORMING
15261  * - \ref SCIP_STAGE_TRANSFORMED
15262  * - \ref SCIP_STAGE_INITPRESOLVE
15263  * - \ref SCIP_STAGE_PRESOLVING
15264  * - \ref SCIP_STAGE_EXITPRESOLVE
15265  * - \ref SCIP_STAGE_PRESOLVED
15266  * - \ref SCIP_STAGE_INITSOLVE
15267  * - \ref SCIP_STAGE_SOLVING
15268  * - \ref SCIP_STAGE_SOLVED
15269  * - \ref SCIP_STAGE_EXITSOLVE
15270  * - \ref SCIP_STAGE_FREETRANS
15271  */
15272 extern
15274  SCIP* scip, /**< SCIP data structure */
15275  SCIP_SOL* sol, /**< primal solution */
15276  int nvars, /**< number of variables to set solution value for */
15277  SCIP_VAR** vars, /**< array with variables to add to solution */
15278  SCIP_Real* vals /**< array with solution values of variables */
15279  );
15280 
15281 /** increases value of variable in primal CIP solution
15282  *
15283  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15284  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15285  *
15286  * @pre This method can be called if SCIP is in one of the following stages:
15287  * - \ref SCIP_STAGE_PROBLEM
15288  * - \ref SCIP_STAGE_TRANSFORMING
15289  * - \ref SCIP_STAGE_TRANSFORMED
15290  * - \ref SCIP_STAGE_INITPRESOLVE
15291  * - \ref SCIP_STAGE_PRESOLVING
15292  * - \ref SCIP_STAGE_EXITPRESOLVE
15293  * - \ref SCIP_STAGE_PRESOLVED
15294  * - \ref SCIP_STAGE_INITSOLVE
15295  * - \ref SCIP_STAGE_SOLVING
15296  * - \ref SCIP_STAGE_SOLVED
15297  * - \ref SCIP_STAGE_EXITSOLVE
15298  * - \ref SCIP_STAGE_FREETRANS
15299  */
15300 extern
15302  SCIP* scip, /**< SCIP data structure */
15303  SCIP_SOL* sol, /**< primal solution */
15304  SCIP_VAR* var, /**< variable to increase solution value for */
15305  SCIP_Real incval /**< increment for solution value of variable */
15306  );
15307 
15308 /** returns value of variable in primal CIP solution, or in current LP/pseudo solution
15309  *
15310  * @return value of variable in primal CIP solution, or in current LP/pseudo solution
15311  *
15312  * @pre In case the solution pointer @p sol is @b NULL, that means it is asked for the LP or pseudo solution, this method
15313  * can only be called if @p scip is in the solving stage \ref SCIP_STAGE_SOLVING. In any other case, this method
15314  * can be called if @p scip is in one of the following stages:
15315  * - \ref SCIP_STAGE_PROBLEM
15316  * - \ref SCIP_STAGE_TRANSFORMING
15317  * - \ref SCIP_STAGE_TRANSFORMED
15318  * - \ref SCIP_STAGE_INITPRESOLVE
15319  * - \ref SCIP_STAGE_PRESOLVING
15320  * - \ref SCIP_STAGE_EXITPRESOLVE
15321  * - \ref SCIP_STAGE_PRESOLVED
15322  * - \ref SCIP_STAGE_INITSOLVE
15323  * - \ref SCIP_STAGE_SOLVING
15324  * - \ref SCIP_STAGE_SOLVED
15325  * - \ref SCIP_STAGE_EXITSOLVE
15326  * - \ref SCIP_STAGE_FREETRANS
15327  */
15328 extern
15330  SCIP* scip, /**< SCIP data structure */
15331  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
15332  SCIP_VAR* var /**< variable to get value for */
15333  );
15334 
15335 /** gets values of multiple variables in primal CIP solution
15336  *
15337  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15338  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15339  *
15340  * @pre This method can be called if SCIP is in one of the following stages:
15341  * - \ref SCIP_STAGE_PROBLEM
15342  * - \ref SCIP_STAGE_TRANSFORMING
15343  * - \ref SCIP_STAGE_TRANSFORMED
15344  * - \ref SCIP_STAGE_INITPRESOLVE
15345  * - \ref SCIP_STAGE_PRESOLVING
15346  * - \ref SCIP_STAGE_EXITPRESOLVE
15347  * - \ref SCIP_STAGE_PRESOLVED
15348  * - \ref SCIP_STAGE_INITSOLVE
15349  * - \ref SCIP_STAGE_SOLVING
15350  * - \ref SCIP_STAGE_SOLVED
15351  * - \ref SCIP_STAGE_EXITSOLVE
15352  * - \ref SCIP_STAGE_FREETRANS
15353  */
15354 extern
15356  SCIP* scip, /**< SCIP data structure */
15357  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
15358  int nvars, /**< number of variables to get solution value for */
15359  SCIP_VAR** vars, /**< array with variables to get value for */
15360  SCIP_Real* vals /**< array to store solution values of variables */
15361  );
15362 
15363 /** returns objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
15364  *
15365  * @return objective value of primal CIP solution w.r.t. original problem, or current LP/pseudo objective value
15366  *
15367  * @pre This method can be called if SCIP is in one of the following stages:
15368  * - \ref SCIP_STAGE_PROBLEM
15369  * - \ref SCIP_STAGE_TRANSFORMING
15370  * - \ref SCIP_STAGE_TRANSFORMED
15371  * - \ref SCIP_STAGE_INITPRESOLVE
15372  * - \ref SCIP_STAGE_PRESOLVING
15373  * - \ref SCIP_STAGE_EXITPRESOLVE
15374  * - \ref SCIP_STAGE_PRESOLVED
15375  * - \ref SCIP_STAGE_INITSOLVE
15376  * - \ref SCIP_STAGE_SOLVING
15377  * - \ref SCIP_STAGE_SOLVED
15378  * - \ref SCIP_STAGE_EXITSOLVE
15379  * - \ref SCIP_STAGE_FREETRANS
15380  */
15381 extern
15383  SCIP* scip, /**< SCIP data structure */
15384  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
15385  );
15386 
15387 /** returns transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
15388  *
15389  * @return transformed objective value of primal CIP solution, or transformed current LP/pseudo objective value
15390  *
15391  * @pre This method can be called if SCIP is in one of the following stages:
15392  * - \ref SCIP_STAGE_TRANSFORMING
15393  * - \ref SCIP_STAGE_TRANSFORMED
15394  * - \ref SCIP_STAGE_INITPRESOLVE
15395  * - \ref SCIP_STAGE_PRESOLVING
15396  * - \ref SCIP_STAGE_EXITPRESOLVE
15397  * - \ref SCIP_STAGE_PRESOLVED
15398  * - \ref SCIP_STAGE_INITSOLVE
15399  * - \ref SCIP_STAGE_SOLVING
15400  * - \ref SCIP_STAGE_SOLVED
15401  * - \ref SCIP_STAGE_EXITSOLVE
15402  * - \ref SCIP_STAGE_FREETRANS
15403  */
15404 extern
15406  SCIP* scip, /**< SCIP data structure */
15407  SCIP_SOL* sol /**< primal solution, or NULL for current LP/pseudo objective value */
15408  );
15409 
15410 /** maps original space objective value into transformed objective value
15411  *
15412  * @return transformed objective value
15413  *
15414  * @pre This method can be called if SCIP is in one of the following stages:
15415  * - \ref SCIP_STAGE_TRANSFORMING
15416  * - \ref SCIP_STAGE_TRANSFORMED
15417  * - \ref SCIP_STAGE_INITPRESOLVE
15418  * - \ref SCIP_STAGE_PRESOLVING
15419  * - \ref SCIP_STAGE_EXITPRESOLVE
15420  * - \ref SCIP_STAGE_PRESOLVED
15421  * - \ref SCIP_STAGE_INITSOLVE
15422  * - \ref SCIP_STAGE_SOLVING
15423  * - \ref SCIP_STAGE_SOLVED
15424  */
15425 extern
15427  SCIP* scip, /**< SCIP data structure */
15428  SCIP_Real obj /**< original space objective value to transform */
15429  );
15430 
15431 /** maps transformed objective value into original space
15432  *
15433  * @return objective value into original space
15434  *
15435  * @pre This method can be called if SCIP is in one of the following stages:
15436  * - \ref SCIP_STAGE_TRANSFORMING
15437  * - \ref SCIP_STAGE_TRANSFORMED
15438  * - \ref SCIP_STAGE_INITPRESOLVE
15439  * - \ref SCIP_STAGE_PRESOLVING
15440  * - \ref SCIP_STAGE_EXITPRESOLVE
15441  * - \ref SCIP_STAGE_PRESOLVED
15442  * - \ref SCIP_STAGE_INITSOLVE
15443  * - \ref SCIP_STAGE_SOLVING
15444  * - \ref SCIP_STAGE_SOLVED
15445  */
15446 extern
15448  SCIP* scip, /**< SCIP data structure */
15449  SCIP_Real obj /**< transformed objective value to retransform in original space */
15450  );
15451 
15452 /** gets clock time, when this solution was found
15453  *
15454  * @return clock time, when this solution was found
15455  *
15456  * @pre This method can be called if SCIP is in one of the following stages:
15457  * - \ref SCIP_STAGE_TRANSFORMING
15458  * - \ref SCIP_STAGE_TRANSFORMED
15459  * - \ref SCIP_STAGE_INITPRESOLVE
15460  * - \ref SCIP_STAGE_PRESOLVING
15461  * - \ref SCIP_STAGE_EXITPRESOLVE
15462  * - \ref SCIP_STAGE_PRESOLVED
15463  * - \ref SCIP_STAGE_INITSOLVE
15464  * - \ref SCIP_STAGE_SOLVING
15465  * - \ref SCIP_STAGE_SOLVED
15466  * - \ref SCIP_STAGE_EXITSOLVE
15467  * - \ref SCIP_STAGE_FREETRANS
15468  */
15469 extern
15471  SCIP* scip, /**< SCIP data structure */
15472  SCIP_SOL* sol /**< primal solution */
15473  );
15474 
15475 /** gets branch and bound run number, where this solution was found
15476  *
15477  * @return branch and bound run number, where this solution was found
15478  *
15479  * @pre This method can be called if SCIP is in one of the following stages:
15480  * - \ref SCIP_STAGE_TRANSFORMING
15481  * - \ref SCIP_STAGE_TRANSFORMED
15482  * - \ref SCIP_STAGE_INITPRESOLVE
15483  * - \ref SCIP_STAGE_PRESOLVING
15484  * - \ref SCIP_STAGE_EXITPRESOLVE
15485  * - \ref SCIP_STAGE_PRESOLVED
15486  * - \ref SCIP_STAGE_INITSOLVE
15487  * - \ref SCIP_STAGE_SOLVING
15488  * - \ref SCIP_STAGE_SOLVED
15489  * - \ref SCIP_STAGE_EXITSOLVE
15490  * - \ref SCIP_STAGE_FREETRANS
15491  */
15492 extern
15493 int SCIPgetSolRunnum(
15494  SCIP* scip, /**< SCIP data structure */
15495  SCIP_SOL* sol /**< primal solution */
15496  );
15497 
15498 /** gets node number of the specific branch and bound run, where this solution was found
15499  *
15500  * @return node number of the specific branch and bound run, where this solution was found
15501  *
15502  * @pre This method can be called if SCIP is in one of the following stages:
15503  * - \ref SCIP_STAGE_TRANSFORMING
15504  * - \ref SCIP_STAGE_TRANSFORMED
15505  * - \ref SCIP_STAGE_INITPRESOLVE
15506  * - \ref SCIP_STAGE_PRESOLVING
15507  * - \ref SCIP_STAGE_EXITPRESOLVE
15508  * - \ref SCIP_STAGE_PRESOLVED
15509  * - \ref SCIP_STAGE_INITSOLVE
15510  * - \ref SCIP_STAGE_SOLVING
15511  * - \ref SCIP_STAGE_SOLVED
15512  * - \ref SCIP_STAGE_EXITSOLVE
15513  * - \ref SCIP_STAGE_FREETRANS
15514  */
15515 extern
15517  SCIP* scip, /**< SCIP data structure */
15518  SCIP_SOL* sol /**< primal solution */
15519  );
15520 
15521 /** gets heuristic, that found this solution (or NULL if it's from the tree)
15522  *
15523  * @return heuristic, that found this solution (or NULL if it's from the tree)
15524  *
15525  * @pre This method can be called if SCIP is in one of the following stages:
15526  * - \ref SCIP_STAGE_TRANSFORMING
15527  * - \ref SCIP_STAGE_TRANSFORMED
15528  * - \ref SCIP_STAGE_INITPRESOLVE
15529  * - \ref SCIP_STAGE_PRESOLVING
15530  * - \ref SCIP_STAGE_EXITPRESOLVE
15531  * - \ref SCIP_STAGE_PRESOLVED
15532  * - \ref SCIP_STAGE_INITSOLVE
15533  * - \ref SCIP_STAGE_SOLVING
15534  * - \ref SCIP_STAGE_SOLVED
15535  * - \ref SCIP_STAGE_EXITSOLVE
15536  * - \ref SCIP_STAGE_FREETRANS
15537  */
15538 extern
15540  SCIP* scip, /**< SCIP data structure */
15541  SCIP_SOL* sol /**< primal solution */
15542  );
15543 
15544 /** returns whether two given solutions are exactly equal
15545  *
15546  * @return returns whether two given solutions are exactly equal
15547  *
15548  * @pre This method can be called if SCIP is in one of the following stages:
15549  * - \ref SCIP_STAGE_PROBLEM
15550  * - \ref SCIP_STAGE_TRANSFORMING
15551  * - \ref SCIP_STAGE_TRANSFORMED
15552  * - \ref SCIP_STAGE_INITPRESOLVE
15553  * - \ref SCIP_STAGE_PRESOLVING
15554  * - \ref SCIP_STAGE_EXITPRESOLVE
15555  * - \ref SCIP_STAGE_PRESOLVED
15556  * - \ref SCIP_STAGE_INITSOLVE
15557  * - \ref SCIP_STAGE_SOLVING
15558  * - \ref SCIP_STAGE_SOLVED
15559  * - \ref SCIP_STAGE_EXITSOLVE
15560  * - \ref SCIP_STAGE_FREETRANS
15561  */
15562 extern
15564  SCIP* scip, /**< SCIP data structure */
15565  SCIP_SOL* sol1, /**< first primal CIP solution */
15566  SCIP_SOL* sol2 /**< second primal CIP solution */
15567  );
15568 
15569 /** adjusts solution values of implicit integer variables in handed solution. Solution objective value is not
15570  * deteriorated by this method.
15571  *
15572  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15573  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15574  *
15575  * @pre This method can be called if SCIP is in one of the following stages:
15576  * - \ref SCIP_STAGE_SOLVING
15577  */
15578 extern
15580  SCIP* scip, /**< SCIP data structure */
15581  SCIP_SOL* sol, /**< primal CIP solution */
15582  SCIP_Bool uselprows /**< should LP row information be considered for none-objective variables */
15583  );
15584 
15585 /** outputs non-zero variables of solution in original problem space to the given file stream
15586  *
15587  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15588  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15589  *
15590  * @pre In case the solution pointer @p sol is NULL (askinking for the current LP/pseudo solution), this method can be
15591  * called if @p scip is in one of the following stages:
15592  * - \ref SCIP_STAGE_PRESOLVING
15593  * - \ref SCIP_STAGE_EXITPRESOLVE
15594  * - \ref SCIP_STAGE_PRESOLVED
15595  * - \ref SCIP_STAGE_INITSOLVE
15596  * - \ref SCIP_STAGE_SOLVING
15597  * - \ref SCIP_STAGE_SOLVED
15598  * - \ref SCIP_STAGE_EXITSOLVE
15599  *
15600  * @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
15601  * following stages:
15602  * - \ref SCIP_STAGE_PROBLEM
15603  * - \ref SCIP_STAGE_TRANSFORMED
15604  * - \ref SCIP_STAGE_INITPRESOLVE
15605  * - \ref SCIP_STAGE_PRESOLVING
15606  * - \ref SCIP_STAGE_EXITPRESOLVE
15607  * - \ref SCIP_STAGE_PRESOLVED
15608  * - \ref SCIP_STAGE_INITSOLVE
15609  * - \ref SCIP_STAGE_SOLVING
15610  * - \ref SCIP_STAGE_SOLVED
15611  * - \ref SCIP_STAGE_EXITSOLVE
15612  */
15613 extern
15615  SCIP* scip, /**< SCIP data structure */
15616  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
15617  FILE* file, /**< output file (or NULL for standard output) */
15618  SCIP_Bool printzeros /**< should variables set to zero be printed? */
15619  );
15620 
15621 /** outputs non-zero variables of solution in transformed problem space to file stream
15622  *
15623  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15624  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15625  *
15626  * @pre This method can be called if SCIP is in one of the following stages:
15627  * - \ref SCIP_STAGE_TRANSFORMED
15628  * - \ref SCIP_STAGE_INITPRESOLVE
15629  * - \ref SCIP_STAGE_PRESOLVING
15630  * - \ref SCIP_STAGE_EXITPRESOLVE
15631  * - \ref SCIP_STAGE_PRESOLVED
15632  * - \ref SCIP_STAGE_INITSOLVE
15633  * - \ref SCIP_STAGE_SOLVING
15634  * - \ref SCIP_STAGE_SOLVED
15635  * - \ref SCIP_STAGE_EXITSOLVE
15636  */
15637 extern
15639  SCIP* scip, /**< SCIP data structure */
15640  SCIP_SOL* sol, /**< primal solution, or NULL for current LP/pseudo solution */
15641  FILE* file, /**< output file (or NULL for standard output) */
15642  SCIP_Bool printzeros /**< should variables set to zero be printed? */
15643  );
15644 
15645 /** outputs dual solution from LP solver to file stream
15646  *
15647  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15648  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15649  *
15650  * @pre This method can be called if SCIP is in one of the following stages:
15651  * - \ref SCIP_STAGE_SOLVED
15652  */
15653 extern
15655  SCIP* scip, /**< SCIP data structure */
15656  FILE* file, /**< output file (or NULL for standard output) */
15657  SCIP_Bool printzeros /**< should variables set to zero be printed? */
15658  );
15659 
15660 
15661 /** outputs non-zero variables of solution representing a ray in original problem space to file stream
15662  *
15663  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15664  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15665  *
15666  * @pre This method can be called if SCIP is in one of the following stages:
15667  * - \ref SCIP_STAGE_PROBLEM
15668  * - \ref SCIP_STAGE_TRANSFORMED
15669  * - \ref SCIP_STAGE_INITPRESOLVE
15670  * - \ref SCIP_STAGE_PRESOLVING
15671  * - \ref SCIP_STAGE_EXITPRESOLVE
15672  * - \ref SCIP_STAGE_PRESOLVED
15673  * - \ref SCIP_STAGE_INITSOLVE
15674  * - \ref SCIP_STAGE_SOLVING
15675  * - \ref SCIP_STAGE_SOLVED
15676  * - \ref SCIP_STAGE_EXITSOLVE
15677  */
15678 extern
15680  SCIP* scip, /**< SCIP data structure */
15681  SCIP_SOL* sol, /**< primal solution representing ray */
15682  FILE* file, /**< output file (or NULL for standard output) */
15683  SCIP_Bool printzeros /**< should variables set to zero be printed? */
15684  );
15685 
15686 /** gets number of feasible primal solutions stored in the solution storage in case the problem is transformed;
15687  * in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate
15688  * storage is returned
15689  *
15690  * @return number of feasible primal solutions stored in the solution storage in case the problem is transformed; or
15691  * number of solution in the original solution candidate storage if the problem stage is SCIP_STAGE_PROBLEM
15692  *
15693  * @pre This method can be called if SCIP is in one of the following stages:
15694  * - \ref SCIP_STAGE_PROBLEM
15695  * - \ref SCIP_STAGE_TRANSFORMED
15696  * - \ref SCIP_STAGE_INITPRESOLVE
15697  * - \ref SCIP_STAGE_PRESOLVING
15698  * - \ref SCIP_STAGE_EXITPRESOLVE
15699  * - \ref SCIP_STAGE_PRESOLVED
15700  * - \ref SCIP_STAGE_INITSOLVE
15701  * - \ref SCIP_STAGE_SOLVING
15702  * - \ref SCIP_STAGE_SOLVED
15703  * - \ref SCIP_STAGE_EXITSOLVE
15704  */
15705 extern
15706 int SCIPgetNSols(
15707  SCIP* scip /**< SCIP data structure */
15708  );
15709 
15710 /** gets array of feasible primal solutions stored in the solution storage in case the problem is transformed; in case
15711  * if the problem stage is in SCIP_STAGE_PROBLEM, it returns the number array of solution candidate stored
15712  *
15713  * @return array of feasible primal solutions
15714  *
15715  * @pre This method can be called if SCIP is in one of the following stages:
15716  * - \ref SCIP_STAGE_PROBLEM
15717  * - \ref SCIP_STAGE_TRANSFORMED
15718  * - \ref SCIP_STAGE_INITPRESOLVE
15719  * - \ref SCIP_STAGE_PRESOLVING
15720  * - \ref SCIP_STAGE_EXITPRESOLVE
15721  * - \ref SCIP_STAGE_PRESOLVED
15722  * - \ref SCIP_STAGE_INITSOLVE
15723  * - \ref SCIP_STAGE_SOLVING
15724  * - \ref SCIP_STAGE_SOLVED
15725  * - \ref SCIP_STAGE_EXITSOLVE
15726  */
15727 extern
15729  SCIP* scip /**< SCIP data structure */
15730  );
15731 
15732 /** gets best feasible primal solution found so far if the problem is transformed; in case the problem is in
15733  * SCIP_STAGE_PROBLEM it returns the best solution candidate, or NULL if no solution has been found or the candidate
15734  * store is empty;
15735  *
15736  * @return best feasible primal solution so far
15737  *
15738  * @pre This method can be called if SCIP is in one of the following stages:
15739  * - \ref SCIP_STAGE_PROBLEM
15740  * - \ref SCIP_STAGE_TRANSFORMED
15741  * - \ref SCIP_STAGE_INITPRESOLVE
15742  * - \ref SCIP_STAGE_PRESOLVING
15743  * - \ref SCIP_STAGE_EXITPRESOLVE
15744  * - \ref SCIP_STAGE_PRESOLVED
15745  * - \ref SCIP_STAGE_INITSOLVE
15746  * - \ref SCIP_STAGE_SOLVING
15747  * - \ref SCIP_STAGE_SOLVED
15748  * - \ref SCIP_STAGE_EXITSOLVE
15749  */
15750 extern
15752  SCIP* scip /**< SCIP data structure */
15753  );
15754 
15755 /** outputs best feasible primal solution found so far to file stream
15756  *
15757  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15758  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15759  *
15760  * @pre This method can be called if SCIP is in one of the following stages:
15761  * - \ref SCIP_STAGE_INIT
15762  * - \ref SCIP_STAGE_PROBLEM
15763  * - \ref SCIP_STAGE_TRANSFORMING
15764  * - \ref SCIP_STAGE_TRANSFORMED
15765  * - \ref SCIP_STAGE_INITPRESOLVE
15766  * - \ref SCIP_STAGE_PRESOLVING
15767  * - \ref SCIP_STAGE_EXITPRESOLVE
15768  * - \ref SCIP_STAGE_PRESOLVED
15769  * - \ref SCIP_STAGE_INITSOLVE
15770  * - \ref SCIP_STAGE_SOLVING
15771  * - \ref SCIP_STAGE_SOLVED
15772  * - \ref SCIP_STAGE_EXITSOLVE
15773  * - \ref SCIP_STAGE_FREE
15774  */
15775 extern
15777  SCIP* scip, /**< SCIP data structure */
15778  FILE* file, /**< output file (or NULL for standard output) */
15779  SCIP_Bool printzeros /**< should variables set to zero be printed? */
15780  );
15781 
15782 /** outputs best feasible primal solution found so far in transformed variables to file stream
15783  *
15784  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15785  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15786  *
15787  * @pre This method can be called if SCIP is in one of the following stages:
15788  * - \ref SCIP_STAGE_INIT
15789  * - \ref SCIP_STAGE_PROBLEM
15790  * - \ref SCIP_STAGE_TRANSFORMING
15791  * - \ref SCIP_STAGE_TRANSFORMED
15792  * - \ref SCIP_STAGE_INITPRESOLVE
15793  * - \ref SCIP_STAGE_PRESOLVING
15794  * - \ref SCIP_STAGE_EXITPRESOLVE
15795  * - \ref SCIP_STAGE_PRESOLVED
15796  * - \ref SCIP_STAGE_INITSOLVE
15797  * - \ref SCIP_STAGE_SOLVING
15798  * - \ref SCIP_STAGE_SOLVED
15799  * - \ref SCIP_STAGE_EXITSOLVE
15800  * - \ref SCIP_STAGE_FREE
15801  */
15802 extern
15804  SCIP* scip, /**< SCIP data structure */
15805  FILE* file, /**< output file (or NULL for standard output) */
15806  SCIP_Bool printzeros /**< should variables set to zero be printed? */
15807  );
15808 
15809 /** try to round given solution
15810  *
15811  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15812  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15813  *
15814  * @pre This method can be called if SCIP is in one of the following stages:
15815  * - \ref SCIP_STAGE_SOLVING
15816  */
15817 extern
15819  SCIP* scip, /**< SCIP data structure */
15820  SCIP_SOL* sol, /**< primal solution */
15821  SCIP_Bool* success /**< pointer to store whether rounding was successful */
15822  );
15823 
15824 /** retransforms solution to original problem space
15825  *
15826  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15827  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15828  *
15829  * @pre This method can be called if SCIP is in one of the following stages:
15830  * - \ref SCIP_STAGE_PROBLEM
15831  * - \ref SCIP_STAGE_TRANSFORMING
15832  * - \ref SCIP_STAGE_TRANSFORMED
15833  * - \ref SCIP_STAGE_INITPRESOLVE
15834  * - \ref SCIP_STAGE_PRESOLVING
15835  * - \ref SCIP_STAGE_EXITPRESOLVE
15836  * - \ref SCIP_STAGE_PRESOLVED
15837  * - \ref SCIP_STAGE_INITSOLVE
15838  * - \ref SCIP_STAGE_SOLVING
15839  * - \ref SCIP_STAGE_SOLVED
15840  * - \ref SCIP_STAGE_EXITSOLVE
15841  * - \ref SCIP_STAGE_FREETRANS
15842  */
15843 extern
15845  SCIP* scip, /**< SCIP data structure */
15846  SCIP_SOL* sol /**< primal CIP solution */
15847  );
15848 
15849 /** reads a given solution file, problem has to be transformed in advance
15850  *
15851  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15852  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15853  *
15854  * @pre This method can be called if SCIP is in one of the following stages:
15855  * - \ref SCIP_STAGE_PROBLEM
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  const char* filename /**< name of the input file */
15868  );
15869 
15870 /** adds feasible primal solution to solution storage by copying it
15871  *
15872  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15873  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15874  *
15875  * @pre This method can be called if SCIP is in one of the following stages:
15876  * - \ref SCIP_STAGE_PROBLEM
15877  * - \ref SCIP_STAGE_TRANSFORMED
15878  * - \ref SCIP_STAGE_INITPRESOLVE
15879  * - \ref SCIP_STAGE_PRESOLVING
15880  * - \ref SCIP_STAGE_EXITPRESOLVE
15881  * - \ref SCIP_STAGE_PRESOLVED
15882  * - \ref SCIP_STAGE_SOLVING
15883  * - \ref SCIP_STAGE_FREETRANS
15884  *
15885  * @note Do not call during propagation, use heur_trysol instead.
15886  */
15887 extern
15889  SCIP* scip, /**< SCIP data structure */
15890  SCIP_SOL* sol, /**< primal CIP solution */
15891  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
15892  );
15893 
15894 /** adds primal solution to solution storage, frees the solution afterwards
15895  *
15896  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15897  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15898  *
15899  * @pre This method can be called if SCIP is in one of the following stages:
15900  * - \ref SCIP_STAGE_PROBLEM
15901  * - \ref SCIP_STAGE_TRANSFORMED
15902  * - \ref SCIP_STAGE_INITPRESOLVE
15903  * - \ref SCIP_STAGE_PRESOLVING
15904  * - \ref SCIP_STAGE_EXITPRESOLVE
15905  * - \ref SCIP_STAGE_PRESOLVED
15906  * - \ref SCIP_STAGE_SOLVING
15907  * - \ref SCIP_STAGE_FREETRANS
15908  *
15909  * @note Do not call during propagation, use heur_trysol instead.
15910  */
15911 extern
15913  SCIP* scip, /**< SCIP data structure */
15914  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
15915  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
15916  );
15917 
15918 /** adds current LP/pseudo solution to solution storage
15919  *
15920  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15921  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15922  *
15923  * @pre This method can be called if SCIP is in one of the following stages:
15924  * - \ref SCIP_STAGE_PRESOLVED
15925  * - \ref SCIP_STAGE_SOLVING
15926  */
15927 extern
15929  SCIP* scip, /**< SCIP data structure */
15930  SCIP_HEUR* heur, /**< heuristic that found the solution */
15931  SCIP_Bool* stored /**< stores whether given solution was good enough to keep */
15932  );
15933 
15934 /** checks solution for feasibility; if possible, adds it to storage by copying
15935  *
15936  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15937  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15938  *
15939  * @pre This method can be called if SCIP is in one of the following stages:
15940  * - \ref SCIP_STAGE_TRANSFORMED
15941  * - \ref SCIP_STAGE_INITPRESOLVE
15942  * - \ref SCIP_STAGE_PRESOLVING
15943  * - \ref SCIP_STAGE_EXITPRESOLVE
15944  * - \ref SCIP_STAGE_PRESOLVED
15945  * - \ref SCIP_STAGE_SOLVING
15946  *
15947  * @note Do not call during propagation, use heur_trysol instead.
15948  */
15949 extern
15951  SCIP* scip, /**< SCIP data structure */
15952  SCIP_SOL* sol, /**< primal CIP solution */
15953  SCIP_Bool printreason, /**< should all reasons of violations be printed? */
15954  SCIP_Bool checkbounds, /**< should the bounds of the variables be checked? */
15955  SCIP_Bool checkintegrality, /**< has integrality to be checked? */
15956  SCIP_Bool checklprows, /**< have current LP rows (both local and global) to be checked? */
15957  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
15958  );
15959 
15960 /** checks primal solution; if feasible, adds it to storage; solution is freed afterwards
15961  *
15962  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15963  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15964  *
15965  * @pre This method can be called if SCIP is in one of the following stages:
15966  * - \ref SCIP_STAGE_TRANSFORMED
15967  * - \ref SCIP_STAGE_INITPRESOLVE
15968  * - \ref SCIP_STAGE_PRESOLVING
15969  * - \ref SCIP_STAGE_EXITPRESOLVE
15970  * - \ref SCIP_STAGE_PRESOLVED
15971  * - \ref SCIP_STAGE_SOLVING
15972  *
15973  * @note Do not call during propagation, use heur_trysol instead.
15974  */
15975 extern
15977  SCIP* scip, /**< SCIP data structure */
15978  SCIP_SOL** sol, /**< pointer to primal CIP solution; is cleared in function call */
15979  SCIP_Bool printreason, /**< should all reasons of violations be printed? */
15980  SCIP_Bool checkbounds, /**< should the bounds of the variables be checked? */
15981  SCIP_Bool checkintegrality, /**< has integrality to be checked? */
15982  SCIP_Bool checklprows, /**< have current LP rows (both local and global) to be checked? */
15983  SCIP_Bool* stored /**< stores whether solution was feasible and good enough to keep */
15984  );
15985 
15986 /** checks current LP/pseudo solution for feasibility; if possible, adds it to storage
15987  *
15988  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
15989  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
15990  *
15991  * @pre This method can be called if SCIP is in one of the following stages:
15992  * - \ref SCIP_STAGE_PRESOLVED
15993  * - \ref SCIP_STAGE_SOLVING
15994  */
15995 extern
15997  SCIP* scip, /**< SCIP data structure */
15998  SCIP_HEUR* heur, /**< heuristic that found the solution */
15999  SCIP_Bool printreason, /**< should all reasons of violations be printed? */
16000  SCIP_Bool checkintegrality, /**< has integrality to be checked? */
16001  SCIP_Bool checklprows, /**< have current LP rows (both local and global) to be checked? */
16002  SCIP_Bool* stored /**< stores whether given solution was feasible and good enough to keep */
16003  );
16004 
16005 /** checks solution for feasibility without adding it to the solution store
16006  *
16007  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16008  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16009  *
16010  * @pre This method can be called if SCIP is in one of the following stages:
16011  * - \ref SCIP_STAGE_PROBLEM
16012  * - \ref SCIP_STAGE_TRANSFORMED
16013  * - \ref SCIP_STAGE_INITPRESOLVE
16014  * - \ref SCIP_STAGE_PRESOLVING
16015  * - \ref SCIP_STAGE_EXITPRESOLVE
16016  * - \ref SCIP_STAGE_PRESOLVED
16017  * - \ref SCIP_STAGE_INITSOLVE
16018  * - \ref SCIP_STAGE_SOLVING
16019  * - \ref SCIP_STAGE_SOLVED
16020  */
16021 extern
16023  SCIP* scip, /**< SCIP data structure */
16024  SCIP_SOL* sol, /**< primal CIP solution */
16025  SCIP_Bool printreason, /**< should all reasons of violations be printed? */
16026  SCIP_Bool checkbounds, /**< should the bounds of the variables be checked? */
16027  SCIP_Bool checkintegrality, /**< has integrality to be checked? */
16028  SCIP_Bool checklprows, /**< have current LP rows (both local and global) to be checked? */
16029  SCIP_Bool* feasible /**< stores whether given solution is feasible */
16030  );
16031 
16032 /** checks solution for feasibility in original problem without adding it to the solution store;
16033  * this method is used to double check a solution in order to validate the presolving process
16034  *
16035  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16036  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16037  *
16038  * @pre This method can be called if SCIP is in one of the following stages:
16039  * - \ref SCIP_STAGE_PROBLEM
16040  * - \ref SCIP_STAGE_TRANSFORMED
16041  * - \ref SCIP_STAGE_INITPRESOLVE
16042  * - \ref SCIP_STAGE_PRESOLVING
16043  * - \ref SCIP_STAGE_EXITPRESOLVE
16044  * - \ref SCIP_STAGE_PRESOLVED
16045  * - \ref SCIP_STAGE_INITSOLVE
16046  * - \ref SCIP_STAGE_SOLVING
16047  * - \ref SCIP_STAGE_SOLVED
16048  */
16049 extern
16051  SCIP* scip, /**< SCIP data structure */
16052  SCIP_SOL* sol, /**< primal CIP solution */
16053  SCIP_Bool* feasible, /**< stores whether given solution is feasible */
16054  SCIP_Bool printreason, /**< should the reason for the violation be printed? */
16055  SCIP_Bool completely /**< should all violations be checked? */
16056  );
16057 
16058 /** return whether a primal ray is stored that proves unboundedness of the LP relaxation
16059  *
16060  * @return return whether a primal ray is stored that proves unboundedness of the LP relaxation
16061  *
16062  * @pre This method can be called if SCIP is in one of the following stages:
16063  * - \ref SCIP_STAGE_SOLVING
16064  * - \ref SCIP_STAGE_SOLVED
16065  */
16066 extern
16068  SCIP* scip /**< SCIP data structure */
16069  );
16070 
16071 /** gets value of given variable in primal ray causing unboundedness of the LP relaxation;
16072  * should only be called if such a ray is stored (check with SCIPhasPrimalRay())
16073  *
16074  * @return value of given variable in primal ray causing unboundedness of the LP relaxation
16075  *
16076  * @pre This method can be called if SCIP is in one of the following stages:
16077  * - \ref SCIP_STAGE_SOLVING
16078  * - \ref SCIP_STAGE_SOLVED
16079  */
16080 extern
16082  SCIP* scip, /**< SCIP data structure */
16083  SCIP_VAR* var /**< variable to get value for */
16084  );
16085 
16086 /**@} */
16087 
16088 
16089 
16090 
16091 /*
16092  * event methods
16093  */
16094 
16095 /**@name Event Methods
16096  *
16097  * Events can only be caught during the operation on the transformed problem.
16098  * Events on variables can only be caught for transformed variables.
16099  * If you want to catch an event for an original variable, you have to get the corresponding transformed variable
16100  * with a call to SCIPgetTransformedVar() and catch the event on the transformed variable.
16101  */
16102 /**@{ */
16103 
16104 /** catches a global (not variable or row dependent) event
16105  *
16106  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16107  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16108  *
16109  * @pre This method can be called if @p scip is in one of the following stages:
16110  * - \ref SCIP_STAGE_TRANSFORMING
16111  * - \ref SCIP_STAGE_TRANSFORMED
16112  * - \ref SCIP_STAGE_INITPRESOLVE
16113  * - \ref SCIP_STAGE_PRESOLVING
16114  * - \ref SCIP_STAGE_EXITPRESOLVE
16115  * - \ref SCIP_STAGE_PRESOLVED
16116  * - \ref SCIP_STAGE_INITSOLVE
16117  * - \ref SCIP_STAGE_SOLVING
16118  * - \ref SCIP_STAGE_SOLVED
16119  * - \ref SCIP_STAGE_EXITSOLVE
16120  * - \ref SCIP_STAGE_FREETRANS
16121  */
16122 extern
16124  SCIP* scip, /**< SCIP data structure */
16125  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
16126  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
16127  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
16128  int* filterpos /**< pointer to store position of event filter entry, or NULL */
16129  );
16130 
16131 /** drops a global event (stops to track event)
16132  *
16133  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16134  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16135  *
16136  * @pre This method can be called if @p scip is in one of the following stages:
16137  * - \ref SCIP_STAGE_TRANSFORMING
16138  * - \ref SCIP_STAGE_TRANSFORMED
16139  * - \ref SCIP_STAGE_INITPRESOLVE
16140  * - \ref SCIP_STAGE_PRESOLVING
16141  * - \ref SCIP_STAGE_EXITPRESOLVE
16142  * - \ref SCIP_STAGE_PRESOLVED
16143  * - \ref SCIP_STAGE_INITSOLVE
16144  * - \ref SCIP_STAGE_SOLVING
16145  * - \ref SCIP_STAGE_SOLVED
16146  * - \ref SCIP_STAGE_EXITSOLVE
16147  * - \ref SCIP_STAGE_FREETRANS
16148  */
16149 extern
16151  SCIP* scip, /**< SCIP data structure */
16152  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
16153  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
16154  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
16155  int filterpos /**< position of event filter entry returned by SCIPcatchEvent(), or -1 */
16156  );
16157 
16158 /** catches an objective value or domain change event on the given transformed variable
16159  *
16160  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16161  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16162  *
16163  * @pre This method can be called if @p scip is in one of the following stages:
16164  * - \ref SCIP_STAGE_TRANSFORMING
16165  * - \ref SCIP_STAGE_TRANSFORMED
16166  * - \ref SCIP_STAGE_INITPRESOLVE
16167  * - \ref SCIP_STAGE_PRESOLVING
16168  * - \ref SCIP_STAGE_EXITPRESOLVE
16169  * - \ref SCIP_STAGE_PRESOLVED
16170  * - \ref SCIP_STAGE_INITSOLVE
16171  * - \ref SCIP_STAGE_SOLVING
16172  * - \ref SCIP_STAGE_SOLVED
16173  * - \ref SCIP_STAGE_EXITSOLVE
16174  * - \ref SCIP_STAGE_FREETRANS
16175  */
16176 extern
16178  SCIP* scip, /**< SCIP data structure */
16179  SCIP_VAR* var, /**< transformed variable to catch event for */
16180  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
16181  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
16182  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
16183  int* filterpos /**< pointer to store position of event filter entry, or NULL */
16184  );
16185 
16186 /** drops an objective value or domain change event (stops to track event) on the given transformed variable
16187  *
16188  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16189  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16190  *
16191  * @pre This method can be called if @p scip is in one of the following stages:
16192  * - \ref SCIP_STAGE_TRANSFORMING
16193  * - \ref SCIP_STAGE_TRANSFORMED
16194  * - \ref SCIP_STAGE_INITPRESOLVE
16195  * - \ref SCIP_STAGE_PRESOLVING
16196  * - \ref SCIP_STAGE_EXITPRESOLVE
16197  * - \ref SCIP_STAGE_PRESOLVED
16198  * - \ref SCIP_STAGE_INITSOLVE
16199  * - \ref SCIP_STAGE_SOLVING
16200  * - \ref SCIP_STAGE_SOLVED
16201  * - \ref SCIP_STAGE_EXITSOLVE
16202  * - \ref SCIP_STAGE_FREETRANS
16203  */
16204 extern
16206  SCIP* scip, /**< SCIP data structure */
16207  SCIP_VAR* var, /**< transformed variable to drop event for */
16208  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
16209  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
16210  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
16211  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
16212  );
16213 
16214 /** catches a row coefficient, constant, or side change event on the given row
16215  *
16216  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16217  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16218  *
16219  * @pre This method can be called if @p scip is in one of the following stages:
16220  * - \ref SCIP_STAGE_TRANSFORMING
16221  * - \ref SCIP_STAGE_TRANSFORMED
16222  * - \ref SCIP_STAGE_INITPRESOLVE
16223  * - \ref SCIP_STAGE_PRESOLVING
16224  * - \ref SCIP_STAGE_EXITPRESOLVE
16225  * - \ref SCIP_STAGE_PRESOLVED
16226  * - \ref SCIP_STAGE_INITSOLVE
16227  * - \ref SCIP_STAGE_SOLVING
16228  * - \ref SCIP_STAGE_SOLVED
16229  * - \ref SCIP_STAGE_EXITSOLVE
16230  * - \ref SCIP_STAGE_FREETRANS
16231  */
16232 extern
16234  SCIP* scip, /**< SCIP data structure */
16235  SCIP_ROW* row, /**< linear row to catch event for */
16236  SCIP_EVENTTYPE eventtype, /**< event type mask to select events to catch */
16237  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
16238  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
16239  int* filterpos /**< pointer to store position of event filter entry, or NULL */
16240  );
16241 
16242 /** drops a row coefficient, constant, or side change event (stops to track event) on the given row
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 @p scip is in one of the following stages:
16248  * - \ref SCIP_STAGE_TRANSFORMING
16249  * - \ref SCIP_STAGE_TRANSFORMED
16250  * - \ref SCIP_STAGE_INITPRESOLVE
16251  * - \ref SCIP_STAGE_PRESOLVING
16252  * - \ref SCIP_STAGE_EXITPRESOLVE
16253  * - \ref SCIP_STAGE_PRESOLVED
16254  * - \ref SCIP_STAGE_INITSOLVE
16255  * - \ref SCIP_STAGE_SOLVING
16256  * - \ref SCIP_STAGE_SOLVED
16257  * - \ref SCIP_STAGE_EXITSOLVE
16258  * - \ref SCIP_STAGE_FREETRANS
16259  */
16260 extern
16262  SCIP* scip, /**< SCIP data structure */
16263  SCIP_ROW* row, /**< linear row to drop event for */
16264  SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */
16265  SCIP_EVENTHDLR* eventhdlr, /**< event handler to process events with */
16266  SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler when processing this event */
16267  int filterpos /**< position of event filter entry returned by SCIPcatchVarEvent(), or -1 */
16268  );
16269 
16270 /**@} */
16271 
16272 
16273 
16274 
16275 /*
16276  * tree methods
16277  */
16278 
16279 /**@name Tree Methods */
16280 /**@{ */
16281 
16282 /** gets current node in the tree
16283  *
16284  * @return the current node of the search tree
16285  *
16286  * @pre This method can be called if @p scip is in one of the following stages:
16287  * - \ref SCIP_STAGE_INITPRESOLVE
16288  * - \ref SCIP_STAGE_PRESOLVING
16289  * - \ref SCIP_STAGE_EXITPRESOLVE
16290  * - \ref SCIP_STAGE_SOLVING
16291  */
16292 extern
16294  SCIP* scip /**< SCIP data structure */
16295  );
16296 
16297 /** gets the root node of the tree
16298  *
16299  * @return the root node of the search tree
16300  *
16301  * @pre This method can be called if @p scip is in one of the following stages:
16302  * - \ref SCIP_STAGE_INITPRESOLVE
16303  * - \ref SCIP_STAGE_PRESOLVING
16304  * - \ref SCIP_STAGE_EXITPRESOLVE
16305  * - \ref SCIP_STAGE_SOLVING
16306  */
16307 extern
16309  SCIP* scip /**< SCIP data structure */
16310  );
16311 
16312 /** returns whether the current node is already solved and only propagated again
16313  *
16314  * @return TRUE is returned if \SCIP performance repropagation, otherwise FALSE.
16315  *
16316  * @pre This method can be called if @p scip is in one of the following stages:
16317  * - \ref SCIP_STAGE_INITPRESOLVE
16318  * - \ref SCIP_STAGE_PRESOLVING
16319  * - \ref SCIP_STAGE_EXITPRESOLVE
16320  * - \ref SCIP_STAGE_SOLVING
16321  */
16322 extern
16324  SCIP* scip /**< SCIP data structure */
16325  );
16326 
16327 /** gets children of focus node along with the number of children
16328  *
16329  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16330  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16331  *
16332  * @pre This method can be called if @p scip is in one of the following stages:
16333  * - \ref SCIP_STAGE_SOLVING
16334  */
16335 extern
16337  SCIP* scip, /**< SCIP data structure */
16338  SCIP_NODE*** children, /**< pointer to store children array, or NULL if not needed */
16339  int* nchildren /**< pointer to store number of children, or NULL if not needed */
16340  );
16341 
16342 /** gets number of children of focus node
16343  *
16344  * @return number of children of the focus node
16345  *
16346  * @pre This method can be called if @p scip is in one of the following stages:
16347  * - \ref SCIP_STAGE_SOLVING
16348  */
16349 extern
16350 int SCIPgetNChildren(
16351  SCIP* scip /**< SCIP data structure */
16352  );
16353 
16354 /** gets siblings of focus node along with the number of siblings
16355  *
16356  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16357  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16358  *
16359  * @pre This method can be called if @p scip is in one of the following stages:
16360  * - \ref SCIP_STAGE_SOLVING
16361  */
16362 extern
16364  SCIP* scip, /**< SCIP data structure */
16365  SCIP_NODE*** siblings, /**< pointer to store siblings array, or NULL if not needed */
16366  int* nsiblings /**< pointer to store number of siblings, or NULL if not needed */
16367  );
16368 
16369 /** gets number of siblings of focus node
16370  *
16371  * @return the number of siblings of focus node
16372  *
16373  * @pre This method can be called if @p scip is in one of the following stages:
16374  * - \ref SCIP_STAGE_SOLVING
16375  */
16376 extern
16377 int SCIPgetNSiblings(
16378  SCIP* scip /**< SCIP data structure */
16379  );
16380 
16381 /** gets leaves of the tree along with the number of leaves
16382  *
16383  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16384  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16385  *
16386  * @pre This method can be called if @p scip is in one of the following stages:
16387  * - \ref SCIP_STAGE_SOLVING
16388  */
16389 extern
16391  SCIP* scip, /**< SCIP data structure */
16392  SCIP_NODE*** leaves, /**< pointer to store leaves array, or NULL if not needed */
16393  int* nleaves /**< pointer to store number of leaves, or NULL if not needed */
16394  );
16395 
16396 /** gets number of leaves in the tree
16397  *
16398  * @return the number of leaves in the tree
16399  *
16400  * @pre This method can be called if @p scip is in one of the following stages:
16401  * - \ref SCIP_STAGE_SOLVING
16402  */
16403 extern
16404 int SCIPgetNLeaves(
16405  SCIP* scip /**< SCIP data structure */
16406  );
16407 
16408 /** gets the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
16409  *
16410  * @return the best child of the focus node w.r.t. the node selection priority assigned by the branching rule
16411  *
16412  * @pre This method can be called if @p scip is in one of the following stages:
16413  * - \ref SCIP_STAGE_SOLVING
16414  */
16415 extern
16417  SCIP* scip /**< SCIP data structure */
16418  );
16419 
16420 /** gets the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
16421  *
16422  * @return the best sibling of the focus node w.r.t. the node selection priority assigned by the branching rule
16423  *
16424  * @pre This method can be called if @p scip is in one of the following stages:
16425  * - \ref SCIP_STAGE_SOLVING
16426  */
16427 extern
16429  SCIP* scip /**< SCIP data structure */
16430  );
16431 
16432 /** gets the best child of the focus node w.r.t. the node selection strategy
16433  *
16434  * @return the best child of the focus node w.r.t. the node selection strategy
16435  *
16436  * @pre This method can be called if @p scip is in one of the following stages:
16437  * - \ref SCIP_STAGE_SOLVING
16438  */
16439 extern
16441  SCIP* scip /**< SCIP data structure */
16442  );
16443 
16444 /** gets the best sibling of the focus node w.r.t. the node selection strategy
16445  *
16446  * @return the best sibling of the focus node w.r.t. the node selection strategy
16447  *
16448  * @pre This method can be called if @p scip is in one of the following stages:
16449  * - \ref SCIP_STAGE_SOLVING
16450  */
16451 extern
16453  SCIP* scip /**< SCIP data structure */
16454  );
16455 
16456 /** gets the best leaf from the node queue w.r.t. the node selection strategy
16457  *
16458  * @return the best leaf from the node queue w.r.t. the node selection strategy
16459  *
16460  * @pre This method can be called if @p scip is in one of the following stages:
16461  * - \ref SCIP_STAGE_SOLVING
16462  */
16463 extern
16465  SCIP* scip /**< SCIP data structure */
16466  );
16467 
16468 /** gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
16469  *
16470  * @return the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy
16471  *
16472  * @pre This method can be called if @p scip is in one of the following stages:
16473  * - \ref SCIP_STAGE_SOLVING
16474  */
16475 extern
16477  SCIP* scip /**< SCIP data structure */
16478  );
16479 
16480 /** gets the node with smallest lower bound from the tree (child, sibling, or leaf)
16481  *
16482  * @return the node with smallest lower bound from the tree (child, sibling, or leaf)
16483  *
16484  * @pre This method can be called if @p scip is in one of the following stages:
16485  * - \ref SCIP_STAGE_SOLVING
16486  */
16487 extern
16489  SCIP* scip /**< SCIP data structure */
16490  );
16491 
16492 /** access to all data of open nodes (leaves, children, and siblings)
16493  *
16494  * @pre This method can be called if @p scip is in one of the following stages:
16495  * - \ref SCIP_STAGE_SOLVING
16496  */
16497 extern
16499  SCIP* scip, /**< SCIP data structure */
16500  SCIP_NODE*** leaves, /**< pointer to store the leaves, or NULL if not needed */
16501  SCIP_NODE*** children, /**< pointer to store the children, or NULL if not needed */
16502  SCIP_NODE*** siblings, /**< pointer to store the siblings, or NULL if not needed */
16503  int* nleaves, /**< pointer to store the number of leaves, or NULL */
16504  int* nchildren, /**< pointer to store the number of children, or NULL */
16505  int* nsiblings /**< pointer to store the number of siblings, or NULL */
16506  );
16507 
16508 /** cuts off node and whole sub tree from branch and bound tree
16509  *
16510  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16511  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16512  *
16513  * @pre This method can be called if @p scip is in one of the following stages:
16514  * - \ref SCIP_STAGE_SOLVING
16515  */
16516 extern
16518  SCIP* scip, /**< SCIP data structure */
16519  SCIP_NODE* node /**< node that should be cut off */
16520  );
16521 
16522 /** marks the given node to be propagated again the next time a node of its subtree is processed
16523  *
16524  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16525  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16526  *
16527  * @pre This method can be called if @p scip is in one of the following stages:
16528  * - \ref SCIP_STAGE_SOLVING
16529  */
16530 extern
16532  SCIP* scip, /**< SCIP data structure */
16533  SCIP_NODE* node /**< node that should be propagated again */
16534  );
16535 
16536 /** returns depth of first node in active path that is marked being cutoff
16537  *
16538  * @return depth of first node in active path that is marked being cutoff
16539  *
16540  * @pre This method can be called if @p scip is in one of the following stages:
16541  * - \ref SCIP_STAGE_SOLVING
16542  */
16543 extern
16544 int SCIPgetCutoffdepth(
16545  SCIP* scip /**< SCIP data structure */
16546  );
16547 
16548 /** returns depth of first node in active path that has to be propagated again
16549  *
16550  * @return depth of first node in active path that has to be propagated again
16551  *
16552  * @pre This method can be called if @p scip is in one of the following stages:
16553  * - \ref SCIP_STAGE_SOLVING
16554  */
16555 extern
16556 int SCIPgetRepropdepth(
16557  SCIP* scip /**< SCIP data structure */
16558  );
16559 
16560 /** prints all branching decisions on variables from the root to the given node
16561  *
16562  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
16563  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
16564  *
16565  * @pre This method can be called if @p scip is in one of the following stages:
16566  * - \ref SCIP_STAGE_SOLVING
16567  */
16568 extern
16570  SCIP* scip, /**< SCIP data structure */
16571  SCIP_NODE* node, /**< node data */
16572  FILE* file /**< output file (or NULL for standard output) */
16573  );
16574 
16575 /**@} */
16576 
16577 
16578 /*
16579  * statistic methods
16580  */
16581 
16582 /**@name Statistic Methods */
16583 /**@{ */
16584 
16585 /** gets number of branch and bound runs performed, including the current run
16586  *
16587  * @return the number of branch and bound runs performed, including the current run
16588  *
16589  * @pre This method can be called if SCIP is in one of the following stages:
16590  * - \ref SCIP_STAGE_PROBLEM
16591  * - \ref SCIP_STAGE_TRANSFORMING
16592  * - \ref SCIP_STAGE_TRANSFORMED
16593  * - \ref SCIP_STAGE_INITPRESOLVE
16594  * - \ref SCIP_STAGE_PRESOLVING
16595  * - \ref SCIP_STAGE_EXITPRESOLVE
16596  * - \ref SCIP_STAGE_PRESOLVED
16597  * - \ref SCIP_STAGE_INITSOLVE
16598  * - \ref SCIP_STAGE_SOLVING
16599  * - \ref SCIP_STAGE_SOLVED
16600  * - \ref SCIP_STAGE_EXITSOLVE
16601  * - \ref SCIP_STAGE_FREETRANS
16602  */
16603 extern
16604 int SCIPgetNRuns(
16605  SCIP* scip /**< SCIP data structure */
16606  );
16607 
16608 /** gets number of processed nodes in current run, including the focus node
16609  *
16610  * @return the number of processed nodes in current run, including the focus node
16611  *
16612  * @pre This method can be called if SCIP is in one of the following stages:
16613  * - \ref SCIP_STAGE_PROBLEM
16614  * - \ref SCIP_STAGE_TRANSFORMING
16615  * - \ref SCIP_STAGE_TRANSFORMED
16616  * - \ref SCIP_STAGE_INITPRESOLVE
16617  * - \ref SCIP_STAGE_PRESOLVING
16618  * - \ref SCIP_STAGE_EXITPRESOLVE
16619  * - \ref SCIP_STAGE_PRESOLVED
16620  * - \ref SCIP_STAGE_INITSOLVE
16621  * - \ref SCIP_STAGE_SOLVING
16622  * - \ref SCIP_STAGE_SOLVED
16623  * - \ref SCIP_STAGE_EXITSOLVE
16624  * - \ref SCIP_STAGE_FREETRANS
16625  */
16626 extern
16628  SCIP* scip /**< SCIP data structure */
16629  );
16630 
16631 /** gets total number of processed nodes in all runs, including the focus node
16632  *
16633  * @return the total number of processed nodes in all runs, including the focus node
16634  *
16635  * @pre This method can be called if SCIP is in one of the following stages:
16636  * - \ref SCIP_STAGE_PROBLEM
16637  * - \ref SCIP_STAGE_TRANSFORMING
16638  * - \ref SCIP_STAGE_TRANSFORMED
16639  * - \ref SCIP_STAGE_INITPRESOLVE
16640  * - \ref SCIP_STAGE_PRESOLVING
16641  * - \ref SCIP_STAGE_EXITPRESOLVE
16642  * - \ref SCIP_STAGE_PRESOLVED
16643  * - \ref SCIP_STAGE_INITSOLVE
16644  * - \ref SCIP_STAGE_SOLVING
16645  * - \ref SCIP_STAGE_SOLVED
16646  * - \ref SCIP_STAGE_EXITSOLVE
16647  * - \ref SCIP_STAGE_FREETRANS
16648  */
16649 extern
16651  SCIP* scip /**< SCIP data structure */
16652  );
16653 
16654 /** gets number of nodes left in the tree (children + siblings + leaves)
16655  *
16656  * @return the number of nodes left in the tree (children + siblings + leaves)
16657  *
16658  * @pre This method can be called if SCIP is in one of the following stages:
16659  * - \ref SCIP_STAGE_PRESOLVED
16660  * - \ref SCIP_STAGE_SOLVING
16661  * - \ref SCIP_STAGE_SOLVED
16662  */
16663 extern
16664 int SCIPgetNNodesLeft(
16665  SCIP* scip /**< SCIP data structure */
16666  );
16667 
16668 /** gets total number of LPs solved so far
16669  *
16670  * @return the total number of LPs solved so far
16671  *
16672  * @pre This method can be called if SCIP is in one of the following stages:
16673  * - \ref SCIP_STAGE_PRESOLVED
16674  * - \ref SCIP_STAGE_SOLVING
16675  * - \ref SCIP_STAGE_SOLVED
16676  */
16677 extern
16679  SCIP* scip /**< SCIP data structure */
16680  );
16681 
16682 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
16683  *
16684  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
16685  *
16686  * @pre This method can be called if SCIP is in one of the following stages:
16687  * - \ref SCIP_STAGE_PRESOLVING
16688  * - \ref SCIP_STAGE_PRESOLVED
16689  * - \ref SCIP_STAGE_SOLVING
16690  * - \ref SCIP_STAGE_SOLVED
16691  */
16692 extern
16694  SCIP* scip /**< SCIP data structure */
16695  );
16696 
16697 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
16698  *
16699  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
16700  *
16701  * @pre This method can be called if SCIP is in one of the following stages:
16702  * - \ref SCIP_STAGE_PRESOLVED
16703  * - \ref SCIP_STAGE_SOLVING
16704  * - \ref SCIP_STAGE_SOLVED
16705  */
16706 extern
16708  SCIP* scip /**< SCIP data structure */
16709  );
16710 
16711 /** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
16712  * node
16713  *
16714  * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
16715  *
16716  * @pre This method can be called if SCIP is in one of the following stages:
16717  * - \ref SCIP_STAGE_PRESOLVED
16718  * - \ref SCIP_STAGE_SOLVING
16719  * - \ref SCIP_STAGE_SOLVED
16720  */
16721 extern
16723  SCIP* scip /**< SCIP data structure */
16724  );
16725 
16726 /** gets total number of primal LPs solved so far
16727  *
16728  * @return the total number of primal LPs solved so far
16729  *
16730  * @pre This method can be called if SCIP is in one of the following stages:
16731  * - \ref SCIP_STAGE_PRESOLVED
16732  * - \ref SCIP_STAGE_SOLVING
16733  * - \ref SCIP_STAGE_SOLVED
16734  */
16735 extern
16737  SCIP* scip /**< SCIP data structure */
16738  );
16739 
16740 /** gets total number of iterations used so far in primal simplex
16741  *
16742  * @return total number of iterations used so far in primal simplex
16743  *
16744  * @pre This method can be called if SCIP is in one of the following stages:
16745  * - \ref SCIP_STAGE_PRESOLVED
16746  * - \ref SCIP_STAGE_SOLVING
16747  * - \ref SCIP_STAGE_SOLVED
16748  */
16749 extern
16751  SCIP* scip /**< SCIP data structure */
16752  );
16753 
16754 /** gets total number of dual LPs solved so far
16755  *
16756  * @return the total number of dual LPs solved so far
16757  *
16758  * @pre This method can be called if SCIP is in one of the following stages:
16759  * - \ref SCIP_STAGE_PRESOLVED
16760  * - \ref SCIP_STAGE_SOLVING
16761  * - \ref SCIP_STAGE_SOLVED
16762  */
16763 extern
16765  SCIP* scip /**< SCIP data structure */
16766  );
16767 
16768 /** gets total number of iterations used so far in dual simplex
16769  *
16770  * @return the total number of iterations used so far in dual simplex
16771  *
16772  * @pre This method can be called if SCIP is in one of the following stages:
16773  * - \ref SCIP_STAGE_PRESOLVED
16774  * - \ref SCIP_STAGE_SOLVING
16775  * - \ref SCIP_STAGE_SOLVED
16776  */
16777 extern
16779  SCIP* scip /**< SCIP data structure */
16780  );
16781 
16782 /** gets total number of barrier LPs solved so far
16783  *
16784  * @return the total number of barrier LPs solved so far
16785  *
16786  * @pre This method can be called if SCIP is in one of the following stages:
16787  * - \ref SCIP_STAGE_PRESOLVED
16788  * - \ref SCIP_STAGE_SOLVING
16789  * - \ref SCIP_STAGE_SOLVED
16790  */
16791 extern
16793  SCIP* scip /**< SCIP data structure */
16794  );
16795 
16796 /** gets total number of iterations used so far in barrier algorithm
16797  *
16798  * @return the total number of iterations used so far in barrier algorithm
16799  *
16800  * @pre This method can be called if SCIP is in one of the following stages:
16801  * - \ref SCIP_STAGE_PRESOLVED
16802  * - \ref SCIP_STAGE_SOLVING
16803  * - \ref SCIP_STAGE_SOLVED
16804  */
16805 extern
16807  SCIP* scip /**< SCIP data structure */
16808  );
16809 
16810 /** gets total number of LPs solved so far that were resolved from an advanced start basis
16811  *
16812  * @return the total number of LPs solved so far that were resolved from an advanced start basis
16813  *
16814  * @pre This method can be called if SCIP is in one of the following stages:
16815  * - \ref SCIP_STAGE_PRESOLVED
16816  * - \ref SCIP_STAGE_SOLVING
16817  * - \ref SCIP_STAGE_SOLVED
16818  */
16819 extern
16821  SCIP* scip /**< SCIP data structure */
16822  );
16823 
16824 /** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
16825  * was available
16826  *
16827  * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
16828  * basis was available
16829  *
16830  * @pre This method can be called if SCIP is in one of the following stages:
16831  * - \ref SCIP_STAGE_PRESOLVED
16832  * - \ref SCIP_STAGE_SOLVING
16833  * - \ref SCIP_STAGE_SOLVED
16834  */
16835 extern
16837  SCIP* scip /**< SCIP data structure */
16838  );
16839 
16840 /** gets total number of primal LPs solved so far that were resolved from an advanced start basis
16841  *
16842  * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
16843  *
16844  * @pre This method can be called if SCIP is in one of the following stages:
16845  * - \ref SCIP_STAGE_PRESOLVED
16846  * - \ref SCIP_STAGE_SOLVING
16847  * - \ref SCIP_STAGE_SOLVED
16848  */
16849 extern
16851  SCIP* scip /**< SCIP data structure */
16852  );
16853 
16854 /** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
16855  * was available
16856  *
16857  * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
16858  * basis was available
16859  *
16860  * @pre This method can be called if SCIP is in one of the following stages:
16861  * - \ref SCIP_STAGE_PRESOLVED
16862  * - \ref SCIP_STAGE_SOLVING
16863  * - \ref SCIP_STAGE_SOLVED
16864  */
16865 extern
16867  SCIP* scip /**< SCIP data structure */
16868  );
16869 
16870 /** gets total number of dual LPs solved so far that were resolved from an advanced start basis
16871  *
16872  * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
16873  *
16874  * @pre This method can be called if SCIP is in one of the following stages:
16875  * - \ref SCIP_STAGE_PRESOLVED
16876  * - \ref SCIP_STAGE_SOLVING
16877  * - \ref SCIP_STAGE_SOLVED
16878  */
16879 extern
16881  SCIP* scip /**< SCIP data structure */
16882  );
16883 
16884 /** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
16885  * was available
16886  *
16887  * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
16888  * basis was available
16889  *
16890  * @pre This method can be called if SCIP is in one of the following stages:
16891  * - \ref SCIP_STAGE_PRESOLVED
16892  * - \ref SCIP_STAGE_SOLVING
16893  * - \ref SCIP_STAGE_SOLVED
16894  */
16895 extern
16897  SCIP* scip /**< SCIP data structure */
16898  );
16899 
16900 /** gets total number of LPs solved so far for node relaxations
16901  *
16902  * @return the total number of LPs solved so far for node relaxations
16903  *
16904  * @pre This method can be called if SCIP is in one of the following stages:
16905  * - \ref SCIP_STAGE_PRESOLVED
16906  * - \ref SCIP_STAGE_SOLVING
16907  * - \ref SCIP_STAGE_SOLVED
16908  */
16909 extern
16911  SCIP* scip /**< SCIP data structure */
16912  );
16913 
16914 /** gets total number of simplex iterations used so far for node relaxations
16915  *
16916  * @return the total number of simplex iterations used so far for node relaxations
16917  *
16918  * @pre This method can be called if SCIP is in one of the following stages:
16919  * - \ref SCIP_STAGE_PRESOLVED
16920  * - \ref SCIP_STAGE_SOLVING
16921  * - \ref SCIP_STAGE_SOLVED
16922  */
16923 extern
16925  SCIP* scip /**< SCIP data structure */
16926  );
16927 
16928 /** gets total number of LPs solved so far for initial LP in node relaxations
16929  *
16930  * @return the total number of LPs solved so far for initial LP in node relaxations
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  * - \ref SCIP_STAGE_SOLVED
16936  */
16937 extern
16939  SCIP* scip /**< SCIP data structure */
16940  );
16941 
16942 /** gets total number of simplex iterations used so far for initial LP in node relaxations
16943  *
16944  * @return the total number of simplex iterations used so far for initial LP in node relaxations
16945  *
16946  * @pre This method can be called if SCIP is in one of the following stages:
16947  * - \ref SCIP_STAGE_PRESOLVED
16948  * - \ref SCIP_STAGE_SOLVING
16949  * - \ref SCIP_STAGE_SOLVED
16950  */
16951 extern
16953  SCIP* scip /**< SCIP data structure */
16954  );
16955 
16956 /** gets total number of LPs solved so far during diving and probing
16957  *
16958  * @return total number of LPs solved so far during diving and probing
16959  *
16960  * @pre This method can be called if SCIP is in one of the following stages:
16961  * - \ref SCIP_STAGE_PRESOLVED
16962  * - \ref SCIP_STAGE_SOLVING
16963  * - \ref SCIP_STAGE_SOLVED
16964  */
16965 extern
16967  SCIP* scip /**< SCIP data structure */
16968  );
16969 
16970 /** gets total number of simplex iterations used so far during diving and probing
16971  *
16972  * @return the total number of simplex iterations used so far during diving and probing
16973  *
16974  * @pre This method can be called if SCIP is in one of the following stages:
16975  * - \ref SCIP_STAGE_PRESOLVED
16976  * - \ref SCIP_STAGE_SOLVING
16977  * - \ref SCIP_STAGE_SOLVED
16978  */
16979 extern
16981  SCIP* scip /**< SCIP data structure */
16982  );
16983 
16984 /** gets total number of times, strong branching was called (each call represents solving two LPs)
16985  *
16986  * @return the total number of times, strong branching was called (each call represents solving two LPs)
16987  *
16988  * @pre This method can be called if SCIP is in one of the following stages:
16989  * - \ref SCIP_STAGE_PRESOLVED
16990  * - \ref SCIP_STAGE_SOLVING
16991  * - \ref SCIP_STAGE_SOLVED
16992  */
16993 extern
16995  SCIP* scip /**< SCIP data structure */
16996  );
16997 
16998 /** gets total number of simplex iterations used so far in strong branching
16999  *
17000  * @return the total number of simplex iterations used so far in strong branching
17001  *
17002  * @pre This method can be called if SCIP is in one of the following stages:
17003  * - \ref SCIP_STAGE_PRESOLVED
17004  * - \ref SCIP_STAGE_SOLVING
17005  * - \ref SCIP_STAGE_SOLVED
17006  */
17007 extern
17009  SCIP* scip /**< SCIP data structure */
17010  );
17011 
17012 /** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
17013  *
17014  * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
17015  *
17016  * @pre This method can be called if SCIP is in one of the following stages:
17017  * - \ref SCIP_STAGE_PRESOLVED
17018  * - \ref SCIP_STAGE_SOLVING
17019  * - \ref SCIP_STAGE_SOLVED
17020  */
17021 extern
17023  SCIP* scip /**< SCIP data structure */
17024  );
17025 
17026 /** gets total number of simplex iterations used so far in strong branching at the root node
17027  *
17028  * @return the total number of simplex iterations used so far in strong branching at the root node
17029  *
17030  * @pre This method can be called if SCIP is in one of the following stages:
17031  * - \ref SCIP_STAGE_PRESOLVED
17032  * - \ref SCIP_STAGE_SOLVING
17033  * - \ref SCIP_STAGE_SOLVED
17034  */
17035 extern
17037  SCIP* scip /**< SCIP data structure */
17038  );
17039 
17040 /** gets number of pricing rounds performed so far at the current node
17041  *
17042  * @return the number of pricing rounds performed so far at the current node
17043  *
17044  * @pre This method can be called if SCIP is in one of the following stages:
17045  * - \ref SCIP_STAGE_SOLVING
17046  */
17047 extern
17049  SCIP* scip /**< SCIP data structure */
17050  );
17051 
17052 /** get current number of variables in the pricing store
17053  *
17054  * @return the current number of variables in the pricing store
17055  *
17056  * @pre This method can be called if SCIP is in one of the following stages:
17057  * - \ref SCIP_STAGE_PRESOLVED
17058  * - \ref SCIP_STAGE_SOLVING
17059  * - \ref SCIP_STAGE_SOLVED
17060  */
17061 extern
17062 int SCIPgetNPricevars(
17063  SCIP* scip /**< SCIP data structure */
17064  );
17065 
17066 /** get total number of pricing variables found so far
17067  *
17068  * @return the total number of pricing variables found so far
17069  *
17070  * @pre This method can be called if SCIP is in one of the following stages:
17071  * - \ref SCIP_STAGE_PRESOLVED
17072  * - \ref SCIP_STAGE_SOLVING
17073  * - \ref SCIP_STAGE_SOLVED
17074  */
17075 extern
17077  SCIP* scip /**< SCIP data structure */
17078  );
17079 
17080 /** get total number of pricing variables applied to the LPs
17081  *
17082  * @return the total number of pricing variables applied to the LPs
17083  *
17084  * @pre This method can be called if SCIP is in one of the following stages:
17085  * - \ref SCIP_STAGE_PRESOLVED
17086  * - \ref SCIP_STAGE_SOLVING
17087  * - \ref SCIP_STAGE_SOLVED
17088  */
17089 extern
17091  SCIP* scip /**< SCIP data structure */
17092  );
17093 
17094 /** gets number of separation rounds performed so far at the current node
17095  *
17096  * @return the number of separation rounds performed so far at the current node
17097  *
17098  * @pre This method can be called if SCIP is in one of the following stages:
17099  * - \ref SCIP_STAGE_SOLVING
17100  */
17101 extern
17102 int SCIPgetNSepaRounds(
17103  SCIP* scip /**< SCIP data structure */
17104  );
17105 
17106 /** get total number of cuts found so far
17107  *
17108  * @return the total number of cuts found so far
17109  *
17110  * @pre This method can be called if SCIP is in one of the following stages:
17111  * - \ref SCIP_STAGE_PRESOLVED
17112  * - \ref SCIP_STAGE_SOLVING
17113  * - \ref SCIP_STAGE_SOLVED
17114  */
17115 extern
17116 int SCIPgetNCutsFound(
17117  SCIP* scip /**< SCIP data structure */
17118  );
17119 
17120 /** get number of cuts found so far in current separation round
17121  *
17122  * @return the number of cuts found so far in current separation round
17123  *
17124  * @pre This method can be called if SCIP is in one of the following stages:
17125  * - \ref SCIP_STAGE_PRESOLVED
17126  * - \ref SCIP_STAGE_SOLVING
17127  * - \ref SCIP_STAGE_SOLVED
17128  */
17129 extern
17131  SCIP* scip /**< SCIP data structure */
17132  );
17133 
17134 /** get total number of cuts applied to the LPs
17135  *
17136  * @return the total number of cuts applied to the LPs
17137  *
17138  * @pre This method can be called if SCIP is in one of the following stages:
17139  * - \ref SCIP_STAGE_PRESOLVED
17140  * - \ref SCIP_STAGE_SOLVING
17141  * - \ref SCIP_STAGE_SOLVED
17142  */
17143 extern
17145  SCIP* scip /**< SCIP data structure */
17146  );
17147 
17148 /** get total number of constraints found in conflict analysis (conflict and reconvergence constraints)
17149  *
17150  * @return the total number of constraints found in conflict analysis (conflict and reconvergence constraints)
17151  *
17152  * @pre This method can be called if SCIP is in one of the following stages:
17153  * - \ref SCIP_STAGE_TRANSFORMED
17154  * - \ref SCIP_STAGE_INITPRESOLVE
17155  * - \ref SCIP_STAGE_PRESOLVING
17156  * - \ref SCIP_STAGE_EXITPRESOLVE
17157  * - \ref SCIP_STAGE_PRESOLVED
17158  * - \ref SCIP_STAGE_INITSOLVE
17159  * - \ref SCIP_STAGE_SOLVING
17160  * - \ref SCIP_STAGE_SOLVED
17161  * - \ref SCIP_STAGE_EXITSOLVE
17162  */
17163 extern
17165  SCIP* scip /**< SCIP data structure */
17166  );
17167 
17168 /** get number of conflict constraints found so far at the current node
17169  *
17170  * @return the number of conflict constraints found so far at the current node
17171  *
17172  * @pre This method can be called if SCIP is in one of the following stages:
17173  * - \ref SCIP_STAGE_TRANSFORMED
17174  * - \ref SCIP_STAGE_INITPRESOLVE
17175  * - \ref SCIP_STAGE_PRESOLVING
17176  * - \ref SCIP_STAGE_EXITPRESOLVE
17177  * - \ref SCIP_STAGE_PRESOLVED
17178  * - \ref SCIP_STAGE_INITSOLVE
17179  * - \ref SCIP_STAGE_SOLVING
17180  * - \ref SCIP_STAGE_SOLVED
17181  * - \ref SCIP_STAGE_EXITSOLVE
17182  */
17183 extern
17185  SCIP* scip /**< SCIP data structure */
17186  );
17187 
17188 /** get total number of conflict constraints added to the problem
17189  *
17190  * @return the total number of conflict constraints added to the problem
17191  *
17192  * @pre This method can be called if SCIP is in one of the following stages:
17193  * - \ref SCIP_STAGE_TRANSFORMED
17194  * - \ref SCIP_STAGE_INITPRESOLVE
17195  * - \ref SCIP_STAGE_PRESOLVING
17196  * - \ref SCIP_STAGE_EXITPRESOLVE
17197  * - \ref SCIP_STAGE_PRESOLVED
17198  * - \ref SCIP_STAGE_INITSOLVE
17199  * - \ref SCIP_STAGE_SOLVING
17200  * - \ref SCIP_STAGE_SOLVED
17201  * - \ref SCIP_STAGE_EXITSOLVE
17202  */
17203 extern
17205  SCIP* scip /**< SCIP data structure */
17206  );
17207 
17208 /** gets depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
17209  * such that the depth includes the probing path
17210  *
17211  * @return the depth of current node, or -1 if no current node exists; in probing, the current node is the last probing node,
17212  * such that the depth includes the probing path
17213  *
17214  * @pre This method can be called if SCIP is in one of the following stages:
17215  * - \ref SCIP_STAGE_TRANSFORMED
17216  * - \ref SCIP_STAGE_INITPRESOLVE
17217  * - \ref SCIP_STAGE_PRESOLVING
17218  * - \ref SCIP_STAGE_EXITPRESOLVE
17219  * - \ref SCIP_STAGE_PRESOLVED
17220  * - \ref SCIP_STAGE_INITSOLVE
17221  * - \ref SCIP_STAGE_SOLVING
17222  * - \ref SCIP_STAGE_SOLVED
17223  * - \ref SCIP_STAGE_EXITSOLVE
17224  */
17225 extern
17226 int SCIPgetDepth(
17227  SCIP* scip /**< SCIP data structure */
17228  );
17229 
17230 /** gets depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
17231  * branching tree, excluding the nodes of the probing path
17232  *
17233  * @return the depth of the focus node, or -1 if no focus node exists; the focus node is the currently processed node in the
17234  * branching tree, excluding the nodes of the probing path
17235  *
17236  * @pre This method can be called if SCIP is in one of the following stages:
17237  * - \ref SCIP_STAGE_TRANSFORMED
17238  * - \ref SCIP_STAGE_INITPRESOLVE
17239  * - \ref SCIP_STAGE_PRESOLVING
17240  * - \ref SCIP_STAGE_EXITPRESOLVE
17241  * - \ref SCIP_STAGE_PRESOLVED
17242  * - \ref SCIP_STAGE_INITSOLVE
17243  * - \ref SCIP_STAGE_SOLVING
17244  * - \ref SCIP_STAGE_SOLVED
17245  * - \ref SCIP_STAGE_EXITSOLVE
17246  */
17247 extern
17248 int SCIPgetFocusDepth(
17249  SCIP* scip /**< SCIP data structure */
17250  );
17251 
17252 /** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
17253  *
17254  * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
17255  *
17256  * @pre This method can be called if SCIP is in one of the following stages:
17257  * - \ref SCIP_STAGE_TRANSFORMED
17258  * - \ref SCIP_STAGE_INITPRESOLVE
17259  * - \ref SCIP_STAGE_PRESOLVING
17260  * - \ref SCIP_STAGE_EXITPRESOLVE
17261  * - \ref SCIP_STAGE_PRESOLVED
17262  * - \ref SCIP_STAGE_INITSOLVE
17263  * - \ref SCIP_STAGE_SOLVING
17264  * - \ref SCIP_STAGE_SOLVED
17265  * - \ref SCIP_STAGE_EXITSOLVE
17266  */
17267 extern
17268 int SCIPgetMaxDepth(
17269  SCIP* scip /**< SCIP data structure */
17270  );
17271 
17272 /** gets maximal depth of all processed nodes over all branch and bound runs
17273  *
17274  * @return the maximal depth of all processed nodes over all branch and bound runs
17275  *
17276  * @pre This method can be called if SCIP is in one of the following stages:
17277  * - \ref SCIP_STAGE_TRANSFORMED
17278  * - \ref SCIP_STAGE_INITPRESOLVE
17279  * - \ref SCIP_STAGE_PRESOLVING
17280  * - \ref SCIP_STAGE_EXITPRESOLVE
17281  * - \ref SCIP_STAGE_PRESOLVED
17282  * - \ref SCIP_STAGE_INITSOLVE
17283  * - \ref SCIP_STAGE_SOLVING
17284  * - \ref SCIP_STAGE_SOLVED
17285  * - \ref SCIP_STAGE_EXITSOLVE
17286  */
17287 extern
17289  SCIP* scip /**< SCIP data structure */
17290  );
17291 
17292 /** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
17293  *
17294  * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
17295  *
17296  * @pre This method can be called if SCIP is in one of the following stages:
17297  * - \ref SCIP_STAGE_TRANSFORMED
17298  * - \ref SCIP_STAGE_INITPRESOLVE
17299  * - \ref SCIP_STAGE_PRESOLVING
17300  * - \ref SCIP_STAGE_EXITPRESOLVE
17301  * - \ref SCIP_STAGE_PRESOLVED
17302  * - \ref SCIP_STAGE_INITSOLVE
17303  * - \ref SCIP_STAGE_SOLVING
17304  * - \ref SCIP_STAGE_SOLVED
17305  * - \ref SCIP_STAGE_EXITSOLVE
17306  */
17307 extern
17309  SCIP* scip /**< SCIP data structure */
17310  );
17311 
17312 /** gets current plunging depth (successive times, a child was selected as next node)
17313  *
17314  * @return the current plunging depth (successive times, a child was selected as next node)
17315  *
17316  * @pre This method can be called if SCIP is in one of the following stages:
17317  * - \ref SCIP_STAGE_PRESOLVED
17318  * - \ref SCIP_STAGE_SOLVING
17319  */
17320 extern
17321 int SCIPgetPlungeDepth(
17322  SCIP* scip /**< SCIP data structure */
17323  );
17324 
17325 /** gets total number of active constraints at the current node
17326  *
17327  * @return the total number of active constraints at the current node
17328  *
17329  * @pre This method can be called if SCIP is in one of the following stages:
17330  * - \ref SCIP_STAGE_PRESOLVED
17331  * - \ref SCIP_STAGE_SOLVING
17332  */
17333 extern
17335  SCIP* scip /**< SCIP data structure */
17336  );
17337 
17338 /** gets total number of enabled constraints at the current node
17339  *
17340  * @return the total number of enabled constraints at the current node
17341  *
17342  * @pre This method can be called if SCIP is in one of the following stages:
17343  * - \ref SCIP_STAGE_PRESOLVED
17344  * - \ref SCIP_STAGE_SOLVING
17345  */
17346 extern
17348  SCIP* scip /**< SCIP data structure */
17349  );
17350 
17351 /** gets average dual bound of all unprocessed nodes for original problem */
17352 extern
17354  SCIP* scip /**< SCIP data structure */
17355  );
17356 
17357 /** gets average lower (dual) bound of all unprocessed nodes in transformed problem
17358  *
17359  * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
17360  *
17361  * @pre This method can be called if SCIP is in one of the following stages:
17362  * - \ref SCIP_STAGE_PRESOLVED
17363  * - \ref SCIP_STAGE_SOLVING
17364  * - \ref SCIP_STAGE_SOLVED
17365  */
17366 extern
17368  SCIP* scip /**< SCIP data structure */
17369  );
17370 
17371 /** gets global dual bound
17372  *
17373  * @return the global dual bound
17374  *
17375  * @pre This method can be called if SCIP is in one of the following stages:
17376  * - \ref SCIP_STAGE_PRESOLVING
17377  * - \ref SCIP_STAGE_EXITPRESOLVE
17378  * - \ref SCIP_STAGE_PRESOLVED
17379  * - \ref SCIP_STAGE_INITSOLVE
17380  * - \ref SCIP_STAGE_SOLVING
17381  * - \ref SCIP_STAGE_SOLVED
17382  */
17383 extern
17385  SCIP* scip /**< SCIP data structure */
17386  );
17387 
17388 /** gets global lower (dual) bound in transformed problem
17389  *
17390  * @return the global lower (dual) bound in transformed problem
17391  *
17392  * @pre This method can be called if SCIP is in one of the following stages:
17393  * - \ref SCIP_STAGE_PRESOLVING
17394  * - \ref SCIP_STAGE_EXITPRESOLVE
17395  * - \ref SCIP_STAGE_PRESOLVED
17396  * - \ref SCIP_STAGE_INITSOLVE
17397  * - \ref SCIP_STAGE_SOLVING
17398  * - \ref SCIP_STAGE_SOLVED
17399  */
17400 extern
17402  SCIP* scip /**< SCIP data structure */
17403  );
17404 
17405 /** gets dual bound of the root node for the original problem
17406  *
17407  * @return the dual bound of the root node for the original problem
17408  *
17409  * @pre This method can be called if SCIP is in one of the following stages:
17410  * - \ref SCIP_STAGE_PRESOLVING
17411  * - \ref SCIP_STAGE_EXITPRESOLVE
17412  * - \ref SCIP_STAGE_PRESOLVED
17413  * - \ref SCIP_STAGE_INITSOLVE
17414  * - \ref SCIP_STAGE_SOLVING
17415  * - \ref SCIP_STAGE_SOLVED
17416  */
17417 extern
17419  SCIP* scip /**< SCIP data structure */
17420  );
17421 
17422 /** gets lower (dual) bound in transformed problem of the root node
17423  *
17424  * @return the lower (dual) bound in transformed problem of the root node
17425  *
17426  * @pre This method can be called if SCIP is in one of the following stages:
17427  * - \ref SCIP_STAGE_PRESOLVING
17428  * - \ref SCIP_STAGE_EXITPRESOLVE
17429  * - \ref SCIP_STAGE_PRESOLVED
17430  * - \ref SCIP_STAGE_INITSOLVE
17431  * - \ref SCIP_STAGE_SOLVING
17432  * - \ref SCIP_STAGE_SOLVED
17433  */
17434 extern
17436  SCIP* scip /**< SCIP data structure */
17437  );
17438 
17439 /** gets dual bound for the original problem obtained by the first LP solve at the root node
17440  *
17441  * @return the dual bound for the original problem of the first LP solve at the root node
17442  *
17443  * @pre This method can be called if SCIP is in one of the following stages:
17444  * - \ref SCIP_STAGE_PRESOLVING
17445  * - \ref SCIP_STAGE_EXITPRESOLVE
17446  * - \ref SCIP_STAGE_PRESOLVED
17447  * - \ref SCIP_STAGE_INITSOLVE
17448  * - \ref SCIP_STAGE_SOLVING
17449  * - \ref SCIP_STAGE_SOLVED
17450  */
17451 extern
17453  SCIP* scip /**< SCIP data structure */
17454  );
17455 
17456 /** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
17457  *
17458  * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
17459  *
17460  * @pre This method can be called if SCIP is in one of the following stages:
17461  * - \ref SCIP_STAGE_PRESOLVING
17462  * - \ref SCIP_STAGE_EXITPRESOLVE
17463  * - \ref SCIP_STAGE_PRESOLVED
17464  * - \ref SCIP_STAGE_INITSOLVE
17465  * - \ref SCIP_STAGE_SOLVING
17466  * - \ref SCIP_STAGE_SOLVED
17467  */
17468 extern
17470  SCIP* scip /**< SCIP data structure */
17471  );
17472 
17473 
17474 /** gets global primal bound (objective value of best solution or user objective limit) for the original problem
17475  *
17476  * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
17477  *
17478  * @pre This method can be called if SCIP is in one of the following stages:
17479  * - \ref SCIP_STAGE_TRANSFORMED
17480  * - \ref SCIP_STAGE_INITPRESOLVE
17481  * - \ref SCIP_STAGE_PRESOLVING
17482  * - \ref SCIP_STAGE_EXITPRESOLVE
17483  * - \ref SCIP_STAGE_PRESOLVED
17484  * - \ref SCIP_STAGE_INITSOLVE
17485  * - \ref SCIP_STAGE_SOLVING
17486  * - \ref SCIP_STAGE_SOLVED
17487  * - \ref SCIP_STAGE_EXITSOLVE
17488  */
17489 extern
17491  SCIP* scip /**< SCIP data structure */
17492  );
17493 
17494 /** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
17495  *
17496  * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
17497  *
17498  * @pre This method can be called if SCIP is in one of the following stages:
17499  * - \ref SCIP_STAGE_TRANSFORMED
17500  * - \ref SCIP_STAGE_INITPRESOLVE
17501  * - \ref SCIP_STAGE_PRESOLVING
17502  * - \ref SCIP_STAGE_EXITPRESOLVE
17503  * - \ref SCIP_STAGE_PRESOLVED
17504  * - \ref SCIP_STAGE_INITSOLVE
17505  * - \ref SCIP_STAGE_SOLVING
17506  * - \ref SCIP_STAGE_SOLVED
17507  * - \ref SCIP_STAGE_EXITSOLVE
17508  */
17509 extern
17511  SCIP* scip /**< SCIP data structure */
17512  );
17513 
17514 /** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
17515  * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
17516  * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
17517  * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
17518  *
17519  * @return global cutoff bound in transformed problem
17520  *
17521  * @pre This method can be called if SCIP is in one of the following stages:
17522  * - \ref SCIP_STAGE_TRANSFORMED
17523  * - \ref SCIP_STAGE_INITPRESOLVE
17524  * - \ref SCIP_STAGE_PRESOLVING
17525  * - \ref SCIP_STAGE_EXITPRESOLVE
17526  * - \ref SCIP_STAGE_PRESOLVED
17527  * - \ref SCIP_STAGE_INITSOLVE
17528  * - \ref SCIP_STAGE_SOLVING
17529  * - \ref SCIP_STAGE_SOLVED
17530  * - \ref SCIP_STAGE_EXITSOLVE
17531  */
17532 extern
17534  SCIP* scip /**< SCIP data structure */
17535  );
17536 
17537 /** updates the cutoff bound
17538  *
17539  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17540  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17541  *
17542  * @pre This method can be called if SCIP is in one of the following stages:
17543  * - \ref SCIP_STAGE_TRANSFORMED
17544  * - \ref SCIP_STAGE_PRESOLVING
17545  * - \ref SCIP_STAGE_PRESOLVED
17546  * - \ref SCIP_STAGE_INITSOLVE
17547  * - \ref SCIP_STAGE_SOLVING
17548  *
17549  * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
17550  */
17551 extern
17553  SCIP* scip, /**< SCIP data structure */
17554  SCIP_Real cutoffbound /**< new cutoff bound */
17555  );
17556 
17557 /** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
17558  * was set from the user as objective limit
17559  *
17560  * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
17561  *
17562  * @pre This method can be called if SCIP is in one of the following stages:
17563  * - \ref SCIP_STAGE_TRANSFORMED
17564  * - \ref SCIP_STAGE_INITPRESOLVE
17565  * - \ref SCIP_STAGE_PRESOLVING
17566  * - \ref SCIP_STAGE_EXITPRESOLVE
17567  * - \ref SCIP_STAGE_PRESOLVED
17568  * - \ref SCIP_STAGE_INITSOLVE
17569  * - \ref SCIP_STAGE_SOLVING
17570  * - \ref SCIP_STAGE_SOLVED
17571  * - \ref SCIP_STAGE_EXITSOLVE
17572  */
17573 extern
17575  SCIP* scip /**< SCIP data structure */
17576  );
17577 
17578 /** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
17579  * or infinity, if they have opposite sign
17580  *
17581  * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
17582  * or infinity, if they have opposite sign
17583  *
17584  * @pre This method can be called if SCIP is in one of the following stages:
17585  * - \ref SCIP_STAGE_PRESOLVED
17586  * - \ref SCIP_STAGE_SOLVING
17587  * - \ref SCIP_STAGE_SOLVED
17588  */
17589 extern
17591  SCIP* scip /**< SCIP data structure */
17592  );
17593 
17594 /** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
17595  * have same sign, or infinity, if they have opposite sign
17596  *
17597  * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
17598  * have same sign, or infinity, if they have opposite sign
17599  *
17600  * @pre This method can be called if SCIP is in one of the following stages:
17601  * - \ref SCIP_STAGE_PRESOLVED
17602  * - \ref SCIP_STAGE_SOLVING
17603  * - \ref SCIP_STAGE_SOLVED
17604  */
17605 extern
17607  SCIP* scip /**< SCIP data structure */
17608  );
17609 
17610 /** gets number of feasible primal solutions found so far
17611  *
17612  * @return the number of feasible primal solutions found so far
17613  *
17614  * @pre This method can be called if SCIP is in one of the following stages:
17615  * - \ref SCIP_STAGE_TRANSFORMED
17616  * - \ref SCIP_STAGE_INITPRESOLVE
17617  * - \ref SCIP_STAGE_PRESOLVING
17618  * - \ref SCIP_STAGE_EXITPRESOLVE
17619  * - \ref SCIP_STAGE_PRESOLVED
17620  * - \ref SCIP_STAGE_INITSOLVE
17621  * - \ref SCIP_STAGE_SOLVING
17622  * - \ref SCIP_STAGE_SOLVED
17623  * - \ref SCIP_STAGE_EXITSOLVE
17624  */
17625 extern
17627  SCIP* scip /**< SCIP data structure */
17628  );
17629 
17630 /** gets number of feasible primal solutions respecting the objective limit found so far
17631  *
17632  * @return the number of feasible primal solutions respecting the objective limit found so far
17633  *
17634  * @pre This method can be called if SCIP is in one of the following stages:
17635  * - \ref SCIP_STAGE_TRANSFORMED
17636  * - \ref SCIP_STAGE_INITPRESOLVE
17637  * - \ref SCIP_STAGE_PRESOLVING
17638  * - \ref SCIP_STAGE_EXITPRESOLVE
17639  * - \ref SCIP_STAGE_PRESOLVED
17640  * - \ref SCIP_STAGE_INITSOLVE
17641  * - \ref SCIP_STAGE_SOLVING
17642  * - \ref SCIP_STAGE_SOLVED
17643  * - \ref SCIP_STAGE_EXITSOLVE
17644  */
17645 extern
17647  SCIP* scip /**< SCIP data structure */
17648  );
17649 
17650 /** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
17651  *
17652  * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
17653  *
17654  * @pre This method can be called if SCIP is in one of the following stages:
17655  * - \ref SCIP_STAGE_TRANSFORMED
17656  * - \ref SCIP_STAGE_INITPRESOLVE
17657  * - \ref SCIP_STAGE_PRESOLVING
17658  * - \ref SCIP_STAGE_EXITPRESOLVE
17659  * - \ref SCIP_STAGE_PRESOLVED
17660  * - \ref SCIP_STAGE_INITSOLVE
17661  * - \ref SCIP_STAGE_SOLVING
17662  * - \ref SCIP_STAGE_SOLVED
17663  * - \ref SCIP_STAGE_EXITSOLVE
17664  */
17665 extern
17667  SCIP* scip /**< SCIP data structure */
17668  );
17669 
17670 /** gets the average pseudo cost value for the given direction over all variables
17671  *
17672  * @return the average pseudo cost value for the given direction over all variables
17673  *
17674  * @pre This method can be called if SCIP is in one of the following stages:
17675  * - \ref SCIP_STAGE_SOLVING
17676  * - \ref SCIP_STAGE_SOLVED
17677  */
17678 extern
17680  SCIP* scip, /**< SCIP data structure */
17681  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
17682  );
17683 
17684 /** gets the average pseudo cost value for the given direction over all variables,
17685  * only using the pseudo cost information of the current run
17686  *
17687  * @return the average pseudo cost value for the given direction over all variables,
17688  * only using the pseudo cost information of the current run
17689  *
17690  * @pre This method can be called if SCIP is in one of the following stages:
17691  * - \ref SCIP_STAGE_SOLVING
17692  * - \ref SCIP_STAGE_SOLVED
17693  */
17694 extern
17696  SCIP* scip, /**< SCIP data structure */
17697  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
17698  );
17699 
17700 /** gets the average number of pseudo cost updates for the given direction over all variables
17701  *
17702  * @return the average number of pseudo cost updates for the given direction over all variables
17703  *
17704  * @pre This method can be called if SCIP is in one of the following stages:
17705  * - \ref SCIP_STAGE_SOLVING
17706  * - \ref SCIP_STAGE_SOLVED
17707  */
17708 extern
17710  SCIP* scip, /**< SCIP data structure */
17711  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
17712  );
17713 
17714 /** gets the average number of pseudo cost updates for the given direction over all variables,
17715  * only using the pseudo cost information of the current run
17716  *
17717  * @return the average number of pseudo cost updates for the given direction over all variables,
17718  * only using the pseudo cost information of the current run
17719  *
17720  * @pre This method can be called if SCIP is in one of the following stages:
17721  * - \ref SCIP_STAGE_SOLVING
17722  * - \ref SCIP_STAGE_SOLVED
17723  */
17724 extern
17726  SCIP* scip, /**< SCIP data structure */
17727  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
17728  );
17729 
17730 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
17731  *
17732  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
17733  *
17734  * @pre This method can be called if SCIP is in one of the following stages:
17735  * - \ref SCIP_STAGE_SOLVING
17736  * - \ref SCIP_STAGE_SOLVED
17737  */
17738 extern
17740  SCIP* scip /**< SCIP data structure */
17741  );
17742 
17743 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
17744  * only using the pseudo cost information of the current run
17745  *
17746  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
17747  * only using the pseudo cost information of the current run
17748  *
17749  * @pre This method can be called if SCIP is in one of the following stages:
17750  * - \ref SCIP_STAGE_SOLVING
17751  * - \ref SCIP_STAGE_SOLVED
17752  */
17753 extern
17755  SCIP* scip /**< SCIP data structure */
17756  );
17757 
17758 /** gets the average conflict score value over all variables */
17759 extern
17761  SCIP* scip /**< SCIP data structure */
17762  );
17763 
17764 /** gets the average conflict score value over all variables, only using the pseudo cost information of the current run
17765  *
17766  * @return the average conflict score value over all variables, only using the pseudo cost information of the current run
17767  *
17768  * @pre This method can be called if SCIP is in one of the following stages:
17769  * - \ref SCIP_STAGE_SOLVING
17770  * - \ref SCIP_STAGE_SOLVED
17771  */
17772 extern
17774  SCIP* scip /**< SCIP data structure */
17775  );
17776 
17777 /** gets the average inference score value over all variables
17778  *
17779  * @return the average inference score value over all variables
17780  *
17781  * @pre This method can be called if SCIP is in one of the following stages:
17782  * - \ref SCIP_STAGE_SOLVING
17783  * - \ref SCIP_STAGE_SOLVED
17784  */
17785 extern
17787  SCIP* scip /**< SCIP data structure */
17788  );
17789 
17790 /** gets the average conflictlength score value over all variables, only using the pseudo cost information of the
17791  * current run
17792  *
17793  * @return the average conflictlength score value over all variables, only using the pseudo cost information of the
17794  * current run
17795  *
17796  * @pre This method can be called if SCIP is in one of the following stages:
17797  * - \ref SCIP_STAGE_SOLVING
17798  * - \ref SCIP_STAGE_SOLVED
17799  */
17800 extern
17802  SCIP* scip /**< SCIP data structure */
17803  );
17804 
17805 /** returns the average number of inferences found after branching in given direction over all variables
17806  *
17807  * @return the average number of inferences found after branching in given direction over all variables
17808  *
17809  * @pre This method can be called if SCIP is in one of the following stages:
17810  * - \ref SCIP_STAGE_SOLVING
17811  * - \ref SCIP_STAGE_SOLVED
17812  */
17813 extern
17815  SCIP* scip, /**< SCIP data structure */
17816  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
17817  );
17818 
17819 /** returns the average number of inferences found after branching in given direction over all variables,
17820  * only using the pseudo cost information of the current run
17821  *
17822  * @return the average number of inferences found after branching in given direction over all variables,
17823  * only using the pseudo cost information of the current run
17824  *
17825  * @pre This method can be called if SCIP is in one of the following stages:
17826  * - \ref SCIP_STAGE_SOLVING
17827  * - \ref SCIP_STAGE_SOLVED
17828  */
17829 extern
17831  SCIP* scip, /**< SCIP data structure */
17832  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
17833  );
17834 
17835 /** gets the average inference score value over all variables
17836  *
17837  * @return the average inference score value over all variables
17838  *
17839  * @pre This method can be called if SCIP is in one of the following stages:
17840  * - \ref SCIP_STAGE_SOLVING
17841  * - \ref SCIP_STAGE_SOLVED
17842  */
17843 extern
17845  SCIP* scip /**< SCIP data structure */
17846  );
17847 
17848 /** gets the average inference score value over all variables, only using the inference information information of the
17849  * current run
17850  *
17851  * @return the average inference score value over all variables, only using the inference information information of the
17852  * current run
17853  *
17854  * @pre This method can be called if SCIP is in one of the following stages:
17855  * - \ref SCIP_STAGE_SOLVING
17856  * - \ref SCIP_STAGE_SOLVED
17857  */
17858 extern
17860  SCIP* scip /**< SCIP data structure */
17861  );
17862 
17863 /** returns the average number of cutoffs found after branching in given direction over all variables
17864  *
17865  * @return the average number of cutoffs found after branching in given direction over all variables
17866  *
17867  * @pre This method can be called if SCIP is in one of the following stages:
17868  * - \ref SCIP_STAGE_SOLVING
17869  * - \ref SCIP_STAGE_SOLVED
17870  */
17871 extern
17873  SCIP* scip, /**< SCIP data structure */
17874  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
17875  );
17876 
17877 /** returns the average number of cutoffs found after branching in given direction over all variables,
17878  * only using the pseudo cost information of the current run
17879  *
17880  * @return the average number of cutoffs found after branching in given direction over all variables,
17881  * only using the pseudo cost information of the current run
17882  *
17883  * @pre This method can be called if SCIP is in one of the following stages:
17884  * - \ref SCIP_STAGE_SOLVING
17885  * - \ref SCIP_STAGE_SOLVED
17886  */
17887 extern
17889  SCIP* scip, /**< SCIP data structure */
17890  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
17891  );
17892 
17893 /** gets the average cutoff score value over all variables
17894  *
17895  * @return the average cutoff score value over all variables
17896  *
17897  * @pre This method can be called if SCIP is in one of the following stages:
17898  * - \ref SCIP_STAGE_SOLVING
17899  * - \ref SCIP_STAGE_SOLVED
17900  */
17901 extern
17903  SCIP* scip /**< SCIP data structure */
17904  );
17905 
17906 /** gets the average cutoff score value over all variables, only using the pseudo cost information of the current run
17907  *
17908  * @return the average cutoff score value over all variables, only using the pseudo cost information of the current run
17909  *
17910  * @pre This method can be called if SCIP is in one of the following stages:
17911  * - \ref SCIP_STAGE_SOLVING
17912  * - \ref SCIP_STAGE_SOLVED
17913  */
17914 extern
17916  SCIP* scip /**< SCIP data structure */
17917  );
17918 
17919 /** outputs original problem to file stream
17920  *
17921  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17922  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17923  *
17924  * @pre This method can be called if SCIP is in one of the following stages:
17925  * - \ref SCIP_STAGE_PROBLEM
17926  * - \ref SCIP_STAGE_TRANSFORMING
17927  * - \ref SCIP_STAGE_TRANSFORMED
17928  * - \ref SCIP_STAGE_INITPRESOLVE
17929  * - \ref SCIP_STAGE_PRESOLVING
17930  * - \ref SCIP_STAGE_EXITPRESOLVE
17931  * - \ref SCIP_STAGE_PRESOLVED
17932  * - \ref SCIP_STAGE_INITSOLVE
17933  * - \ref SCIP_STAGE_SOLVING
17934  * - \ref SCIP_STAGE_SOLVED
17935  * - \ref SCIP_STAGE_EXITSOLVE
17936  * - \ref SCIP_STAGE_FREETRANS
17937  */
17938 extern
17940  SCIP* scip, /**< SCIP data structure */
17941  FILE* file, /**< output file (or NULL for standard output) */
17942  const char* extension, /**< file format (or NULL for default CIP format)*/
17943  SCIP_Bool genericnames /**< using generic variable and constraint names? */
17944  );
17945 
17946 /** outputs transformed problem of the current node to file stream
17947  *
17948  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17949  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17950  *
17951  * @pre This method can be called if SCIP is in one of the following stages:
17952  * - \ref SCIP_STAGE_TRANSFORMED
17953  * - \ref SCIP_STAGE_INITPRESOLVE
17954  * - \ref SCIP_STAGE_PRESOLVING
17955  * - \ref SCIP_STAGE_EXITPRESOLVE
17956  * - \ref SCIP_STAGE_PRESOLVED
17957  * - \ref SCIP_STAGE_INITSOLVE
17958  * - \ref SCIP_STAGE_SOLVING
17959  * - \ref SCIP_STAGE_SOLVED
17960  * - \ref SCIP_STAGE_EXITSOLVE
17961  * - \ref SCIP_STAGE_FREETRANS
17962  */
17963 extern
17965  SCIP* scip, /**< SCIP data structure */
17966  FILE* file, /**< output file (or NULL for standard output) */
17967  const char* extension, /**< file format (or NULL for default CIP format)*/
17968  SCIP_Bool genericnames /**< using generic variable and constraint names? */
17969  );
17970 
17971 /** outputs solving statistics
17972  *
17973  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17974  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
17975  *
17976  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
17977  * thus may to correspond to the original status.
17978  *
17979  * @pre This method can be called if SCIP is in one of the following stages:
17980  * - \ref SCIP_STAGE_INIT
17981  * - \ref SCIP_STAGE_PROBLEM
17982  * - \ref SCIP_STAGE_TRANSFORMED
17983  * - \ref SCIP_STAGE_INITPRESOLVE
17984  * - \ref SCIP_STAGE_PRESOLVING
17985  * - \ref SCIP_STAGE_EXITPRESOLVE
17986  * - \ref SCIP_STAGE_PRESOLVED
17987  * - \ref SCIP_STAGE_SOLVING
17988  * - \ref SCIP_STAGE_SOLVED
17989  */
17990 extern
17992  SCIP* scip, /**< SCIP data structure */
17993  FILE* file /**< output file (or NULL for standard output) */
17994  );
17995 
17996 /** outputs history statistics about branchings on variables
17997  *
17998  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
17999  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18000  *
18001  * @pre This method can be called if SCIP is in one of the following stages:
18002  * - \ref SCIP_STAGE_INIT
18003  * - \ref SCIP_STAGE_PROBLEM
18004  * - \ref SCIP_STAGE_TRANSFORMED
18005  * - \ref SCIP_STAGE_INITPRESOLVE
18006  * - \ref SCIP_STAGE_PRESOLVING
18007  * - \ref SCIP_STAGE_EXITPRESOLVE
18008  * - \ref SCIP_STAGE_PRESOLVED
18009  * - \ref SCIP_STAGE_SOLVING
18010  * - \ref SCIP_STAGE_SOLVED
18011  */
18012 extern
18014  SCIP* scip, /**< SCIP data structure */
18015  FILE* file /**< output file (or NULL for standard output) */
18016  );
18017 
18018 /** outputs node information display line
18019  *
18020  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18021  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18022  *
18023  * @pre This method can be called if SCIP is in one of the following stages:
18024  * - \ref SCIP_STAGE_SOLVING
18025  */
18026 extern
18028  SCIP* scip, /**< SCIP data structure */
18029  FILE* file, /**< output file (or NULL for standard output) */
18030  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
18031  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
18032  );
18033 
18034 /** gets total number of implications between variables that are stored in the implication graph
18035  *
18036  * @return the total number of implications between variables that are stored in the implication graph
18037  *
18038  * @pre This method can be called if SCIP is in one of the following stages:
18039  * - \ref SCIP_STAGE_INITPRESOLVE
18040  * - \ref SCIP_STAGE_PRESOLVING
18041  * - \ref SCIP_STAGE_EXITPRESOLVE
18042  * - \ref SCIP_STAGE_PRESOLVED
18043  * - \ref SCIP_STAGE_INITSOLVE
18044  * - \ref SCIP_STAGE_SOLVING
18045  * - \ref SCIP_STAGE_SOLVED
18046  */
18047 extern
18049  SCIP* scip /**< SCIP data structure */
18050  );
18051 
18052 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
18053  *
18054  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18055  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18056  *
18057  * @pre This method can be called if SCIP is in one of the following stages:
18058  * - \ref SCIP_STAGE_TRANSFORMED
18059  * - \ref SCIP_STAGE_INITPRESOLVE
18060  * - \ref SCIP_STAGE_PRESOLVING
18061  * - \ref SCIP_STAGE_EXITPRESOLVE
18062  * - \ref SCIP_STAGE_PRESOLVED
18063  * - \ref SCIP_STAGE_INITSOLVE
18064  * - \ref SCIP_STAGE_SOLVING
18065  * - \ref SCIP_STAGE_SOLVED
18066  * - \ref SCIP_STAGE_EXITSOLVE
18067  */
18068 extern
18070  SCIP* scip, /**< SCIP data structure */
18071  const char* filename /**< file name, or NULL for stdout */
18072  );
18073 
18074 /**@} */
18075 
18076 
18077 
18078 
18079 /*
18080  * timing methods
18081  */
18082 
18083 /**@name Timing Methods */
18084 /**@{ */
18085 
18086 /** gets current time of day in seconds (standard time zone)
18087  *
18088  * @return the current time of day in seconds (standard time zone).
18089  */
18090 extern
18092  SCIP* scip /**< SCIP data structure */
18093  );
18094 
18095 /** creates a clock using the default clock type
18096  *
18097  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18098  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18099  */
18100 extern
18102  SCIP* scip, /**< SCIP data structure */
18103  SCIP_CLOCK** clck /**< pointer to clock timer */
18104  );
18105 
18106 /** creates a clock counting the CPU user seconds
18107  *
18108  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18109  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18110  */
18111 extern
18113  SCIP* scip, /**< SCIP data structure */
18114  SCIP_CLOCK** clck /**< pointer to clock timer */
18115  );
18116 
18117 /** creates a clock counting the wall clock seconds
18118  *
18119  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18120  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18121  */
18122 extern
18124  SCIP* scip, /**< SCIP data structure */
18125  SCIP_CLOCK** clck /**< pointer to clock timer */
18126  );
18127 
18128 /** frees a clock
18129  *
18130  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18131  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18132  */
18133 extern
18135  SCIP* scip, /**< SCIP data structure */
18136  SCIP_CLOCK** clck /**< pointer to clock timer */
18137  );
18138 
18139 /** resets the time measurement of a clock to zero and completely stops the clock
18140  *
18141  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18142  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18143  */
18144 extern
18146  SCIP* scip, /**< SCIP data structure */
18147  SCIP_CLOCK* clck /**< clock timer */
18148  );
18149 
18150 /** starts the time measurement of a clock
18151  *
18152  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18153  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18154  */
18155 extern
18157  SCIP* scip, /**< SCIP data structure */
18158  SCIP_CLOCK* clck /**< clock timer */
18159  );
18160 
18161 /** stops the time measurement of a clock
18162  *
18163  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18164  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18165  */
18166 extern
18168  SCIP* scip, /**< SCIP data structure */
18169  SCIP_CLOCK* clck /**< clock timer */
18170  );
18171 
18172 /** starts the current solving time
18173  *
18174  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18175  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18176  *
18177  * @pre This method can be called if SCIP is in one of the following stages:
18178  * - \ref SCIP_STAGE_PROBLEM
18179  * - \ref SCIP_STAGE_TRANSFORMING
18180  * - \ref SCIP_STAGE_TRANSFORMED
18181  * - \ref SCIP_STAGE_INITPRESOLVE
18182  * - \ref SCIP_STAGE_PRESOLVING
18183  * - \ref SCIP_STAGE_EXITPRESOLVE
18184  * - \ref SCIP_STAGE_PRESOLVED
18185  * - \ref SCIP_STAGE_INITSOLVE
18186  * - \ref SCIP_STAGE_SOLVING
18187  * - \ref SCIP_STAGE_SOLVED
18188  * - \ref SCIP_STAGE_EXITSOLVE
18189  * - \ref SCIP_STAGE_FREETRANS
18190  *
18191  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18192  */
18193 extern
18195  SCIP* scip /**< SCIP data structure */
18196  );
18197 
18198 /** stops the current solving time in seconds
18199  *
18200  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18201  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18202  *
18203  * @pre This method can be called if SCIP is in one of the following stages:
18204  * - \ref SCIP_STAGE_PROBLEM
18205  * - \ref SCIP_STAGE_TRANSFORMING
18206  * - \ref SCIP_STAGE_TRANSFORMED
18207  * - \ref SCIP_STAGE_INITPRESOLVE
18208  * - \ref SCIP_STAGE_PRESOLVING
18209  * - \ref SCIP_STAGE_EXITPRESOLVE
18210  * - \ref SCIP_STAGE_PRESOLVED
18211  * - \ref SCIP_STAGE_INITSOLVE
18212  * - \ref SCIP_STAGE_SOLVING
18213  * - \ref SCIP_STAGE_SOLVED
18214  * - \ref SCIP_STAGE_EXITSOLVE
18215  * - \ref SCIP_STAGE_FREETRANS
18216  *
18217  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18218  */
18219 extern
18221  SCIP* scip /**< SCIP data structure */
18222  );
18223 
18224 /** gets the measured time of a clock in seconds
18225  *
18226  * @return the measured time of a clock in seconds.
18227  */
18228 extern
18230  SCIP* scip, /**< SCIP data structure */
18231  SCIP_CLOCK* clck /**< clock timer */
18232  );
18233 
18234 /** sets the measured time of a clock to the given value in seconds
18235  *
18236  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18237  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18238  */
18239 extern
18241  SCIP* scip, /**< SCIP data structure */
18242  SCIP_CLOCK* clck, /**< clock timer */
18243  SCIP_Real sec /**< time in seconds to set the clock's timer to */
18244  );
18245 
18246 /** gets the current total SCIP time in seconds
18247  *
18248  * @return the current total SCIP time in seconds.
18249  */
18250 extern
18252  SCIP* scip /**< SCIP data structure */
18253  );
18254 
18255 /** gets the current solving time in seconds
18256  *
18257  * @return the current solving time in seconds.
18258  *
18259  * @pre This method can be called if SCIP is in one of the following stages:
18260  * - \ref SCIP_STAGE_PROBLEM
18261  * - \ref SCIP_STAGE_TRANSFORMING
18262  * - \ref SCIP_STAGE_TRANSFORMED
18263  * - \ref SCIP_STAGE_INITPRESOLVE
18264  * - \ref SCIP_STAGE_PRESOLVING
18265  * - \ref SCIP_STAGE_EXITPRESOLVE
18266  * - \ref SCIP_STAGE_PRESOLVED
18267  * - \ref SCIP_STAGE_INITSOLVE
18268  * - \ref SCIP_STAGE_SOLVING
18269  * - \ref SCIP_STAGE_SOLVED
18270  *
18271  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18272  */
18273 extern
18275  SCIP* scip /**< SCIP data structure */
18276  );
18277 
18278 /** gets the current reading time in seconds
18279  *
18280  * @return the current reading time in seconds.
18281  *
18282  * @pre This method can be called if SCIP is in one of the following stages:
18283  * - \ref SCIP_STAGE_PROBLEM
18284  * - \ref SCIP_STAGE_TRANSFORMING
18285  * - \ref SCIP_STAGE_TRANSFORMED
18286  * - \ref SCIP_STAGE_INITPRESOLVE
18287  * - \ref SCIP_STAGE_PRESOLVING
18288  * - \ref SCIP_STAGE_EXITPRESOLVE
18289  * - \ref SCIP_STAGE_PRESOLVED
18290  * - \ref SCIP_STAGE_INITSOLVE
18291  * - \ref SCIP_STAGE_SOLVING
18292  * - \ref SCIP_STAGE_SOLVED
18293  *
18294  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18295  */
18296 extern
18298  SCIP* scip /**< SCIP data structure */
18299  );
18300 
18301 /** gets the current presolving time in seconds
18302  *
18303  * @return the current presolving time in seconds.
18304  *
18305  * @pre This method can be called if SCIP is in one of the following stages:
18306  * - \ref SCIP_STAGE_INITPRESOLVE
18307  * - \ref SCIP_STAGE_PRESOLVING
18308  * - \ref SCIP_STAGE_EXITPRESOLVE
18309  * - \ref SCIP_STAGE_PRESOLVED
18310  * - \ref SCIP_STAGE_INITSOLVE
18311  * - \ref SCIP_STAGE_SOLVING
18312  * - \ref SCIP_STAGE_SOLVED
18313  *
18314  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18315  */
18316 extern
18318  SCIP* scip /**< SCIP data structure */
18319  );
18320 
18321 /** gets the time need to solve the first LP in the root node
18322  *
18323  * @return the solving time for the first LP in the root node in seconds.
18324  *
18325  * @pre This method can be called if SCIP is in one of the following stages:
18326  * - \ref SCIP_STAGE_TRANSFORMING
18327  * - \ref SCIP_STAGE_TRANSFORMED
18328  * - \ref SCIP_STAGE_INITPRESOLVE
18329  * - \ref SCIP_STAGE_PRESOLVING
18330  * - \ref SCIP_STAGE_EXITPRESOLVE
18331  * - \ref SCIP_STAGE_PRESOLVED
18332  * - \ref SCIP_STAGE_INITSOLVE
18333  * - \ref SCIP_STAGE_SOLVING
18334  * - \ref SCIP_STAGE_SOLVED
18335  *
18336  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
18337  */
18338 extern
18340  SCIP* scip /**< SCIP data structure */
18341  );
18342 
18343 /**@} */
18344 
18345 
18346 
18347 
18348 /*
18349  * numeric values and comparisons
18350  */
18351 
18352 /**@name Numerical Methods */
18353 /**@{ */
18354 
18355 
18356 /** returns value treated as zero
18357  *
18358  * @return value treated as zero
18359  */
18360 extern
18362  SCIP* scip /**< SCIP data structure */
18363  );
18364 
18365 /** returns value treated as zero for sums of floating point values
18366  *
18367  * @return value treated as zero for sums of floating point values
18368  */
18369 extern
18371  SCIP* scip /**< SCIP data structure */
18372  );
18373 
18374 /** returns feasibility tolerance for constraints
18375  *
18376  * @return feasibility tolerance for constraints
18377  */
18378 extern
18380  SCIP* scip /**< SCIP data structure */
18381  );
18382 
18383 /** returns primal feasibility tolerance of LP solver
18384  *
18385  * @return primal feasibility tolerance of LP solver
18386  */
18387 extern
18389  SCIP* scip /**< SCIP data structure */
18390  );
18391 
18392 /** returns feasibility tolerance for reduced costs
18393  *
18394  * @return feasibility tolerance for reduced costs
18395  */
18396 extern
18398  SCIP* scip /**< SCIP data structure */
18399  );
18400 
18401 /** returns convergence tolerance used in barrier algorithm
18402  *
18403  * @return convergence tolerance used in barrier algorithm
18404  */
18405 extern
18407  SCIP* scip /**< SCIP data structure */
18408  );
18409 
18410 /** return the cutoff bound delta
18411  *
18412  * @return cutoff bound data
18413  */
18414 extern
18416  SCIP* scip /**< SCIP data structure */
18417  );
18418 
18419 /** sets the feasibility tolerance for constraints
18420  *
18421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18423  */
18424 extern
18426  SCIP* scip, /**< SCIP data structure */
18427  SCIP_Real feastol /**< new feasibility tolerance for constraints */
18428  );
18429 
18430 /** sets the primal feasibility tolerance of LP solver
18431  *
18432  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18433  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18434  */
18435 extern
18437  SCIP* scip, /**< SCIP data structure */
18438  SCIP_Real lpfeastol, /**< new primal feasibility tolerance of LP solver */
18439  SCIP_Bool printnewvalue /**< should "numerics/lpfeastol = ..." be printed? */
18440  );
18441 
18442 /** sets the feasibility tolerance for reduced costs
18443  *
18444  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18445  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18446  */
18447 extern
18449  SCIP* scip, /**< SCIP data structure */
18450  SCIP_Real dualfeastol /**< new feasibility tolerance for reduced costs */
18451  );
18452 
18453 /** sets the convergence tolerance used in barrier algorithm
18454  *
18455  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
18456  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
18457  */
18458 extern
18460  SCIP* scip, /**< SCIP data structure */
18461  SCIP_Real barrierconvtol /**< new convergence tolerance used in barrier algorithm */
18462  );
18463 
18464 /** marks that some limit parameter was changed */
18465 extern
18467  SCIP* scip /**< SCIP data structure */
18468  );
18469 
18470 /** returns value treated as infinity */
18471 extern
18473  SCIP* scip /**< SCIP data structure */
18474  );
18475 
18476 /** returns the minimum value that is regarded as huge and should be handled separately (e.g., in activity
18477  * computation)
18478  */
18479 extern
18481  SCIP* scip /**< SCIP data structure */
18482  );
18483 
18484 /** checks, if values are in range of epsilon */
18485 extern
18487  SCIP* scip, /**< SCIP data structure */
18488  SCIP_Real val1, /**< first value to be compared */
18489  SCIP_Real val2 /**< second value to be compared */
18490  );
18491 
18492 /** checks, if val1 is (more than epsilon) lower than val2 */
18493 extern
18495  SCIP* scip, /**< SCIP data structure */
18496  SCIP_Real val1, /**< first value to be compared */
18497  SCIP_Real val2 /**< second value to be compared */
18498  );
18499 
18500 /** checks, if val1 is not (more than epsilon) greater than val2 */
18501 extern
18503  SCIP* scip, /**< SCIP data structure */
18504  SCIP_Real val1, /**< first value to be compared */
18505  SCIP_Real val2 /**< second value to be compared */
18506  );
18507 
18508 /** checks, if val1 is (more than epsilon) greater than val2 */
18509 extern
18511  SCIP* scip, /**< SCIP data structure */
18512  SCIP_Real val1, /**< first value to be compared */
18513  SCIP_Real val2 /**< second value to be compared */
18514  );
18515 
18516 /** checks, if val1 is not (more than epsilon) lower than val2 */
18517 extern
18519  SCIP* scip, /**< SCIP data structure */
18520  SCIP_Real val1, /**< first value to be compared */
18521  SCIP_Real val2 /**< second value to be compared */
18522  );
18523 
18524 /** checks, if value is (positive) infinite */
18525 extern
18527  SCIP* scip, /**< SCIP data structure */
18528  SCIP_Real val /**< value to be compared against infinity */
18529  );
18530 
18531 /** checks, if value is huge and should be handled separately (e.g., in activity computation) */
18532 extern
18534  SCIP* scip, /**< SCIP data structure */
18535  SCIP_Real val /**< value to be checked whether it is huge */
18536  );
18537 
18538 /** checks, if value is in range epsilon of 0.0 */
18539 extern
18541  SCIP* scip, /**< SCIP data structure */
18542  SCIP_Real val /**< value to process */
18543  );
18544 
18545 /** checks, if value is greater than epsilon */
18546 extern
18548  SCIP* scip, /**< SCIP data structure */
18549  SCIP_Real val /**< value to process */
18550  );
18551 
18552 /** checks, if value is lower than -epsilon */
18553 extern
18555  SCIP* scip, /**< SCIP data structure */
18556  SCIP_Real val /**< value to process */
18557  );
18558 
18559 /** checks, if value is integral within epsilon */
18560 extern
18562  SCIP* scip, /**< SCIP data structure */
18563  SCIP_Real val /**< value to process */
18564  );
18565 
18566 /** checks whether the product val * scalar is integral in epsilon scaled by scalar */
18567 extern
18569  SCIP* scip, /**< SCIP data structure */
18570  SCIP_Real val, /**< unscaled value to check for scaled integrality */
18571  SCIP_Real scalar /**< value to scale val with for checking for integrality */
18572  );
18573 
18574 /** checks, if given fractional part is smaller than epsilon */
18575 extern
18577  SCIP* scip, /**< SCIP data structure */
18578  SCIP_Real val /**< value to process */
18579  );
18580 
18581 /** rounds value + epsilon down to the next integer */
18582 extern
18584  SCIP* scip, /**< SCIP data structure */
18585  SCIP_Real val /**< value to process */
18586  );
18587 
18588 /** rounds value - epsilon up to the next integer */
18589 extern
18591  SCIP* scip, /**< SCIP data structure */
18592  SCIP_Real val /**< value to process */
18593  );
18594 
18595 /** rounds value to the nearest integer with epsilon tolerance */
18596 extern
18598  SCIP* scip, /**< SCIP data structure */
18599  SCIP_Real val /**< value to process */
18600  );
18601 
18602 /** returns fractional part of value, i.e. x - floor(x) in epsilon tolerance */
18603 extern
18605  SCIP* scip, /**< SCIP data structure */
18606  SCIP_Real val /**< value to return fractional part for */
18607  );
18608 
18609 /** checks, if values are in range of sumepsilon */
18610 extern
18612  SCIP* scip, /**< SCIP data structure */
18613  SCIP_Real val1, /**< first value to be compared */
18614  SCIP_Real val2 /**< second value to be compared */
18615  );
18616 
18617 /** checks, if val1 is (more than sumepsilon) lower than val2 */
18618 extern
18620  SCIP* scip, /**< SCIP data structure */
18621  SCIP_Real val1, /**< first value to be compared */
18622  SCIP_Real val2 /**< second value to be compared */
18623  );
18624 
18625 /** checks, if val1 is not (more than sumepsilon) greater than val2 */
18626 extern
18628  SCIP* scip, /**< SCIP data structure */
18629  SCIP_Real val1, /**< first value to be compared */
18630  SCIP_Real val2 /**< second value to be compared */
18631  );
18632 
18633 /** checks, if val1 is (more than sumepsilon) greater than val2 */
18634 extern
18636  SCIP* scip, /**< SCIP data structure */
18637  SCIP_Real val1, /**< first value to be compared */
18638  SCIP_Real val2 /**< second value to be compared */
18639  );
18640 
18641 /** checks, if val1 is not (more than sumepsilon) lower than val2 */
18642 extern
18644  SCIP* scip, /**< SCIP data structure */
18645  SCIP_Real val1, /**< first value to be compared */
18646  SCIP_Real val2 /**< second value to be compared */
18647  );
18648 
18649 /** checks, if value is in range sumepsilon of 0.0 */
18650 extern
18652  SCIP* scip, /**< SCIP data structure */
18653  SCIP_Real val /**< value to process */
18654  );
18655 
18656 /** checks, if value is greater than sumepsilon */
18657 extern
18659  SCIP* scip, /**< SCIP data structure */
18660  SCIP_Real val /**< value to process */
18661  );
18662 
18663 /** checks, if value is lower than -sumepsilon */
18664 extern
18666  SCIP* scip, /**< SCIP data structure */
18667  SCIP_Real val /**< value to process */
18668  );
18669 
18670 /** checks, if relative difference of values is in range of feasibility tolerance */
18671 extern
18673  SCIP* scip, /**< SCIP data structure */
18674  SCIP_Real val1, /**< first value to be compared */
18675  SCIP_Real val2 /**< second value to be compared */
18676  );
18677 
18678 /** checks, if relative difference val1 and val2 is lower than feasibility tolerance */
18679 extern
18681  SCIP* scip, /**< SCIP data structure */
18682  SCIP_Real val1, /**< first value to be compared */
18683  SCIP_Real val2 /**< second value to be compared */
18684  );
18685 
18686 /** checks, if relative difference of val1 and val2 is not greater than feasibility tolerance */
18687 extern
18689  SCIP* scip, /**< SCIP data structure */
18690  SCIP_Real val1, /**< first value to be compared */
18691  SCIP_Real val2 /**< second value to be compared */
18692  );
18693 
18694 /** checks, if relative difference of val1 and val2 is greater than feastol */
18695 extern
18697  SCIP* scip, /**< SCIP data structure */
18698  SCIP_Real val1, /**< first value to be compared */
18699  SCIP_Real val2 /**< second value to be compared */
18700  );
18701 
18702 /** checks, if relative difference of val1 and val2 is not lower than -feastol */
18703 extern
18705  SCIP* scip, /**< SCIP data structure */
18706  SCIP_Real val1, /**< first value to be compared */
18707  SCIP_Real val2 /**< second value to be compared */
18708  );
18709 
18710 /** checks, if value is in range feasibility tolerance of 0.0 */
18711 extern
18713  SCIP* scip, /**< SCIP data structure */
18714  SCIP_Real val /**< value to process */
18715  );
18716 
18717 /** checks, if value is greater than feasibility tolerance */
18718 extern
18720  SCIP* scip, /**< SCIP data structure */
18721  SCIP_Real val /**< value to process */
18722  );
18723 
18724 /** checks, if value is lower than -feasibility tolerance */
18725 extern
18727  SCIP* scip, /**< SCIP data structure */
18728  SCIP_Real val /**< value to process */
18729  );
18730 
18731 /** checks, if value is integral within the LP feasibility bounds */
18732 extern
18734  SCIP* scip, /**< SCIP data structure */
18735  SCIP_Real val /**< value to process */
18736  );
18737 
18738 /** checks, if given fractional part is smaller than feastol */
18739 extern
18741  SCIP* scip, /**< SCIP data structure */
18742  SCIP_Real val /**< value to process */
18743  );
18744 
18745 /** rounds value + feasibility tolerance down to the next integer */
18746 extern
18748  SCIP* scip, /**< SCIP data structure */
18749  SCIP_Real val /**< value to process */
18750  );
18751 
18752 /** rounds value - feasibility tolerance up to the next integer */
18753 extern
18755  SCIP* scip, /**< SCIP data structure */
18756  SCIP_Real val /**< value to process */
18757  );
18758 
18759 /** rounds value - feasibility tolerance up to the next integer in feasibility tolerance */
18760 extern
18762  SCIP* scip, /**< SCIP data structure */
18763  SCIP_Real val /**< value to process */
18764  );
18765 
18766 /** returns fractional part of value, i.e. x - floor(x) */
18767 extern
18769  SCIP* scip, /**< SCIP data structure */
18770  SCIP_Real val /**< value to process */
18771  );
18772 
18773 /** checks, if the given new lower bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
18774 extern
18776  SCIP* scip, /**< SCIP data structure */
18777  SCIP_Real newlb, /**< new lower bound */
18778  SCIP_Real oldlb, /**< old lower bound */
18779  SCIP_Real oldub /**< old upper bound */
18780  );
18781 
18782 /** checks, if the given new upper bound is tighter (w.r.t. bound strengthening epsilon) than the old one */
18784  SCIP* scip, /**< SCIP data structure */
18785  SCIP_Real newub, /**< new upper bound */
18786  SCIP_Real oldlb, /**< old lower bound */
18787  SCIP_Real oldub /**< old upper bound */
18788  );
18789 
18790 /** checks, if relative difference of values is in range of epsilon */
18791 extern
18793  SCIP* scip, /**< SCIP data structure */
18794  SCIP_Real val1, /**< first value to be compared */
18795  SCIP_Real val2 /**< second value to be compared */
18796  );
18797 
18798 /** checks, if relative difference of val1 and val2 is lower than epsilon */
18799 extern
18801  SCIP* scip, /**< SCIP data structure */
18802  SCIP_Real val1, /**< first value to be compared */
18803  SCIP_Real val2 /**< second value to be compared */
18804  );
18805 
18806 /** checks, if relative difference of val1 and val2 is not greater than epsilon */
18807 extern
18809  SCIP* scip, /**< SCIP data structure */
18810  SCIP_Real val1, /**< first value to be compared */
18811  SCIP_Real val2 /**< second value to be compared */
18812  );
18813 
18814 /** checks, if relative difference of val1 and val2 is greater than epsilon */
18815 extern
18817  SCIP* scip, /**< SCIP data structure */
18818  SCIP_Real val1, /**< first value to be compared */
18819  SCIP_Real val2 /**< second value to be compared */
18820  );
18821 
18822 /** checks, if relative difference of val1 and val2 is not lower than -epsilon */
18823 extern
18825  SCIP* scip, /**< SCIP data structure */
18826  SCIP_Real val1, /**< first value to be compared */
18827  SCIP_Real val2 /**< second value to be compared */
18828  );
18829 
18830 /** checks, if relative difference of values is in range of sumepsilon */
18831 extern
18833  SCIP* scip, /**< SCIP data structure */
18834  SCIP_Real val1, /**< first value to be compared */
18835  SCIP_Real val2 /**< second value to be compared */
18836  );
18837 
18838 /** checks, if relative difference of val1 and val2 is lower than sumepsilon */
18839 extern
18841  SCIP* scip, /**< SCIP data structure */
18842  SCIP_Real val1, /**< first value to be compared */
18843  SCIP_Real val2 /**< second value to be compared */
18844  );
18845 
18846 /** checks, if relative difference of val1 and val2 is not greater than sumepsilon */
18847 extern
18849  SCIP* scip, /**< SCIP data structure */
18850  SCIP_Real val1, /**< first value to be compared */
18851  SCIP_Real val2 /**< second value to be compared */
18852  );
18853 
18854 /** checks, if relative difference of val1 and val2 is greater than sumepsilon */
18855 extern
18857  SCIP* scip, /**< SCIP data structure */
18858  SCIP_Real val1, /**< first value to be compared */
18859  SCIP_Real val2 /**< second value to be compared */
18860  );
18861 
18862 /** checks, if relative difference of val1 and val2 is not lower than -sumepsilon */
18863 extern
18865  SCIP* scip, /**< SCIP data structure */
18866  SCIP_Real val1, /**< first value to be compared */
18867  SCIP_Real val2 /**< second value to be compared */
18868  );
18869 
18870 /** Checks, if an iteratively updated value is reliable or should be recomputed from scratch.
18871  * This is useful, if the value, e.g., the activity of a linear constraint or the pseudo objective value, gets a high
18872  * absolute value during the optimization process which is later reduced significantly. In this case, the last digits
18873  * were canceled out when increasing the value and are random after decreasing it.
18874  * We do not consider the cancellations which can occur during increasing the absolute value because they just cannot
18875  * be expressed using fixed precision floating point arithmetic, anymore.
18876  * In order to get more reliable values, the idea is to always store the last reliable value, where increasing the
18877  * absolute of the value is viewed as preserving reliability. Then, after each update, the new absolute value can be
18878  * compared against the last reliable one with this method, checking whether it was decreased by a factor of at least
18879  * "lp/recompfac" and should be recomputed.
18880  */
18881 extern
18883  SCIP* scip, /**< SCIP data structure */
18884  SCIP_Real newvalue, /**< new value after update */
18885  SCIP_Real oldvalue /**< old value, i.e., last reliable value */
18886  );
18887 
18888 #ifdef NDEBUG
18889 
18890 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
18891  * speed up the algorithms.
18892  */
18893 
18894 #define SCIPinfinity(scip) SCIPsetInfinity((scip)->set)
18895 #define SCIPisInfinity(scip, val) SCIPsetIsInfinity((scip)->set, val)
18896 #define SCIPisHugeValue(scip, val) SCIPsetIsHugeValue((scip)->set, val)
18897 #define SCIPgetHugeValue(scip) SCIPsetGetHugeValue((scip)->set)
18898 #define SCIPisEQ(scip, val1, val2) SCIPsetIsEQ((scip)->set, val1, val2)
18899 #define SCIPisLT(scip, val1, val2) SCIPsetIsLT((scip)->set, val1, val2)
18900 #define SCIPisLE(scip, val1, val2) SCIPsetIsLE((scip)->set, val1, val2)
18901 #define SCIPisGT(scip, val1, val2) SCIPsetIsGT((scip)->set, val1, val2)
18902 #define SCIPisGE(scip, val1, val2) SCIPsetIsGE((scip)->set, val1, val2)
18903 #define SCIPisZero(scip, val) SCIPsetIsZero((scip)->set, val)
18904 #define SCIPisPositive(scip, val) SCIPsetIsPositive((scip)->set, val)
18905 #define SCIPisNegative(scip, val) SCIPsetIsNegative((scip)->set, val)
18906 #define SCIPisIntegral(scip, val) SCIPsetIsIntegral((scip)->set, val)
18907 #define SCIPisScalingIntegral(scip, val, scalar) SCIPsetIsScalingIntegral((scip)->set, val, scalar)
18908 #define SCIPisFracIntegral(scip, val) SCIPsetIsFracIntegral((scip)->set, val)
18909 #define SCIPfloor(scip, val) SCIPsetFloor((scip)->set, val)
18910 #define SCIPceil(scip, val) SCIPsetCeil((scip)->set, val)
18911 #define SCIPround(scip, val) SCIPsetRound((scip)->set, val)
18912 #define SCIPfrac(scip, val) SCIPsetFrac((scip)->set, val)
18913 
18914 #define SCIPisSumEQ(scip, val1, val2) SCIPsetIsSumEQ((scip)->set, val1, val2)
18915 #define SCIPisSumLT(scip, val1, val2) SCIPsetIsSumLT((scip)->set, val1, val2)
18916 #define SCIPisSumLE(scip, val1, val2) SCIPsetIsSumLE((scip)->set, val1, val2)
18917 #define SCIPisSumGT(scip, val1, val2) SCIPsetIsSumGT((scip)->set, val1, val2)
18918 #define SCIPisSumGE(scip, val1, val2) SCIPsetIsSumGE((scip)->set, val1, val2)
18919 #define SCIPisSumZero(scip, val) SCIPsetIsSumZero((scip)->set, val)
18920 #define SCIPisSumPositive(scip, val) SCIPsetIsSumPositive((scip)->set, val)
18921 #define SCIPisSumNegative(scip, val) SCIPsetIsSumNegative((scip)->set, val)
18922 
18923 #define SCIPisFeasEQ(scip, val1, val2) SCIPsetIsFeasEQ((scip)->set, val1, val2)
18924 #define SCIPisFeasLT(scip, val1, val2) SCIPsetIsFeasLT((scip)->set, val1, val2)
18925 #define SCIPisFeasLE(scip, val1, val2) SCIPsetIsFeasLE((scip)->set, val1, val2)
18926 #define SCIPisFeasGT(scip, val1, val2) SCIPsetIsFeasGT((scip)->set, val1, val2)
18927 #define SCIPisFeasGE(scip, val1, val2) SCIPsetIsFeasGE((scip)->set, val1, val2)
18928 #define SCIPisFeasZero(scip, val) SCIPsetIsFeasZero((scip)->set, val)
18929 #define SCIPisFeasPositive(scip, val) SCIPsetIsFeasPositive((scip)->set, val)
18930 #define SCIPisFeasNegative(scip, val) SCIPsetIsFeasNegative((scip)->set, val)
18931 #define SCIPisFeasIntegral(scip, val) SCIPsetIsFeasIntegral((scip)->set, val)
18932 #define SCIPisFeasFracIntegral(scip, val) SCIPsetIsFeasFracIntegral((scip)->set, val)
18933 #define SCIPfeasFloor(scip, val) SCIPsetFeasFloor((scip)->set, val)
18934 #define SCIPfeasCeil(scip, val) SCIPsetFeasCeil((scip)->set, val)
18935 #define SCIPfeasRound(scip, val) SCIPsetFeasRound((scip)->set, val)
18936 #define SCIPfeasFrac(scip, val) SCIPsetFeasFrac((scip)->set, val)
18937 
18938 
18939 #define SCIPisLbBetter(scip, newlb, oldlb, oldub) SCIPsetIsLbBetter(scip->set, newlb, oldlb, oldub)
18940 #define SCIPisUbBetter(scip, newub, oldlb, oldub) SCIPsetIsUbBetter(scip->set, newub, oldlb, oldub)
18941 
18942 #define SCIPisRelEQ(scip, val1, val2) SCIPsetIsRelEQ((scip)->set, val1, val2)
18943 #define SCIPisRelLT(scip, val1, val2) SCIPsetIsRelLT((scip)->set, val1, val2)
18944 #define SCIPisRelLE(scip, val1, val2) SCIPsetIsRelLE((scip)->set, val1, val2)
18945 #define SCIPisRelGT(scip, val1, val2) SCIPsetIsRelGT((scip)->set, val1, val2)
18946 #define SCIPisRelGE(scip, val1, val2) SCIPsetIsRelGE((scip)->set, val1, val2)
18947 
18948 #define SCIPisSumRelEQ(scip, val1, val2) SCIPsetIsSumRelEQ((scip)->set, val1, val2)
18949 #define SCIPisSumRelLT(scip, val1, val2) SCIPsetIsSumRelLT((scip)->set, val1, val2)
18950 #define SCIPisSumRelLE(scip, val1, val2) SCIPsetIsSumRelLE((scip)->set, val1, val2)
18951 #define SCIPisSumRelGT(scip, val1, val2) SCIPsetIsSumRelGT((scip)->set, val1, val2)
18952 #define SCIPisSumRelGE(scip, val1, val2) SCIPsetIsSumRelGE((scip)->set, val1, val2)
18953 
18954 #define SCIPisUpdateUnreliable(scip, newval, oldval) SCIPsetIsUpdateUnreliable((scip)->set, newval, oldval)
18955 #endif
18956 
18957 /** outputs a real number, or "+infinity", or "-infinity" to a file */
18958 extern
18959 void SCIPprintReal(
18960  SCIP* scip, /**< SCIP data structure */
18961  FILE* file, /**< output file (or NULL for standard output) */
18962  SCIP_Real val, /**< value to print */
18963  int width, /**< width of the field */
18964  int precision /**< number of significant digits printed */
18965  );
18966 
18967 /**@} */
18968 
18969 
18970 
18971 
18972 /*
18973  * memory management
18974  */
18975 
18976 /**@name Memory Management */
18977 /**@{ */
18978 
18979 #define SCIPallocMemory(scip,ptr) ( (BMSallocMemory((ptr)) == NULL) \
18980  ? SCIP_NOMEMORY : SCIP_OKAY )
18981 #define SCIPallocMemoryArray(scip,ptr,num) ( (BMSallocMemoryArray((ptr), (num)) == NULL) \
18982  ? SCIP_NOMEMORY : SCIP_OKAY )
18983 #define SCIPallocClearMemoryArray(scip,ptr,num) ( (BMSallocClearMemoryArray((ptr), (num)) == NULL) \
18984  ? SCIP_NOMEMORY : SCIP_OKAY )
18985 #define SCIPallocMemorySize(scip,ptr,size) ( (BMSallocMemorySize((ptr), (size)) == NULL) \
18986  ? SCIP_NOMEMORY : SCIP_OKAY )
18987 #define SCIPreallocMemoryArray(scip,ptr,newnum) ( (BMSreallocMemoryArray((ptr), (newnum)) == NULL) \
18988  ? SCIP_NOMEMORY : SCIP_OKAY )
18989 #define SCIPreallocMemorySize(scip,ptr,newsize) ( (BMSreallocMemorySize((ptr), (newsize)) == NULL) \
18990  ? SCIP_NOMEMORY : SCIP_OKAY )
18991 #define SCIPduplicateMemory(scip, ptr, source) ( (BMSduplicateMemory((ptr), (source)) == NULL) \
18992  ? SCIP_NOMEMORY : SCIP_OKAY )
18993 #define SCIPduplicateMemoryArray(scip, ptr, source, num) \
18994  ( (BMSduplicateMemoryArray((ptr), (source), (num)) == NULL) \
18995  ? SCIP_NOMEMORY : SCIP_OKAY )
18996 #define SCIPfreeMemory(scip,ptr) BMSfreeMemory(ptr)
18997 #define SCIPfreeMemoryNull(scip,ptr) BMSfreeMemoryNull(ptr)
18998 #define SCIPfreeMemoryArray(scip,ptr) BMSfreeMemoryArray(ptr)
18999 #define SCIPfreeMemoryArrayNull(scip,ptr) BMSfreeMemoryArrayNull(ptr)
19000 #define SCIPfreeMemorySize(scip,ptr) BMSfreeMemorySize(ptr)
19001 #define SCIPfreeMemorySizeNull(scip,ptr) BMSfreeMemorySizeNull(ptr)
19002 
19003 #define SCIPallocBlockMemory(scip,ptr) ( (BMSallocBlockMemory(SCIPblkmem(scip), (ptr)) == NULL) \
19004  ? SCIP_NOMEMORY : SCIP_OKAY )
19005 #define SCIPallocBlockMemoryArray(scip,ptr,num) ( (BMSallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (num)) == NULL) \
19006  ? SCIP_NOMEMORY : SCIP_OKAY )
19007 #define SCIPallocBlockMemorySize(scip,ptr,size) ( (BMSallocBlockMemorySize(SCIPblkmem(scip), (ptr), (size)) == NULL) \
19008  ? SCIP_NOMEMORY : SCIP_OKAY )
19009 #define SCIPreallocBlockMemoryArray(scip,ptr,oldnum,newnum) \
19010  ( (BMSreallocBlockMemoryArray(SCIPblkmem(scip), (ptr), (oldnum), (newnum)) \
19011  == NULL) ? SCIP_NOMEMORY : SCIP_OKAY )
19012 #define SCIPreallocBlockMemorySize(scip,ptr,oldsize,newsize) \
19013  ( (BMSreallocBlockMemorySize(SCIPblkmem(scip), (ptr), (oldsize), (newsize)) \
19014  == NULL) ? SCIP_NOMEMORY : SCIP_OKAY )
19015 #define SCIPduplicateBlockMemory(scip, ptr, source) \
19016  ( (BMSduplicateBlockMemory(SCIPblkmem(scip), (ptr), (source)) == NULL) \
19017  ? SCIP_NOMEMORY : SCIP_OKAY )
19018 #define SCIPduplicateBlockMemoryArray(scip, ptr, source, num) \
19019  ( (BMSduplicateBlockMemoryArray(SCIPblkmem(scip), (ptr), (source), (num)) \
19020  == NULL) ? SCIP_NOMEMORY : SCIP_OKAY )
19021 #define SCIPensureBlockMemoryArray(scip,ptr,arraysizeptr,minsize) \
19022  ( (SCIPensureBlockMemoryArray_call((scip), (void**)(ptr), sizeof(**(ptr)), \
19023  (arraysizeptr), (minsize))) )
19024 #define SCIPfreeBlockMemory(scip,ptr) BMSfreeBlockMemory(SCIPblkmem(scip), (ptr))
19025 #define SCIPfreeBlockMemoryNull(scip,ptr) BMSfreeBlockMemoryNull(SCIPblkmem(scip), (ptr))
19026 #define SCIPfreeBlockMemoryArray(scip,ptr,num) BMSfreeBlockMemoryArray(SCIPblkmem(scip), (ptr), (num))
19027 #define SCIPfreeBlockMemoryArrayNull(scip,ptr,num) \
19028  BMSfreeBlockMemoryArrayNull(SCIPblkmem(scip), (ptr), (num))
19029 #define SCIPfreeBlockMemorySize(scip,ptr,size) BMSfreeBlockMemorySize(SCIPblkmem(scip), (ptr), (size))
19030 #define SCIPfreeBlockMemorySizeNull(scip,ptr,size) \
19031  BMSfreeBlockMemorySizeNull(SCIPblkmem(scip), (ptr), (size))
19032 
19033 #define SCIPallocBuffer(scip,ptr) SCIPallocBufferSize(scip, (void**)(ptr), (int)sizeof(**(ptr)))
19034 #define SCIPallocBufferArray(scip,ptr,num) SCIPallocBufferSize(scip, (void**)(ptr), (num)*(int)sizeof(**(ptr)))
19035 #define SCIPreallocBufferArray(scip,ptr,num) SCIPreallocBufferSize(scip, (void**)(ptr), (num)*(int)sizeof(**(ptr)))
19036 #define SCIPduplicateBuffer(scip,ptr,source) SCIPduplicateBufferSize(scip, (void**)(ptr), source, (int)sizeof(**(ptr)))
19037 #define SCIPduplicateBufferArray(scip,ptr,source,num) \
19038  SCIPduplicateBufferSize(scip, (void**)(ptr), source, (num)*(int)sizeof(**(ptr)))
19039 #define SCIPfreeBuffer(scip,ptr) SCIPfreeBufferSize(scip, (void**)(ptr), 0)
19040 #define SCIPfreeBufferNull(scip,ptr) { if( *(ptr) != NULL ) SCIPfreeBuffer(scip, ptr); }
19041 #define SCIPfreeBufferArray(scip,ptr) SCIPfreeBufferSize(scip, (void**)(ptr), 0)
19042 #define SCIPfreeBufferArrayNull(scip,ptr) { if( *(ptr) != NULL ) SCIPfreeBufferArray(scip, ptr); }
19043 
19044 
19045 /** returns block memory to use at the current time
19046  *
19047  * @return the block memory to use at the current time.
19048  */
19049 extern
19051  SCIP* scip /**< SCIP data structure */
19052  );
19053 
19054 /** returns the total number of bytes used in block memory
19055  *
19056  * @return the total number of bytes used in block memory.
19057  */
19058 extern
19060  SCIP* scip /**< SCIP data structure */
19061  );
19062 
19063 /** returns the estimated number of bytes used by external software, e.g., the LP solver
19064  *
19065  * @return the estimated number of bytes used by external software, e.g., the LP solver.
19066  */
19067 extern
19069  SCIP* scip /**< SCIP data structure */
19070  );
19071 
19072 /** calculate memory size for dynamically allocated arrays
19073  *
19074  * @return the memory size for dynamically allocated arrays.
19075  */
19076 extern
19078  SCIP* scip, /**< SCIP data structure */
19079  int num /**< minimum number of entries to store */
19080  );
19081 
19082 /** extends a dynamically allocated block memory array to be able to store at least the given number of elements;
19083  * use SCIPensureBlockMemoryArray() define to call this method!
19084  *
19085  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19086  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19087  */
19088 extern
19090  SCIP* scip, /**< SCIP data structure */
19091  void** arrayptr, /**< pointer to dynamically sized array */
19092  size_t elemsize, /**< size in bytes of each element in array */
19093  int* arraysize, /**< pointer to current array size */
19094  int minsize /**< required minimal array size */
19095  );
19096 
19097 /** gets a memory buffer with at least the given size
19098  *
19099  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19100  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19101  */
19102 extern
19104  SCIP* scip, /**< SCIP data structure */
19105  void** ptr, /**< pointer to store the buffer */
19106  int size /**< required size in bytes of buffer */
19107  );
19108 
19109 /** allocates a memory buffer with at least the given size and copies the given memory into the buffer
19110  *
19111  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19112  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19113  */
19114 extern
19116  SCIP* scip, /**< SCIP data structure */
19117  void** ptr, /**< pointer to store the buffer */
19118  const void* source, /**< memory block to copy into the buffer */
19119  int size /**< required size in bytes of buffer */
19120  );
19121 
19122 /** reallocates a memory buffer to at least the given size
19123  *
19124  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19125  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19126  */
19127 extern
19129  SCIP* scip, /**< SCIP data structure */
19130  void** ptr, /**< pointer to the buffer */
19131  int size /**< required size in bytes of buffer */
19132  );
19133 
19134 /** frees a memory buffer */
19135 extern
19136 void SCIPfreeBufferSize(
19137  SCIP* scip, /**< SCIP data structure */
19138  void** ptr, /**< pointer to the buffer */
19139  int dummysize /**< used to get a safer define for SCIPfreeBuffer() and SCIPfreeBufferArray() */
19140  );
19141 
19142 /** prints output about used memory */
19143 extern
19145  SCIP* scip /**< SCIP data structure */
19146  );
19147 
19148 /**@} */
19149 
19150 
19151 
19152 
19153 /*
19154  * dynamic arrays
19155  */
19156 
19157 /**@name Dynamic Arrays */
19158 /**@{ */
19159 
19160 /** creates a dynamic array of real values
19161  *
19162  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19163  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19164  */
19165 extern
19167  SCIP* scip, /**< SCIP data structure */
19168  SCIP_REALARRAY** realarray /**< pointer to store the real array */
19169  );
19170 
19171 /** frees a dynamic array of real values
19172  *
19173  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19174  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19175  */
19176 extern
19178  SCIP* scip, /**< SCIP data structure */
19179  SCIP_REALARRAY** realarray /**< pointer to the real array */
19180  );
19181 
19182 /** extends dynamic array to be able to store indices from minidx to maxidx
19183  *
19184  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19185  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19186  */
19187 extern
19189  SCIP* scip, /**< SCIP data structure */
19190  SCIP_REALARRAY* realarray, /**< dynamic real array */
19191  int minidx, /**< smallest index to allocate storage for */
19192  int maxidx /**< largest index to allocate storage for */
19193  );
19194 
19195 /** clears a dynamic real array
19196  *
19197  * @return clears a dynamic real array
19198  */
19199 extern
19201  SCIP* scip, /**< SCIP data structure */
19202  SCIP_REALARRAY* realarray /**< dynamic real array */
19203  );
19204 
19205 /** gets value of entry in dynamic array */
19206 extern
19208  SCIP* scip, /**< SCIP data structure */
19209  SCIP_REALARRAY* realarray, /**< dynamic real array */
19210  int idx /**< array index to get value for */
19211  );
19212 
19213 /** sets value of entry in dynamic array
19214  *
19215  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19216  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19217  */
19218 extern
19220  SCIP* scip, /**< SCIP data structure */
19221  SCIP_REALARRAY* realarray, /**< dynamic real array */
19222  int idx, /**< array index to set value for */
19223  SCIP_Real val /**< value to set array index to */
19224  );
19225 
19226 /** increases value of entry in dynamic array
19227  *
19228  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19229  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19230  */
19231 extern
19233  SCIP* scip, /**< SCIP data structure */
19234  SCIP_REALARRAY* realarray, /**< dynamic real array */
19235  int idx, /**< array index to increase value for */
19236  SCIP_Real incval /**< value to increase array index */
19237  );
19238 
19239 /** returns the minimal index of all stored non-zero elements
19240  *
19241  * @return the minimal index of all stored non-zero elements
19242  */
19243 extern
19245  SCIP* scip, /**< SCIP data structure */
19246  SCIP_REALARRAY* realarray /**< dynamic real array */
19247  );
19248 
19249 /** returns the maximal index of all stored non-zero elements
19250  *
19251  * @return the maximal index of all stored non-zero elements
19252  */
19253 extern
19255  SCIP* scip, /**< SCIP data structure */
19256  SCIP_REALARRAY* realarray /**< dynamic real array */
19257  );
19258 
19259 /** creates a dynamic array of int values
19260  *
19261  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19262  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19263  */
19264 extern
19266  SCIP* scip, /**< SCIP data structure */
19267  SCIP_INTARRAY** intarray /**< pointer to store the int array */
19268  );
19269 
19270 /** frees a dynamic array of int values
19271  *
19272  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19273  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19274  */
19275 extern
19277  SCIP* scip, /**< SCIP data structure */
19278  SCIP_INTARRAY** intarray /**< pointer to the int array */
19279  );
19280 
19281 /** extends dynamic array to be able to store indices from minidx to maxidx
19282  *
19283  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19284  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19285  */
19286 extern
19288  SCIP* scip, /**< SCIP data structure */
19289  SCIP_INTARRAY* intarray, /**< dynamic int array */
19290  int minidx, /**< smallest index to allocate storage for */
19291  int maxidx /**< largest index to allocate storage for */
19292  );
19293 
19294 /** clears a dynamic int array
19295  *
19296  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19297  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19298  */
19299 extern
19301  SCIP* scip, /**< SCIP data structure */
19302  SCIP_INTARRAY* intarray /**< dynamic int array */
19303  );
19304 
19305 /** gets value of entry in dynamic array
19306  *
19307  * @return value of entry in dynamic array
19308  */
19309 extern
19310 int SCIPgetIntarrayVal(
19311  SCIP* scip, /**< SCIP data structure */
19312  SCIP_INTARRAY* intarray, /**< dynamic int array */
19313  int idx /**< array index to get value for */
19314  );
19315 
19316 /** sets value of entry in dynamic array
19317  *
19318  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19319  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19320  */
19321 extern
19323  SCIP* scip, /**< SCIP data structure */
19324  SCIP_INTARRAY* intarray, /**< dynamic int array */
19325  int idx, /**< array index to set value for */
19326  int val /**< value to set array index to */
19327  );
19328 
19329 /** increases value of entry in dynamic array
19330  *
19331  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19332  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19333  */
19334 extern
19336  SCIP* scip, /**< SCIP data structure */
19337  SCIP_INTARRAY* intarray, /**< dynamic int array */
19338  int idx, /**< array index to increase value for */
19339  int incval /**< value to increase array index */
19340  );
19341 
19342 /** returns the minimal index of all stored non-zero elements
19343  *
19344  * @return the minimal index of all stored non-zero elements
19345  */
19346 extern
19348  SCIP* scip, /**< SCIP data structure */
19349  SCIP_INTARRAY* intarray /**< dynamic int array */
19350  );
19351 
19352 /** returns the maximal index of all stored non-zero elements
19353  *
19354  * @return the maximal index of all stored non-zero elements
19355  */
19356 extern
19358  SCIP* scip, /**< SCIP data structure */
19359  SCIP_INTARRAY* intarray /**< dynamic int array */
19360  );
19361 
19362 /** creates a dynamic array of bool values
19363  *
19364  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19365  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19366  */
19367 extern
19369  SCIP* scip, /**< SCIP data structure */
19370  SCIP_BOOLARRAY** boolarray /**< pointer to store the bool array */
19371  );
19372 
19373 /** frees a dynamic array of bool values
19374  *
19375  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19376  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19377  */
19378 extern
19380  SCIP* scip, /**< SCIP data structure */
19381  SCIP_BOOLARRAY** boolarray /**< pointer to the bool array */
19382  );
19383 
19384 /** extends dynamic array to be able to store indices from minidx to maxidx
19385  *
19386  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19387  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19388  */
19389 extern
19391  SCIP* scip, /**< SCIP data structure */
19392  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
19393  int minidx, /**< smallest index to allocate storage for */
19394  int maxidx /**< largest index to allocate storage for */
19395  );
19396 
19397 /** clears a dynamic bool array
19398  *
19399  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19400  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19401  */
19402 extern
19404  SCIP* scip, /**< SCIP data structure */
19405  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
19406  );
19407 
19408 /** gets value of entry in dynamic array
19409  *
19410  * @return value of entry in dynamic array at position idx
19411  */
19412 extern
19414  SCIP* scip, /**< SCIP data structure */
19415  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
19416  int idx /**< array index to get value for */
19417  );
19418 
19419 /** sets value of entry in dynamic array
19420  *
19421  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19422  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19423  */
19424 extern
19426  SCIP* scip, /**< SCIP data structure */
19427  SCIP_BOOLARRAY* boolarray, /**< dynamic bool array */
19428  int idx, /**< array index to set value for */
19429  SCIP_Bool val /**< value to set array index to */
19430  );
19431 
19432 /** returns the minimal index of all stored non-zero elements
19433  *
19434  * @return the minimal index of all stored non-zero elements
19435  */
19436 extern
19438  SCIP* scip, /**< SCIP data structure */
19439  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
19440  );
19441 
19442 /** returns the maximal index of all stored non-zero elements
19443  *
19444  * @return the maximal index of all stored non-zero elements
19445  */
19446 extern
19448  SCIP* scip, /**< SCIP data structure */
19449  SCIP_BOOLARRAY* boolarray /**< dynamic bool array */
19450  );
19451 
19452 /** creates a dynamic array of pointers
19453  *
19454  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19455  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19456  */
19457 extern
19459  SCIP* scip, /**< SCIP data structure */
19460  SCIP_PTRARRAY** ptrarray /**< pointer to store the int array */
19461  );
19462 
19463 /** frees a dynamic array of pointers
19464  *
19465  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19466  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19467  */
19468 extern
19470  SCIP* scip, /**< SCIP data structure */
19471  SCIP_PTRARRAY** ptrarray /**< pointer to the int array */
19472  );
19473 
19474 /** extends dynamic array to be able to store indices from minidx to maxidx
19475  *
19476  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19477  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19478  */
19479 extern
19481  SCIP* scip, /**< SCIP data structure */
19482  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
19483  int minidx, /**< smallest index to allocate storage for */
19484  int maxidx /**< largest index to allocate storage for */
19485  );
19486 
19487 /** clears a dynamic pointer array
19488  *
19489  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
19490  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
19491  */
19492 extern
19494  SCIP* scip, /**< SCIP data structure */
19495  SCIP_PTRARRAY* ptrarray /**< dynamic int array */
19496  );
19497 
19498 /** gets value of entry in dynamic array */
19499 extern
19500 void* SCIPgetPtrarrayVal(
19501  SCIP* scip, /**< SCIP data structure */
19502  SCIP_PTRARRAY* ptrarray, /**< dynamic int array */
19503  int idx /**< array index to get value for */
19504  );
19505 
19506 /** sets value of entry in dynamic array
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_PTRARRAY* ptrarray, /**< dynamic int array */
19515  int idx, /**< array index to set value for */
19516  void* val /**< value to set array index to */
19517  );
19518 
19519 /** returns the minimal index of all stored non-zero elements
19520  *
19521  * @return the minimal index of all stored non-zero elements
19522  */
19523 extern
19525  SCIP* scip, /**< SCIP data structure */
19526  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
19527  );
19528 
19529 /** returns the maximal index of all stored non-zero elements
19530  *
19531  * @return the maximal index of all stored non-zero elements
19532  */
19533 extern
19535  SCIP* scip, /**< SCIP data structure */
19536  SCIP_PTRARRAY* ptrarray /**< dynamic ptr array */
19537  );
19538 
19539 #ifdef NDEBUG
19540 
19541 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
19542  * speed up the algorithms.
19543  */
19544 
19545 #define SCIPcreateRealarray(scip, realarray) SCIPrealarrayCreate(realarray, SCIPblkmem(scip))
19546 #define SCIPfreeRealarray(scip, realarray) SCIPrealarrayFree(realarray)
19547 #define SCIPextendRealarray(scip, realarray, minidx, maxidx) SCIPrealarrayExtend(realarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, minidx, maxidx)
19548 #define SCIPclearRealarray(scip, realarray) SCIPrealarrayClear(realarray)
19549 #define SCIPgetRealarrayVal(scip, realarray, idx) SCIPrealarrayGetVal(realarray, idx)
19550 #define SCIPsetRealarrayVal(scip, realarray, idx, val) SCIPrealarraySetVal(realarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, idx, val)
19551 #define SCIPincRealarrayVal(scip, realarray, idx, incval) SCIPrealarrayIncVal(realarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, idx, incval)
19552 #define SCIPgetRealarrayMinIdx(scip, realarray) SCIPrealarrayGetMinIdx(realarray)
19553 #define SCIPgetRealarrayMaxIdx(scip, realarray) SCIPrealarrayGetMaxIdx(realarray)
19554 
19555 #define SCIPcreateIntarray(scip, intarray) SCIPintarrayCreate(intarray, SCIPblkmem(scip))
19556 #define SCIPfreeIntarray(scip, intarray) SCIPintarrayFree(intarray)
19557 #define SCIPextendIntarray(scip, intarray, minidx, maxidx) SCIPintarrayExtend(intarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, minidx, maxidx)
19558 #define SCIPclearIntarray(scip, intarray) SCIPintarrayClear(intarray)
19559 #define SCIPgetIntarrayVal(scip, intarray, idx) SCIPintarrayGetVal(intarray, idx)
19560 #define SCIPsetIntarrayVal(scip, intarray, idx, val) SCIPintarraySetVal(intarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, idx, val)
19561 #define SCIPincIntarrayVal(scip, intarray, idx, incval) SCIPintarrayIncVal(intarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, idx, incval)
19562 #define SCIPgetIntarrayMinIdx(scip, intarray) SCIPintarrayGetMinIdx(intarray)
19563 #define SCIPgetIntarrayMaxIdx(scip, intarray) SCIPintarrayGetMaxIdx(intarray)
19564 
19565 #define SCIPcreateBoolarray(scip, boolarray) SCIPboolarrayCreate(boolarray, SCIPblkmem(scip))
19566 #define SCIPfreeBoolarray(scip, boolarray) SCIPboolarrayFree(boolarray)
19567 #define SCIPextendBoolarray(scip, boolarray, minidx, maxidx) SCIPboolarrayExtend(boolarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, minidx, maxidx)
19568 #define SCIPclearBoolarray(scip, boolarray) SCIPboolarrayClear(boolarray)
19569 #define SCIPgetBoolarrayVal(scip, boolarray, idx) SCIPboolarrayGetVal(boolarray, idx)
19570 #define SCIPsetBoolarrayVal(scip, boolarray, idx, val) SCIPboolarraySetVal(boolarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, idx, val)
19571 #define SCIPgetBoolarrayMinIdx(scip, boolarray) SCIPboolarrayGetMinIdx(boolarray)
19572 #define SCIPgetBoolarrayMaxIdx(scip, boolarray) SCIPboolarrayGetMaxIdx(boolarray)
19573 
19574 #define SCIPcreatePtrarray(scip, ptrarray) SCIPptrarrayCreate(ptrarray, SCIPblkmem(scip))
19575 #define SCIPfreePtrarray(scip, ptrarray) SCIPptrarrayFree(ptrarray)
19576 #define SCIPextendPtrarray(scip, ptrarray, minidx, maxidx) SCIPptrarrayExtend(ptrarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, minidx, maxidx)
19577 #define SCIPclearPtrarray(scip, ptrarray) SCIPptrarrayClear(ptrarray)
19578 #define SCIPgetPtrarrayVal(scip, ptrarray, idx) SCIPptrarrayGetVal(ptrarray, idx)
19579 #define SCIPsetPtrarrayVal(scip, ptrarray, idx, val) SCIPptrarraySetVal(ptrarray, (scip)->set->mem_arraygrowinit, (scip)->set->mem_arraygrowfac, idx, val)
19580 #define SCIPgetPtrarrayMinIdx(scip, ptrarray) SCIPptrarrayGetMinIdx(ptrarray)
19581 #define SCIPgetPtrarrayMaxIdx(scip, ptrarray) SCIPptrarrayGetMaxIdx(ptrarray)
19582 
19583 #endif
19584 
19585 /**@} */
19586 #ifdef __cplusplus
19587 }
19588 #endif
19589 
19590 #endif
19591