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