Scippy

SCIP

Solving Constraint Integer Programs

scip_solvingstats.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-2018 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 visit scip.zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_solvingstats.h
17  * @ingroup PUBLICCOREAPI
18  * @brief public methods for querying solving statistics
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  * @author Gregor Hendel
26  * @author Robert Lion Gottwald
27  */
28 
29 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
30 
31 #ifndef __SCIP_SCIP_SOLVINGSTATS_H__
32 #define __SCIP_SCIP_SOLVINGSTATS_H__
33 
34 
35 #include "scip/def.h"
36 #include "scip/type_history.h"
37 #include "scip/type_message.h"
38 #include "scip/type_retcode.h"
39 #include "scip/type_scip.h"
40 
41 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
42  * this structure except the interface methods in scip.c.
43  * In optimized mode, the structure is included in scip.h, because some of the methods
44  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
45  * Additionally, the internal "set.h" is included, such that the defines in set.h are
46  * available in optimized mode.
47  */
48 #ifdef NDEBUG
49 #include "scip/struct_scip.h"
50 #include "scip/struct_stat.h"
51 #include "scip/set.h"
52 #include "scip/tree.h"
53 #include "scip/misc.h"
54 #include "scip/var.h"
55 #include "scip/cons.h"
56 #include "scip/solve.h"
57 #include "scip/debug.h"
58 #endif
59 
60 #ifdef __cplusplus
61 extern "C" {
62 #endif
63 
64 /**@addtogroup PublicSolvingStatsMethods
65  *
66  * @{
67  */
68 
69 /** gets number of branch and bound runs performed, including the current run
70  *
71  * @return the number of branch and bound runs performed, including the current run
72  *
73  * @pre This method can be called if SCIP is in one of the following stages:
74  * - \ref SCIP_STAGE_PROBLEM
75  * - \ref SCIP_STAGE_TRANSFORMING
76  * - \ref SCIP_STAGE_TRANSFORMED
77  * - \ref SCIP_STAGE_INITPRESOLVE
78  * - \ref SCIP_STAGE_PRESOLVING
79  * - \ref SCIP_STAGE_EXITPRESOLVE
80  * - \ref SCIP_STAGE_PRESOLVED
81  * - \ref SCIP_STAGE_INITSOLVE
82  * - \ref SCIP_STAGE_SOLVING
83  * - \ref SCIP_STAGE_SOLVED
84  * - \ref SCIP_STAGE_EXITSOLVE
85  * - \ref SCIP_STAGE_FREETRANS
86  */
87 extern
88 int SCIPgetNRuns(
89  SCIP* scip /**< SCIP data structure */
90  );
91 
92 /** gets number of reoptimization runs performed, including the current run
93  *
94  * @return the number of reoptimization runs performed, including the current run
95  *
96  * @pre This method can be called if SCIP is in one of the following stages:
97  * - \ref SCIP_STAGE_PROBLEM
98  * - \ref SCIP_STAGE_TRANSFORMING
99  * - \ref SCIP_STAGE_TRANSFORMED
100  * - \ref SCIP_STAGE_INITPRESOLVE
101  * - \ref SCIP_STAGE_PRESOLVING
102  * - \ref SCIP_STAGE_EXITPRESOLVE
103  * - \ref SCIP_STAGE_PRESOLVED
104  * - \ref SCIP_STAGE_INITSOLVE
105  * - \ref SCIP_STAGE_SOLVING
106  * - \ref SCIP_STAGE_SOLVED
107  * - \ref SCIP_STAGE_EXITSOLVE
108  * - \ref SCIP_STAGE_FREETRANS
109  */
110 extern
112  SCIP* scip /**< SCIP data structure */
113  );
114 
115 /** add given number to the number of processed nodes in current run and in all runs, including the focus node
116  *
117  * @return the number of processed nodes in current run, including the focus node
118  *
119  * @pre This method can be called if SCIP is in one of the following stages:
120  * - \ref SCIP_STAGE_PROBLEM
121  * - \ref SCIP_STAGE_TRANSFORMING
122  * - \ref SCIP_STAGE_TRANSFORMED
123  * - \ref SCIP_STAGE_INITPRESOLVE
124  * - \ref SCIP_STAGE_PRESOLVING
125  * - \ref SCIP_STAGE_EXITPRESOLVE
126  * - \ref SCIP_STAGE_PRESOLVED
127  * - \ref SCIP_STAGE_INITSOLVE
128  * - \ref SCIP_STAGE_SOLVING
129  * - \ref SCIP_STAGE_SOLVED
130  * - \ref SCIP_STAGE_EXITSOLVE
131  * - \ref SCIP_STAGE_FREETRANS
132  */
133 extern
134 void SCIPaddNNodes(
135  SCIP* scip, /**< SCIP data structure */
136  SCIP_Longint nnodes /**< number of processed nodes to add to the statistics */
137  );
138 
139 /** gets number of processed nodes in current run, including the focus node
140  *
141  * @return the number of processed nodes in current run, including the focus node
142  *
143  * @pre This method can be called if SCIP is in one of the following stages:
144  * - \ref SCIP_STAGE_PROBLEM
145  * - \ref SCIP_STAGE_TRANSFORMING
146  * - \ref SCIP_STAGE_TRANSFORMED
147  * - \ref SCIP_STAGE_INITPRESOLVE
148  * - \ref SCIP_STAGE_PRESOLVING
149  * - \ref SCIP_STAGE_EXITPRESOLVE
150  * - \ref SCIP_STAGE_PRESOLVED
151  * - \ref SCIP_STAGE_INITSOLVE
152  * - \ref SCIP_STAGE_SOLVING
153  * - \ref SCIP_STAGE_SOLVED
154  * - \ref SCIP_STAGE_EXITSOLVE
155  * - \ref SCIP_STAGE_FREETRANS
156  */
157 extern
159  SCIP* scip /**< SCIP data structure */
160  );
161 
162 /** gets total number of processed nodes in all runs, including the focus node
163  *
164  * @return the total number of processed nodes in all runs, including the focus node
165  *
166  * @pre This method can be called if SCIP is in one of the following stages:
167  * - \ref SCIP_STAGE_PROBLEM
168  * - \ref SCIP_STAGE_TRANSFORMING
169  * - \ref SCIP_STAGE_TRANSFORMED
170  * - \ref SCIP_STAGE_INITPRESOLVE
171  * - \ref SCIP_STAGE_PRESOLVING
172  * - \ref SCIP_STAGE_EXITPRESOLVE
173  * - \ref SCIP_STAGE_PRESOLVED
174  * - \ref SCIP_STAGE_INITSOLVE
175  * - \ref SCIP_STAGE_SOLVING
176  * - \ref SCIP_STAGE_SOLVED
177  * - \ref SCIP_STAGE_EXITSOLVE
178  * - \ref SCIP_STAGE_FREETRANS
179  */
180 extern
182  SCIP* scip /**< SCIP data structure */
183  );
184 
185 /** gets number of leaf nodes processed with feasible relaxation solution
186  *
187  * @return number of leaf nodes processed with feasible relaxation solution
188  *
189  * @pre This method can be called if SCIP is in one of the following stages:
190  * - \ref SCIP_STAGE_PROBLEM
191  * - \ref SCIP_STAGE_TRANSFORMING
192  * - \ref SCIP_STAGE_TRANSFORMED
193  * - \ref SCIP_STAGE_INITPRESOLVE
194  * - \ref SCIP_STAGE_PRESOLVING
195  * - \ref SCIP_STAGE_EXITPRESOLVE
196  * - \ref SCIP_STAGE_PRESOLVED
197  * - \ref SCIP_STAGE_INITSOLVE
198  * - \ref SCIP_STAGE_SOLVING
199  * - \ref SCIP_STAGE_SOLVED
200  * - \ref SCIP_STAGE_EXITSOLVE
201  * - \ref SCIP_STAGE_FREETRANS
202  */
203 extern
205  SCIP* scip /**< SCIP data structure */
206  );
207 
208 /** gets number of infeasible leaf nodes processed
209  *
210  * @return number of infeasible leaf nodes processed
211  *
212  * @pre This method can be called if SCIP is in one of the following stages:
213  * - \ref SCIP_STAGE_PROBLEM
214  * - \ref SCIP_STAGE_TRANSFORMING
215  * - \ref SCIP_STAGE_TRANSFORMED
216  * - \ref SCIP_STAGE_INITPRESOLVE
217  * - \ref SCIP_STAGE_PRESOLVING
218  * - \ref SCIP_STAGE_EXITPRESOLVE
219  * - \ref SCIP_STAGE_PRESOLVED
220  * - \ref SCIP_STAGE_INITSOLVE
221  * - \ref SCIP_STAGE_SOLVING
222  * - \ref SCIP_STAGE_SOLVED
223  * - \ref SCIP_STAGE_EXITSOLVE
224  * - \ref SCIP_STAGE_FREETRANS
225  */
226 extern
228  SCIP* scip /**< SCIP data structure */
229  );
230 
231 /** gets number of processed leaf nodes that hit LP objective limit
232  *
233  * @return number of processed leaf nodes that hit LP objective limit
234  *
235  * @pre This method can be called if SCIP is in one of the following stages:
236  * - \ref SCIP_STAGE_PROBLEM
237  * - \ref SCIP_STAGE_TRANSFORMING
238  * - \ref SCIP_STAGE_TRANSFORMED
239  * - \ref SCIP_STAGE_INITPRESOLVE
240  * - \ref SCIP_STAGE_PRESOLVING
241  * - \ref SCIP_STAGE_EXITPRESOLVE
242  * - \ref SCIP_STAGE_PRESOLVED
243  * - \ref SCIP_STAGE_INITSOLVE
244  * - \ref SCIP_STAGE_SOLVING
245  * - \ref SCIP_STAGE_SOLVED
246  * - \ref SCIP_STAGE_EXITSOLVE
247  * - \ref SCIP_STAGE_FREETRANS
248  */
249 extern
251  SCIP* scip /**< SCIP data structure */
252  );
253 
254 /** gets number of times a selected node was from a cut off subtree
255  *
256  * @return number of times a selected node was from a cut off subtree
257  *
258  * @pre This method can be called if SCIP is in one of the following stages:
259  * - \ref SCIP_STAGE_PROBLEM
260  * - \ref SCIP_STAGE_TRANSFORMING
261  * - \ref SCIP_STAGE_TRANSFORMED
262  * - \ref SCIP_STAGE_INITPRESOLVE
263  * - \ref SCIP_STAGE_PRESOLVING
264  * - \ref SCIP_STAGE_EXITPRESOLVE
265  * - \ref SCIP_STAGE_PRESOLVED
266  * - \ref SCIP_STAGE_INITSOLVE
267  * - \ref SCIP_STAGE_SOLVING
268  * - \ref SCIP_STAGE_SOLVED
269  * - \ref SCIP_STAGE_EXITSOLVE
270  * - \ref SCIP_STAGE_FREETRANS
271  */
272 extern
274  SCIP* scip /**< SCIP data structure */
275  );
276 
277 /** gets total number of LPs solved so far
278  *
279  * @return the total number of LPs solved so far
280  *
281  * @pre This method can be called if SCIP is in one of the following stages:
282  * - \ref SCIP_STAGE_PROBLEM
283  * - \ref SCIP_STAGE_TRANSFORMING
284  * - \ref SCIP_STAGE_TRANSFORMED
285  * - \ref SCIP_STAGE_INITPRESOLVE
286  * - \ref SCIP_STAGE_PRESOLVING
287  * - \ref SCIP_STAGE_EXITPRESOLVE
288  * - \ref SCIP_STAGE_PRESOLVED
289  * - \ref SCIP_STAGE_INITSOLVE
290  * - \ref SCIP_STAGE_SOLVING
291  * - \ref SCIP_STAGE_SOLVED
292  * - \ref SCIP_STAGE_EXITSOLVE
293  * - \ref SCIP_STAGE_FREETRANS
294  */
295 extern
297  SCIP* scip /**< SCIP data structure */
298  );
299 
300 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm
301  *
302  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm
303  *
304  * @pre This method can be called if SCIP is in one of the following stages:
305  * - \ref SCIP_STAGE_PRESOLVING
306  * - \ref SCIP_STAGE_PRESOLVED
307  * - \ref SCIP_STAGE_SOLVING
308  * - \ref SCIP_STAGE_SOLVED
309  */
310 extern
312  SCIP* scip /**< SCIP data structure */
313  );
314 
315 /** gets number of active non-zeros in the current transformed problem
316  *
317  * @return the number of active non-zeros in the current transformed problem
318  *
319  * @pre This method can be called if SCIP is in one of the following stages:
320  * - \ref SCIP_STAGE_PROBLEM
321  * - \ref SCIP_STAGE_TRANSFORMING
322  * - \ref SCIP_STAGE_TRANSFORMED
323  * - \ref SCIP_STAGE_INITPRESOLVE
324  * - \ref SCIP_STAGE_PRESOLVING
325  * - \ref SCIP_STAGE_EXITPRESOLVE
326  * - \ref SCIP_STAGE_PRESOLVED
327  * - \ref SCIP_STAGE_INITSOLVE
328  * - \ref SCIP_STAGE_SOLVING
329  * - \ref SCIP_STAGE_SOLVED
330  * - \ref SCIP_STAGE_EXITSOLVE
331  */
332 extern
334  SCIP* scip /**< SCIP data structure */
335  );
336 
337 
338 /** gets total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
339  *
340  * @return the total number of iterations used so far in primal and dual simplex and barrier algorithm for the root node
341  *
342  * @pre This method can be called if SCIP is in one of the following stages:
343  * - \ref SCIP_STAGE_PRESOLVED
344  * - \ref SCIP_STAGE_SOLVING
345  * - \ref SCIP_STAGE_SOLVED
346  */
347 extern
349  SCIP* scip /**< SCIP data structure */
350  );
351 
352 /** gets total number of iterations used in primal and dual simplex and barrier algorithm for the first LP at the root
353  * node
354  *
355  * @return the total number of iterations used in primal and dual simplex and barrier algorithm for the first root LP
356  *
357  * @pre This method can be called if SCIP is in one of the following stages:
358  * - \ref SCIP_STAGE_PRESOLVED
359  * - \ref SCIP_STAGE_SOLVING
360  * - \ref SCIP_STAGE_SOLVED
361  */
362 extern
364  SCIP* scip /**< SCIP data structure */
365  );
366 
367 /** gets total number of primal LPs solved so far
368  *
369  * @return the total number of primal LPs solved so far
370  *
371  * @pre This method can be called if SCIP is in one of the following stages:
372  * - \ref SCIP_STAGE_PRESOLVED
373  * - \ref SCIP_STAGE_SOLVING
374  * - \ref SCIP_STAGE_SOLVED
375  */
376 extern
378  SCIP* scip /**< SCIP data structure */
379  );
380 
381 /** gets total number of iterations used so far in primal simplex
382  *
383  * @return total number of iterations used so far in primal simplex
384  *
385  * @pre This method can be called if SCIP is in one of the following stages:
386  * - \ref SCIP_STAGE_PRESOLVED
387  * - \ref SCIP_STAGE_SOLVING
388  * - \ref SCIP_STAGE_SOLVED
389  */
390 extern
392  SCIP* scip /**< SCIP data structure */
393  );
394 
395 /** gets total number of dual LPs solved so far
396  *
397  * @return the total number of dual LPs solved so far
398  *
399  * @pre This method can be called if SCIP is in one of the following stages:
400  * - \ref SCIP_STAGE_PRESOLVED
401  * - \ref SCIP_STAGE_SOLVING
402  * - \ref SCIP_STAGE_SOLVED
403  */
404 extern
406  SCIP* scip /**< SCIP data structure */
407  );
408 
409 /** gets total number of iterations used so far in dual simplex
410  *
411  * @return the total number of iterations used so far in dual simplex
412  *
413  * @pre This method can be called if SCIP is in one of the following stages:
414  * - \ref SCIP_STAGE_PRESOLVED
415  * - \ref SCIP_STAGE_SOLVING
416  * - \ref SCIP_STAGE_SOLVED
417  */
418 extern
420  SCIP* scip /**< SCIP data structure */
421  );
422 
423 /** gets total number of barrier LPs solved so far
424  *
425  * @return the total number of barrier LPs solved so far
426  *
427  * @pre This method can be called if SCIP is in one of the following stages:
428  * - \ref SCIP_STAGE_PRESOLVED
429  * - \ref SCIP_STAGE_SOLVING
430  * - \ref SCIP_STAGE_SOLVED
431  */
432 extern
434  SCIP* scip /**< SCIP data structure */
435  );
436 
437 /** gets total number of iterations used so far in barrier algorithm
438  *
439  * @return the total number of iterations used so far in barrier algorithm
440  *
441  * @pre This method can be called if SCIP is in one of the following stages:
442  * - \ref SCIP_STAGE_PRESOLVED
443  * - \ref SCIP_STAGE_SOLVING
444  * - \ref SCIP_STAGE_SOLVED
445  */
446 extern
448  SCIP* scip /**< SCIP data structure */
449  );
450 
451 /** gets total number of LPs solved so far that were resolved from an advanced start basis
452  *
453  * @return the total number of LPs solved so far that were resolved from an advanced start basis
454  *
455  * @pre This method can be called if SCIP is in one of the following stages:
456  * - \ref SCIP_STAGE_PRESOLVED
457  * - \ref SCIP_STAGE_SOLVING
458  * - \ref SCIP_STAGE_SOLVED
459  */
460 extern
462  SCIP* scip /**< SCIP data structure */
463  );
464 
465 /** gets total number of simplex iterations used so far in primal and dual simplex calls where an advanced start basis
466  * was available
467  *
468  * @return the total number of simplex iterations used so far in primal and dual simplex calls where an advanced start
469  * basis was available
470  *
471  * @pre This method can be called if SCIP is in one of the following stages:
472  * - \ref SCIP_STAGE_PRESOLVED
473  * - \ref SCIP_STAGE_SOLVING
474  * - \ref SCIP_STAGE_SOLVED
475  */
476 extern
478  SCIP* scip /**< SCIP data structure */
479  );
480 
481 /** gets total number of primal LPs solved so far that were resolved from an advanced start basis
482  *
483  * @return the total number of primal LPs solved so far that were resolved from an advanced start basis
484  *
485  * @pre This method can be called if SCIP is in one of the following stages:
486  * - \ref SCIP_STAGE_PRESOLVED
487  * - \ref SCIP_STAGE_SOLVING
488  * - \ref SCIP_STAGE_SOLVED
489  */
490 extern
492  SCIP* scip /**< SCIP data structure */
493  );
494 
495 /** gets total number of simplex iterations used so far in primal simplex calls where an advanced start basis
496  * was available
497  *
498  * @return the total number of simplex iterations used so far in primal simplex calls where an advanced start
499  * basis was available
500  *
501  * @pre This method can be called if SCIP is in one of the following stages:
502  * - \ref SCIP_STAGE_PRESOLVED
503  * - \ref SCIP_STAGE_SOLVING
504  * - \ref SCIP_STAGE_SOLVED
505  */
506 extern
508  SCIP* scip /**< SCIP data structure */
509  );
510 
511 /** gets total number of dual LPs solved so far that were resolved from an advanced start basis
512  *
513  * @return the total number of dual LPs solved so far that were resolved from an advanced start basis
514  *
515  * @pre This method can be called if SCIP is in one of the following stages:
516  * - \ref SCIP_STAGE_PRESOLVED
517  * - \ref SCIP_STAGE_SOLVING
518  * - \ref SCIP_STAGE_SOLVED
519  */
520 extern
522  SCIP* scip /**< SCIP data structure */
523  );
524 
525 /** gets total number of simplex iterations used so far in dual simplex calls where an advanced start basis
526  * was available
527  *
528  * @return the total number of simplex iterations used so far in dual simplex calls where an advanced start
529  * basis was available
530  *
531  * @pre This method can be called if SCIP is in one of the following stages:
532  * - \ref SCIP_STAGE_PRESOLVED
533  * - \ref SCIP_STAGE_SOLVING
534  * - \ref SCIP_STAGE_SOLVED
535  */
536 extern
538  SCIP* scip /**< SCIP data structure */
539  );
540 
541 /** gets total number of LPs solved so far for node relaxations
542  *
543  * @return the total number of LPs solved so far for node relaxations
544  *
545  * @pre This method can be called if SCIP is in one of the following stages:
546  * - \ref SCIP_STAGE_PRESOLVED
547  * - \ref SCIP_STAGE_SOLVING
548  * - \ref SCIP_STAGE_SOLVED
549  */
550 extern
552  SCIP* scip /**< SCIP data structure */
553  );
554 
555 /** gets total number of simplex iterations used so far for node relaxations
556  *
557  * @return the total number of simplex iterations used so far for node relaxations
558  *
559  * @pre This method can be called if SCIP is in one of the following stages:
560  * - \ref SCIP_STAGE_PRESOLVED
561  * - \ref SCIP_STAGE_SOLVING
562  * - \ref SCIP_STAGE_SOLVED
563  */
564 extern
566  SCIP* scip /**< SCIP data structure */
567  );
568 
569 /** gets total number of LPs solved so far for initial LP in node relaxations
570  *
571  * @return the total number of LPs solved so far for initial LP in node relaxations
572  *
573  * @pre This method can be called if SCIP is in one of the following stages:
574  * - \ref SCIP_STAGE_PRESOLVED
575  * - \ref SCIP_STAGE_SOLVING
576  * - \ref SCIP_STAGE_SOLVED
577  */
578 extern
580  SCIP* scip /**< SCIP data structure */
581  );
582 
583 /** gets total number of simplex iterations used so far for initial LP in node relaxations
584  *
585  * @return the total number of simplex iterations used so far for initial LP in node relaxations
586  *
587  * @pre This method can be called if SCIP is in one of the following stages:
588  * - \ref SCIP_STAGE_PRESOLVED
589  * - \ref SCIP_STAGE_SOLVING
590  * - \ref SCIP_STAGE_SOLVED
591  */
592 extern
594  SCIP* scip /**< SCIP data structure */
595  );
596 
597 /** gets total number of LPs solved so far during diving and probing
598  *
599  * @return total number of LPs solved so far during diving and probing
600  *
601  * @pre This method can be called if SCIP is in one of the following stages:
602  * - \ref SCIP_STAGE_PRESOLVED
603  * - \ref SCIP_STAGE_SOLVING
604  * - \ref SCIP_STAGE_SOLVED
605  */
606 extern
608  SCIP* scip /**< SCIP data structure */
609  );
610 
611 /** gets total number of simplex iterations used so far during diving and probing
612  *
613  * @return the total number of simplex iterations used so far during diving and probing
614  *
615  * @pre This method can be called if SCIP is in one of the following stages:
616  * - \ref SCIP_STAGE_PRESOLVED
617  * - \ref SCIP_STAGE_SOLVING
618  * - \ref SCIP_STAGE_SOLVED
619  */
620 extern
622  SCIP* scip /**< SCIP data structure */
623  );
624 
625 /** gets total number of times, strong branching was called (each call represents solving two LPs)
626  *
627  * @return the total number of times, strong branching was called (each call represents solving two LPs)
628  *
629  * @pre This method can be called if SCIP is in one of the following stages:
630  * - \ref SCIP_STAGE_PRESOLVED
631  * - \ref SCIP_STAGE_SOLVING
632  * - \ref SCIP_STAGE_SOLVED
633  */
634 extern
636  SCIP* scip /**< SCIP data structure */
637  );
638 
639 /** gets total number of simplex iterations used so far in strong branching
640  *
641  * @return the total number of simplex iterations used so far in strong branching
642  *
643  * @pre This method can be called if SCIP is in one of the following stages:
644  * - \ref SCIP_STAGE_PRESOLVED
645  * - \ref SCIP_STAGE_SOLVING
646  * - \ref SCIP_STAGE_SOLVED
647  */
648 extern
650  SCIP* scip /**< SCIP data structure */
651  );
652 
653 /** gets total number of times, strong branching was called at the root node (each call represents solving two LPs)
654  *
655  * @return the total number of times, strong branching was called at the root node (each call represents solving two LPs)
656  *
657  * @pre This method can be called if SCIP is in one of the following stages:
658  * - \ref SCIP_STAGE_PRESOLVED
659  * - \ref SCIP_STAGE_SOLVING
660  * - \ref SCIP_STAGE_SOLVED
661  */
662 extern
664  SCIP* scip /**< SCIP data structure */
665  );
666 
667 /** gets total number of simplex iterations used so far in strong branching at the root node
668  *
669  * @return the total number of simplex iterations used so far in strong branching at the root node
670  *
671  * @pre This method can be called if SCIP is in one of the following stages:
672  * - \ref SCIP_STAGE_PRESOLVED
673  * - \ref SCIP_STAGE_SOLVING
674  * - \ref SCIP_STAGE_SOLVED
675  */
676 extern
678  SCIP* scip /**< SCIP data structure */
679  );
680 
681 /** gets number of pricing rounds performed so far at the current node
682  *
683  * @return the number of pricing rounds performed so far at the current node
684  *
685  * @pre This method can be called if SCIP is in one of the following stages:
686  * - \ref SCIP_STAGE_SOLVING
687  */
688 extern
690  SCIP* scip /**< SCIP data structure */
691  );
692 
693 /** get current number of variables in the pricing store
694  *
695  * @return the current number of variables in the pricing store
696  *
697  * @pre This method can be called if SCIP is in one of the following stages:
698  * - \ref SCIP_STAGE_PRESOLVED
699  * - \ref SCIP_STAGE_SOLVING
700  * - \ref SCIP_STAGE_SOLVED
701  */
702 extern
704  SCIP* scip /**< SCIP data structure */
705  );
706 
707 /** get total number of pricing variables found so far
708  *
709  * @return the total number of pricing variables found so far
710  *
711  * @pre This method can be called if SCIP is in one of the following stages:
712  * - \ref SCIP_STAGE_PRESOLVED
713  * - \ref SCIP_STAGE_SOLVING
714  * - \ref SCIP_STAGE_SOLVED
715  */
716 extern
718  SCIP* scip /**< SCIP data structure */
719  );
720 
721 /** get total number of pricing variables applied to the LPs
722  *
723  * @return the total number of pricing variables applied to the LPs
724  *
725  * @pre This method can be called if SCIP is in one of the following stages:
726  * - \ref SCIP_STAGE_PRESOLVED
727  * - \ref SCIP_STAGE_SOLVING
728  * - \ref SCIP_STAGE_SOLVED
729  */
730 extern
732  SCIP* scip /**< SCIP data structure */
733  );
734 
735 /** gets number of separation rounds performed so far at the current node
736  *
737  * @return the number of separation rounds performed so far at the current node
738  *
739  * @pre This method can be called if SCIP is in one of the following stages:
740  * - \ref SCIP_STAGE_SOLVING
741  */
742 extern
744  SCIP* scip /**< SCIP data structure */
745  );
746 
747 /** get total number of cuts found so far
748  *
749  * @return the total number of cuts found so far
750  *
751  * @pre This method can be called if SCIP is in one of the following stages:
752  * - \ref SCIP_STAGE_PRESOLVED
753  * - \ref SCIP_STAGE_SOLVING
754  * - \ref SCIP_STAGE_SOLVED
755  */
756 extern
758  SCIP* scip /**< SCIP data structure */
759  );
760 
761 /** get number of cuts found so far in current separation round
762  *
763  * @return the number of cuts found so far in current separation round
764  *
765  * @pre This method can be called if SCIP is in one of the following stages:
766  * - \ref SCIP_STAGE_PRESOLVED
767  * - \ref SCIP_STAGE_SOLVING
768  * - \ref SCIP_STAGE_SOLVED
769  */
770 extern
772  SCIP* scip /**< SCIP data structure */
773  );
774 
775 /** get total number of cuts applied to the LPs
776  *
777  * @return the total number of cuts applied to the LPs
778  *
779  * @pre This method can be called if SCIP is in one of the following stages:
780  * - \ref SCIP_STAGE_PRESOLVED
781  * - \ref SCIP_STAGE_SOLVING
782  * - \ref SCIP_STAGE_SOLVED
783  */
784 extern
786  SCIP* scip /**< SCIP data structure */
787  );
788 
789 /** get total number of constraints found in conflict analysis (conflict and reconvergence constraints)
790  *
791  * @return the total number of constraints found in conflict analysis (conflict and reconvergence constraints)
792  *
793  * @pre This method can be called if SCIP is in one of the following stages:
794  * - \ref SCIP_STAGE_TRANSFORMED
795  * - \ref SCIP_STAGE_INITPRESOLVE
796  * - \ref SCIP_STAGE_PRESOLVING
797  * - \ref SCIP_STAGE_EXITPRESOLVE
798  * - \ref SCIP_STAGE_PRESOLVED
799  * - \ref SCIP_STAGE_INITSOLVE
800  * - \ref SCIP_STAGE_SOLVING
801  * - \ref SCIP_STAGE_SOLVED
802  * - \ref SCIP_STAGE_EXITSOLVE
803  */
804 extern
806  SCIP* scip /**< SCIP data structure */
807  );
808 
809 /** get number of conflict constraints found so far at the current node
810  *
811  * @return the number of conflict constraints found so far at the current node
812  *
813  * @pre This method can be called if SCIP is in one of the following stages:
814  * - \ref SCIP_STAGE_TRANSFORMED
815  * - \ref SCIP_STAGE_INITPRESOLVE
816  * - \ref SCIP_STAGE_PRESOLVING
817  * - \ref SCIP_STAGE_EXITPRESOLVE
818  * - \ref SCIP_STAGE_PRESOLVED
819  * - \ref SCIP_STAGE_INITSOLVE
820  * - \ref SCIP_STAGE_SOLVING
821  * - \ref SCIP_STAGE_SOLVED
822  * - \ref SCIP_STAGE_EXITSOLVE
823  */
824 extern
826  SCIP* scip /**< SCIP data structure */
827  );
828 
829 /** get total number of conflict constraints added to the problem
830  *
831  * @return the total number of conflict constraints added to the problem
832  *
833  * @pre This method can be called if SCIP is in one of the following stages:
834  * - \ref SCIP_STAGE_TRANSFORMED
835  * - \ref SCIP_STAGE_INITPRESOLVE
836  * - \ref SCIP_STAGE_PRESOLVING
837  * - \ref SCIP_STAGE_EXITPRESOLVE
838  * - \ref SCIP_STAGE_PRESOLVED
839  * - \ref SCIP_STAGE_INITSOLVE
840  * - \ref SCIP_STAGE_SOLVING
841  * - \ref SCIP_STAGE_SOLVED
842  * - \ref SCIP_STAGE_EXITSOLVE
843  */
844 extern
846  SCIP* scip /**< SCIP data structure */
847  );
848 
849 /** gets maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
850  *
851  * @return the maximal depth of all processed nodes in current branch and bound run (excluding probing nodes)
852  *
853  * @pre This method can be called if SCIP is in one of the following stages:
854  * - \ref SCIP_STAGE_TRANSFORMED
855  * - \ref SCIP_STAGE_INITPRESOLVE
856  * - \ref SCIP_STAGE_PRESOLVING
857  * - \ref SCIP_STAGE_EXITPRESOLVE
858  * - \ref SCIP_STAGE_PRESOLVED
859  * - \ref SCIP_STAGE_INITSOLVE
860  * - \ref SCIP_STAGE_SOLVING
861  * - \ref SCIP_STAGE_SOLVED
862  * - \ref SCIP_STAGE_EXITSOLVE
863  */
864 extern
865 int SCIPgetMaxDepth(
866  SCIP* scip /**< SCIP data structure */
867  );
868 
869 /** gets maximal depth of all processed nodes over all branch and bound runs
870  *
871  * @return the maximal depth of all processed nodes over all branch and bound runs
872  *
873  * @pre This method can be called if SCIP is in one of the following stages:
874  * - \ref SCIP_STAGE_TRANSFORMED
875  * - \ref SCIP_STAGE_INITPRESOLVE
876  * - \ref SCIP_STAGE_PRESOLVING
877  * - \ref SCIP_STAGE_EXITPRESOLVE
878  * - \ref SCIP_STAGE_PRESOLVED
879  * - \ref SCIP_STAGE_INITSOLVE
880  * - \ref SCIP_STAGE_SOLVING
881  * - \ref SCIP_STAGE_SOLVED
882  * - \ref SCIP_STAGE_EXITSOLVE
883  */
884 extern
886  SCIP* scip /**< SCIP data structure */
887  );
888 
889 /** gets total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
890  *
891  * @return the total number of backtracks, i.e. number of times, the new node was selected from the leaves queue
892  *
893  * @pre This method can be called if SCIP is in one of the following stages:
894  * - \ref SCIP_STAGE_TRANSFORMED
895  * - \ref SCIP_STAGE_INITPRESOLVE
896  * - \ref SCIP_STAGE_PRESOLVING
897  * - \ref SCIP_STAGE_EXITPRESOLVE
898  * - \ref SCIP_STAGE_PRESOLVED
899  * - \ref SCIP_STAGE_INITSOLVE
900  * - \ref SCIP_STAGE_SOLVING
901  * - \ref SCIP_STAGE_SOLVED
902  * - \ref SCIP_STAGE_EXITSOLVE
903  */
904 extern
906  SCIP* scip /**< SCIP data structure */
907  );
908 
909 /** gets total number of active constraints at the current node
910  *
911  * @return the total number of active constraints at the current node
912  *
913  * @pre This method can be called if SCIP is in one of the following stages:
914  * - \ref SCIP_STAGE_INITPRESOLVE
915  * - \ref SCIP_STAGE_PRESOLVING
916  * - \ref SCIP_STAGE_EXITPRESOLVE
917  * - \ref SCIP_STAGE_PRESOLVED
918  * - \ref SCIP_STAGE_SOLVING
919  */
920 extern
922  SCIP* scip /**< SCIP data structure */
923  );
924 
925 /** gets total number of enabled constraints at the current node
926  *
927  * @return the total number of enabled constraints at the current node
928  *
929  * @pre This method can be called if SCIP is in one of the following stages:
930  * - \ref SCIP_STAGE_PRESOLVED
931  * - \ref SCIP_STAGE_SOLVING
932  */
933 extern
935  SCIP* scip /**< SCIP data structure */
936  );
937 
938 /** gets average dual bound of all unprocessed nodes for original problem */
939 extern
941  SCIP* scip /**< SCIP data structure */
942  );
943 
944 /** gets average lower (dual) bound of all unprocessed nodes in transformed problem
945  *
946  * @return the average lower (dual) bound of all unprocessed nodes in transformed problem
947  *
948  * @pre This method can be called if SCIP is in one of the following stages:
949  * - \ref SCIP_STAGE_PRESOLVED
950  * - \ref SCIP_STAGE_SOLVING
951  * - \ref SCIP_STAGE_SOLVED
952  */
953 extern
955  SCIP* scip /**< SCIP data structure */
956  );
957 
958 /** gets global dual bound
959  *
960  * @return the global dual bound
961  *
962  * @pre This method can be called if SCIP is in one of the following stages:
963  * - \ref SCIP_STAGE_TRANSFORMED
964  * - \ref SCIP_STAGE_INITPRESOLVE
965  * - \ref SCIP_STAGE_PRESOLVING
966  * - \ref SCIP_STAGE_EXITPRESOLVE
967  * - \ref SCIP_STAGE_PRESOLVED
968  * - \ref SCIP_STAGE_INITSOLVE
969  * - \ref SCIP_STAGE_SOLVING
970  * - \ref SCIP_STAGE_SOLVED
971  */
972 extern
974  SCIP* scip /**< SCIP data structure */
975  );
976 
977 /** gets global lower (dual) bound in transformed problem
978  *
979  * @return the global lower (dual) bound in transformed problem
980  *
981  * @pre This method can be called if SCIP is in one of the following stages:
982  * - \ref SCIP_STAGE_TRANSFORMED
983  * - \ref SCIP_STAGE_INITPRESOLVE
984  * - \ref SCIP_STAGE_PRESOLVING
985  * - \ref SCIP_STAGE_EXITPRESOLVE
986  * - \ref SCIP_STAGE_PRESOLVED
987  * - \ref SCIP_STAGE_INITSOLVE
988  * - \ref SCIP_STAGE_SOLVING
989  * - \ref SCIP_STAGE_SOLVED
990  */
991 extern
993  SCIP* scip /**< SCIP data structure */
994  );
995 
996 /** gets dual bound of the root node for the original problem
997  *
998  * @return the dual bound of the root node for the original problem
999  *
1000  * @pre This method can be called if SCIP is in one of the following stages:
1001  * - \ref SCIP_STAGE_PRESOLVING
1002  * - \ref SCIP_STAGE_EXITPRESOLVE
1003  * - \ref SCIP_STAGE_PRESOLVED
1004  * - \ref SCIP_STAGE_INITSOLVE
1005  * - \ref SCIP_STAGE_SOLVING
1006  * - \ref SCIP_STAGE_SOLVED
1007  */
1008 extern
1010  SCIP* scip /**< SCIP data structure */
1011  );
1012 
1013 /** gets lower (dual) bound in transformed problem of the root node
1014  *
1015  * @return the lower (dual) bound in transformed problem of the root node
1016  *
1017  * @pre This method can be called if SCIP is in one of the following stages:
1018  * - \ref SCIP_STAGE_PRESOLVING
1019  * - \ref SCIP_STAGE_EXITPRESOLVE
1020  * - \ref SCIP_STAGE_PRESOLVED
1021  * - \ref SCIP_STAGE_INITSOLVE
1022  * - \ref SCIP_STAGE_SOLVING
1023  * - \ref SCIP_STAGE_SOLVED
1024  */
1025 extern
1027  SCIP* scip /**< SCIP data structure */
1028  );
1029 
1030 /** gets dual bound for the original problem obtained by the first LP solve at the root node
1031  *
1032  * @return the dual bound for the original problem of the first LP solve at the root node
1033  *
1034  * @pre This method can be called if SCIP is in one of the following stages:
1035  * - \ref SCIP_STAGE_PRESOLVING
1036  * - \ref SCIP_STAGE_EXITPRESOLVE
1037  * - \ref SCIP_STAGE_PRESOLVED
1038  * - \ref SCIP_STAGE_INITSOLVE
1039  * - \ref SCIP_STAGE_SOLVING
1040  * - \ref SCIP_STAGE_SOLVED
1041  */
1042 extern
1044  SCIP* scip /**< SCIP data structure */
1045  );
1046 
1047 /** gets lower (dual) bound in transformed problem obtained by the first LP solve at the root node
1048  *
1049  * @return the lower (dual) bound in transformed problem obtained by first LP solve at the root node
1050  *
1051  * @pre This method can be called if SCIP is in one of the following stages:
1052  * - \ref SCIP_STAGE_PRESOLVING
1053  * - \ref SCIP_STAGE_EXITPRESOLVE
1054  * - \ref SCIP_STAGE_PRESOLVED
1055  * - \ref SCIP_STAGE_INITSOLVE
1056  * - \ref SCIP_STAGE_SOLVING
1057  * - \ref SCIP_STAGE_SOLVED
1058  */
1059 extern
1061  SCIP* scip /**< SCIP data structure */
1062  );
1063 
1064 
1065 /** the primal bound of the very first solution */
1066 extern
1068  SCIP* scip /**< SCIP data structure */
1069  );
1070 
1071 /** gets global primal bound (objective value of best solution or user objective limit) for the original problem
1072  *
1073  * @return the global primal bound (objective value of best solution or user objective limit) for the original problem
1074  *
1075  * @pre This method can be called if SCIP is in one of the following stages:
1076  * - \ref SCIP_STAGE_TRANSFORMED
1077  * - \ref SCIP_STAGE_INITPRESOLVE
1078  * - \ref SCIP_STAGE_PRESOLVING
1079  * - \ref SCIP_STAGE_EXITPRESOLVE
1080  * - \ref SCIP_STAGE_PRESOLVED
1081  * - \ref SCIP_STAGE_INITSOLVE
1082  * - \ref SCIP_STAGE_SOLVING
1083  * - \ref SCIP_STAGE_SOLVED
1084  * - \ref SCIP_STAGE_EXITSOLVE
1085  */
1086 extern
1088  SCIP* scip /**< SCIP data structure */
1089  );
1090 
1091 /** gets global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
1092  *
1093  * @return the global upper (primal) bound in transformed problem (objective value of best solution or user objective limit)
1094  *
1095  * @pre This method can be called if SCIP is in one of the following stages:
1096  * - \ref SCIP_STAGE_TRANSFORMED
1097  * - \ref SCIP_STAGE_INITPRESOLVE
1098  * - \ref SCIP_STAGE_PRESOLVING
1099  * - \ref SCIP_STAGE_EXITPRESOLVE
1100  * - \ref SCIP_STAGE_PRESOLVED
1101  * - \ref SCIP_STAGE_INITSOLVE
1102  * - \ref SCIP_STAGE_SOLVING
1103  * - \ref SCIP_STAGE_SOLVED
1104  * - \ref SCIP_STAGE_EXITSOLVE
1105  */
1106 extern
1108  SCIP* scip /**< SCIP data structure */
1109  );
1110 
1111 /** gets global cutoff bound in transformed problem: a sub problem with lower bound larger than the cutoff
1112  * cannot contain a better feasible solution; usually, this bound is equal to the upper bound, but if the
1113  * objective value is always integral, the cutoff bound is (nearly) one less than the upper bound;
1114  * additionally, due to objective function domain propagation, the cutoff bound can be further reduced
1115  *
1116  * @return global cutoff bound in transformed problem
1117  *
1118  * @pre This method can be called if SCIP is in one of the following stages:
1119  * - \ref SCIP_STAGE_TRANSFORMED
1120  * - \ref SCIP_STAGE_INITPRESOLVE
1121  * - \ref SCIP_STAGE_PRESOLVING
1122  * - \ref SCIP_STAGE_EXITPRESOLVE
1123  * - \ref SCIP_STAGE_PRESOLVED
1124  * - \ref SCIP_STAGE_INITSOLVE
1125  * - \ref SCIP_STAGE_SOLVING
1126  * - \ref SCIP_STAGE_SOLVED
1127  * - \ref SCIP_STAGE_EXITSOLVE
1128  */
1129 extern
1131  SCIP* scip /**< SCIP data structure */
1132  );
1133 
1134 /** updates the cutoff bound
1135  *
1136  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1137  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1138  *
1139  * @note using this method in the solving stage can lead to an erroneous SCIP solving status; in particular,
1140  * if a solution not respecting the cutoff bound was found before installing a cutoff bound which
1141  * renders the remaining problem infeasible, this solution may be reported as optimal
1142  *
1143  * @pre This method can be called if SCIP is in one of the following stages:
1144  * - \ref SCIP_STAGE_TRANSFORMED
1145  * - \ref SCIP_STAGE_PRESOLVING
1146  * - \ref SCIP_STAGE_PRESOLVED
1147  * - \ref SCIP_STAGE_INITSOLVE
1148  * - \ref SCIP_STAGE_SOLVING
1149  *
1150  * @note the given cutoff bound has to better or equal to known one (SCIPgetCutoffbound())
1151  */
1152 extern
1154  SCIP* scip, /**< SCIP data structure */
1155  SCIP_Real cutoffbound /**< new cutoff bound */
1156  );
1157 
1158 /** returns whether the current primal bound is justified with a feasible primal solution; if not, the primal bound
1159  * was set from the user as objective limit
1160  *
1161  * @return TRUE if the current primal bound is justified with a feasible primal solution, otherwise FALSE
1162  *
1163  * @pre This method can be called if SCIP is in one of the following stages:
1164  * - \ref SCIP_STAGE_TRANSFORMED
1165  * - \ref SCIP_STAGE_INITPRESOLVE
1166  * - \ref SCIP_STAGE_PRESOLVING
1167  * - \ref SCIP_STAGE_EXITPRESOLVE
1168  * - \ref SCIP_STAGE_PRESOLVED
1169  * - \ref SCIP_STAGE_INITSOLVE
1170  * - \ref SCIP_STAGE_SOLVING
1171  * - \ref SCIP_STAGE_SOLVED
1172  * - \ref SCIP_STAGE_EXITSOLVE
1173  */
1174 extern
1176  SCIP* scip /**< SCIP data structure */
1177  );
1178 
1179 /** gets current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
1180  * or infinity, if they have opposite sign
1181  *
1182  * @return the current gap |(primalbound - dualbound)/min(|primalbound|,|dualbound|)| if both bounds have same sign,
1183  * or infinity, if they have opposite sign
1184  *
1185  * @pre This method can be called if SCIP is in one of the following stages:
1186  * - \ref SCIP_STAGE_PRESOLVED
1187  * - \ref SCIP_STAGE_SOLVING
1188  * - \ref SCIP_STAGE_SOLVED
1189  */
1190 extern
1192  SCIP* scip /**< SCIP data structure */
1193  );
1194 
1195 /** gets current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
1196  * have same sign, or infinity, if they have opposite sign
1197  *
1198  * @return current gap |(upperbound - lowerbound)/min(|upperbound|,|lowerbound|)| in transformed problem if both bounds
1199  * have same sign, or infinity, if they have opposite sign
1200  *
1201  * @pre This method can be called if SCIP is in one of the following stages:
1202  * - \ref SCIP_STAGE_PRESOLVED
1203  * - \ref SCIP_STAGE_SOLVING
1204  * - \ref SCIP_STAGE_SOLVED
1205  */
1206 extern
1208  SCIP* scip /**< SCIP data structure */
1209  );
1210 
1211 /** gets number of feasible primal solutions found so far
1212  *
1213  * @return the number of feasible primal solutions found so far
1214  *
1215  * @pre This method can be called if SCIP is in one of the following stages:
1216  * - \ref SCIP_STAGE_TRANSFORMED
1217  * - \ref SCIP_STAGE_INITPRESOLVE
1218  * - \ref SCIP_STAGE_PRESOLVING
1219  * - \ref SCIP_STAGE_EXITPRESOLVE
1220  * - \ref SCIP_STAGE_PRESOLVED
1221  * - \ref SCIP_STAGE_INITSOLVE
1222  * - \ref SCIP_STAGE_SOLVING
1223  * - \ref SCIP_STAGE_SOLVED
1224  * - \ref SCIP_STAGE_EXITSOLVE
1225  */
1226 extern
1228  SCIP* scip /**< SCIP data structure */
1229  );
1230 
1231 /** gets number of feasible primal solutions respecting the objective limit found so far
1232  *
1233  * @return the number of feasible primal solutions respecting the objective limit found so far
1234  *
1235  * @pre This method can be called if SCIP is in one of the following stages:
1236  * - \ref SCIP_STAGE_INIT
1237  * - \ref SCIP_STAGE_PROBLEM
1238  * - \ref SCIP_STAGE_TRANSFORMING
1239  * - \ref SCIP_STAGE_TRANSFORMED
1240  * - \ref SCIP_STAGE_INITPRESOLVE
1241  * - \ref SCIP_STAGE_PRESOLVING
1242  * - \ref SCIP_STAGE_EXITPRESOLVE
1243  * - \ref SCIP_STAGE_PRESOLVED
1244  * - \ref SCIP_STAGE_INITSOLVE
1245  * - \ref SCIP_STAGE_SOLVING
1246  * - \ref SCIP_STAGE_SOLVED
1247  * - \ref SCIP_STAGE_EXITSOLVE
1248  */
1249 extern
1251  SCIP* scip /**< SCIP data structure */
1252  );
1253 
1254 /** gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found
1255  *
1256  * @return the number of feasible primal solutions found so far, that improved the primal bound at the time they were found
1257  *
1258  * @pre This method can be called if SCIP is in one of the following stages:
1259  * - \ref SCIP_STAGE_TRANSFORMED
1260  * - \ref SCIP_STAGE_INITPRESOLVE
1261  * - \ref SCIP_STAGE_PRESOLVING
1262  * - \ref SCIP_STAGE_EXITPRESOLVE
1263  * - \ref SCIP_STAGE_PRESOLVED
1264  * - \ref SCIP_STAGE_INITSOLVE
1265  * - \ref SCIP_STAGE_SOLVING
1266  * - \ref SCIP_STAGE_SOLVED
1267  * - \ref SCIP_STAGE_EXITSOLVE
1268  */
1269 extern
1271  SCIP* scip /**< SCIP data structure */
1272  );
1273 
1274 /** gets the average pseudo cost value for the given direction over all variables
1275  *
1276  * @return the average pseudo cost value for the given direction over all variables
1277  *
1278  * @pre This method can be called if SCIP is in one of the following stages:
1279  * - \ref SCIP_STAGE_SOLVING
1280  * - \ref SCIP_STAGE_SOLVED
1281  */
1282 extern
1284  SCIP* scip, /**< SCIP data structure */
1285  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1286  );
1287 
1288 /** gets the average pseudo cost value for the given direction over all variables,
1289  * only using the pseudo cost information of the current run
1290  *
1291  * @return the average pseudo cost value for the given direction over all variables,
1292  * only using the pseudo cost information of the current run
1293  *
1294  * @pre This method can be called if SCIP is in one of the following stages:
1295  * - \ref SCIP_STAGE_SOLVING
1296  * - \ref SCIP_STAGE_SOLVED
1297  */
1298 extern
1300  SCIP* scip, /**< SCIP data structure */
1301  SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
1302  );
1303 
1304 /** gets the average number of pseudo cost updates for the given direction over all variables
1305  *
1306  * @return the average number of pseudo cost updates for the given direction over all variables
1307  *
1308  * @pre This method can be called if SCIP is in one of the following stages:
1309  * - \ref SCIP_STAGE_SOLVING
1310  * - \ref SCIP_STAGE_SOLVED
1311  */
1312 extern
1314  SCIP* scip, /**< SCIP data structure */
1315  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1316  );
1317 
1318 /** gets the average number of pseudo cost updates for the given direction over all variables,
1319  * only using the pseudo cost information of the current run
1320  *
1321  * @return the average number of pseudo cost updates for the given direction over all variables,
1322  * only using the pseudo cost information of the current run
1323  *
1324  * @pre This method can be called if SCIP is in one of the following stages:
1325  * - \ref SCIP_STAGE_SOLVING
1326  * - \ref SCIP_STAGE_SOLVED
1327  */
1328 extern
1330  SCIP* scip, /**< SCIP data structure */
1331  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1332  );
1333 
1334 /** gets the number of pseudo cost updates for the given direction over all variables
1335  *
1336  * @return the number of pseudo cost updates for the given direction over all variables
1337  *
1338  * @pre This method can be called if SCIP is in one of the following stages:
1339  * - \ref SCIP_STAGE_SOLVING
1340  * - \ref SCIP_STAGE_SOLVED
1341  */
1342 extern
1344  SCIP* scip, /**< SCIP data structure */
1345  SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
1346  SCIP_Bool onlycurrentrun /**< use only history of current run? */
1347  );
1348 
1349 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5
1350  *
1351  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5
1352  *
1353  * @pre This method can be called if SCIP is in one of the following stages:
1354  * - \ref SCIP_STAGE_SOLVING
1355  * - \ref SCIP_STAGE_SOLVED
1356  */
1357 extern
1359  SCIP* scip /**< SCIP data structure */
1360  );
1361 
1362 /** returns the variance of pseudo costs for all variables in the requested direction
1363  *
1364  * @return the variance of pseudo costs for all variables in the requested direction
1365  *
1366  * @pre This method can be called if SCIP is in one of the following stages:
1367  * - \ref SCIP_STAGE_SOLVING
1368  * - \ref SCIP_STAGE_SOLVED
1369  */
1370 extern
1372  SCIP* scip, /**< SCIP data structure */
1373  SCIP_BRANCHDIR branchdir, /**< the branching direction, up or down */
1374  SCIP_Bool onlycurrentrun /**< use only history of current run? */
1375  );
1376 
1377 /** gets the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
1378  * only using the pseudo cost information of the current run
1379  *
1380  * @return the average pseudo cost score value over all variables, assuming a fractionality of 0.5,
1381  * only using the pseudo cost information of the current run
1382  *
1383  * @pre This method can be called if SCIP is in one of the following stages:
1384  * - \ref SCIP_STAGE_SOLVING
1385  * - \ref SCIP_STAGE_SOLVED
1386  */
1387 extern
1389  SCIP* scip /**< SCIP data structure */
1390  );
1391 
1392 /** gets the average conflict score value over all variables */
1393 extern
1395  SCIP* scip /**< SCIP data structure */
1396  );
1397 
1398 /** gets the average conflict score value over all variables, only using the conflict information of the current run
1399  *
1400  * @return the average conflict score value over all variables, only using the conflict information of the current run
1401  *
1402  * @pre This method can be called if SCIP is in one of the following stages:
1403  * - \ref SCIP_STAGE_SOLVING
1404  * - \ref SCIP_STAGE_SOLVED
1405  */
1406 extern
1408  SCIP* scip /**< SCIP data structure */
1409  );
1410 
1411 /** gets the average inference score value over all variables
1412  *
1413  * @return the average inference score value over all variables
1414  *
1415  * @pre This method can be called if SCIP is in one of the following stages:
1416  * - \ref SCIP_STAGE_SOLVING
1417  * - \ref SCIP_STAGE_SOLVED
1418  */
1419 extern
1421  SCIP* scip /**< SCIP data structure */
1422  );
1423 
1424 /** gets the average conflictlength score value over all variables, only using the conflictlength information of the
1425  * current run
1426  *
1427  * @return the average conflictlength score value over all variables, only using the conflictlength information of the
1428  * current run
1429  *
1430  * @pre This method can be called if SCIP is in one of the following stages:
1431  * - \ref SCIP_STAGE_SOLVING
1432  * - \ref SCIP_STAGE_SOLVED
1433  */
1434 extern
1436  SCIP* scip /**< SCIP data structure */
1437  );
1438 
1439 /** returns the average number of inferences found after branching in given direction over all variables
1440  *
1441  * @return the average number of inferences found after branching in given direction over all variables
1442  *
1443  * @pre This method can be called if SCIP is in one of the following stages:
1444  * - \ref SCIP_STAGE_SOLVING
1445  * - \ref SCIP_STAGE_SOLVED
1446  */
1447 extern
1449  SCIP* scip, /**< SCIP data structure */
1450  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1451  );
1452 
1453 /** returns the average number of inferences found after branching in given direction over all variables,
1454  * only using the inference information of the current run
1455  *
1456  * @return the average number of inferences found after branching in given direction over all variables,
1457  * only using the inference information of the current run
1458  *
1459  * @pre This method can be called if SCIP is in one of the following stages:
1460  * - \ref SCIP_STAGE_SOLVING
1461  * - \ref SCIP_STAGE_SOLVED
1462  */
1463 extern
1465  SCIP* scip, /**< SCIP data structure */
1466  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1467  );
1468 
1469 /** gets the average inference score value over all variables
1470  *
1471  * @return the average inference score value over all variables
1472  *
1473  * @pre This method can be called if SCIP is in one of the following stages:
1474  * - \ref SCIP_STAGE_SOLVING
1475  * - \ref SCIP_STAGE_SOLVED
1476  */
1477 extern
1479  SCIP* scip /**< SCIP data structure */
1480  );
1481 
1482 /** gets the average inference score value over all variables, only using the inference information of the
1483  * current run
1484  *
1485  * @return the average inference score value over all variables, only using the inference information of the
1486  * current run
1487  *
1488  * @pre This method can be called if SCIP is in one of the following stages:
1489  * - \ref SCIP_STAGE_SOLVING
1490  * - \ref SCIP_STAGE_SOLVED
1491  */
1492 extern
1494  SCIP* scip /**< SCIP data structure */
1495  );
1496 
1497 /** returns the average number of cutoffs found after branching in given direction over all variables
1498  *
1499  * @return the average number of cutoffs found after branching in given direction over all variables
1500  *
1501  * @pre This method can be called if SCIP is in one of the following stages:
1502  * - \ref SCIP_STAGE_SOLVING
1503  * - \ref SCIP_STAGE_SOLVED
1504  */
1505 extern
1507  SCIP* scip, /**< SCIP data structure */
1508  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1509  );
1510 
1511 /** returns the average number of cutoffs found after branching in given direction over all variables,
1512  * only using the cutoff information of the current run
1513  *
1514  * @return the average number of cutoffs found after branching in given direction over all variables,
1515  * only using the cutoff information of the current run
1516  *
1517  * @pre This method can be called if SCIP is in one of the following stages:
1518  * - \ref SCIP_STAGE_SOLVING
1519  * - \ref SCIP_STAGE_SOLVED
1520  */
1521 extern
1523  SCIP* scip, /**< SCIP data structure */
1524  SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
1525  );
1526 
1527 /** gets the average cutoff score value over all variables
1528  *
1529  * @return the average cutoff score value over all variables
1530  *
1531  * @pre This method can be called if SCIP is in one of the following stages:
1532  * - \ref SCIP_STAGE_SOLVING
1533  * - \ref SCIP_STAGE_SOLVED
1534  */
1535 extern
1537  SCIP* scip /**< SCIP data structure */
1538  );
1539 
1540 /** gets the average cutoff score value over all variables, only using the cutoff information of the current run
1541  *
1542  * @return the average cutoff score value over all variables, only using the cutoff information of the current run
1543  *
1544  * @pre This method can be called if SCIP is in one of the following stages:
1545  * - \ref SCIP_STAGE_SOLVING
1546  * - \ref SCIP_STAGE_SOLVED
1547  */
1548 extern
1550  SCIP* scip /**< SCIP data structure */
1551  );
1552 
1553 /** gets deterministic time number of LPs solved so far
1554  *
1555  * @return the total number of LPs solved so far
1556  *
1557  * @pre This method can be called if SCIP is in one of the following stages:
1558  * - \ref SCIP_STAGE_PRESOLVED
1559  * - \ref SCIP_STAGE_SOLVING
1560  * - \ref SCIP_STAGE_SOLVED
1561  */
1562 extern
1564  SCIP* scip /**< SCIP data structure */
1565  );
1566 
1567 /** outputs original problem to file stream
1568  *
1569  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1570  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1571  *
1572  * @pre This method can be called if SCIP is in one of the following stages:
1573  * - \ref SCIP_STAGE_PROBLEM
1574  * - \ref SCIP_STAGE_TRANSFORMING
1575  * - \ref SCIP_STAGE_TRANSFORMED
1576  * - \ref SCIP_STAGE_INITPRESOLVE
1577  * - \ref SCIP_STAGE_PRESOLVING
1578  * - \ref SCIP_STAGE_EXITPRESOLVE
1579  * - \ref SCIP_STAGE_PRESOLVED
1580  * - \ref SCIP_STAGE_INITSOLVE
1581  * - \ref SCIP_STAGE_SOLVING
1582  * - \ref SCIP_STAGE_SOLVED
1583  * - \ref SCIP_STAGE_EXITSOLVE
1584  * - \ref SCIP_STAGE_FREETRANS
1585  */
1586 extern
1588  SCIP* scip, /**< SCIP data structure */
1589  FILE* file, /**< output file (or NULL for standard output) */
1590  const char* extension, /**< file format (or NULL for default CIP format)*/
1591  SCIP_Bool genericnames /**< using generic variable and constraint names? */
1592  );
1593 
1594 /** outputs transformed problem of the current node to file stream
1595  *
1596  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1597  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1598  *
1599  * @pre This method can be called if SCIP is in one of the following stages:
1600  * - \ref SCIP_STAGE_TRANSFORMED
1601  * - \ref SCIP_STAGE_INITPRESOLVE
1602  * - \ref SCIP_STAGE_PRESOLVING
1603  * - \ref SCIP_STAGE_EXITPRESOLVE
1604  * - \ref SCIP_STAGE_PRESOLVED
1605  * - \ref SCIP_STAGE_INITSOLVE
1606  * - \ref SCIP_STAGE_SOLVING
1607  * - \ref SCIP_STAGE_SOLVED
1608  * - \ref SCIP_STAGE_EXITSOLVE
1609  * - \ref SCIP_STAGE_FREETRANS
1610  */
1611 extern
1613  SCIP* scip, /**< SCIP data structure */
1614  FILE* file, /**< output file (or NULL for standard output) */
1615  const char* extension, /**< file format (or NULL for default CIP format)*/
1616  SCIP_Bool genericnames /**< using generic variable and constraint names? */
1617  );
1618 
1619 /** outputs status statistics
1620  *
1621  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
1622  * thus may to correspond to the original status.
1623  *
1624  * @pre This method can be called if SCIP is in one of the following stages:
1625  * - \ref SCIP_STAGE_INIT
1626  * - \ref SCIP_STAGE_PROBLEM
1627  * - \ref SCIP_STAGE_TRANSFORMED
1628  * - \ref SCIP_STAGE_INITPRESOLVE
1629  * - \ref SCIP_STAGE_PRESOLVING
1630  * - \ref SCIP_STAGE_EXITPRESOLVE
1631  * - \ref SCIP_STAGE_PRESOLVED
1632  * - \ref SCIP_STAGE_SOLVING
1633  * - \ref SCIP_STAGE_SOLVED
1634  */
1635 extern
1637  SCIP* scip, /**< SCIP data structure */
1638  FILE* file /**< output file */
1639  );
1640 
1641 /** outputs timing statistics
1642  *
1643  * @pre This method can be called if SCIP is in one of the following stages:
1644  * - \ref SCIP_STAGE_PROBLEM
1645  * - \ref SCIP_STAGE_TRANSFORMED
1646  * - \ref SCIP_STAGE_INITPRESOLVE
1647  * - \ref SCIP_STAGE_PRESOLVING
1648  * - \ref SCIP_STAGE_EXITPRESOLVE
1649  * - \ref SCIP_STAGE_PRESOLVED
1650  * - \ref SCIP_STAGE_SOLVING
1651  * - \ref SCIP_STAGE_SOLVED
1652  */
1653 extern
1655  SCIP* scip, /**< SCIP data structure */
1656  FILE* file /**< output file */
1657  );
1658 
1659 /** outputs statistics for original problem
1660  *
1661  * @pre This method can be called if SCIP is in one of the following stages:
1662  * - \ref SCIP_STAGE_PROBLEM
1663  * - \ref SCIP_STAGE_TRANSFORMED
1664  * - \ref SCIP_STAGE_INITPRESOLVE
1665  * - \ref SCIP_STAGE_PRESOLVING
1666  * - \ref SCIP_STAGE_EXITPRESOLVE
1667  * - \ref SCIP_STAGE_PRESOLVED
1668  * - \ref SCIP_STAGE_SOLVING
1669  * - \ref SCIP_STAGE_SOLVED
1670  */
1671 extern
1673  SCIP* scip, /**< SCIP data structure */
1674  FILE* file /**< output file (or NULL for standard output) */
1675  );
1676 
1677 /** outputs statistics for transformed problem
1678  *
1679  * @pre This method can be called if SCIP is in one of the following stages:
1680  * - \ref SCIP_STAGE_PROBLEM
1681  * - \ref SCIP_STAGE_TRANSFORMED
1682  * - \ref SCIP_STAGE_INITPRESOLVE
1683  * - \ref SCIP_STAGE_PRESOLVING
1684  * - \ref SCIP_STAGE_EXITPRESOLVE
1685  * - \ref SCIP_STAGE_PRESOLVED
1686  * - \ref SCIP_STAGE_SOLVING
1687  * - \ref SCIP_STAGE_SOLVED
1688  */
1689 extern
1691  SCIP* scip, /**< SCIP data structure */
1692  FILE* file /**< output file */
1693  );
1694 
1695 /** outputs presolver statistics
1696  *
1697  * @pre This method can be called if SCIP is in one of the following stages:
1698  * - \ref SCIP_STAGE_TRANSFORMED
1699  * - \ref SCIP_STAGE_INITPRESOLVE
1700  * - \ref SCIP_STAGE_PRESOLVING
1701  * - \ref SCIP_STAGE_EXITPRESOLVE
1702  * - \ref SCIP_STAGE_PRESOLVED
1703  * - \ref SCIP_STAGE_SOLVING
1704  * - \ref SCIP_STAGE_SOLVED
1705  */
1706 extern
1708  SCIP* scip, /**< SCIP data structure */
1709  FILE* file /**< output file */
1710  );
1711 
1712 /** outputs constraint statistics
1713  *
1714  * @pre This method can be called if SCIP is in one of the following stages:
1715  * - \ref SCIP_STAGE_TRANSFORMED
1716  * - \ref SCIP_STAGE_INITPRESOLVE
1717  * - \ref SCIP_STAGE_PRESOLVING
1718  * - \ref SCIP_STAGE_EXITPRESOLVE
1719  * - \ref SCIP_STAGE_PRESOLVED
1720  * - \ref SCIP_STAGE_SOLVING
1721  * - \ref SCIP_STAGE_SOLVED
1722  */
1723 extern
1725  SCIP* scip, /**< SCIP data structure */
1726  FILE* file /**< output file */
1727  );
1728 
1729 /** outputs constraint timing statistics
1730  *
1731  * @pre This method can be called if SCIP is in one of the following stages:
1732  * - \ref SCIP_STAGE_TRANSFORMED
1733  * - \ref SCIP_STAGE_INITPRESOLVE
1734  * - \ref SCIP_STAGE_PRESOLVING
1735  * - \ref SCIP_STAGE_EXITPRESOLVE
1736  * - \ref SCIP_STAGE_PRESOLVED
1737  * - \ref SCIP_STAGE_SOLVING
1738  * - \ref SCIP_STAGE_SOLVED
1739  */
1740 extern
1742  SCIP* scip, /**< SCIP data structure */
1743  FILE* file /**< output file */
1744  );
1745 
1746 /** outputs propagator statistics
1747  *
1748  * @pre This method can be called if SCIP is in one of the following stages:
1749  * - \ref SCIP_STAGE_TRANSFORMED
1750  * - \ref SCIP_STAGE_INITPRESOLVE
1751  * - \ref SCIP_STAGE_PRESOLVING
1752  * - \ref SCIP_STAGE_EXITPRESOLVE
1753  * - \ref SCIP_STAGE_PRESOLVED
1754  * - \ref SCIP_STAGE_SOLVING
1755  * - \ref SCIP_STAGE_SOLVED
1756  */
1757 extern
1759  SCIP* scip, /**< SCIP data structure */
1760  FILE* file /**< output file */
1761  );
1762 
1763 /** outputs conflict statistics
1764  *
1765  * @pre This method can be called if SCIP is in one of the following stages:
1766  * - \ref SCIP_STAGE_TRANSFORMED
1767  * - \ref SCIP_STAGE_INITPRESOLVE
1768  * - \ref SCIP_STAGE_PRESOLVING
1769  * - \ref SCIP_STAGE_EXITPRESOLVE
1770  * - \ref SCIP_STAGE_PRESOLVED
1771  * - \ref SCIP_STAGE_SOLVING
1772  * - \ref SCIP_STAGE_SOLVED
1773  */
1774 extern
1776  SCIP* scip, /**< SCIP data structure */
1777  FILE* file /**< output file */
1778  );
1779 
1780 /** outputs separator statistics
1781  *
1782  * @pre This method can be called if SCIP is in one of the following stages:
1783  * - \ref SCIP_STAGE_SOLVING
1784  * - \ref SCIP_STAGE_SOLVED
1785  */
1786 extern
1788  SCIP* scip, /**< SCIP data structure */
1789  FILE* file /**< output file */
1790  );
1791 
1792 /** outputs pricer statistics
1793  *
1794  * @pre This method can be called if SCIP is in one of the following stages:
1795  * - \ref SCIP_STAGE_SOLVING
1796  * - \ref SCIP_STAGE_SOLVED
1797  */
1798 extern
1800  SCIP* scip, /**< SCIP data structure */
1801  FILE* file /**< output file */
1802  );
1803 
1804 /** outputs branching rule statistics
1805  *
1806  * @pre This method can be called if SCIP is in one of the following stages:
1807  * - \ref SCIP_STAGE_SOLVING
1808  * - \ref SCIP_STAGE_SOLVED
1809  */
1810 extern
1812  SCIP* scip, /**< SCIP data structure */
1813  FILE* file /**< output file */
1814  );
1815 
1816 /** outputs heuristics statistics
1817  *
1818  * @pre This method can be called if SCIP is in one of the following stages:
1819  * - \ref SCIP_STAGE_PRESOLVING
1820  * - \ref SCIP_STAGE_EXITPRESOLVE
1821  * - \ref SCIP_STAGE_PRESOLVED
1822  * - \ref SCIP_STAGE_SOLVING
1823  * - \ref SCIP_STAGE_SOLVED
1824  */
1825 extern
1827  SCIP* scip, /**< SCIP data structure */
1828  FILE* file /**< output file */
1829  );
1830 
1831 /** outputs compression statistics
1832  *
1833  * @pre This method can be called if SCIP is in one of the following stages:
1834  * - \ref SCIP_STAGE_PRESOLVING
1835  * - \ref SCIP_STAGE_EXITPRESOLVE
1836  * - \ref SCIP_STAGE_PRESOLVED
1837  * - \ref SCIP_STAGE_SOLVING
1838  * - \ref SCIP_STAGE_SOLVED
1839  */
1840 extern
1842  SCIP* scip, /**< SCIP data structure */
1843  FILE* file /**< output file */
1844  );
1845 
1846 /** outputs LP statistics
1847  *
1848  * @pre This method can be called if SCIP is in one of the following stages:
1849  * - \ref SCIP_STAGE_SOLVING
1850  * - \ref SCIP_STAGE_SOLVED
1851  */
1852 extern
1854  SCIP* scip, /**< SCIP data structure */
1855  FILE* file /**< output file */
1856  );
1857 
1858 /** outputs NLP statistics
1859  *
1860  * @pre This method can be called if SCIP is in one of the following stages:
1861  * - \ref SCIP_STAGE_SOLVING
1862  * - \ref SCIP_STAGE_SOLVED
1863  */
1864 extern
1866  SCIP* scip, /**< SCIP data structure */
1867  FILE* file /**< output file */
1868  );
1869 
1870 /** outputs relaxator statistics
1871  *
1872  * @pre This method can be called if SCIP is in one of the following stages:
1873  * - \ref SCIP_STAGE_SOLVING
1874  * - \ref SCIP_STAGE_SOLVED
1875  */
1876 extern
1878  SCIP* scip, /**< SCIP data structure */
1879  FILE* file /**< output file */
1880  );
1881 
1882 /** outputs tree statistics
1883  *
1884  * @pre This method can be called if SCIP is in one of the following stages:
1885  * - \ref SCIP_STAGE_SOLVING
1886  * - \ref SCIP_STAGE_SOLVED
1887  */
1888 extern
1890  SCIP* scip, /**< SCIP data structure */
1891  FILE* file /**< output file */
1892  );
1893 
1894 /** outputs root statistics
1895  *
1896  * @pre This method can be called if SCIP is in one of the following stages:
1897  * - \ref SCIP_STAGE_SOLVING
1898  * - \ref SCIP_STAGE_SOLVED
1899  */
1900 extern
1902  SCIP* scip, /**< SCIP data structure */
1903  FILE* file /**< output file */
1904  );
1905 
1906 /** outputs solution statistics
1907  *
1908  * @pre This method can be called if SCIP is in one of the following stages:
1909  * - \ref SCIP_STAGE_PRESOLVING
1910  * - \ref SCIP_STAGE_EXITPRESOLVE
1911  * - \ref SCIP_STAGE_PRESOLVED
1912  * - \ref SCIP_STAGE_SOLVING
1913  * - \ref SCIP_STAGE_SOLVED
1914  */
1915 extern
1917  SCIP* scip, /**< SCIP data structure */
1918  FILE* file /**< output file */
1919  );
1920 
1921 /** outputs concurrent solver statistics
1922  *
1923  * @pre This method can be called if SCIP is in one of the following stages:
1924  * - \ref SCIP_STAGE_TRANSFORMED
1925  * - \ref SCIP_STAGE_INITPRESOLVE
1926  * - \ref SCIP_STAGE_PRESOLVING
1927  * - \ref SCIP_STAGE_EXITPRESOLVE
1928  * - \ref SCIP_STAGE_PRESOLVED
1929  * - \ref SCIP_STAGE_SOLVING
1930  * - \ref SCIP_STAGE_SOLVED
1931  */
1932 extern
1934  SCIP* scip, /**< SCIP data structure */
1935  FILE* file /**< output file */
1936  );
1937 
1938 /** outputs Benders' decomposition statistics
1939  *
1940  * @pre This method can be called if SCIP is in one of the following stages:
1941  * - \ref SCIP_STAGE_SOLVING
1942  * - \ref SCIP_STAGE_SOLVED
1943  */
1944 extern
1946  SCIP* scip, /**< SCIP data structure */
1947  FILE* file /**< output file */
1948  );
1949 
1950 /** outputs solving statistics
1951  *
1952  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1953  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1954  *
1955  * @note If limits have been changed between the solution and the call to this function, the status is recomputed and
1956  * thus may to correspond to the original status.
1957  *
1958  * @pre This method can be called if SCIP is in one of the following stages:
1959  * - \ref SCIP_STAGE_INIT
1960  * - \ref SCIP_STAGE_PROBLEM
1961  * - \ref SCIP_STAGE_TRANSFORMED
1962  * - \ref SCIP_STAGE_INITPRESOLVE
1963  * - \ref SCIP_STAGE_PRESOLVING
1964  * - \ref SCIP_STAGE_EXITPRESOLVE
1965  * - \ref SCIP_STAGE_PRESOLVED
1966  * - \ref SCIP_STAGE_SOLVING
1967  * - \ref SCIP_STAGE_SOLVED
1968  */
1969 extern
1971  SCIP* scip, /**< SCIP data structure */
1972  FILE* file /**< output file (or NULL for standard output) */
1973  );
1974 
1975 /** outputs reoptimization statistics
1976  *
1977  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1978  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1979  *
1980  * @pre This method can be called if SCIP is in one of the following stages:
1981  * - \ref SCIP_STAGE_INIT
1982  * - \ref SCIP_STAGE_PROBLEM
1983  * - \ref SCIP_STAGE_TRANSFORMED
1984  * - \ref SCIP_STAGE_INITPRESOLVE
1985  * - \ref SCIP_STAGE_PRESOLVING
1986  * - \ref SCIP_STAGE_EXITPRESOLVE
1987  * - \ref SCIP_STAGE_PRESOLVED
1988  * - \ref SCIP_STAGE_SOLVING
1989  * - \ref SCIP_STAGE_SOLVED
1990  */
1991 extern
1993  SCIP* scip, /**< SCIP data structure */
1994  FILE* file /**< output file (or NULL for standard output) */
1995  );
1996 
1997 /** outputs history statistics about branchings on variables
1998  *
1999  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2000  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2001  *
2002  * @pre This method can be called if SCIP is in one of the following stages:
2003  * - \ref SCIP_STAGE_INIT
2004  * - \ref SCIP_STAGE_PROBLEM
2005  * - \ref SCIP_STAGE_TRANSFORMED
2006  * - \ref SCIP_STAGE_INITPRESOLVE
2007  * - \ref SCIP_STAGE_PRESOLVING
2008  * - \ref SCIP_STAGE_EXITPRESOLVE
2009  * - \ref SCIP_STAGE_PRESOLVED
2010  * - \ref SCIP_STAGE_SOLVING
2011  * - \ref SCIP_STAGE_SOLVED
2012  */
2013 extern
2015  SCIP* scip, /**< SCIP data structure */
2016  FILE* file /**< output file (or NULL for standard output) */
2017  );
2018 
2019 /** outputs node information display line
2020  *
2021  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2022  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2023  *
2024  * @pre This method can be called if SCIP is in one of the following stages:
2025  * - \ref SCIP_STAGE_SOLVING
2026  */
2027 extern
2029  SCIP* scip, /**< SCIP data structure */
2030  FILE* file, /**< output file (or NULL for standard output) */
2031  SCIP_VERBLEVEL verblevel, /**< minimal verbosity level to actually display the information line */
2032  SCIP_Bool endline /**< should the line be terminated with a newline symbol? */
2033  );
2034 
2035 /** gets total number of implications between variables that are stored in the implication graph
2036  *
2037  * @return the total number of implications between variables that are stored in the implication graph
2038  *
2039  * @pre This method can be called if SCIP is in one of the following stages:
2040  * - \ref SCIP_STAGE_INITPRESOLVE
2041  * - \ref SCIP_STAGE_PRESOLVING
2042  * - \ref SCIP_STAGE_EXITPRESOLVE
2043  * - \ref SCIP_STAGE_PRESOLVED
2044  * - \ref SCIP_STAGE_INITSOLVE
2045  * - \ref SCIP_STAGE_SOLVING
2046  * - \ref SCIP_STAGE_SOLVED
2047  */
2048 extern
2050  SCIP* scip /**< SCIP data structure */
2051  );
2052 
2053 /** stores conflict graph of binary variables' implications into a file, which can be used as input for the DOT tool
2054  *
2055  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2056  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2057  *
2058  * @pre This method can be called if SCIP is in one of the following stages:
2059  * - \ref SCIP_STAGE_TRANSFORMED
2060  * - \ref SCIP_STAGE_INITPRESOLVE
2061  * - \ref SCIP_STAGE_PRESOLVING
2062  * - \ref SCIP_STAGE_EXITPRESOLVE
2063  * - \ref SCIP_STAGE_PRESOLVED
2064  * - \ref SCIP_STAGE_INITSOLVE
2065  * - \ref SCIP_STAGE_SOLVING
2066  * - \ref SCIP_STAGE_SOLVED
2067  * - \ref SCIP_STAGE_EXITSOLVE
2068  *
2069  * @deprecated because binary implications are now stored as cliques
2070  */
2071 extern
2073  SCIP* scip, /**< SCIP data structure */
2074  const char* filename /**< file name, or NULL for stdout */
2075  );
2076 
2077 
2078 /** update statistical information when a new solution was found */
2079 extern
2081  SCIP* scip /**< SCIP data structure */
2082  );
2083 
2084 /**@} */
2085 
2086 #ifdef __cplusplus
2087 }
2088 #endif
2089 
2090 #endif
SCIP_RETCODE SCIPprintReoptStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgPseudocostCountCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Real SCIPgetFirstPrimalBound(SCIP *scip)
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
void SCIPprintSeparatorStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgPseudocostScoreCurrentRun(SCIP *scip)
void SCIPprintConstraintStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetFirstLPLowerboundRoot(SCIP *scip)
internal methods for branch and bound tree
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Real SCIPgetDualboundRoot(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_RETCODE SCIPupdateCutoffbound(SCIP *scip, SCIP_Real cutoffbound)
SCIP_Longint SCIPgetNSolsFound(SCIP *scip)
SCIP_Longint SCIPgetNBarrierLPs(SCIP *scip)
void SCIPprintConcsolverStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgCutoffScoreCurrentRun(SCIP *scip)
SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
SCIP_Longint SCIPgetNDualLPs(SCIP *scip)
int SCIPgetMaxDepth(SCIP *scip)
void SCIPprintStatusStatistics(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPprintDisplayLine(SCIP *scip, FILE *file, SCIP_VERBLEVEL verblevel, SCIP_Bool endline)
SCIP_Longint SCIPgetNPrimalResolveLPs(SCIP *scip)
void SCIPprintBendersStatistics(SCIP *scip, FILE *file)
void SCIPprintTransProblemStatistics(SCIP *scip, FILE *file)
void SCIPprintTimingStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetDeterministicTime(SCIP *scip)
SCIP_Longint SCIPgetNStrongbranchs(SCIP *scip)
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
void SCIPprintHeuristicStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgLowerbound(SCIP *scip)
SCIP_Longint SCIPgetNRootFirstLPIterations(SCIP *scip)
enum SCIP_VerbLevel SCIP_VERBLEVEL
Definition: type_message.h:48
SCIP_Longint SCIPgetNNZs(SCIP *scip)
SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)
int SCIPgetNActiveConss(SCIP *scip)
SCIP_Longint SCIPgetNBacktracks(SCIP *scip)
SCIP_Longint SCIPgetNDivingLPIterations(SCIP *scip)
void SCIPprintPresolverStatistics(SCIP *scip, FILE *file)
type definitions for return codes for SCIP methods
int SCIPgetNCutsFoundRound(SCIP *scip)
void SCIPprintBranchruleStatistics(SCIP *scip, FILE *file)
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgCutoffs(SCIP *scip, SCIP_BRANCHDIR dir)
SCIP_Real SCIPgetLowerboundRoot(SCIP *scip)
SCIP_RETCODE SCIPprintBranchingStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIP_Real SCIPgetFirstLPDualboundRoot(SCIP *scip)
int SCIPgetNCutsApplied(SCIP *scip)
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
void SCIPstoreSolutionGap(SCIP *scip)
int SCIPgetNCutsFound(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
type definitions for SCIP&#39;s main datastructure
SCIP_Real SCIPgetTransGap(SCIP *scip)
SCIP_Longint SCIPgetNResolveLPIterations(SCIP *scip)
void SCIPprintConflictStatistics(SCIP *scip, FILE *file)
void SCIPprintCompressionStatistics(SCIP *scip, FILE *file)
void SCIPprintLPStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNDelayedCutoffs(SCIP *scip)
internal miscellaneous methods
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
void SCIPprintPropagatorStatistics(SCIP *scip, FILE *file)
internal methods for global SCIP settings
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Bool SCIPisPrimalboundSol(SCIP *scip)
SCIP main data structure.
SCIP_Real SCIPgetAvgPseudocostCurrentRun(SCIP *scip, SCIP_Real solvaldelta)
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
SCIP_Longint SCIPgetNBarrierLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNPrimalResolveLPIterations(SCIP *scip)
void SCIPprintRootStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
SCIP_Real SCIPgetAvgInferencesCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
internal methods for problem variables
#define SCIP_Bool
Definition: def.h:62
int SCIPgetMaxTotalDepth(SCIP *scip)
void SCIPprintRelaxatorStatistics(SCIP *scip, FILE *file)
void SCIPprintTreeStatistics(SCIP *scip, FILE *file)
void SCIPprintSolutionStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetPseudocostVariance(SCIP *scip, SCIP_BRANCHDIR branchdir, SCIP_Bool onlycurrentrun)
SCIP_Real SCIPgetGap(SCIP *scip)
SCIP_Real SCIPgetAvgConflictlengthScoreCurrentRun(SCIP *scip)
SCIP_RETCODE SCIPwriteImplicationConflictGraph(SCIP *scip, const char *filename)
SCIP_Longint SCIPgetNPrimalLPs(SCIP *scip)
methods for debugging
SCIP_Longint SCIPgetNConflictConssFound(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffsCurrentRun(SCIP *scip, SCIP_BRANCHDIR dir)
void SCIPprintNLPStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)
SCIP_Longint SCIPgetNDualLPIterations(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
datastructures for problem statistics
SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)
void SCIPprintPricerStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetAvgDualbound(SCIP *scip)
SCIP_Longint SCIPgetNResolveLPs(SCIP *scip)
SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)
SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)
SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)
SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)
internal methods for main solving loop and node processing
int SCIPgetNReoptRuns(SCIP *scip)
SCIP_Longint SCIPgetNDivingLPs(SCIP *scip)
int SCIPgetNPricevars(SCIP *scip)
SCIP_Longint SCIPgetNPrimalLPIterations(SCIP *scip)
SCIP_Real SCIPgetAvgPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir)
int SCIPgetNPriceRounds(SCIP *scip)
int SCIPgetNImplications(SCIP *scip)
SCIP_Real SCIPgetAvgInferenceScoreCurrentRun(SCIP *scip)
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
#define SCIP_Real
Definition: def.h:150
int SCIPgetNPricevarsFound(SCIP *scip)
type definitions for branching and inference history
void SCIPprintConstraintTimingStatistics(SCIP *scip, FILE *file)
internal methods for constraints and constraint handlers
int SCIPgetNConflictConssFoundNode(SCIP *scip)
#define SCIP_Longint
Definition: def.h:135
type definitions for message output methods
SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
#define nnodes
Definition: gastrans.c:65
int SCIPgetNPricevarsApplied(SCIP *scip)
SCIP_Real SCIPgetAvgPseudocost(SCIP *scip, SCIP_Real solvaldelta)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
common defines and data types used in all packages of SCIP
void SCIPaddNNodes(SCIP *scip, SCIP_Longint nnodes)
int SCIPgetNEnabledConss(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Longint SCIPgetNLPs(SCIP *scip)
SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)
SCIP_Real SCIPgetAvgConflictScoreCurrentRun(SCIP *scip)
void SCIPprintOrigProblemStatistics(SCIP *scip, FILE *file)
SCIP_Longint SCIPgetNFeasibleLeaves(SCIP *scip)
SCIP_Longint SCIPgetNRootStrongbranchs(SCIP *scip)
SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)
int SCIPgetNSepaRounds(SCIP *scip)
SCIP_Real SCIPgetPseudocostCount(SCIP *scip, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
SCIP_Real SCIPgetAvgInferences(SCIP *scip, SCIP_BRANCHDIR dir)